private static final Object[] OBJECT_ARGS = new Object[0];

    /**
     * Use a WeakHashMap here, so the keys (Class objects) can be garbage collected.
     * This approach prevents permgen space overflows due to retention of discarded
     * classloaders.
     */
    private static final Map<Class<?>, WeakReference<ClassMap>> CLASS_MAPS = new WeakHashMap<>();

    static final int EOF = -1;

### Bug or Regression

- Correctly handle resetting cpuacct in a live container ([#94040](https://github.com/kubernetes/kubernetes/pull/94040), [@andyzhangx](https://github.com/andyzhangx)) [SIG Node and Windows]
- Fix uint64 overflow when elapsed ([#94038](https://github.com/kubernetes/kubernetes/pull/94038), [@andyzhangx](https://github.com/andyzhangx)) [SIG Node and Windows]

     * and the counter returned by {@link #totalProblemsReported()} are not equal (latter is bigger than former).
     *
     * @return true if the problem collector has overflowed and some problems were not preserved
     */
    boolean problemsOverflow();

    /**
     * Reports a problem: always maintains the counters, but whether problem is preserved in memory, depends on

    data: ByteString,
    formatOpcode: Int,
  ): Boolean {
    // Don't send new frames after we've failed or enqueued a close frame.
    if (failed || enqueuedClose) return false

    // If this frame overflows the buffer, reject it and close the web socket.
    if (queueSize + data.size > MAX_QUEUE_SIZE) {
      close(CLOSE_CLIENT_GOING_AWAY, null)
      return false
    }

    // Enqueue the message frame.

        .webSocketUpgrade(serverListener)
        .build(),
    )
    val webSocket: WebSocket = newWebSocket()
    clientListener.assertOpen()

    // Send messages until the client's outgoing buffer overflows!
    val message: ByteString = ByteString.of(*ByteArray(1024 * 1024))
    var messageCount: Long = 0
    while (true) {
      val success = webSocket.send(message)
      if (!success) break
      messageCount++

func (p *Parser) positiveAtoi(str string) int64 {
	value, err := strconv.ParseInt(str, 0, 64)
	if err != nil {
		p.errorf("%s", err)
	}
	if value < 0 {
		p.errorf("%s overflows int64", str)
	}
	return value
}

func (p *Parser) atoi(str string) uint64 {
	value, err := strconv.ParseUint(str, 0, 64)
	if err != nil {
		p.errorf("%s", err)
	}
	return value
}

		t.Errorf("Archive has unexpected number of files, got %d, want 5", len(r.File))
	}
}

func TestCVE202139293(t *testing.T) {
	// directory size is so large, that the check in Reader.init
	// overflows when subtracting from the archive size, causing
	// the pre-allocation check to be bypassed.
	data := []byte{
		0x50, 0x4b, 0x06, 0x06, 0x05, 0x06, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x4b,

pkg syscall (darwin-386), const ENOTSUP = 45
pkg syscall (darwin-386), const ENOTTY = 25
pkg syscall (darwin-386), const ENXIO = 6
pkg syscall (darwin-386), const EOPNOTSUPP = 102
pkg syscall (darwin-386), const EOVERFLOW = 84
pkg syscall (darwin-386), const EOWNERDEAD = 105
pkg syscall (darwin-386), const EPERM = 1
pkg syscall (darwin-386), const EPFNOSUPPORT = 46
pkg syscall (darwin-386), const EPIPE = 32

pkg syscall (freebsd-arm64), const ENOTTY = 25
pkg syscall (freebsd-arm64), const ENXIO = 6
pkg syscall (freebsd-arm64), const EOPNOTSUPP = 45
pkg syscall (freebsd-arm64), const EOVERFLOW = 84
pkg syscall (freebsd-arm64), const EOWNERDEAD = 96
pkg syscall (freebsd-arm64), const EOWNERDEAD Errno
pkg syscall (freebsd-arm64), const EPERM = 1
pkg syscall (freebsd-arm64), const EPFNOSUPPORT = 46

pkg syscall (darwin-arm64), const ENOTSUP = 45
pkg syscall (darwin-arm64), const ENOTTY = 25
pkg syscall (darwin-arm64), const ENXIO = 6
pkg syscall (darwin-arm64), const EOPNOTSUPP = 102
pkg syscall (darwin-arm64), const EOVERFLOW = 84
pkg syscall (darwin-arm64), const EOWNERDEAD = 105
pkg syscall (darwin-arm64), const EOWNERDEAD Errno
pkg syscall (darwin-arm64), const EPERM = 1
pkg syscall (darwin-arm64), const EPFNOSUPPORT = 46