// Just returning an Integer with the index here is faster, but requires a lot of if/then/else to check for
            // -1
            //  or QUALIFIERS.size and then resort to lexical ordering. Most comparisons are decided by the first
            // character,
            // so this is still fast. If more characters are needed then it requires a lexical sort anyway.

pkg debug/plan9obj, type FileHeader struct, HdrSize uint64
pkg debug/plan9obj, type FileHeader struct, LoadAddress uint64

# CL 122960043 encoding/xml: add InputOffset method to Decoder, Russ Cox <******@****.***>
pkg encoding/xml, method (*Decoder) InputOffset() int64

# CL 124940043 cmd/go, go/build: implement import comment checking, Russ Cox <******@****.***>
pkg go/build, const ImportComment = 4

        final int idx = name.lastIndexOf('/');
        if (idx >= 0) {
            name = name.substring(idx + 1);
        }
        try {
            return URLDecoder.decode(name, enc);
        } catch (final Exception e) {
            return name;
        }
    }

    /**
     * Get the host on file.
     * @param url The URL.
     * @return The host on file.

      output = subprocess.check_output(cmd, stderr=stderr)
    except subprocess.CalledProcessError as e:
      output = e.output
  else:
    output = subprocess.check_output(cmd, stderr=stderr)
  return output.decode('UTF-8').strip()


def cygpath(path):
  """Convert path from posix to windows."""
  return os.path.abspath(path).replace('\\', '/')


def get_python_path(environ_cp, python_bin_path):

                    return;
                }
            } else { /* Basic */
                final String auth = new String(Base64.decode(msg.substring(6)), "US-ASCII");
                int index = auth.indexOf(':');
                String user = index != -1 ? auth.substring(0, index) : auth;

   * </ul>
   *
   * @throws NumberFormatException if the string does not contain a valid unsigned {@code int} value
   * @since 13.0
   */
  @CanIgnoreReturnValue
  public static int decode(String stringValue) {
    ParseRequest request = ParseRequest.fromString(stringValue);

    try {
      return parseUnsignedInt(request.rawValue, request.radix);
    } catch (NumberFormatException e) {

        if (data == null || data.length == 0) {
            return;
        }

        QueryNetworkInterfaceInfoResponse response = new QueryNetworkInterfaceInfoResponse();
        response.decode(data, 0, data.length);

        for (NetworkInterfaceInfo info : response.getInterfaces()) {
            if (info.isUsableForChannel()) {
                remoteInterfaces.add(info);
            }
        }

     */
    public byte[] decryptMessage(final byte[] encryptedMessage) throws CIFSException {
        try {
            // Parse transform header
            final Smb2TransformHeader transformHeader = Smb2TransformHeader.decode(encryptedMessage, 0);
            final byte[] associatedData = transformHeader.getAssociatedData();
            byte[] nonce = transformHeader.getNonce();
            final byte[] authTag = transformHeader.getSignature();

                if ((ntlm = NtlmSsp.authenticate(req, resp, challenge)) == null) {
                    return;
                }
            } else { /* Basic */
                final String auth = new String(Base64.decode(msg.substring(6)), "US-ASCII");
                int index = auth.indexOf(':');
                String user = index != -1 ? auth.substring(0, index) : auth;

		}
		mac := hmac.New(sha256.New, key)
		mac.Write([]byte(baseKey))
		return sio.DecryptBuffer(nil, input, sio.Config{Key: mac.Sum(nil)})
	}
}

// decryptPartsChecksums will attempt to decrypt and decode part checksums, and save
// only the decrypted part checksum values on ObjectInfo directly.
// if part > 0, and we have the checksum for the part that will be returned.