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