this.h1 = seed;
      this.length = 0;
      isDone = false;
    }

    private void update(int nBytes, long update) {
      // 1 <= nBytes <= 4
      buffer |= (update & 0xFFFFFFFFL) << shift;
      shift += nBytes * 8;
      length += nBytes;

      if (shift >= 32) {
        h1 = mixH1(h1, mixK1((int) buffer));
        buffer >>>= 32;
        shift -= 32;
      }
    }

        }
    }

    @Test
    void testLargeBatchParameters() {
        // Test with maximum allowed values
        int maxSid = 0xFFFF;
        int maxResumeKey = 0x7FFFFFFF;
        int maxBatchCount = 65535;
        int maxBatchSize = 65535;

        trans2FindNext2 = new Trans2FindNext2(config, maxSid, maxResumeKey, TEST_FILENAME, maxBatchCount, maxBatchSize);

	AND	$0xff00ff, R2                       // AND	$16711935, R2                   // fb1f80d2fb1fa0f242001b8a
	AND	$0xff00ffff, R1                     // AND	$4278255615, R1                 // fbff9fd21be0bff221001b8a
	ANDS	$0xffff, R2                         // ANDS	$65535, R2                      // 423c40f2
	AND	$0x7fffffff, R3                     // AND	$2147483647, R3                 // 63784092

            this.sub_authority = new int[this.sub_authority_count];
            for (int i = 0; i < this.sub_authority_count; i++) {
                this.sub_authority[i] = (int) (Long.parseLong(st.nextToken()) & 0xFFFFFFFFL);
            }
        }
    }

    /**
     * Construct a SID from a domain SID and an RID
     * (relative identifier). For example, a domain SID

            assertArrayEquals(token, actualToken);
        }
    }

    @ParameterizedTest
    @CsvSource({ "0x00, 0x00000000", "0x01, 0x00000001", "0x03, 0x0000000F", "0xFF, 0x7FFFFFFF" })
    @DisplayName("Should handle various security modes and capabilities")
    void testVariousSecurityModesAndCapabilities(String securityModeHex, String capabilitiesHex) throws Exception {
        // Given

      }

      @Override
      long mulMod(long a, long b, long m) {
        long aHi = a >>> 32; // < 2^31
        long bHi = b >>> 32; // < 2^31
        long aLo = a & 0xFFFFFFFFL; // < 2^32
        long bLo = b & 0xFFFFFFFFL; // < 2^32

        /*
         * a * b == aHi * bHi * 2^64 + (aHi * bLo + aLo * bHi) * 2^32 + aLo * bLo.
         *       == (aHi * bHi * 2^32 + aHi * bLo + aLo * bHi) * 2^32 + aLo * bLo

                final SmbComWriteResponse rsp = new SmbComWriteResponse(th.getConfig());
                th.send(new SmbComWrite(th.getConfig(), fh.getFid(), (int) (newLength & 0xFFFFFFFFL), 0, this.tmp, 0, 0), rsp,
                        RequestParam.NO_RETRY);
            }
        } catch (final CIFSException e) {
            throw SmbException.wrap(e);
        }
    }

    @Override

	TST $0xfffffff0, LR                        // TST $4294967280, R30          // df6f7cf2
	TSTW R10@>21, R2                           // 5f54ca6a
	TST R17<<11, R24                           // 1f2f11ea
	ANDSW $0x80000007, R9, ZR                  // ANDSW   $2147483655, R9, ZR   // 3f0d0172
	ANDS $0xfffffff0, LR, ZR                   // ANDS    $4294967280, R30, ZR  // df6f7cf2

    assertBytes(0xe0 or 31, 154, 10)
  }

  @Test
  fun max31BitValue() {
    hpackWriter!!.writeInt(0x7fffffff, 31, 0)
    assertBytes(31, 224, 255, 255, 255, 7)
    assertThat(newReader(byteStream(224, 255, 255, 255, 7)).readInt(31, 31))
      .isEqualTo(0x7fffffff)
  }

  @Test
  fun prefixMask() {
    hpackWriter!!.writeInt(31, 31, 0)
    assertBytes(31, 0)

 * primitive utilities</a>.
 *
 * @author Louis Wasserman
 * @since 11.0
 */
@GwtCompatible
public final class UnsignedInts {
  static final long INT_MASK = 0xffffffffL;

  private UnsignedInts() {}

  static int flip(int value) {
    return value ^ Integer.MIN_VALUE;
  }

  /**