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