}

  private void setSucceeds(int pred, int succ) {
    if (pred == ENDPOINT) {
      firstEntry = succ;
    } else {
      setSuccessor(pred, succ);
    }

    if (succ == ENDPOINT) {
      lastEntry = pred;
    } else {
      setPredecessor(succ, pred);
    }
  }

  @Override
  void insertEntry(int entryIndex, @ParametricNullness E object, int hash, int mask) {

	var locksHeld int64
	if locksHeld, reply = l.lockMap[args.Resources[0]]; !reply {
		l.lockMap[args.Resources[0]] = ReadLock // No locks held on the given name, so claim (first) read lock
		reply = true
	} else if reply = locksHeld != WriteLock; reply { // Unless there is a write lock
		l.lockMap[args.Resources[0]] = locksHeld + ReadLock // Grant another read lock
	}
	return reply, nil
}

	if !ok {
		return nil, errNoSuchUser
	}

	if caPublicKey != nil && pass == nil {
		err := validateKey(c, key)
		if err != nil {
			return nil, errAuthentication
		}
	} else {
		// Temporary credentials are not allowed.
		if ui.Credentials.IsTemp() {
			return nil, errAuthentication
		}
		if subtle.ConstantTimeCompare([]byte(ui.Credentials.SecretKey), pass) != 1 {

			if err != nil {
				err = msgp.WrapError(err, "BucketStatuses")
				return
			}
			if z.BucketStatuses == nil {
				z.BucketStatuses = make(map[string]ResyncStatusType, zb0002)
			} else if len(z.BucketStatuses) > 0 {
				for key := range z.BucketStatuses {
					delete(z.BucketStatuses, key)
				}
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string
				var za0002 ResyncStatusType

            async with nested_context(app) as maybe_nested_state:
                if maybe_nested_state is None and maybe_original_state is None:
                    yield None  # old ASGI compatibility
                else:
                    yield {**(maybe_nested_state or {}), **(maybe_original_state or {})}

    return merged_lifespan  # type: ignore[return-value]


async def serialize_response(
    *,

    body: RequestBody? = null,
  ) : this(
    Builder()
      .url(url)
      .headers(headers)
      .method(
        when {
          method != "\u0000" -> method
          body != null -> "POST"
          else -> "GET"
        },
        body,
      ),
  )

  fun header(name: String): String? = commonHeader(name)

  fun headers(name: String): List<String> = commonHeaders(name)

      // optimize for common output types which are optimized to deal with char[]
      if (to instanceof StringBuilder) {
        return copyReaderToBuilder((Reader) from, (StringBuilder) to);
      } else {
        return copyReaderToWriter((Reader) from, asWriter(to));
      }
    }

    checkNotNull(from);
    checkNotNull(to);
    long total = 0;
    CharBuffer buf = createBuffer();

	if b, ok := value.([]byte); ok {
		if len(b) < 3 || b[0] != '*' || b[1] != '*' || b[2] != '*' {
			return errors.New("Too short")
		}

		*data = append((*data)[0:], b[3:]...)
		return nil
	} else if s, ok := value.(string); ok {
		*data = []byte(s[3:])
		return nil
	}

	return errors.New("Bytes expected")
}

func (data EncryptedData) Value() (driver.Value, error) {

        String host = u.getHost();
        String path, ref;
        int port;

        if ( spec.equals("smb://") ) {
            spec = "smb:////";
            limit += 2;
        }
        else if ( spec.startsWith("smb://") == false && host != null && host.length() == 0 ) {
            spec = "//" + spec;
            limit += 2;
        }
        super.parseURL(u, spec, start, limit);
        path = u.getPath();

     * <li>point either at file or directory</li>
     * </ul>
     * If the given path points at a directory, the provided {@code ModelLocator} will be used
     * to find the POM file, else if no locator is provided, a file named 'pom.xml' needs to be
     * used by the requested model source.
     *
     * @param locator locator used to locate the pom file