func (p *Parser) floatExpr() float64 {
	tok := p.next()
	switch tok.ScanToken {
	case '(':
		v := p.floatExpr()
		if p.next().ScanToken != ')' {
			p.errorf("missing closing paren")
		}
		return v
	case '+':
		return +p.floatExpr()
	case '-':
		return -p.floatExpr()
	case scanner.Float:
		return p.atof(tok.String())
	}

    protected int maxReadWriteSize;
    
    public enum RdmaConnectionState {
        DISCONNECTED,
        CONNECTING,
        CONNECTED,
        ESTABLISHED,
        ERROR,
        CLOSING,
        CLOSED
    }
    
    public RdmaConnection(InetSocketAddress remote, InetSocketAddress local) {
        this.remoteAddress = remote;
        this.localAddress = local;

  /**
   * The reason why this stream was closed, or null if it closed normally or has not yet been
   * closed.
   *
   * If there are multiple reasons to abnormally close this stream (such as both peers closing it
   * near-simultaneously) then this is the first reason known to this peer.
   */
  internal var errorCode: ErrorCode? = null
    get() = withLock { field }

{tab content, may span many lines}
////

Keep everything before the vertical bar (|) as is, including the vertical bar. Translate the tab title. Translate the tab content, applying the rules you know. Keep the four block closing slashes as is.

Examples:

Source (English):

//// tab | Python 3.8+ non-Annotated
Hello
////

Result (German):

//// tab | Python 3.8+ nicht annotiert
Hallo
////

    val connection = server.url("/").toUrl().openConnection() as HttpURLConnection
    connection.readTimeout = 500
    assertFailsWith<SocketTimeoutException> {
      connection.responseCode
    }

    // Closing the server should unblock the dispatcher.
    server.close()
  }

  @Test
  fun requestUrlReconstructed() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("hello world")

                    in_code_block4 = True
                    current_block_lang = get_code_block_lang(stripped)
                    current_block_lines = [line]
                    continue

        # --- Detect closing fence ---
        elif in_code_block3:
            if stripped.startswith("```"):
                count = len(stripped) - len(stripped.lstrip("`"))
                if count == 3:

     *
     * @param lastGoodStreamId the last stream ID the peer processed before sending this message. If
     *     [lastGoodStreamId] is zero, the peer processed no frames.
     * @param errorCode reason for closing the connection.
     * @param debugData only valid for HTTP/2; opaque debug data to send.
     */
    fun goAway(
      lastGoodStreamId: Int,
      errorCode: ErrorCode,
      debugData: ByteString,
    )

    chunked but has no data.

 *  Breaking: Replace `SocketPolicy` with a new type, `SocketEffect`. It splits triggers (request
    start, response body, etc.) from effects (closing the socket, closing the stream, etc.).

 *  Breaking: Rename `RecordedRequest.sequenceNumber` to `exchangeIndex` and introduce
    `connectionIndex` on that type. These properties may be useful when testing features like

                // StringWriter close() should not throw IOException, but log just in case
                if (logger.isDebugEnabled()) {
                    logger.debug("Unexpected IOException while closing StringWriter", e);
                }
            }
            return buf.toString();
        };
        final String message;

  }

  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
  private static void closeAll(BaseStream<?, ?>[] toClose) {
    // If one of the streams throws an exception, continue closing the others, then throw the
    // exception later. If more than one stream throws an exception, the later ones are added to the
    // first as suppressed exceptions. We don't catch Error on the grounds that it should be allowed