* CRC(x ^ y) == CRC(x) ^ CRC(y).  The approach we take is to break the message as follows,
     * with each letter representing a 4-byte word: ABCDABCDABCDABCD... and to calculate
     * CRC(A000A000A000...), CRC(0B000B000B...), CRC(00C000C000C...), CRC(000D000D000D...)
     * and then to XOR them together.  The strideTable enables us to hash an int followed by 12

			return nil, ObjectInfo{}, err
		}
		b, err := io.ReadAll(gr)
		gr.Close()
		if err != nil {
			return nil, ObjectInfo{}, err
		}
		if size > len(b) {
			size = len(b)
		}

		// Calculate the object real size if encrypted
		if _, ok := crypto.IsEncrypted(gr.ObjInfo.UserDefined); ok {
			objSize, err = gr.ObjInfo.DecryptedSize()
			if err != nil {
				return nil, ObjectInfo{}, err
			}
		} else {

        // MS-SMB2 3.2.4.1.6: Alternative Channel Creation
        // Channel binding requires SMB2_SESSION_FLAG_BINDING (0x01) in session setup

        // Calculate channel binding hash per MS-SMB2 3.2.5.3.1
        byte[] bindingInfo = calculateBindingInfo(channel);
        byte[] bindingHash = calculateBindingHash(bindingInfo);
        channel.setBindingHash(bindingHash);

    "testProject" : "santaTrackerAndroidBuild",
    "linux" : 461,
    "windows" : 823,
    "macOs" : 385
  } ]
}, {
  "scenario" : "org.gradle.performance.regression.android.RealLifeAndroidBuildPerformanceTest.calculate task graph with test finalizer",
  "durations" : [ {
    "testProject" : "largeAndroidBuild",
    "linux" : 501
  } ]
}, {

            + Long.numberOfLeadingZeros(b)
            + Long.numberOfLeadingZeros(~b);
    if (leadingZeros > Long.SIZE + 1) {
      return a * b;
    }
    // the return value if we will overflow (which we calculate by overflowing a long :) )
    long limit = Long.MAX_VALUE + ((a ^ b) >>> (Long.SIZE - 1));
    if (leadingZeros < Long.SIZE | (a < 0 & b == Long.MIN_VALUE)) {
      // overflow
      return limit;
    }

        // When
        boolean valid = response.isValid(mockContext, mockRequest);

        // Then
        assertTrue(valid);
    }

    @Test
    @DisplayName("Should calculate buffer sizes correctly")
    void testBufferSizeCalculations() throws Exception {
        // Given
        setResponseAsReceived(response);
        setPrivateField(response, "dialectRevision", 0x0300);

	// was requested, fetch content without decrypting.
	if opts.Transition.RestoreRequest != nil || opts.NoDecryption {
		isEncrypted = false
		isCompressed = false
	}

	// Calculate range to read (different for encrypted/compressed objects)
	switch {
	case isCompressed:
		var firstPart int
		if opts.PartNumber > 0 {
			// firstPart is an index to Parts slice,

    FailedService(Service service) {
      super(
          service.toString(),
          service.failureCause(),
          false /* don't enable suppression */,
          false /* don't calculate a stack trace. */);
    }
  }

 *     throw new IllegalArgumentException("input is negative: " + value);
 *   }
 *   // calculate square root
 * }
 * }
 *
 * <p>to be replaced with the more compact
 *
 * {@snippet :
 * public static double sqrt(double value) {
 *   checkArgument(value >= 0, "input is negative: %s", value);
 *   // calculate square root
 * }
 * }
 *
 * <p>so that a hypothetical bad caller of this method, such as:
 *

          <type>String</type>
          <required>true</required>
          <description>
            The Java type for this parameter. This is used to validate the result of any expressions used to calculate
            the value which should be injected into the Mojo for this parameter.
          </description>
        </field>
        <field>
          <name>required</name>
          <version>1.0.0+</version>