case 0:
			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
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGenerated

		return "BE"
	}
	return "LE"
}

// A Shift describes an ARM shift operation.
type Shift uint8

const (
	ShiftLeft        Shift = 0 // left shift
	ShiftRight       Shift = 1 // logical (unsigned) right shift
	ShiftRightSigned Shift = 2 // arithmetic (signed) right shift
	RotateRight      Shift = 3 // right rotate
	RotateRightExt   Shift = 4 // right rotate through carry (Count will always be 1)
)

// as well as
// https://github.com/llvm/llvm-project/blob/704d92607d26e696daba596b72cb70effe79a872/compiler-rt/lib/fuzzer/FuzzerValueBitMap.h#L34
// ValueProfileMap.AddValue() truncates its argument to 16 bits and shifts the
// PC to the left by log_2(128)=7, which means that only the lowest 16 - 7 bits
// of the return address matter. String compare hooks use the lowest 12 bits,

			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

            ${testedComponentDsl} {
                sourceCompatibility = SwiftVersion.SWIFT3
            }

            task verifyBinariesSwiftVersion {
                doLast {
                    ${componentUnderTestDsl}.binaries.get().each {
                        assert it.targetPlatform.sourceCompatibility == SwiftVersion.SWIFT3
                    }
                }
            }
        """

  // 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; \