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