returned_type = quant::ConvertSignedQuantizedToUnsigned(
            dequantize_input.getType(), dequantize_op.getLoc());
        // replace the dequantize op by a quantize op
        TypeAttr type_attr = TypeAttr::get(returned_type);
        auto quantize_op = builder.create<QuantizeOp>(
            dequantize_op.getLoc(), returned_type, dequantize_input, type_attr);
        returned_value = quantize_op.getOutput();
      } else {

    // See core/kernels/data/iterator_ops.cc.)
    resource_op = builder.create<TF::IteratorOp>(
        op->getLoc(), resource.getType(), shared_name, container,
        it.getOutputTypes(), it.getOutputShapes());
  } else {
    resource_op = builder.create<TF::VarHandleOp>(
        op->getLoc(), resource.getType(), container, shared_name);
  }
  op->setOperand(0, resource_op->getResult(0));
}

    builder.setInsertionPoint(op);
    for (auto& op_operand : op->getOpOperands()) {
      if (IsLargeFloatType(op_operand.get().getType())) {
        op_operand.set(builder.create<TF::CastOp>(
            op->getLoc(), ToBfloat16Type(op_operand.get().getType()),
            op_operand.get()));
      }
    }
    builder.setInsertionPointAfter(op);
    for (auto op_result : op->getOpResults()) {

  builder.create<tf_saved_model::SessionInitializerOp>(
      module->getLoc(), builder.getArrayAttr(func_names));
  // Create AssetOp; this holds the checkpoint_path.
  // TODO(b/318761632): Cleanup usage of string literals, instead use constants.
  auto asset_op = builder.create<tf_saved_model::AssetOp>(
      module->getLoc(),
      /*sym_name=*/

  auto cluster = builder.create<mlir::tf_device::ClusterOp>(
      call_op->getLoc(), call_op->getResultTypes());
  cluster.getBody().push_back(new Block);
  call_op->replaceAllUsesWith(cluster.getResults());
  call_op->moveBefore(&cluster.GetBody(), cluster.GetBody().end());
  builder.setInsertionPointToEnd(&cluster.GetBody());
  builder.create<mlir::tf_device::ReturnOp>(call_op->getLoc(),
                                            call_op->getResults());

      if (ClusterFuncHasResourceRead(cluster_func, resource_and_type.resource))
        continue;
      auto new_read = builder.create<TF::ReadVariableOp>(
          resource_and_type.resource.getLoc(), resource_and_type.subtype,
          resource_and_type.resource);
      read_operands.push_back(new_read.getValue());
    }

    if (read_operands.empty()) continue;

            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) {

 */

package org.gradle.api.internal.project;

import org.apache.tools.ant.Task;

public class TestAntTask extends Task {
    @Override
    public void execute() {
        org.apache.commons.logging.LogFactory.getLog("ant-test").info("a jcl log message");
        org.slf4j.LoggerFactory.getLogger("ant-test").info("an slf4j log message");
        org.apache.log4j.Logger.getLogger("ant-test").info("a log4j log message");
    }

    // 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());