for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if data[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {

  if (quantized_multiplier == (1LL << 31)) {
    quantized_multiplier /= 2;
    ++shift;
  }
  assert(quantized_multiplier <= std::numeric_limits<int32_t>::max());

  // Check that the shift amount is not greater than 31 or less than -31.
  if (shift > 31 || shift < -31) {
    return {0, 0};
  }

  return {static_cast<int32_t>(quantized_multiplier), shift};
}

// Calculates the quantized range for a given scale, zero point, minimum and

  // no matter what.
  if (quantized_fraction == (1L << 15)) {
    quantized_fraction /= 2;
    ++shift;
  }
  if (shift < -15) {
    shift = 0;
    quantized_fraction = 0;
  }
  if (shift > 14) {
    shift = 14;
    quantized_fraction = (1LL << 15) - 1;
  }
  return success();
}

            case "$2" in
                "") shift 2 ;;
                *) TF_PREFIX=$2 ; shift 2 ;;
            esac ;;
        -l|--libdir)
            case "$2" in
                "") shift 2 ;;
                *) LIBDIR=$2 ; shift 2 ;;
            esac ;;
        -v|--version)
            case "$2" in
                "") shift 2 ;;
                *) TF_VERSION=$2 ; shift 2 ;;
            esac ;;

// license that can be found in the LICENSE file.

// issue 1664

package main

func main() {
	var i uint = 33
	var a = (1<<i) + 4.5  // ERROR "shift of type float64|invalid.*shift"
	println(a)
	
	var b = (1<<i) + 4.0  // ERROR "shift of type float64|invalid.*shift"
	println(b)

	var c int64 = (1<<i) + 4.0  // ok - it's all int64
	println(c)

#define ROUND3FIRST(a, b, c, d, index, const, shift) \
	MOVL	d,		R9; \
	XORL	c,		R9; \
	XORL	b,		R9; \
	ADDL	$const,	a; \
	ADDL	R8,		a; \
	MOVL	(index*4)(SI),R8; \
	ADDL	R9,		a; \
	ROLL	$shift,		a; \
	ADDL	b,		a

#define ROUND3(a, b, c, d, index, const, shift) \
	XORL	a,		R9; \
	XORL	b,		R9; \
	ADDL	$const,	a; \
	ADDL	R8,		a; \

		}
	}
}

var sink string

func BenchmarkDecimalConversion(b *testing.B) {
	for i := 0; i < b.N; i++ {
		for shift := -100; shift <= +100; shift++ {
			var d decimal
			d.init(natOne, shift)
			sink = d.String()
		}
	}
}

func BenchmarkFloatString(b *testing.B) {
	x := new(Float)
	for _, prec := range []uint{1e2, 1e3, 1e4, 1e5} {

}

// Expand 48-bit input to 64-bit, with each 6-bit block padded by extra two bits at the top.
// By doing so, we can have the input blocks (four bits each), and the key blocks (six bits each) well-aligned without
// extra shifts/rotations for alignments.
func unpack(x uint64) uint64 {
	return ((x>>(6*1))&0xff)<<(8*0) |
		((x>>(6*3))&0xff)<<(8*1) |
		((x>>(6*5))&0xff)<<(8*2) |
		((x>>(6*7))&0xff)<<(8*3) |
		((x>>(6*0))&0xff)<<(8*4) |

	case TypeImmSigned:
		return Imm(a.BitFields.ParseSigned(i) << a.Shift)
	case TypeImmUnsigned:
		return Imm(a.BitFields.Parse(i) << a.Shift)
	case TypePCRel:
		return PCRel(a.BitFields.ParseSigned(i) << a.Shift)
	case TypeLabel:
		return Label(a.BitFields.ParseSigned(i) << a.Shift)
	case TypeOffset:
		return Offset(a.BitFields.ParseSigned(i) << a.Shift)
	case TypeNegOffset:

    --node-image)
      NODE_IMAGE=$2
      shift 2
    ;;
    # Config for enabling different Kubernetes features in KinD (see prow/config{endpointslice.yaml,trustworthy-jwt.yaml}).
    --kind-config)
    KIND_CONFIG=$2
    shift 2
    ;;
    --skip-setup)
      SKIP_SETUP=true
      shift
    ;;
    --skip-cleanup)
      SKIP_CLEANUP=true
      shift
    ;;
    --skip-build)
      SKIP_BUILD=true