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