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