* @param a the first {@code int} to compare
   * @param b the second {@code int} to compare
   * @return a negative value if {@code a} is less than {@code b}; a positive value if {@code a} is
   *     greater than {@code b}; or zero if they are equal
   */
  @InlineMe(replacement = "Integer.compare(a, b)")
  public static int compare(int a, int b) {
    return Integer.compare(a, b);
  }

  /**

	"context"
	"errors"
	"fmt"
	"io"
	"strings"

	"github.com/minio/madmin-go/v3"
	xhttp "github.com/minio/minio/internal/http"
)

// WarmBackendGetOpts is used to express byte ranges within an object. The zero
// value represents the entire byte range of an object.
type WarmBackendGetOpts struct {
	startOffset int64
	length      int64
}

// WarmBackend provides interface to be implemented by remote tier backends

		tags := make(map[string]any, len(reqInfo.tags))
		for _, t := range reqInfo.tags {
			tags[t.Key] = t.Val
		}
		entry.Tags = tags
		// ignore cases for ttfb when its zero.
		if timeToFirstByte != 0 {
			entry.API.TimeToFirstByte = strconv.FormatInt(timeToFirstByte.Nanoseconds(), 10) + "ns"
			entry.API.TimeToFirstByteInNS = strconv.FormatInt(timeToFirstByte.Nanoseconds(), 10)
		}
	} else {

        // Test negative value
        FileEndOfFileInformation info1 = new FileEndOfFileInformation(-100L);
        assertEquals("EndOfFileInformation[endOfFile=-100]", info1.toString());

        // Test zero
        FileEndOfFileInformation info2 = new FileEndOfFileInformation(0L);
        assertEquals("EndOfFileInformation[endOfFile=0]", info2.toString());

        // Test max value

- **Composite**: NormalizerChain, ReadingConverterChain
- **Strategy**: Normalizer, ReadingConverter, ContentsParser
- **Deferred/Promise**: Async operations

### Index Alias Strategy

Zero-downtime index updates using dual aliases:

```
Index Naming: {baseIndex}.{timestamp}
Example:      my-suggest.20250123120000

Aliases:
├── Search Alias: {baseIndex}          (read operations)

        return 0;
    }

    @Override
    protected int readParametersWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        // observed two zero bytes here with at least win98
        return 2;
    }

    @Override
    protected int readDataWireFormat(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {

        dstIndex += 4;

        SMBUtil.writeInt4(leaseFlags, dst, dstIndex); // LeaseFlags (4 bytes)
        dstIndex += 4;

        SMBUtil.writeInt8(0, dst, dstIndex); // LeaseDuration (8 bytes) - reserved, must be zero
        dstIndex += 8;

        return dstIndex - start;
    }

// having zero bytes. As such, the encoding and decoding logic in this package
// deals with sparseDatas.
//
// However, the external API uses sparseHoles instead of sparseDatas because the
// zero value of sparseHoles logically represents a normal file (i.e., there are
// no holes in it). On the other hand, the zero value of sparseDatas implies

        Smb2LeaseKey key = new Smb2LeaseKey(testBytes);

        assertArrayEquals(testBytes, key.getKey());
        assertFalse(key.isZero());
    }

    @Test
    @DisplayName("Should create zero lease key")
    void testZeroLeaseKey() {
        byte[] zeroBytes = new byte[16];
        Arrays.fill(zeroBytes, (byte) 0);

        Smb2LeaseKey key = new Smb2LeaseKey(zeroBytes);

        assertTrue(key.isZero());

      ) {
        exchange.noNewExchangesOnConnection()
      }
      if ((code == 204 || code == 205) && response.body.contentLength() > 0L) {
        throw ProtocolException(
          "HTTP $code had non-zero Content-Length: ${response.body.contentLength()}",
        )
      }
      return response
    } catch (e: IOException) {
      if (sendRequestException != null) {
        sendRequestException.addSuppressed(e)