dst[dstIndex + 2] = (byte) (val >> 16);
        dst[dstIndex + 3] = (byte) (val >> 24);
    }

    private void writeInt8(long val, byte[] dst, int dstIndex) {
        writeInt4((int) (val & 0xFFFFFFFFL), dst, dstIndex);
        writeInt4((int) (val >> 32), dst, dstIndex + 4);
    }

    private void writeTime(long t, byte[] dst, int dstIndex) {
        writeInt8(t, dst, dstIndex);
    }

        this.call = (pipe.getPipeType() & SmbPipeResource.PIPE_TYPE_CALL) == SmbPipeResource.PIPE_TYPE_CALL;
        this.openFlags = pipe.getPipeType() & 0xFFFF00FF | SmbConstants.O_EXCL;
        this.access = pipe.getPipeType() & 7 | 0x20000;
        this.uncPath = this.pipe.getUncPath();
    }

    /**
     * {@inheritDoc}
     *

      }

      @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

        }
    }

    @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);

            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

            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

    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;
  }

  /**

  @Override
  <E extends Comparable<E>> ImmutableSortedSet.Builder<E> builder() {
    return ImmutableSortedSet.naturalOrder();
  }

  @Override
  int getComplexBuilderSetLastElement() {
    return 0x00FFFFFF;
  }

  public void testLegacyComparable_of() {
    ImmutableSortedSet<LegacyComparable> set0 = ImmutableSortedSet.of();
    assertThat(set0).isEmpty();

            this.largeReadX = true;
            this.readSizeFile =
                    Math.min(th.getConfig().getReceiveBufferSize() - 70, th.areSignaturesActive() ? 0xFFFF - 70 : 0xFFFFFF - 70);
            log.debug("Enabling LARGE_READX with " + this.readSizeFile);
        } else {
            log.debug("LARGE_READX disabled");
            this.readSizeFile = this.readSize;
        }