{"XYZ?", 36, false, nat{(33*36+34)*36 + 35}, 36, 3, nil, '?'},
	{"XYZ?", 62, false, nat{(59*62+60)*62 + 61}, 62, 3, nil, '?'},
	{"0x", 16, false, nil, 16, 1, nil, 'x'},
	{"0xdeadbeef", 0, false, nat{0xdeadbeef}, 16, 8, nil, 0},
	{"0XDEADBEEF", 0, false, nat{0xdeadbeef}, 16, 8, nil, 0},

	// valid, with decimal point
	{"0.", 0, false, nil, 10, 1, nil, '.'},
	{"0.", 10, true, nil, 10, 0, nil, 0},

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

// issue 5515: miscompilation doing inlining in generated method wrapper

package main

type T uint32

func main() {
        b := make([]T, 8)
        b[0] = 0xdeadbeef
        rs := Slice(b)
        sort(rs)
}

type Slice []T

func (s Slice) Swap(i, j int) {
        tmp := s[i]
        s[i] = s[j]
        s[j] = tmp
}

type Interface interface {

		a[i] = byte(i)
	}
}

func k0(a [100]int) [100]int {
	for i := 10; i < 90; i++ { // ERROR "Induction variable: limits \[10,90\), increment 1$"
		if a[0] == 0xdeadbeef {
			// This is a trick to prohibit sccp to optimize out the following out of bound check
			continue
		}
		a[i-11] = i
		a[i-10] = i // ERROR "(\([0-9]+\) )?Proved IsInBounds$"

  int size;

  String data;

  @BeforeExperiment
  public void setUp() {
    // precalculate some random strings of ascii characters.
    StringBuilder sb = new StringBuilder();
    Random random = new Random(0xdeadbeef); // for unpredictable but reproducible behavior
    sb.ensureCapacity(size);
    for (int k = 0; k < size; k++) {
      // [9-127) includes all ascii non-control characters

    stripes = new int[numStripes];
    for (int i = 0; i < numStripes; i++) {
      stripes[i] = i;
    }
    List<Integer> asList = Ints.asList(stripes);
    Collections.shuffle(asList, new Random(0xdeadbeef));

    // do bulk gets with exactly 10 keys (possibly <10 stripes) (or less if numStripes is smaller)
    bulkGetSet = ImmutableList.copyOf(limit(cycle(asList), 10));
  }

  @Footprint
  Object sizeOfStriped() {

  int nonAlphaRatio; // one non-alpha char per this many chars

  @Param boolean noWorkToDo;

  Random random;
  String testString;

  @BeforeExperiment
  void setUp() {
    random = new Random(0xdeadbeef); // fix the seed so results are comparable across runs

    int nonAlpha = size / nonAlphaRatio;
    int alpha = size - nonAlpha;

    List<Character> chars = Lists.newArrayListWithCapacity(size);

def TFL_ConstBytesAttr : AttrDef<TFL_Dialect, "ConstBytes"> {
  let summary = "A string attribute representation of compiled bytes";
  let description = [{
    Syntax Examples:

    ```mlir
    #tfl<const_bytes : "0xDEADBEEF">
    ```
  }];
  let mnemonic = "const_bytes";
  let parameters = (ins StringRefParameter<"">:$value);
  let hasCustomAssemblyFormat = 1;
}

	{"13+0i", true, true, true, true, 13, 13, 13, 13},
	// funny bases
	{"0123", true, true, true, false, 0123, 0123, 0123, 0},
	{"-0x0", true, true, true, false, 0, 0, 0, 0},
	{"0xdeadbeef", true, true, true, false, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0},
	// character constants
	{`'a'`, true, true, true, false, 'a', 'a', 'a', 0},
	{`'\n'`, true, true, true, false, '\n', '\n', '\n', 0},
	{`'\\'`, true, true, true, false, '\\', '\\', '\\', 0},

  int nonAlphaRatio; // one non-alpha char per this many chars

  @Param boolean noWorkToDo;

  Random random;
  String testString;

  @BeforeExperiment
  void setUp() {
    random = new Random(0xdeadbeef); // fix the seed so results are comparable across runs

    int nonAlpha = size / nonAlphaRatio;
    int alpha = size - nonAlpha;

    List<Character> chars = Lists.newArrayListWithCapacity(size);

  Charset charset;
  ByteSource data;

  @BeforeExperiment
  public void setUp() {
    charset = Charset.forName(charsetName);
    StringBuilder sb = new StringBuilder();
    Random random = new Random(0xdeadbeef); // for unpredictable but reproducible behavior
    sb.ensureCapacity(size);
    for (int k = 0; k < size; k++) {
      // [9-127) includes all ascii non-control characters