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