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