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