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