atomic.Casuintptr(&hpetDevMap[idx], 0, ^uintptr(0))
		return
	}

	addr, mmapErr := mmap(nil, physPageSize, _PROT_READ, _MAP_SHARED, fd, 0)
	closefd(fd)
	newP := uintptr(addr)
	if mmapErr != 0 {
		newP = ^uintptr(0)
	}
	if !atomic.Casuintptr(&hpetDevMap[idx], 0, newP) && mmapErr == 0 {
		munmap(addr, physPageSize)
	}
}

//go:nosplit
func (th *vdsoTimehands) getTimecounter() (uint32, bool) {
	switch th.algo {

  auto new_op = OpBuilder(op).create<TFL::WhileOp>(
      op->getLoc(), op->getResultTypes(), op->getOperands(),
      while_op.getIsStateless());
  Location loc = while_op->getLoc();
  CreateRegionWithCall(while_op.cond_function(), new_op.getCond(), loc);
  CreateRegionWithCall(while_op.body_function(), new_op.getBody(), loc);

  op->replaceAllUsesWith(new_op.getResults());
  op->erase();
}

  auto new_op = OpBuilder(op).create<CaseOrIfOp>(
      op.getLoc(), first_branch.getFunctionType().getResults(), new_operands,
      op->getAttrs());
  for (const auto& entry : output_buffer_to_size) {
    (*buffer_to_size)[new_op.getResult(std::get<0>(entry))] = {
        new_op.getResult(std::get<1>(entry)), std::get<2>(entry)};
  }
  op.replaceAllUsesWith(new_op.getResults().take_front(op.getNumResults()));

	return nil
}

func (fb *FakeBinding) GetParamRef() *v1.ParamRef {
	return nil
}

func (fp *FakePolicy) DeepCopyObject() runtime.Object {
	// totally fudged deepcopy
	newFP := &FakePolicy{}
	*newFP = *fp
	return newFP
}

func (fb *FakeBinding) DeepCopyObject() runtime.Object {
	// totally fudged deepcopy
	newFB := &FakeBinding{}
	*newFB = *fb
	return newFB

  auto operands = llvm::to_vector<4>(op->getOperands());
  operands.push_back(operand);
  auto new_op = builder->create<OpT>(op->getLoc(), op->getResultTypes(),
                                     operands, attr.getAttrs());
  op->replaceAllUsesWith(new_op.getOperation()->getResults());
  op->erase();
  return new_op;
}

// Returns success if the function has at most one op of the template type and

        call_result.replaceAllUsesWith(new_result);
      }
      continue;
    }

    Operation& new_op = *builder.clone(op, arg_mapper);
    for (auto [result, new_result] :
         llvm::zip_equal(op.getResults(), new_op.getResults())) {
      new_op_mapper.map(result, new_result);
    }
  }

  call_op.erase();
}

                                                .cast<quant::QuantizedType>()
                                                .getStorageType());
        auto new_op = builder.create<TFR::CastOp>(
            returned_op->getLoc(), new_type, returned_op.getArg());
        returned_value.set(new_op.getResult());
        if (returned_op.use_empty()) {
          returned_op.erase();
        }
      } else {

             return opb.create<mlir::TF::LessOp>(loc, x, y).getOperation();
           });

  // mlir::TF::NegOp
  py::class_<mlir::TF::NegOp>(m, "Tf_NegOp")
      .def("create",
           [](mlir::OpBuilder& opb, mlir::Location loc,
              mlir::Value x) -> mlir::Operation* {
             return opb.create<mlir::TF::NegOp>(loc, x).getOperation();
           });

  py::class_<mlir::TF::NotEqualOp>(m, "Tf_NotEqualOp")

		}
	}
	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<