private final RandomAccessFile file;

    public RandomAccessFileInputStream(RandomAccessFile file) {
        this.file = file;
    }

    @Override
    public long skip(long n) throws IOException {
        file.seek(file.getFilePointer() + n);
        return n;
    }

    @Override
    public int read(byte[] bytes) throws IOException {
        return file.read(bytes);
    }

        @Override
        public JvmMemoryStatus read(Decoder decoder) throws EOFException, Exception {
            long committedMemory = decoder.readLong();
            long maxMemory = decoder.readLong();
            return new JvmMemoryStatusSnapshot(maxMemory, committedMemory);
        }

        @Override

    @Override
    public void setLastAccessTime(File file, long millis) {
        try {
            Files.setLastModifiedTime(file.toPath(), FileTime.fromMillis(millis));
        } catch (IOException e) {
            LOGGER.debug("Ignoring failure to set last access time of " + file, e);
        }
    }

    @Override
    public long getLastAccessTime(File file) {
        return file.lastModified();
    }

        "1 hour"            | "10 hours"          | hours(1) + minutes(1) + seconds(1)  | "1h 1m 1s"
    }

    private static long hours(double value) {
        return minutes(value * 60.0)
    }

    private static long minutes(double value) {
        return seconds(value * 60.0)
    }

    private static long seconds(double value) {
        return value * 1000.0
    }

internal fun ServerSocket.closeQuietly() {
  try {
    close()
  } catch (rethrown: RuntimeException) {
    throw rethrown
  } catch (_: Exception) {
  }
}

internal fun Long.toHexString(): String = java.lang.Long.toHexString(this)

internal fun Int.toHexString(): String = Integer.toHexString(this)

@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "NOTHING_TO_INLINE")

  // in `internal_outputs`.
  std::unordered_set<int> internal_outputs;
  std::unordered_set<Node*> visited;
  // Initialize `queue` for BFS traversal. Nodes in `queue` hold upcoming nodes
  // along with the last Node in `output_` encountered along that path. If no
  // `output_` node was encountered, pair.second will be nullptr.
  std::deque<std::pair<Node*, Node*>> queue;
  for (const Output& nout : inputs_) {

    }
  }
  return result
}

internal const val USER_AGENT: String = "okhttp/${CONST_VERSION}"

internal fun checkOffsetAndCount(
  arrayLength: Long,
  offset: Long,
  count: Long,
) {
  if (offset or count < 0L || offset > arrayLength || arrayLength - offset < count) {
    throw ArrayIndexOutOfBoundsException("length=$arrayLength, offset=$offset, count=$offset")
  }
}

    def "PID unboxing should not happen in Status"() {
        given:
        Long unknownPID = null;

        when:
        def status = new Status(unknownPID, "", "");

        then:
        notThrown(NullPointerException)
        status.pid == null
    }

    def "PID unboxing should not happen in DaemonStopEvent"() {
        given:
        Long unknownPID = null;

        when:

        }
    }

    /**
     * The interceptor for {@link Long#getLong(String)}, {@link Long#getLong(String, long)}, and {@link Long#getLong(String, Long)}.
     */
    private static class LongGetLongInterceptor extends ClassBoundCallInterceptor implements FilterableCallInterceptor, InstrumentationInterceptor {
        public LongGetLongInterceptor() {
            super(Long.class, InterceptScope.methodsNamed("getLong"));
        }

    ) : ConfigurationCacheFingerprint()

    abstract class ChangingDependencyResolutionValue(
        val expireAt: Long
    ) : ConfigurationCacheFingerprint() {
        abstract val reason: String
    }

    class DynamicDependencyVersion(
        val displayName: String,
        expireAt: Long
    ) : ChangingDependencyResolutionValue(expireAt) {
        override val reason: String