ServerMessageBlock2Response resp = (ServerMessageBlock2Response) response;
        synchronized ( resp ) {
            if ( resp.isAsync() && !resp.isAsyncHandled() && resp.getStatus() == NtStatus.NT_STATUS_PENDING && resp.getAsyncId() != 0 ) {
                resp.setAsyncHandled(true);
                boolean first = !req.isAsync();
                req.setAsyncId(resp.getAsyncId());

  }

  @Benchmark
  int collections(int reps) {
    int dummy = 0;
    // Yes, this could be done more elegantly
    if (mutable) {
      for (int i = 0; i < reps; i++) {
        List<Integer> copy = new ArrayList<>(input);
        Collections.sort(copy);
        dummy += copy.get(0);
      }
    } else {
      for (int i = 0; i < reps; i++) {
        List<Integer> copy = new ArrayList<>(input);

  // CRC32C

  @Benchmark
  byte crc32cHashFunction(int reps) {
    return runHashFunction(reps, Hashing.crc32c());
  }

  // Adler32

  @Benchmark
  byte adler32HashFunction(int reps) {
    return runHashFunction(reps, Hashing.adler32());
  }

  @Benchmark
  byte adler32Checksum(int reps) throws Exception {
    byte result = 0x01;
    for (int i = 0; i < reps; i++) {
      Adler32 checksum = new Adler32();

  }

  @Benchmark
  public long timeComplete_Normal(int reps) throws Exception {
    long r = 0;
    List<Facade<Integer>> list = new ArrayList<>(reps);
    for (int i = 0; i < reps; i++) {
      final Facade<Integer> localFuture = impl.newFacade();
      list.add(localFuture);
      localFuture.set(i);
    }
    for (int i = 0; i < reps; i++) {
      r += list.get(i).get();
    }
    return r;
  }

  int hashString_4(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      dummy += Objects.hashCode(S0, S1, S2, S3);
    }
    return dummy;
  }

  @Benchmark
  int hashString_5(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      dummy += Objects.hashCode(S0, S1, S2, S3, S4);
    }
    return dummy;
  }

  @Benchmark
  int hashMixed_5(int reps) {
    int dummy = 0;

	select {
	case <-time.After(a.timeout):
		a.t.Fatalf("did not get response in time")
	case resp := <-a.responses:
		if resp == nil {
			a.t.Fatalf("expected response")
		}
		if resp != nil && (len(resp.RemovedResources) > 0 || len(resp.Resources) > 0) {
			a.t.Fatalf("expected empty response. received %v", resp)
		}
		return resp
	case err := <-a.error:
		a.t.Fatalf("got error: %v", err)
	}
	return nil
}

func (l *lockRESTServer) RefreshHandler(args *dsync.LockArgs) (*dsync.LockResp, *grid.RemoteErr) {
	resp := lockRPCRefresh.NewResponse()
	refreshed, err := l.ll.Refresh(context.Background(), *args)
	if err != nil {
		return l.makeResp(resp, err)
	}
	if !refreshed {
		return l.makeResp(resp, errLockNotFound)
	}
	return l.makeResp(resp, err)
}

// LockHandler - Acquires a lock.

}

func (checker GenericHttpResponseChecker) Check(resp *http.Response) error {
	if resp.StatusCode < http.StatusOK || resp.StatusCode > http.StatusPartialContent {
		defer resp.Body.Close()
		bodyBytes, err := ioutil.ReadAll(io.LimitReader(resp.Body, maxReadLength))
		if err != nil {
			return errors.NewInternalError(err)
		}
		bodyText := string(bodyBytes)

		switch {
		case resp.StatusCode == http.StatusInternalServerError:

  @Benchmark
  int branchFreeLtIntInlined(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & SAMPLE_MASK;
      int x = xInts[j];
      int y = yInts[j];
      int z = constant[j];
      tmp += z + ((x - y) >>> (Integer.SIZE - 1));
    }
    return tmp;
  }

  @Benchmark
  int branchFreeLtInt(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & SAMPLE_MASK;

	if resp != nil && resp.User != nil {
		tokenReview.Status.User = authentication.UserInfo{
			Username: resp.User.GetName(),
			UID:      resp.User.GetUID(),
			Groups:   resp.User.GetGroups(),
			Extra:    map[string]authentication.ExtraValue{},
		}
		for k, v := range resp.User.GetExtra() {
			tokenReview.Status.User.Extra[k] = authentication.ExtraValue(v)
		}
		tokenReview.Status.Audiences = resp.Audiences
	}