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