return op.getOperation();
  }
  auto op = builder.create<tfl::ConstOp>(loc, value);
  op->setAttr("tfl.is_variable", builder.getUnitAttr());
  if (tensor.quantization && !tensor.quantization->min.empty()) {
    if (auto stats_op =
            ConvertMinMaxToStatsOp(tensor, builder, op.getResult())) {
      return stats_op;
    }
  }
  return op.getOperation();
}

        return WalkResult::interrupt();
      // Mark op as stateful due to side-effecting communication ops.
      if_op->setAttr("is_stateless", builder.getBoolAttr(false));
      MarkOutsideCompiled(host_if.getOperation());
    }
    if (auto while_op = llvm::dyn_cast<mlir::TF::WhileRegionOp>(op)) {
      if (!HasOutsideCompilationNested(op)) return WalkResult::advance();
      OpBuilder builder(while_op);

    if (!it.second.is_written) continue;
    int index = it.second.result_index - num_old_results;
    new_result_types[index] = it.second.data_type;
    new_while_operands[index] = it.second.hoisted_read;
  }
  op.getOperation()->insertOperands(op.getNumOperands(), new_while_operands);

  // Patch the cond and body regions to have additional arguments, and replace
  // the remaining resource reads (which will be resource reads for written

    }

    @Override
    protected Expression transformBinaryExpression(BinaryExpression be) {
        Expression left = transform(be.getLeftExpression());
        int type = be.getOperation().getType();
        if ((type == Types.ASSIGNMENT_OPERATOR || type == Types.EQUAL)
            && left instanceof ClassExpression) {
            ClassExpression ce = (ClassExpression) left;

#include "tensorflow/compiler/mlir/quantization/tensorflow/passes/quantize_composite_functions.inc"

void QuantizeCompositeFunctionsPass::runOnOperation() {
  MLIRContext* ctx = &getContext();
  ModuleOp module = getOperation();

  PassManager pm(ctx);
  // Intermediate output from QuantizePass will have PartitionedCall ops with
  // quantized input and output types, which are not allowed in TF dialect.

      return failure();
    }

    return success();
  }
};

void ComposeUniformQuantizedTypePass::runOnOperation() {
  ModuleOp module_op = getOperation();
  MLIRContext& ctx = getContext();

  RewritePatternSet patterns(&ctx);
  patterns.add<ComposeUniformQuantizedConvolutionOp,
               ComposeUniformQuantizedDotGeneralOp,

  }
};

void PrepareTFPass::runOnOperation() {
  MLIRContext *ctx = &getContext();
  RewritePatternSet patterns(ctx);
  RewritePatternSet phase_2_patterns(ctx);
  auto func = getOperation();

  // Check illegal ops in a TFLite pipeline (e.g. trainning only ops) , since
  // PrepareTFPass is the very first TFLite pass in the pipeline.

    }
    return WalkResult::advance();
  });
  return res.wasInterrupted();
}

void LowerStaticTensorListPass::runOnOperation() {
  auto *context = &getContext();
  ModuleOp module = getOperation();

  // When allow_tensorlist_pass_through_ == false the target dynamic legal
  // checks will cause this pass to fail if there are any variant type tensors

  return new_caller;
}

void EmbeddingPipeliningPass::runOnOperation() {
  LOG(INFO) << "EmbeddingPipeliningPass::runOnOperation()";
  ModuleOp module = getOperation();

  // We only use one of the EmbeddingPipelining and EmbeddingSequencing passes.
  if (!UseEmbeddingPipelining(module)) return;

  SymbolTable symbol_table(module);