numUnits := uint32(d.r.ReadULEB128())
	fnameidx := uint32(d.r.ReadULEB128())
	fileidx := uint32(d.r.ReadULEB128())

	f.Srcfile = d.strtab.Get(fileidx)
	f.Funcname = d.strtab.Get(fnameidx)

	// Now the units
	f.Units = f.Units[:0]
	if cap(f.Units) < int(numUnits) {
		f.Units = make([]coverage.CoverableUnit, 0, numUnits)
	}
	for k := uint32(0); k < numUnits; k++ {

	for m.Len() < 10000 {
		Println("map at ", m.Len())
		if m.Len()%100 == 0 {
			runtime.Gosched()
		}
		m.AddItem()
		m.AddItem()
		m.DelItem()
		var wg sync.WaitGroup
		const numGets = 10
		wg.Add(numGets)
		for i := 0; i < numGets; i++ {
			go func(i int) {
				if i&1 == 0 {
					m.GetItem()
				} else {
					m.RangeAll()
				}
				wg.Done()
			}(i)
		}
		wg.Wait()
	}
	for m.Len() > 0 {

  %0 = "tf.FakeQuantWithMinMaxVars"(%arg0, %arg1, %arg2) {num_bits = 3, narrow_range = false} : (tensor<8xf32>, tensor<f32>, tensor<f32>) -> tensor<8xf32>
  %1 = "quantfork.qcast"(%0) : (tensor<8xf32>) -> tensor<8x!quant.uniform<i4:f32, 1.000000e+00:-8>>
  func.return %1 : tensor<8x!quant.uniform<i4:f32, 1.000000e+00:-8>>

// CHECK:  %0 = "tf.FakeQuantWithMinMaxVars"(%arg0, %cst, %cst_0) <{narrow_range = false, num_bits = 3 : i64}>

      "x/.ATTRIBUTES/VARIABLE_VALUE", DT_FLOAT, &x_handle));
  AbstractTensorPtr x = testing::TensorHandleToTensor(x_handle.get());
  EXPECT_EQ(x->Type(), DT_FLOAT);
  EXPECT_EQ(x->NumElements(), 1);
  EXPECT_EQ(x->NumDims(), 0);
  EXPECT_FLOAT_EQ(*reinterpret_cast<float*>(x->Data()), 1.0f);

  ImmediateTensorHandlePtr y_handle;
  TF_EXPECT_OK(internal::SingleRestore(
      context(), CheckpointPrefix("VarsAndArithmeticObjectGraph"),

    %0 = "tf.FakeQuantWithMinMaxArgs"(%arg0) {device = "", max = 2.000000e-01 : f32, min = -1.000000e-01 : f32, narrow_range = false, num_bits = 8 : i64} : (tensor<1x3x4x3xf32>) -> tensor<1x3x4x3xf32>

// WRAPPED-NEXT:   %[[fq:.*]] = "tf.FakeQuantWithMinMaxVarsPerChannel"(%arg1, %arg2, %arg3) <{narrow_range = true, num_bits = 8 : i64}> {device = ""} : (tensor<*xf32>, tensor<186xf32>, tensor<186xf32>) -> tensor<*xf32>
// WRAPPED-NEXT:   "tfl.yield"(%[[fq]]) : (tensor<*xf32>) -> ()
// WRAPPED-NEXT:   }) {device = "", narrow_range = true, num_bits = 8 : i64} : (tensor<*xf32>, tensor<186xf32>, tensor<186xf32>) -> tensor<*xf32>

struct ConvertStatsToQDQs : public OpRewritePattern<quantfork::StatisticsOp> {
  ConvertStatsToQDQs(int num_bits, bool narrow_range, bool is_signed,
                     bool legacy_float_scale, MLIRContext* context)
      : OpRewritePattern<quantfork::StatisticsOp>(context),
        num_bits(num_bits),
        narrow_range(narrow_range),
        is_signed(is_signed),
        legacy_float_scale(legacy_float_scale) {}

  %0 = "tf.FakeQuantWithMinMaxArgs"(%arg1) {device = "", max = 2.000000e+00 : f32, min = -1.000000e+00 : f32, narrow_range = false, num_bits = 8 : i64} : (tensor<2x3x3x2xf32>) -> tensor<*xf32>
  %1 = "tf.FakeQuantWithMinMaxArgs"(%arg0) {device = "", max = 2.000000e-01 : f32, min = -1.000000e-01 : f32, narrow_range = false, num_bits = 8 : i64} : (tensor<1x3x4x3xf32>) -> tensor<*xf32>

  input: "sequential/quant_dense/MatMul/kquant/FakeQuantWithMinMaxVars/ReadVariableOp_1"
  attr {
    key: "narrow_range"
    value {
      b: false
    }
  }
  attr {
    key: "num_bits"
    value {
      i: 8
    }
  }
}
node {
  name: "sequential/quant_dense/MatMul/kquant/IdentityN"
  op: "IdentityN"
  input: "sequential/quant_dense/MatMul/kquant/FakeQuantWithMinMaxVars"

  }
}

// Sets the min / max, scale and zero_points from the fake quant num_bits
// attribute from QAT.
QuantizedType ResetMinMaxFromNumBits(const QuantizedType type,
                                     const int num_bits,
                                     const bool narrow_range,
                                     const bool is_signed) {
  if (num_bits >= 8) {
    return type;
  }