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