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