auto new_host_launch_op = CreateNewHostLaunchOpWithNewResult(
        &old_launch_op, new_launch_op_results);
    UpdateReturnOpResultWithLaunchOpResult(&new_host_launch_op);

    old_launch_op->erase();

    tf_device::LaunchOp new_device_launch_op;
    if (failed(CreateNewDeviceLaunchOp(op, replicated, new_device_launch_op)))
      return signalPassFailure();

        replicate_op.GetReplicaOperandForBlockArgument(block_arg,
                                                       /*replica=*/0));
    shape_op.replaceAllUsesWith(new_shape_op.getOperation());
    shape_op.erase();
  }
}

// Checks if op and inner op operands are all replicate invariant.
bool IsOpReplicateInvariant(Region* replicate_region, Operation* op) {
  auto ancestor_of_replicate = [&](Region* region) {

  // Those ops should be removed.
  for (auto* op : subgraph.partition_ops_) {
    if (IsConstantOrNone(op)) {
      continue;
    }
    op->dropAllDefinedValueUses();
    op->dropAllReferences();
    op->erase();
  }
  // Ensure that users of the call op's results appear after the launch op in
  // order to preserve the dominance property.
  TF::ReorderOpResultUses(call_op);
}

}  // namespace common

    outer_op.getBody().takeBody(region);
    // Careful: We can't use outer_op.getResults(), because that also includes
    // the control token.
    op->replaceAllUsesWith(outer_op.getOutputs());
    op->erase();
    // Control token is last result of outer_op.
    control_tokens.assign(1, outer_op.getResults().back());
  }
}
}  // namespace

// and remove them.
void RemoveSerializedStablehloFunctions(ModuleOp module) {
  module.walk([&](func::FuncOp f) {
    if (f->hasAttr(kFromXlaCallModuleAttrName)) {
      f->erase();
    }
  });
}

class XlaCallModuleSerializationPass
    : public impl::XlaCallModuleSerializationPassBase<
          XlaCallModuleSerializationPass> {
 public:
  void runOnOperation() override {

      island_op.getBody().push_back(new Block);
      replacer.create<mlir::func::ReturnOp>(yield_op.getLoc(),
                                            yield_op.getOperands());
      yield_op.erase();
    }

    // Remap the captured operands in the (former) island block with newly
    // created entry block arguments in the function body.
    {
      Block &entry_block = outlined_func.getBody().front();

		mp.locks--
	}
}

// mrandinit initializes the random state of an m.
func mrandinit(mp *m) {
	var seed [4]uint64
	for i := range seed {
		seed[i] = bootstrapRand()
	}
	bootstrapRandReseed() // erase key we just extracted
	mp.chacha8.Init64(seed)
	mp.cheaprand = rand()
}

// randn is like rand() % n but faster.
// Do not change signature: used via linkname from other packages.
//
//go:nosplit