for (final Sitemap sitemap : sitemapSet.getSitemaps()) {
                if (sitemap != null) {
                    requestDataSet.add(RequestDataBuilder.newRequestData().get().url(sitemap.getLoc()).build());
                }
            }
            throw new ChildUrlsException(requestDataSet, this.getClass().getName() + "#process");
        } catch (final IOException e) {

  auto island = builder.create<IslandOp>(
      sub_op->getLoc(), sub_op->getResultTypes(), control_type, control_inputs);
  island.getBody().push_back(new Block);
  Block* block = &island.getBody().back();
  builder.setInsertionPointToEnd(block);
  sub_op->replaceAllUsesWith(island.getOutputs());
  sub_op->moveBefore(block, block->begin());
  builder.create<YieldOp>(sub_op->getLoc(), sub_op->getResults());
  return island;
}

            builder.create<SparseQConstOp>(op->getLoc(), cst.getQtypeAttr(),
                                           cst.getValue(), s_param, new_value);
        value.replaceAllUsesWith(s_qconst.getResult());
        cst.erase();
      }

      if (result.needs_densify) {
        auto value = op->getOperand(operand);
        auto densify =
            builder.create<DensifyOp>(op->getLoc(), value.getType(), value);

  for (int64_t dim : element_shape) {
    buffer_shape.push_back(dim);
  }
  auto zero = CreateScalarConst(0, builder, op->getLoc());
  if (getElementTypeOrSelf(zero.getType()) != element_dtype) {
    zero = builder.create<TF::CastOp>(
        op->getLoc(),
        ArrayRef<Type>{tensorflow::GetTypeFromTFTensorShape({}, element_dtype)},
        ArrayRef<Value>{zero});
  }
  auto buffer_type =

    // and its users.
    Value value = tf_op.getOutputs();
    auto quantize = rewriter.create<quantfork::QuantizeCastOp>(
        tf_op.getLoc(), qtype.getValue(), value);
    auto dequantize = rewriter.create<quantfork::DequantizeCastOp>(
        tf_op.getLoc(), res_type, quantize.getResult());
    value.replaceAllUsesWith(dequantize);
    quantize.getOperation()->replaceUsesOfWith(dequantize, value);

      filtered_ops.push_back(func);
    }
    return;
  }

  llvm::Regex op_regex(tac_filter.op_filter().op_name_pattern());
  module.walk([&](Operation* op) {
    auto named_loc = mlir::dyn_cast<NameLoc>(op->getLoc());
    if (!named_loc) {
      return;
    }
    if (!op_regex.match(named_loc.getName())) {
      return;
    }

    op->setAttr(kSkipTargetAnnotation, builder.getUnitAttr());

        replicated_input.getLoc(), replicated_input.getType(),
        operands_per_replica, replicated_input->getAttrs());
    replicate_op.setIsPacked(is_packed);
    operands_per_core.push_back(replicate_op);
  }

  auto pi = builder.create<TF::TPUPartitionedInputV2Op>(
      first_partitioned_input.getLoc(), replicated_input.getType(),

bool EmitMustBeConstantError(Operation* op) {
  if (operations_to_skip->contains(op->getRegisteredInfo()->getTypeID())) {
    IncrementCounterFor(mlir_non_static_op_skip_count, op);
    return true;
  }
  emitError(op->getLoc()) << absl::StrCat(
      "Node `", op->getName().getStringRef().str(), "` ", kMustBeConstantError);
  return false;
}

bool IsStaticOperation(Operation* op) {
  for (auto o : op->getResults()) {

    // It is currently not possible to easily pack the output of a multi-result
    // op into an op with a single varidic output in `.td`.
    auto converted = rewriter.create<TFL::CustomOp>(
        op->getLoc(), op->getResultTypes(), op->getOperands(),
        "TensorListPopBack", TFL::ConstBytesAttr::get(getContext(), ""));
    rewriter.replaceOp(op, converted.getResults());
    return success();
  }
};

    "$_builder.create<TF::ShapeOp>($0.getLoc(), $1, $2)">;

def IsI32 : NativeCodeCall<
    "$_builder.getBoolAttr(getElementTypeOrSelf($0.getType()).isInteger(32))">;

def CreateTFCastOpF32 : NativeCodeCall<
    "CreateTFCastOpF32(&$_builder, $0.getLoc(), $1, $2)">;

def CreateTFCastOpI32 : NativeCodeCall<
    "CreateTFCastOpI32(&$_builder, $0.getLoc(), $1, $2)">;

def CreateTensorScatterNdOp : NativeCodeCall<