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