for i := 0; i < 10; i++ {
		if err := batch.Add(99, 99); err != nil {
			t.Fatalf("failed to add duplicate item %v to batch after Get; %v", i, err)
		}
	}
	if _, ok := batch.GetByKey(99); !ok {
		t.Fatal("failed to get the duplicxate item by key '99' after adding")
	}
	keys, items, err = batch.GetAll()
	if err != nil {
		t.Fatalf("unable to get the items from the batch; %v", err)
	}
	if len(items) != 1 {

00000010  a9 75 5b a6 8f 9f 47 6f  fe e7 3d 3e 5c d8 35 01  |.u[...Go..=>\.5.|
00000020  c9 25 fd 94 e4 ac 7e b4  e1 4e 0f 20 56 29 44 cd  |.%....~..N. V)D.|
00000030  7f 99 7b a6 9a 4d d4 3c  e8 01 00 93 e5 e0 a8 7b  |..{..M.<.......{|
00000040  81 13 85 e9 2e 4e 12 a2  b9 d4 7d 8e 00 04 13 03  |.....N....}.....|
00000050  00 ff 01 00 00 91 00 0b  00 04 03 00 01 02 00 0a  |................|

    }
  }

  public static final class BytesAsListTailSubListGenerator extends TestByteListGenerator {
    @Override
    protected List<Byte> create(Byte[] elements) {
      Byte[] prefix = {(byte) 86, (byte) 99};
      Byte[] all = concat(prefix, elements);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  public static final class BytesAsListMiddleSubListGenerator extends TestByteListGenerator {

  }

  public static final class CharsAsListTailSubListGenerator extends TestCharListGenerator {
    @Override
    protected List<Character> create(Character[] elements) {
      Character[] prefix = {(char) 86, (char) 99};
      Character[] all = concat(prefix, elements);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  public static final class CharsAsListMiddleSubListGenerator extends TestCharListGenerator {

    }
  }

  public static final class DoublesAsListTailSubListGenerator extends TestDoubleListGenerator {
    @Override
    protected List<Double> create(Double[] elements) {
      Double[] prefix = {(double) 86, (double) 99};
      Double[] all = concat(prefix, elements);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  public static final class DoublesAsListMiddleSubListGenerator extends TestDoubleListGenerator {

00000050  bf 95 e4 ea b8 74 e7 99  d4 c4 53 f5 97 f5 08 f9  |.....t....S.....|
00000060  ef 03 e7 76 b8 2c 31 f6  9b 2c cd 27 c8 42 6a a8  |...v.,1..,.'.Bj.|
00000070  c0 e0 b9 5e cd                                    |...^.|
>>> Flow 4 (server to client)
00000000  14 03 03 00 01 01 16 03  03 00 40 89 35 48 2e 99  |..........@.5H..|

    }
  }

  public static final class IntsAsListTailSubListGenerator extends TestIntegerListGenerator {
    @Override
    protected List<Integer> create(Integer[] elements) {
      Integer[] prefix = {(int) 86, (int) 99};
      Integer[] all = concat(prefix, elements);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  public static final class IntsAsListMiddleSubListGenerator extends TestIntegerListGenerator {

	f := new(big.Float)
	_, err := fmt.Sscan("1.19282e99", f)
	if err != nil {
		log.Println("error scanning value:", err)
	} else {
		fmt.Println(f)
	}
	// Output: 1.19282e+99
}

// This example demonstrates how to use big.Int to compute the smallest
// Fibonacci number with 100 decimal digits and to test whether it is prime.
func Example_fibonacci() {

    }
  }

  public static final class LongsAsListTailSubListGenerator extends TestLongListGenerator {
    @Override
    protected List<Long> create(Long[] elements) {
      Long[] prefix = {(long) 86, (long) 99};
      Long[] all = concat(prefix, elements);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  public static final class LongsAsListMiddleSubListGenerator extends TestLongListGenerator {

    }
  }

  public static final class ShortsAsListTailSubListGenerator extends TestShortListGenerator {
    @Override
    protected List<Short> create(Short[] elements) {
      Short[] prefix = {(short) 86, (short) 99};
      Short[] all = concat(prefix, elements);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  public static final class ShortsAsListMiddleSubListGenerator extends TestShortListGenerator {