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