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

	}

	// Our range is [0.5,1) but floating point range is [1,2).
	exp--

	// Minimum representable exponent is flt.bias+1.
	// If the exponent is smaller, move it up and
	// adjust d accordingly.
	if exp < flt.bias+1 {
		n := flt.bias + 1 - exp
		d.Shift(-n)
		exp += n
	}

	if exp-flt.bias >= 1<<flt.expbits-1 {
		goto overflow
	}

	// Extract 1+flt.mantbits bits.
	d.Shift(int(1 + flt.mantbits))

// CHECK: return %[[TRANSPOSE_1]]

// -----

// Tests that a `add(convolution(%activation, %weight), %bias)` pattern with the
// activation tensor of NCHW format and non-constant bias is converted to NHWC
// convolution, but without the deferred transpose for `stablehlo.add`.
// Transpose ops are inserted to the activation and output of

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

// 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)),

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

  %weight = arith.constant dense_resource<__elided__> : tensor<2x3x3x2xf32>
  %bias = arith.constant dense<[7.11401462, 7.05456924]> : tensor<2xf32>

  %q_input= "quantfork.qcast"(%input) : (tensor<1x3x4x3xf32>) -> tensor<1x3x4x3x!quant.uniform<i8:f32, 0.58810077742034317:-128>>

  //     constant is used by multiple ops as a bias, duplicate constants and
  //     let each op assign its own quantization parameter for bias.
  //   - Adds all the non-bias constants (weights) to a set for looking up
  //     later.
  //   - Adds all per-channel weights to a set for looking up later.
  void PreprocessConstantOps();

                    "\""# 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)">;