}

// InitUniverse initializes the universe block.
func InitUniverse() {
	types.InitTypes(func(sym *types.Sym, typ *types.Type) types.Object {
		n := ir.NewDeclNameAt(src.NoXPos, ir.OTYPE, sym)
		n.SetType(typ)
		n.SetTypecheck(1)
		sym.Def = n
		return n
	})

	for _, s := range &builtinFuncs {
		ir.NewBuiltin(types.BuiltinPkg.Lookup(s.name), s.op)
	}

	for _, s := range &unsafeFuncs {

    if (!req_op) return failure();

    // Create a new func.call op with f32 output.
    auto new_call_op = call_op.clone();
    new_call_op->getResult(0).setType(
        mlir::cast<ShapedType>(call_op.getResult(0).getType())
            .clone(rewriter.getF32Type()));
    rewriter.setInsertionPoint(call_op);
    rewriter.insert(new_call_op);

  TFRTensorType unconstrainted_type = rewriter.getType<TFRTensorType>();
  SmallVector<Value, 4> new_results;
  for (auto res : llvm::enumerate(call_op.getResultTypes())) {
    Type res_type = res.value();
    if (mlir::dyn_cast<TFRTensorType>(res_type)) {
      Value new_res = new_op->getResult(res.index());
      auto casted = rewriter.create<CastOp>(loc, res_type, new_res);
      new_results.push_back(casted.getOut());

    private static final Type SYSTEM_TYPE = getType(System.class);
    private static final Type INTEGER_TYPE = getType(Integer.class);
    private static final Type INSTRUMENTED_TYPE = getType(Instrumented.class);
    private static final Type LONG_TYPE = getType(Long.class);
    private static final Type BOOLEAN_TYPE = getType(Boolean.class);
    public static final Type PROPERTIES_TYPE = getType(Properties.class);

  }

  QuantizationComponent quantization_component = 1;

  // Defines the target bit of the data.
  BitWidth bit_width = 2;

  // Defines the type of data of the quantized component.
  BitType bit_type = 3;

  // Defines whether quantization is done in narrow range.
  bool enable_narrow_range = 4;

  // Defines whether quantiation is done per-channel.
  bool enable_per_channel_quantization = 5;

			return n // already visited n.X before wrapping
		}

		ok := match(n)

		ir.EditChildren(n, mark)

		if ok {
			paren := ir.NewParenExpr(n.Pos(), n)
			paren.SetType(n.Type())
			paren.SetTypecheck(n.Typecheck())

			parens = append(parens, paren)
			n = paren
		}

		return n
	}
	ir.EditChildren(fn, mark)

	// Edit until stable.
	for {

    @Override
    public Type visitPrimitive(PrimitiveType t, Void unused) {
        TypeKind kind = t.getKind();
        if (kind == TypeKind.INT) {
            return Type.INT_TYPE;
        }
        if (kind == TypeKind.BYTE) {
            return Type.BYTE_TYPE;
        }
        if (kind == TypeKind.BOOLEAN) {
            return Type.BOOLEAN_TYPE;
        }

	ldr := ctxt.loader
	s := ldr.LookupOrCreateSym(name, version)
	ldr.SetIsGeneratedSym(s, true)
	sb := ldr.MakeSymbolUpdater(s)
	sb.SetType(t)
	sb.SetSize(size)
	ctxt.generatorSyms[s] = gen
	return s

      if (out_type.isa<TFRTensorType>()) {
        new_cst = rewriter.create<CastOp>(loc, out_type, new_cst->getResult(0));
      }
      rewriter.replaceOp(cst_tensor_op, new_cst->getResult(0));
      return success();
    }

    TypedAttr scalar;
    if (matchPattern(cst_tensor_op.getArg(), m_Constant(&scalar))) {
      Type new_out_type = RankedTensorType::get({}, scalar.getType());

    for (int i = 0; i < arg_shapes.size(); ++i) {
      auto metadata_arg = metadata_proto.add_args();
      metadata_arg->set_kind(
          tensorflow::tpu::TPUCompileMetadataProto::Arg::PARAMETER);
      metadata_arg->set_dtype(dtype);
    }
    // Set up one dummy retval.
    metadata_proto.add_retvals();
    bool use_tuple_args = true;
    std::vector<tensorflow::tpu::ShardingAndIndex> arg_core_mapping;