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