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