std.offset = -int(i.Bias) * 60
		l.cacheStart = alpha
		l.cacheEnd = omega
		l.cacheZone = std
		l.tx = make([]zoneTrans, 1)
		l.tx[0].when = l.cacheStart
		l.tx[0].index = 0
		return
	}

	// StandardBias must be ignored if StandardDate is not set,
	// so this computation is delayed until after the nzone==1
	// return above.
	std.offset = -int(i.Bias+i.StandardBias) * 60

	dst := &l.zone[1]

    }
    const int64_t cost_per_col = 2 * weight_type.getNumElements();

    *count = cost_per_col * cols;

    auto bias = op->getOperand(2);
    if (bias) {
      auto bias_type =
          mlir::dyn_cast_or_null<mlir::RankedTensorType>(bias.getType());
      if (bias_type && bias_type.hasStaticShape()) {
        *count += output_type.getNumElements();
      }
    }

    return true;
  }

	switch {
	case f == 0:
		return f, 0 // correctly return -0
	case IsInf(f, 0) || IsNaN(f):
		return f, 0
	}
	f, exp = normalize(f)
	x := Float64bits(f)
	exp += int((x>>shift)&mask) - bias + 1
	x &^= mask << shift
	x |= (-1 + bias) << shift
	frac = Float64frombits(x)
	return

	exp += e
	x := Float64bits(frac)
	exp += int(x>>shift)&mask - bias
	if exp < -1075 {
		return Copysign(0, frac) // underflow
	}
	if exp > 1023 { // overflow
		if frac < 0 {
			return Inf(-1)
		}
		return Inf(1)
	}
	var m float64 = 1
	if exp < -1022 { // denormal
		exp += 53
		m = 1.0 / (1 << 53) // 2**-53
	}
	x &^= mask << shift
	x |= uint64(exp+bias) << shift
	return m * Float64frombits(x)

  def optimizeConsecutiveConv#OpsTuple[0]#OpsTuple[1] : Pat<
    (OpsTuple[1]
      (OpsTuple[0] $input, $zp_offset, $broadcast_dims_1),
      $bias, $broadcast_dims_2),
    (OpsTuple[0]
      $input,
      (OpsTuple[2] $zp_offset, $bias, $broadcast_dims_2), $broadcast_dims_1),
    [
      (IsNull $broadcast_dims_1),
      (IsNull $broadcast_dims_2),
      (TensorOf<[AnyInteger]> $input),

// Specify this trait if the bias-th input of the op is a bias input, which
// needs a scale based on the scales of op1 and op2.
class AccumulatorUniformScale<int bias, int op1, int op2> : NativeOpTrait<
  !strconcat("quant::AccumulatorUniformScale<",
             !interleave([bias, op1, op2], ", "),
             ">::Impl")>;

def FoldQuantWeightsIntoTposeConv : Pat<
  (TFL_TransposeConvOp
    $output_shape,
    (TFL_DequantizeOp $quant_weights),
    $quant_input,
    $bias, $padding, $stride_h, $stride_w, $faf),
  (TFL_TransposeConvOp $output_shape, $quant_weights,
    $quant_input, $bias, $padding, $stride_h, $stride_w, $faf), 

// Keeps Add and Sub ops if the second operand is bias.
def KeepAddV2Op : Pat<
  (TF_AddV2Op:$add_op $input, (TF_ConstOp:$bias_cst $bias)),
  (MarkNoFallback (TF_AddV2Op $input, $bias_cst)),
  [(IsFusibleWithBias $input), (RankEquals<"1"> $bias_cst),
  (NoFallbackAttrNotSet $add_op)]>;

def KeepSubOp : Pat<
  (TF_SubOp:$sub_op $input, (TF_ConstOp:$bias_cst $bias)),
  (MarkNoFallback (TF_SubOp $input, $bias_cst)),

                    "\""# func_name #"\", $0...)", returns>;

// Add the second argument to the first argument, which is expected to be an
// argument list.
// bias(einsum(inputs), bias) --> einsum_with_bias(AppendToVector(inputs, bias))
// Since inputs is a vector in case of einsum, we cannot use ArgumentList here.
def AppendToVector : NativeCodeCall<"AppendToVector($0, $1)">;

    A.reset(A_raw);
  }
  // Bias
  float Bias_vals[] = {2.0f, 3.0f};
  int64_t Bias_dims[] = {2};
  AbstractTensorHandlePtr Bias;
  {
    AbstractTensorHandle* Bias_raw;
    status_ = TestTensorHandleWithDims<float, TF_FLOAT>(
        immediate_execution_ctx_.get(), Bias_vals, Bias_dims, 1, &Bias_raw);
    ASSERT_EQ(errors::OK, status_.code()) << status_.message();
    Bias.reset(Bias_raw);
  }