var zb0004 uint32
	zb0004, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if (*z) == nil {
		(*z) = make(localLockMap, zb0004)
	} else if len((*z)) > 0 {
		for key := range *z {
			delete((*z), key)
		}
	}
	var field []byte
	_ = field
	for zb0004 > 0 {
		zb0004--
		var zb0001 string
		var zb0002 []lockRequesterInfo

		if [ -n "${MINIO_UID}" ] && [ -n "${MINIO_GID}" ]; then
			chroot --userspec=${MINIO_UID}:${MINIO_GID} / "$@"
		else
			echo "${MINIO_USERNAME}:x:1000:1000:${MINIO_USERNAME}:/:/sbin/nologin" >>/etc/passwd
			echo "${MINIO_GROUPNAME}:x:1000" >>/etc/group
			chroot --userspec=${MINIO_USERNAME}:${MINIO_GROUPNAME} / "$@"
		fi
	else
		exec "$@"
	fi
}

## DEPRECATED and unsupported - switch to user if applicable.

		if err != nil {
			return
		}
	} else {
		err = z.XferRateLrg.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "XferRateLrg")
			return
		}
	}
	// write "st"
	err = en.Append(0xa2, 0x73, 0x74)
	if err != nil {
		return
	}
	if z.XferRateSml == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.XferRateSml.EncodeMsg(en)

            server.useHttps(serverSslSocketFactory)
          } else if (socketMode == Channel) {
            socketFactory(ChannelSocketFactory())
          }
        }.build()

    server.enqueue(MockResponse(body = "abc"))

    @Suppress("HttpUrlsUsage")
    val url =
      if (socketMode is TlsInstance) {
        "https://$hostname:${server.port}/get"
      } else {
        "http://$hostname:${server.port}/get"
      }

        } else if (cae.isInfoEnabled()) {
            logger.info("[{}] {}", failureUrlId, cae.getMessage());
        } else if (cae.isWarnEnabled()) {
            logger.warn("[{}] Crawling Access Exception at {}", failureUrlId, urlQueue.getUrl(), cae);
        } else if (cae.isErrorEnabled()) {

                    serverNoContextTakeover = true
                  }
                  else -> {
                    unexpectedValues = true // Unexpected parameter.
                  }
                }
              }
            }

            else -> {
              unexpectedValues = true // Unexpected extension.
            }
          }
        }
      }

            domainName.equals(HOSTNAME_THAT_ONLY_THE_PROXY_KNOWS, ignoreCase = true) -> {
              InetAddress.getByName("localhost")
            }
            else -> InetAddress.getByName(domainName)
          }
        }

        else -> throw ProtocolException("unsupported address type: $addressType")
      }

    val port = fromSource.readShort() and 0xffff

    when (command) {

            return false;
        }
        final String value;
        if (urlStr.startsWith("://")) {
            value = "http" + urlStr;
        } else if (urlStr.startsWith("//")) {
            value = "http:" + urlStr;
        } else {
            value = urlStr;
        }
        try {
            final URL url = new java.net.URL(value);
            final String host = url.getHost();

     * @return The {@literal byte} array
     */
    public static byte[] toBinary(final Object o) {
        if (o instanceof byte[]) {
            return (byte[]) o;
        } else if (o == null) {
            return null;
        } else {
            assertArgument("o", o instanceof String, o.getClass().toString());
            return ((String) o).getBytes();
        }
    }

            if (other.value1 != null) {
                return false;
            }
        } else if (!value1.equals(other.value1)) {
            return false;
        }
        if (value2 == null) {
            if (other.value2 != null) {
                return false;
            }
        } else if (!value2.equals(other.value2)) {
            return false;
        }
        if (value3 == null) {