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