doDelete(entity, null);
    }

    public int queryDelete(CBCall<RequestHeaderCB> cbLambda) {
        return doQueryDelete(createCB(cbLambda), null);
    }

    public int[] batchInsert(List<RequestHeader> list) {
        return batchInsert(list, null, null);
    }

    public int[] batchInsert(List<RequestHeader> list, RequestOptionCall<BulkRequestBuilder> call) {

        doDelete(entity, null);
    }

    public int queryDelete(CBCall<ThumbnailQueueCB> cbLambda) {
        return doQueryDelete(createCB(cbLambda), null);
    }

    public int[] batchInsert(List<ThumbnailQueue> list) {
        return batchInsert(list, null, null);
    }

    public int[] batchInsert(List<ThumbnailQueue> list, RequestOptionCall<BulkRequestBuilder> call) {

package dsync

import (
	"math/rand"
	"time"
)

func backoffWait(minSleep, unit, maxSleep time.Duration) func(*rand.Rand, uint) time.Duration {
	if unit > time.Hour {
		// Protect against integer overflow
		panic("unit cannot exceed one hour")
	}
	return func(r *rand.Rand, attempt uint) time.Duration {
		sleep := minSleep
		sleep += unit * time.Duration(attempt)
		if sleep > maxSleep {
			sleep = maxSleep
		}

     * @param len
     *            read up to <code>len</code> bytes
     * @return number of bytes read
     * @throws SmbException if an I/O error occurs during read
     */
    int read(byte[] b, int off, int len) throws SmbException;

    /**
     * Current position in file
     *
     * @return current position
     */
    long getFilePointer();

    /**
     * Seek to new position
     *

                            "name": "item_id",
                            "in": "path",
                        }
                    ],
                }
            },
            "/path/int/{item_id}": {
                "get": {
                    "responses": {
                        "200": {
                            "description": "Successful Response",

  private final char[][] replacements;
  // The number of elements in the replacement array.
  private final int replacementsLength;
  // The first code point in the safe range.
  private final int safeMin;
  // The last code point in the safe range.
  private final int safeMax;

  // Cropped values used in the fast path range checks.
  private final char safeMinChar;
  private final char safeMaxChar;

    /**
     *
     */
    private static final long serialVersionUID = -6113895861333916945L;

    static String getMessageByDcerpcError(final int errcode) {
        int min = 0;
        int max = DCERPC_FAULT_CODES.length;

        while (max >= min) {
            final int mid = (min + max) / 2;

            if (errcode > DCERPC_FAULT_CODES[mid]) {
                min = mid + 1;

    private static final int MAX_LOG_PREFIX_SIZE = 8; // "[ERROR] "
    private static final int PROJECT_STATUS_SUFFIX_SIZE = 20; // "SUCCESS [  0.000 s]"
    private static final int MIN_TERMINAL_WIDTH = 60;
    private static final int DEFAULT_TERMINAL_WIDTH = 80;
    private static final int MAX_TERMINAL_WIDTH = 130;
    private static final int MAX_PADDED_BUILD_TIME_DURATION_LENGTH = 9;

        private final long accountsLocked;
        private final long ipsBlocked;
        private final int activeAccounts;
        private final int activeIps;

        public RateLimiterStats(long totalBlocked, long accountsLocked, long ipsBlocked, int activeAccounts, int activeIps) {
            this.totalBlocked = totalBlocked;
            this.accountsLocked = accountsLocked;

      @ParametricNullness T left, @ParametricNullness T right, Comparator<T> comparator);

  /**
   * Compares two {@code int} values as specified by {@link Integer#compare}, <i>if</i> the result
   * of this comparison chain has not already been determined.
   */
  public abstract ComparisonChain compare(int left, int right);

  /**
   * Compares two {@code long} values as specified by {@link Long#compare}, <i>if</i> the result of