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