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