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