return Integer.reverseBytes(this.dis.readInt());
    }


    public long readLong () throws IOException {
        align(8);
        return Long.reverseBytes(this.dis.readLong());
    }


    public int readUnsignedByte () throws IOException {
        return ( readByte() ) & 0xff;
    }


    public long readUnsignedInt () throws IOException {
        return ( readInt() ) & 0xffffffffL;
    }

    }

    @Override
    @CheckForNull
    public Long previous(Long value) {
      long l = value;
      return (l == Long.MIN_VALUE) ? null : l - 1;
    }

    @Override
    Long offset(Long origin, long distance) {
      checkNonnegative(distance, "distance");
      long result = origin + distance;
      if (result < 0) {
        checkArgument(origin < 0, "overflow");
      }

     * @param ts
     */
    public AvTimestamp ( long ts ) {
        this(encode(ts));
    }


    /**
     * @param ts
     * @return
     */
    private static byte[] encode ( long ts ) {
        byte[] data = new byte[8];
        SMBUtil.writeInt8(ts, data, 0);
        return data;
    }


    /**
     * @return the timestamp
     */
    public long getTimestamp () {

                      SmbConstants.FILE_NO_SHARE) ) {
                long mtime = src.lastModified();
                long ctime = src.createTime();
                long atime = src.lastAccess();
                int i = 0;
                long off = 0L;
                while ( true ) {
                    int read = fis.read(b[ i ]);
                    synchronized ( w ) {

   */
  public long sum() {
    return map.values().stream().mapToLong(Long::longValue).sum();
  }

  @LazyInit @CheckForNull private transient Map<K, Long> asMap;

  /** Returns a live, read-only view of the map backing this {@code AtomicLongMap}. */
  public Map<K, Long> asMap() {
    Map<K, Long> result = asMap;
    return (result == null) ? asMap = createAsMap() : result;

  /** Invokes {@code unit.}{@link TimeUnit#sleep(long) sleep(sleepFor)} uninterruptibly. */
  @J2ktIncompatible
  @GwtIncompatible // concurrency
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  public static void sleepUninterruptibly(long sleepFor, TimeUnit unit) {
    boolean interrupted = false;
    try {
      long remainingNanos = unit.toNanos(sleepFor);
      long end = System.nanoTime() + remainingNanos;

		{`C:\`, `C:\`},
		{`C:`, `C:`},
		// The "long" substring is replaced by a looooooong
		// string which triggers the rewriting. Except in the
		// cases below where it doesn't.
		{`C:\long\foo.txt`, `\\?\C:\long\foo.txt`},
		{`C:/long/foo.txt`, `\\?\C:\long\foo.txt`},
		{`C:\long\foo\\bar\.\baz\\`, `\\?\C:\long\foo\bar\baz`},
		{`\\unc\path`, `\\unc\path`},
		{`long.txt`, `long.txt`},
		{`C:long.txt`, `C:long.txt`},

  - login: cryptapi
    avatarUrl: https://avatars.githubusercontent.com/u/44925437?u=61369138589bc7fee6c417f3fbd50fbd38286cc4&v=4
    url: https://github.com/cryptapi
  - login: Kong
    avatarUrl: https://avatars.githubusercontent.com/u/962416?v=4
    url: https://github.com/Kong
  - login: codacy
    avatarUrl: https://avatars.githubusercontent.com/u/1834093?v=4
    url: https://github.com/codacy
  - login: scalar

public class AccessToken extends BsAccessToken {

    private static final long serialVersionUID = 1L;

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {
        return asDocMeta().version();
    }

    public void setVersionNo(final Long version) {
        asDocMeta().version(version);
    }

    protected final boolean hasError;
    protected final List<Throwable> errors = new ArrayList<>();
    protected final long took;

    protected SuggestIndexResponse(final int numberOfSuggestDocs, final int numberOfInputDocs, final List<Throwable> errors,
            final long took) {
        this.numberOfSuggestDocs = numberOfSuggestDocs;
        this.numberOfInputDocs = numberOfInputDocs;
        this.took = took;