writer := newBitrotWriter(disk, "", volume, filePath, 35, bitrotAlgo, 10)

	_, err = writer.Write([]byte("aaaaaaaaaa"))
	if err != nil {
		t.Fatal(err)
	}
	_, err = writer.Write([]byte("aaaaaaaaaa"))
	if err != nil {
		t.Fatal(err)
	}
	_, err = writer.Write([]byte("aaaaaaaaaa"))
	if err != nil {
		t.Fatal(err)
	}
	_, err = writer.Write([]byte("aaaaa"))
	if err != nil {
		t.Fatal(err)
	}

// Test for AppendFile.
func TestAppendFile(t *testing.T) {
	f, err := os.CreateTemp(t.TempDir(), "")
	if err != nil {
		t.Fatal(err)
	}
	name1 := f.Name()
	defer os.Remove(name1)
	f.WriteString("aaaaaaaaaa")
	f.Close()

	f, err = os.CreateTemp(t.TempDir(), "")
	if err != nil {
		t.Fatal(err)
	}
	name2 := f.Name()
	defer os.Remove(name2)
	f.WriteString("bbbbbbbbbb")
	f.Close()

     * fit comfortably within a single ethernet packet (1500 bytes) even with framing overhead.
     *
     * For tests this must be big enough to realize real compression on test messages like
     * 'aaaaaaaaaa...'. Our tests check if compression was applied just by looking at the size if
     * the inbound buffer.
     */
    const val DEFAULT_MINIMUM_DEFLATE_SIZE = 1024L
  }

	SWI.P	$0                 // ERROR "invalid .P suffix"
	MOVW.S	$0xaaaaaaaa, R7    // ERROR "invalid .S suffix"
	MOVW.P	$0xffffff44, R1    // ERROR "invalid .P suffix"
	MOVW.S	$0xffffff77, R1    // ERROR "invalid .S suffix"
	MVN.S	$0xffffffaa, R8    // ERROR "invalid .S suffix"
	MVN.S	$0xaaaaaaaa, R8    // ERROR "invalid .S suffix"
	ADD.U	$0xaaaaaaaa, R4    // ERROR "invalid .U suffix"

        work = (right >>> 8 ^ leftt) & 0x00ff00ff;
        leftt ^= work;
        right ^= work << 8;
        right = right << 1 | right >>> 31 & 1;

        work = (leftt ^ right) & 0xaaaaaaaa;
        leftt ^= work;
        right ^= work;
        leftt = leftt << 1 | leftt >>> 31 & 1;

        for (round = 0; round < 8; ++round) {
            work = right << 28 | right >>> 4;

aaaaaaaaaa aaaaaaaaaa
aaaaaaaaa. aaaaaaaaa.
aaaaaaaaa/ aaaaaaaaa
aaaaaaaa.a aaaaaaaa.a
aaaaaaaa.. aaaaaaaa..
aaaaaaaa./ aaaaaaaa.
aaaaaaaa/a aaaaaaaa/a
aaaaaaaa/. aaaaaaaa
aaaaaaaa// aaaaaaaa
aaaaaaa.aa aaaaaaa.aa
aaaaaaa.a. aaaaaaa.a.
aaaaaaa.a/ aaaaaaa.a
aaaaaaa..a aaaaaaa..a
aaaaaaa... aaaaaaa...
aaaaaaa../ aaaaaaa..
aaaaaaa./a aaaaaaa./a
aaaaaaa./. aaaaaaa.
aaaaaaa.// aaaaaaa.
aaaaaaa/aa aaaaaaa/aa
aaaaaaa/a. aaaaaaa/a.

   * are the "next" pointer (pointing to the next entry in the bucket chain), which will always be
   * less than or equal to the hashtable mask.
   *
   * <pre>
   * hash  = aaaaaaaa
   * mask  = 00000fff
   * next  = 00000bbb
   * entry = aaaaabbb
   * </pre>
   *
   * <p>The pointers in [size(), entries.length) are all "null" (UNSET).
   */

	MOVW	$-0xff(R0), R1       // MOVW $-255(R0), R1        // ff1040e2
	MOVW.S	$-0xff(R0), R1       // MOVW.S $-255(R0), R1      // ff1050e2
	MOVW	$0xffffffae, R1      // MOVW $4294967214, R1      // 5110e0e3
	MOVW	$0xaaaaaaaa, R1      // MOVW $2863311530, R1
	MOVW	R1, (R2)                                          // 001082e5
	MOVW.P	R1, (R2)                                          // 001082e4

  }

  private Heap heapForIndex(int i) {
    return isEvenLevel(i) ? minHeap : maxHeap;
  }

  private static final int EVEN_POWERS_OF_TWO = 0x55555555;
  private static final int ODD_POWERS_OF_TWO = 0xaaaaaaaa;

  @VisibleForTesting
  static boolean isEvenLevel(int index) {
    int oneBased = ~~(index + 1); // for GWT
    checkState(oneBased > 0, "negative index");

   * the "next" pointer (pointing to the next entry in the bucket chain), which will always be less
   * than or equal to the hashtable mask.
   *
   * <pre>
   * hash  = aaaaaaaa
   * mask  = 00000fff
   * next  = 00000bbb
   * entry = aaaaabbb
   * </pre>
   *
   * <p>The pointers in [size(), entries.length) are all "null" (UNSET).
   */