}
	}
	for i < len(oi) && j < len(newOi) {
		if oi[i].First < newOi[j].First {
			appendOrMergeWithLastInterval(oi[i])
			i++
		} else {
			appendOrMergeWithLastInterval(newOi[j])
			j++
		}
	}
	for i < len(oi) {
		appendOrMergeWithLastInterval(oi[i])
		i++
	}
	for j < len(newOi) {
		appendOrMergeWithLastInterval(newOi[j])
		j++
	}
	return result
}

  for (auto& use : tensor_list.getUses()) {
    uses.emplace_back(&use);
  }
  OpBuilder builder(tensor_list_op.getOperation());
  for (OpOperand* operand : uses) {
    auto new_op = builder.clone(*tensor_list_op.getOperation());
    operand->set(new_op->getResult(0));
  }
}

// This transformation pass replicates TensorList initialization ops.
class ReplicateTensorListInitOps
    : public impl::ReplicateTensorListInitOpsPassBase<

  Operation* new_op = rewriter.create(new_state);
  if (materialize_derived_attrs_) {
    for (const auto& attr : derived_attrs) {
      // Add or update the derived attribute with the value. Skip the fixed
      // element type attributes, in case they are present in the NodeDef.
      if (!fixed_elt_type_attrs_.contains(attr.first())) {
        new_op->setAttr(attr.first(), attr.second);
      }
    }

                                        new_op->getResult(0), dump_attributes);

      if (debugger_type_ == DebuggerConfig::DEBUGGER_TYPE_FLOAT_PER_LAYER) {
        // Swap all uses between call_op and ref_call_op, except for the
        // particular use that owns DumpTensor.
        rewriter.replaceUsesWithIf(
            op.getResult(0), new_op->getResult(0), [](OpOperand &use) -> bool {

package p2

import "./p1"

              op->getLoc(), cast<TypedAttr>(attribute));
        }
        new_operands.push_back(attr_cst);
      }
    }

    // Create the TFR call op
    auto new_op = builder.create<CallOp>(
        op->getLoc(), compose_func_type.getResults(),
        SymbolRefAttr::get(builder.getContext(), compose_func.getName()),
        new_operands);

	Call wasm_pc_f_loop(SB)

	Return

// wasm_export_getsp gets called from JavaScript to retrieve the SP.
TEXT wasm_export_getsp(SB),NOSPLIT,$0
	Get SP
	Return

TEXT runtime·pause(SB), NOSPLIT, $0-8
	MOVD newsp+0(FP), SP
	I32Const $1
	Set PAUSE
	RETUNWIND

TEXT runtime·exit(SB), NOSPLIT, $0-4
	I32Const $0
	Call runtime·wasmExit(SB)
	I32Const $1
	Set PAUSE

					crHash := strings.Join([]string{newIOP.Name, newIOP.Namespace, string(component), host}, "-")
					cache.RemoveCache(crHash)
				}
			}

			if oldIOP.GetDeletionTimestamp() != newIOP.GetDeletionTimestamp() {
				metrics.IncrementReconcileRequest("update_deletion_timestamp")
				return true
			}

			if oldIOP.GetGeneration() != newIOP.GetGeneration() {

    builder->setInsertionPoint(op);
    Operation* new_op = builder->create(state);

    // Insert quantize ops for every outputs and rewrite.
    for (int i = 0; i < op->getNumResults(); ++i) {
      auto result = op->getResult(i);
      auto result_type = result.getType();

      Value new_result = new_op->getResult(i);
      if (IsQI8Type(result_type) || IsQUI8Type(result_type)) {

    if (!caller_func) return failure();

    builder.setInsertionPoint(call_op);
    for (auto [lifted_op, arg_idx] : lifted_op_and_arg_idx) {
      auto new_op = builder.clone(*lifted_op, mapping);
      call_op->insertOperands(arg_idx, new_op->getResult(0));
    }

    // Try to lift recursively until the main function.
    if (failed(LiftHashTableOpsToArguments(module_op, caller_func))) {
      return failure();