// Set SMB 3.1.1 dialect and 1 context
        SMBUtil.writeInt2(0x0311, buffer, 4);
        SMBUtil.writeInt2(1, buffer, 6);
        SMBUtil.writeInt4(100, buffer, 60); // Context offset

        // At context position, set data that extends beyond buffer
        int contextPos = 164; // 100 + 64 (header start)
        if (contextPos + 8 < buffer.length) {
            SMBUtil.writeInt2(1, buffer, contextPos); // Context type

   * k) worst case.
   */
  private void trim() {
    int left = 0;
    int right = 2 * k - 1;

    int minThresholdPosition = 0;
    // The leftmost position at which the greatest of the k lower elements
    // -- the new value of threshold -- might be found.

    int iterations = 0;
    int maxIterations = IntMath.log2(right - left, RoundingMode.CEILING) * 3;

   *     {@link ByteOrder#LITTLE_ENDIAN}, to which a BYTES-long byte representation of this instance
   *     is written. In the process increases the position of {@link ByteBuffer} by BYTES.
   */
  void writeTo(ByteBuffer buffer) {
    checkNotNull(buffer);
    checkArgument(
        buffer.remaining() >= BYTES,

        pad8Method.setAccessible(true);

        // Test various positions
        int[] positions = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 15, 16 };
        for (int pos : positions) {
            int padding = (int) pad8Method.invoke(req, pos);

            // Verify padding makes position 8-byte aligned
            assertEquals(0, (pos + padding) % 8);
        }
    }

    @Test

     * @return the allocationSize
     */
    public final long getAllocationSize() {
        return this.allocationSize;
    }

    /**
     * Get the end of file position
     * @return the endOfFile
     */
    public final long getEndOfFile() {
        return this.endOfFile;
    }

    /**
     * {@inheritDoc}
     *

		}
		if !meta.IsValid() {
			inconsistent++
			continue
		}
		if meta.XLV1 != fi.XLV1 {
			inconsistent++
			continue
		}
		// check if erasure distribution order matches the index
		// position if this is not correct we discard the disk
		// and move to collect others
		if distribution[i] != meta.Erasure.Index {
			inconsistent++ // keep track of inconsistent entries
			continue
		}

 *    no pinning will be enforced if additional prefixes are present, or if no prefixes are present.
 *
 * Note that any other form is unsupported. You may not use asterisks in any position other than
 * the leftmost label.
 *
 * If multiple patterns match a hostname, any match is sufficient. For example, suppose pin A

    for (int i = start; i < end; i++) {
      if (array[i] == target) {
        return i;
      }
    }
    return -1;
  }

  /**
   * Returns the start position of the first occurrence of the specified {@code target} within
   * {@code array}, or {@code -1} if there is no such occurrence.
   *

    for (int i = start; i < end; i++) {
      if (array[i] == target) {
        return i;
      }
    }
    return -1;
  }

  /**
   * Returns the start position of the first occurrence of the specified {@code target} within
   * {@code array}, or {@code -1} if there is no such occurrence.
   *

                continue;
            }
            return false;
        }
        return true;
    }

    /**
     * If the argument type at the specified position is a number, converts the argument to match the type.
     *
     * @param paramTypes
     *            array of parameter types
     * @param args
     *            array of arguments
     * @param index