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