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