checkPositionIndexes(off, off + len, bytes.length);
    StringBuilder result = new StringBuilder(maxEncodedSize(len));
    try {
      encodeTo(result, bytes, off, len);
    } catch (IOException impossible) {
      throw new AssertionError(impossible);
    }
    return result.toString();
  }

  /**

      if (connection !in connections) {
        connection.withLock { put(connection) }
      }

      return 0L // run again immediately to create more connections if needed
    } catch (e: IOException) {
      // No need to log, user.connectFailed() will already have been called. Just try again later.
      return state.policy.backoffDelayMillis.jitterBy(state.policy.backoffJitterMillis) * 1_000_000
    }

                     * have a real NetBIOS name
                     */
                    this.calledName = null;
                    return getHostName();
                }
            }
            catch ( UnknownHostException uhe ) {
                this.calledName = null;
            }
        }
        else {
            this.calledName = null;
        }

        return this.calledName;
    }

    public static SID SYSTEM = null;

    static {
        try {
            EVERYONE = new SID("S-1-1-0");
            CREATOR_OWNER = new SID("S-1-3-0");
            SYSTEM = new SID("S-1-5-18");
        } catch (SmbException se) {
        }
    }

    static Map sid_cache = new HashMap();

    static void resolveSids(DcerpcHandle handle,
                LsaPolicyHandle policyHandle,

   */
  static boolean safeContains(Collection<?> collection, @CheckForNull Object object) {
    checkNotNull(collection);
    try {
      return collection.contains(object);
    } catch (ClassCastException | NullPointerException e) {
      return false;
    }
  }

  /**
   * Delegates to {@link Collection#remove}. Returns {@code false} if the {@code remove} method

            parser.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, StringUtil.EMPTY);
            parser.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, StringUtil.EMPTY);
            parser.parse(is, this);
        } catch (final Exception e) {
            throw new GsaConfigException("Failed to parse XML file.", e);
        }
    }

    @Override
    public void startDocument() throws SAXException {

                        urlQueue.getUrl(), urlQueue.getDepth() != null ? urlQueue.getDepth() + 1 : 1);
            } catch (final Throwable t) {
                if (!ComponentUtil.available()) {
                    throw new ContainerNotAvailableException(t);
                }
                throw t;
            }
        }
    }

    assertTrue(Arrays.equals(expectedHashCode.bytes, bb));
    assertEquals(expectedHashCode.asInt, hash.asInt());
    if (expectedHashCode.asLong == null) {
      try {
        hash.asLong();
        fail();
      } catch (IllegalStateException expected) {
      }
    } else {
      assertEquals(expectedHashCode.asLong.longValue(), hash.asLong());
    }
    assertEquals(expectedHashCode.toString, hash.toString());

        synchronized ( this ) {
            try {
                this.state = 1;
                DcerpcMessage bind = new DcerpcBind(this.binding, this);
                sendrecv(bind);
            }
            catch ( IOException ioe ) {
                this.state = 0;
                throw ioe;
            }
        }
    }


    /**
     * 
     * @param msg
     * @throws DcerpcException

                    return new CoreExtensionsStaxReader().read(is, true).getExtensions();
                }
            }
            return List.of();
        } catch (XMLStreamException e) {
            throw new ParserException("Failed to parse extensions file: " + extensionsFile, e);
        }
    }