Пакеты / com.hypixel.hytale.lib.quiche / QuicheNative

QuicheNative class

Пакет: com.hypixel.hytale.lib.quiche

Файл: com/hypixel/hytale/lib/quiche/QuicheNative.java

Поля (216)

МодификаторыТипИмя
private static final QuicheNative.QuicheError[] BY_CODE
BY_CODE
C_BOOL
C_BYTE
C_INT
C_LONG
C_POINTER
C_SHORT
C_SIZE_T
LOOKUP
PLATFORM
PLATFORM
PLATFORM
QUICHE_ACCEPT
QUICHE_CONFIG_DISCOVER_PMTU
QUICHE_CONFIG_ENABLE_DGRAM
QUICHE_CONFIG_ENABLE_EARLY_DATA
QUICHE_CONFIG_ENABLE_HYSTART
QUICHE_CONFIG_ENABLE_PACING
QUICHE_CONFIG_FREE
QUICHE_CONFIG_GREASE
QUICHE_CONFIG_LOAD_CERT
QUICHE_CONFIG_LOAD_CERT_CHAIN_FROM_PEM_FILE
QUICHE_CONFIG_LOAD_PRIV_KEY
QUICHE_CONFIG_LOAD_PRIV_KEY_FROM_PEM_FILE
QUICHE_CONFIG_LOAD_VERIFY_LOCATIONS_FROM_DIRECTORY
QUICHE_CONFIG_LOAD_VERIFY_LOCATIONS_FROM_FILE
QUICHE_CONFIG_LOG_KEYS
QUICHE_CONFIG_NEW
QUICHE_CONFIG_SET_ACK_DELAY_EXPONENT
QUICHE_CONFIG_SET_ACTIVE_CONNECTION_ID_LIMIT
QUICHE_CONFIG_SET_APPLICATION_PROTOS
QUICHE_CONFIG_SET_CC_ALGORITHM
QUICHE_CONFIG_SET_CC_ALGORITHM_NAME
QUICHE_CONFIG_SET_DISABLE_ACTIVE_MIGRATION
QUICHE_CONFIG_SET_DISABLE_DCID_REUSE
QUICHE_CONFIG_SET_INITIAL_CONGESTION_WINDOW_PACKETS
QUICHE_CONFIG_SET_INITIAL_MAX_DATA
QUICHE_CONFIG_SET_INITIAL_MAX_STREAMS_BIDI
QUICHE_CONFIG_SET_INITIAL_MAX_STREAMS_UNI
QUICHE_CONFIG_SET_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL
QUICHE_CONFIG_SET_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE
QUICHE_CONFIG_SET_INITIAL_MAX_STREAM_DATA_UNI
QUICHE_CONFIG_SET_MAX_ACK_DELAY
QUICHE_CONFIG_SET_MAX_AMPLIFICATION_FACTOR
QUICHE_CONFIG_SET_MAX_CONNECTION_WINDOW
QUICHE_CONFIG_SET_MAX_IDLE_TIMEOUT
QUICHE_CONFIG_SET_MAX_PACING_RATE
QUICHE_CONFIG_SET_MAX_RECV_UDP_PAYLOAD_SIZE
QUICHE_CONFIG_SET_MAX_SEND_UDP_PAYLOAD_SIZE
QUICHE_CONFIG_SET_MAX_STREAM_WINDOW
QUICHE_CONFIG_SET_STATELESS_RESET_TOKEN
QUICHE_CONFIG_SET_TICKET_KEY
QUICHE_CONFIG_VERIFY_PEER
QUICHE_CONFIG_VERIFY_PEER_OPTIONAL
QUICHE_CONNECT
QUICHE_CONNECTION_ID_ITER_FREE
QUICHE_CONNECTION_ID_ITER_NEXT
QUICHE_CONN_ACTIVE_SCIDS
QUICHE_CONN_APPLICATION_PROTO
QUICHE_CONN_AVAILABLE_DCIDS
QUICHE_CONN_CLOSE
QUICHE_CONN_DESTINATION_ID
QUICHE_CONN_DGRAM_MAX_WRITABLE_LEN
QUICHE_CONN_DGRAM_PURGE_OUTGOING
QUICHE_CONN_DGRAM_RECV
QUICHE_CONN_DGRAM_RECV_FRONT_LEN
QUICHE_CONN_DGRAM_RECV_QUEUE_BYTE_SIZE
QUICHE_CONN_DGRAM_RECV_QUEUE_LEN
QUICHE_CONN_DGRAM_SEND
QUICHE_CONN_DGRAM_SEND_QUEUE_BYTE_SIZE
QUICHE_CONN_DGRAM_SEND_QUEUE_LEN
QUICHE_CONN_FREE
QUICHE_CONN_IS_CLOSED
QUICHE_CONN_IS_DGRAM_RECV_QUEUE_FULL
QUICHE_CONN_IS_DGRAM_SEND_QUEUE_FULL
QUICHE_CONN_IS_DRAINING
QUICHE_CONN_IS_ESTABLISHED
QUICHE_CONN_IS_IN_EARLY_DATA
QUICHE_CONN_IS_PATH_VALIDATED
QUICHE_CONN_IS_READABLE
QUICHE_CONN_IS_RESUMED
QUICHE_CONN_IS_SERVER
QUICHE_CONN_IS_TIMED_OUT
QUICHE_CONN_LOCAL_ERROR
QUICHE_CONN_MAX_SEND_UDP_PAYLOAD_SIZE
QUICHE_CONN_MIGRATE
QUICHE_CONN_MIGRATE_SOURCE
QUICHE_CONN_NEW_SCID
QUICHE_CONN_NEW_WITH_TLS
QUICHE_CONN_ON_TIMEOUT
QUICHE_CONN_PATHS_ITER
QUICHE_CONN_PATH_EVENT_NEXT
QUICHE_CONN_PATH_STATS
QUICHE_CONN_PEER_CERT
QUICHE_CONN_PEER_ERROR
QUICHE_CONN_PEER_STREAMS_LEFT_BIDI
QUICHE_CONN_PEER_STREAMS_LEFT_UNI
QUICHE_CONN_PEER_TRANSPORT_PARAMS
QUICHE_CONN_PROBE_PATH
QUICHE_CONN_READABLE
QUICHE_CONN_RECV
QUICHE_CONN_RETIRED_SCIDS
QUICHE_CONN_RETIRE_DCID
QUICHE_CONN_SCIDS_LEFT
QUICHE_CONN_SEND
QUICHE_CONN_SEND_ACK_ELICITING
QUICHE_CONN_SEND_ACK_ELICITING_ON_PATH
QUICHE_CONN_SEND_ON_PATH
QUICHE_CONN_SEND_QUANTUM
QUICHE_CONN_SEND_QUANTUM_ON_PATH
QUICHE_CONN_SERVER_NAME
QUICHE_CONN_SESSION
QUICHE_CONN_SET_KEYLOG_PATH
QUICHE_CONN_SET_MAX_IDLE_TIMEOUT
QUICHE_CONN_SET_QLOG_PATH
QUICHE_CONN_SET_SESSION
QUICHE_CONN_SOURCE_ID
QUICHE_CONN_SOURCE_IDS
QUICHE_CONN_STATS
QUICHE_CONN_STREAM_CAPACITY
QUICHE_CONN_STREAM_FINISHED
QUICHE_CONN_STREAM_PRIORITY
QUICHE_CONN_STREAM_READABLE
QUICHE_CONN_STREAM_READABLE_NEXT
QUICHE_CONN_STREAM_RECV
QUICHE_CONN_STREAM_SEND
QUICHE_CONN_STREAM_SHUTDOWN
QUICHE_CONN_STREAM_WRITABLE
QUICHE_CONN_STREAM_WRITABLE_NEXT
QUICHE_CONN_TIMEOUT_AS_MILLIS
QUICHE_CONN_TIMEOUT_AS_NANOS
QUICHE_CONN_TRACE_ID
QUICHE_CONN_WRITABLE
QUICHE_ENABLE_DEBUG_LOGGING
QUICHE_GET_VARINT
QUICHE_H3_CONFIG_ENABLE_EXTENDED_CONNECT
QUICHE_H3_CONFIG_FREE
QUICHE_H3_CONFIG_NEW
QUICHE_H3_CONFIG_SET_MAX_FIELD_SECTION_SIZE
QUICHE_H3_CONFIG_SET_QPACK_BLOCKED_STREAMS
QUICHE_H3_CONFIG_SET_QPACK_MAX_TABLE_CAPACITY
QUICHE_H3_CONN_FREE
QUICHE_H3_CONN_NEW_WITH_TRANSPORT
QUICHE_H3_CONN_POLL
QUICHE_H3_CONN_STATS
QUICHE_H3_DGRAM_ENABLED_BY_PEER
QUICHE_H3_EVENT_FOR_EACH_HEADER
QUICHE_H3_EVENT_FREE
QUICHE_H3_EVENT_HEADERS_HAS_MORE_FRAMES
QUICHE_H3_EVENT_TYPE
QUICHE_H3_EXTENDED_CONNECT_ENABLED_BY_PEER
QUICHE_H3_FOR_EACH_SETTING
QUICHE_H3_PARSE_EXTENSIBLE_PRIORITY
QUICHE_H3_RECV_BODY
QUICHE_H3_SEND_ADDITIONAL_HEADERS
QUICHE_H3_SEND_BODY
QUICHE_H3_SEND_GOAWAY
QUICHE_H3_SEND_PRIORITY_UPDATE_FOR_REQUEST
QUICHE_H3_SEND_REQUEST
QUICHE_H3_SEND_RESPONSE
QUICHE_H3_SEND_RESPONSE_WITH_PRIORITY
QUICHE_H3_TAKE_LAST_PRIORITY_UPDATE
QUICHE_HEADER_INFO
final int QUICHE_MAX_CONN_ID_LEN
QUICHE_NEGOTIATE_VERSION
QUICHE_PATH_EVENT_CLOSED
QUICHE_PATH_EVENT_FAILED_VALIDATION
QUICHE_PATH_EVENT_FREE
QUICHE_PATH_EVENT_NEW
QUICHE_PATH_EVENT_PEER_MIGRATED
QUICHE_PATH_EVENT_REUSED_SOURCE_CONNECTION_ID
QUICHE_PATH_EVENT_TYPE
QUICHE_PATH_EVENT_VALIDATED
QUICHE_PUT_VARINT
QUICHE_RETRY
QUICHE_SOCKET_ADDR_ITER_FREE
QUICHE_SOCKET_ADDR_ITER_NEXT
QUICHE_STREAM_ITER_FREE
QUICHE_STREAM_ITER_NEXT
QUICHE_VERSION
QUICHE_VERSION_IS_SUPPORTED
RECV_INFO_FROM
RECV_INFO_FROM_LEN
RECV_INFO_LAYOUT
RECV_INFO_TO
RECV_INFO_TO_LEN
SEND_INFO_AT_OFFSET
SEND_INFO_FROM_LEN
SEND_INFO_FROM_OFFSET
SEND_INFO_LAYOUT
SEND_INFO_TO_LEN
SEND_INFO_TO_OFFSET
SOCKADDR_FAMILY
SOCKADDR_LAYOUT
SOCKADDR_STORAGE_DATA_OFFSET
SOCKADDR_STORAGE_FAMILY
SOCKADDR_STORAGE_LAYOUT
SOCKADDR_STORAGE_LEN
TIMESPEC_LAYOUT
TIMESPEC_NSEC
TIMESPEC_SEC
LINUX, MACOS, WINDOWS
break
break
break
break
break
private final int code
String var0
QuicheNative.QuicheError[] var0
String var1
int var1
String var2
Path var4
Path var5

Методы (222)

МодификаторыВозвратСигнатура
abstract throw new ExceptionInInitializerErrorthrow new ExceptionInInitializerError(var8)
abstract throw new IllegalArgumentExceptionthrow new IllegalArgumentException("Invalid shutdown direction: " + var3)
abstract throw new IllegalStateExceptionthrow new IllegalStateException("Native library not found on classpath: " + var2)
abstract OPTIMISTIC_ACK_DETECTED OPTIMISTIC_ACK_DETECTED(-22)
Platform Platform()
QuicheError QuicheError(int nullxx)
abstract throw new UnsupportedOperationExceptionthrow new UnsupportedOperationException("Unsupported size_t layout: " + C_SIZE_T)
abstract throw new UnsupportedOperationExceptionthrow new UnsupportedOperationException("Unsupported OS: " + var0)
abstract throw new UnsupportedOperationExceptionthrow new UnsupportedOperationException("Unsupported Linux architecture: " + var1)
abstract throw new UnsupportedOperationExceptionthrow new UnsupportedOperationException("Unsupported macOS architecture: " + var1)
abstract throw new UnsupportedOperationExceptionthrow new UnsupportedOperationException("Unsupported Windows architecture: " + var1)
static MemorySegment acceptMemorySegment accept(MemorySegment var0, long var1, MemorySegment var3, long var4, MemorySegment var6, int var7, MemorySegment var8, int var9, MemorySegment var10)
public int codepublic int code()
static void configDiscoverPmtuvoid configDiscoverPmtu(MemorySegment var0, boolean var1)
static void configEnableDgramvoid configEnableDgram(MemorySegment var0, boolean var1, long var2, long var4)
static void configEnableEarlyDatavoid configEnableEarlyData(MemorySegment var0)
static void configEnableHystartvoid configEnableHystart(MemorySegment var0, boolean var1)
static void configEnablePacingvoid configEnablePacing(MemorySegment var0, boolean var1)
static void configFreevoid configFree(MemorySegment var0)
static void configGreasevoid configGrease(MemorySegment var0, boolean var1)
static int configLoadCertint configLoadCert(MemorySegment var0, MemorySegment var1, long var2)
static int configLoadCertChainFromPemFileint configLoadCertChainFromPemFile(MemorySegment var0, MemorySegment var1)
static int configLoadPrivKeyint configLoadPrivKey(MemorySegment var0, MemorySegment var1, long var2)
static int configLoadPrivKeyFromPemFileint configLoadPrivKeyFromPemFile(MemorySegment var0, MemorySegment var1)
static int configLoadVerifyLocationsFromDirectoryint configLoadVerifyLocationsFromDirectory(MemorySegment var0, MemorySegment var1)
static int configLoadVerifyLocationsFromFileint configLoadVerifyLocationsFromFile(MemorySegment var0, MemorySegment var1)
static void configLogKeysvoid configLogKeys(MemorySegment var0)
static MemorySegment configNewMemorySegment configNew(int var0)
static void configSetAckDelayExponentvoid configSetAckDelayExponent(MemorySegment var0, long var1)
static void configSetActiveConnectionIdLimitvoid configSetActiveConnectionIdLimit(MemorySegment var0, long var1)
static int configSetApplicationProtosint configSetApplicationProtos(MemorySegment var0, MemorySegment var1, long var2)
static void configSetCcAlgorithmvoid configSetCcAlgorithm(MemorySegment var0, int var1)
static int configSetCcAlgorithmNameint configSetCcAlgorithmName(MemorySegment var0, MemorySegment var1)
static void configSetDisableActiveMigrationvoid configSetDisableActiveMigration(MemorySegment var0, boolean var1)
static void configSetDisableDcidReusevoid configSetDisableDcidReuse(MemorySegment var0, boolean var1)
static void configSetInitialCongestionWindowPacketsvoid configSetInitialCongestionWindowPackets(MemorySegment var0, long var1)
static void configSetInitialMaxDatavoid configSetInitialMaxData(MemorySegment var0, long var1)
static void configSetInitialMaxStreamDataBidiLocalvoid configSetInitialMaxStreamDataBidiLocal(MemorySegment var0, long var1)
static void configSetInitialMaxStreamDataBidiRemotevoid configSetInitialMaxStreamDataBidiRemote(MemorySegment var0, long var1)
static void configSetInitialMaxStreamDataUnivoid configSetInitialMaxStreamDataUni(MemorySegment var0, long var1)
static void configSetInitialMaxStreamsBidivoid configSetInitialMaxStreamsBidi(MemorySegment var0, long var1)
static void configSetInitialMaxStreamsUnivoid configSetInitialMaxStreamsUni(MemorySegment var0, long var1)
static void configSetMaxAckDelayvoid configSetMaxAckDelay(MemorySegment var0, long var1)
static void configSetMaxAmplificationFactorvoid configSetMaxAmplificationFactor(MemorySegment var0, long var1)
static void configSetMaxConnectionWindowvoid configSetMaxConnectionWindow(MemorySegment var0, long var1)
static void configSetMaxIdleTimeoutvoid configSetMaxIdleTimeout(MemorySegment var0, long var1)
static void configSetMaxPacingRatevoid configSetMaxPacingRate(MemorySegment var0, long var1)
static void configSetMaxRecvUdpPayloadSizevoid configSetMaxRecvUdpPayloadSize(MemorySegment var0, long var1)
static void configSetMaxSendUdpPayloadSizevoid configSetMaxSendUdpPayloadSize(MemorySegment var0, long var1)
static void configSetMaxStreamWindowvoid configSetMaxStreamWindow(MemorySegment var0, long var1)
static void configSetStatelessResetTokenvoid configSetStatelessResetToken(MemorySegment var0, MemorySegment var1)
static int configSetTicketKeyint configSetTicketKey(MemorySegment var0, MemorySegment var1, long var2)
static void configVerifyPeervoid configVerifyPeer(MemorySegment var0, boolean var1)
static void configVerifyPeerOptionalvoid configVerifyPeerOptional(MemorySegment var0)
static long connActiveScidslong connActiveScids(MemorySegment var0)
static void connApplicationProtovoid connApplicationProto(MemorySegment var0, MemorySegment var1, MemorySegment var2)
static long connAvailableDcidslong connAvailableDcids(MemorySegment var0)
static int connCloseint connClose(MemorySegment var0, boolean var1, long var2, MemorySegment var4, long var5)
static void connDestinationIdvoid connDestinationId(MemorySegment var0, MemorySegment var1, MemorySegment var2)
static long connDgramMaxWritableLenlong connDgramMaxWritableLen(MemorySegment var0)
static void connDgramPurgeOutgoingvoid connDgramPurgeOutgoing(MemorySegment var0, MemorySegment var1)
static long connDgramRecvlong connDgramRecv(MemorySegment var0, MemorySegment var1, long var2)
static long connDgramRecvFrontLenlong connDgramRecvFrontLen(MemorySegment var0)
static long connDgramRecvQueueByteSizelong connDgramRecvQueueByteSize(MemorySegment var0)
static long connDgramRecvQueueLenlong connDgramRecvQueueLen(MemorySegment var0)
static long connDgramSendlong connDgramSend(MemorySegment var0, MemorySegment var1, long var2)
static long connDgramSendQueueByteSizelong connDgramSendQueueByteSize(MemorySegment var0)
static long connDgramSendQueueLenlong connDgramSendQueueLen(MemorySegment var0)
static void connFreevoid connFree(MemorySegment var0)
static boolean connIsClosedboolean connIsClosed(MemorySegment var0)
static boolean connIsDgramRecvQueueFullboolean connIsDgramRecvQueueFull(MemorySegment var0)
static boolean connIsDgramSendQueueFullboolean connIsDgramSendQueueFull(MemorySegment var0)
static boolean connIsDrainingboolean connIsDraining(MemorySegment var0)
static boolean connIsEstablishedboolean connIsEstablished(MemorySegment var0)
static boolean connIsInEarlyDataboolean connIsInEarlyData(MemorySegment var0)
static int connIsPathValidatedint connIsPathValidated(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, long var5)
static boolean connIsReadableboolean connIsReadable(MemorySegment var0)
static boolean connIsResumedboolean connIsResumed(MemorySegment var0)
static boolean connIsServerboolean connIsServer(MemorySegment var0)
static boolean connIsTimedOutboolean connIsTimedOut(MemorySegment var0)
static boolean connLocalErrorboolean connLocalError(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4)
static long connMaxSendUdpPayloadSizelong connMaxSendUdpPayloadSize(MemorySegment var0)
static int connMigrateint connMigrate(MemorySegment var0, MemorySegment var1, int var2, MemorySegment var3, int var4, MemorySegment var5)
static int connMigrateSourceint connMigrateSource(MemorySegment var0, MemorySegment var1, int var2, MemorySegment var3)
static int connNewScidint connNewScid(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, boolean var5, MemorySegment var6)
static MemorySegment connNewWithTlsMemorySegment connNewWithTls(MemorySegment var0, long var1, MemorySegment var3, long var4, MemorySegment var6, int var7, MemorySegment var8, int var9, MemorySegment var10, MemorySegment var11, boolean var12)
static void connOnTimeoutvoid connOnTimeout(MemorySegment var0)
static MemorySegment connPathEventNextMemorySegment connPathEventNext(MemorySegment var0)
static int connPathStatsint connPathStats(MemorySegment var0, long var1, MemorySegment var3)
static MemorySegment connPathsIterMemorySegment connPathsIter(MemorySegment var0, MemorySegment var1, long var2)
static void connPeerCertvoid connPeerCert(MemorySegment var0, MemorySegment var1, MemorySegment var2)
static boolean connPeerErrorboolean connPeerError(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4)
static long connPeerStreamsLeftBidilong connPeerStreamsLeftBidi(MemorySegment var0)
static long connPeerStreamsLeftUnilong connPeerStreamsLeftUni(MemorySegment var0)
static boolean connPeerTransportParamsboolean connPeerTransportParams(MemorySegment var0, MemorySegment var1)
static int connProbePathint connProbePath(MemorySegment var0, MemorySegment var1, int var2, MemorySegment var3, int var4, MemorySegment var5)
static MemorySegment connReadableMemorySegment connReadable(MemorySegment var0)
static long connRecvlong connRecv(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4)
static int connRetireDcidint connRetireDcid(MemorySegment var0, long var1)
static long connRetiredScidslong connRetiredScids(MemorySegment var0)
static long connScidsLeftlong connScidsLeft(MemorySegment var0)
static long connSendlong connSend(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4)
static long connSendAckElicitinglong connSendAckEliciting(MemorySegment var0)
static long connSendAckElicitingOnPathlong connSendAckElicitingOnPath(MemorySegment var0, MemorySegment var1, int var2, MemorySegment var3, int var4)
static long connSendOnPathlong connSendOnPath(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, int var5, MemorySegment var6, int var7, MemorySegment var8)
static long connSendQuantumlong connSendQuantum(MemorySegment var0)
static long connSendQuantumOnPathlong connSendQuantumOnPath(MemorySegment var0, MemorySegment var1, int var2, MemorySegment var3, int var4)
static void connServerNamevoid connServerName(MemorySegment var0, MemorySegment var1, MemorySegment var2)
static void connSessionvoid connSession(MemorySegment var0, MemorySegment var1, MemorySegment var2)
static boolean connSetKeylogPathboolean connSetKeylogPath(MemorySegment var0, MemorySegment var1)
static int connSetMaxIdleTimeoutint connSetMaxIdleTimeout(MemorySegment var0, long var1)
static boolean connSetQlogPathboolean connSetQlogPath(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3)
static int connSetSessionint connSetSession(MemorySegment var0, MemorySegment var1, long var2)
static void connSourceIdvoid connSourceId(MemorySegment var0, MemorySegment var1, MemorySegment var2)
static MemorySegment connSourceIdsMemorySegment connSourceIds(MemorySegment var0)
static void connStatsvoid connStats(MemorySegment var0, MemorySegment var1)
static long connStreamCapacitylong connStreamCapacity(MemorySegment var0, long var1)
static boolean connStreamFinishedboolean connStreamFinished(MemorySegment var0, long var1)
static int connStreamPriorityint connStreamPriority(MemorySegment var0, long var1, byte var3, boolean var4)
static boolean connStreamReadableboolean connStreamReadable(MemorySegment var0, long var1)
static long connStreamReadableNextlong connStreamReadableNext(MemorySegment var0)
static long connStreamRecvlong connStreamRecv(MemorySegment var0, long var1, MemorySegment var3, long var4, MemorySegment var6, MemorySegment var7)
static long connStreamSendlong connStreamSend(MemorySegment var0, long var1, MemorySegment var3, long var4, boolean var6, MemorySegment var7)
static int connStreamShutdownint connStreamShutdown(MemorySegment var0, long var1, int var3, long var4)
static int connStreamWritableint connStreamWritable(MemorySegment var0, long var1, long var3)
static long connStreamWritableNextlong connStreamWritableNext(MemorySegment var0)
static long connTimeoutAsMillislong connTimeoutAsMillis(MemorySegment var0)
static long connTimeoutAsNanoslong connTimeoutAsNanos(MemorySegment var0)
static void connTraceIdvoid connTraceId(MemorySegment var0, MemorySegment var1, MemorySegment var2)
static MemorySegment connWritableMemorySegment connWritable(MemorySegment var0)
static MemorySegment connectMemorySegment connect(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, int var5, MemorySegment var6, int var7, MemorySegment var8)
static void connectionIdIterFreevoid connectionIdIterFree(MemorySegment var0)
static boolean connectionIdIterNextboolean connectionIdIterNext(MemorySegment var0, MemorySegment var1, MemorySegment var2)
static MethodHandle downcallMethodHandle downcall(String var0, FunctionDescriptor var1)
static int enableDebugLoggingint enableDebugLogging(MemorySegment var0, MemorySegment var1)
for for(QuicheNative.QuicheError var4 : var0)
public static QuicheNative.QuicheError fromCodepublic static QuicheNative.QuicheError fromCode(int var0)
static MemorySegment getRecvInfoFromMemorySegment getRecvInfoFrom(MemorySegment var0)
static int getRecvInfoFromLenint getRecvInfoFromLen(MemorySegment var0)
static MemorySegment getRecvInfoToMemorySegment getRecvInfoTo(MemorySegment var0)
static int getRecvInfoToLenint getRecvInfoToLen(MemorySegment var0)
static MemorySegment getSendInfoAtMemorySegment getSendInfoAt(MemorySegment var0)
static MemorySegment getSendInfoFromMemorySegment getSendInfoFrom(MemorySegment var0)
static int getSendInfoFromLenint getSendInfoFromLen(MemorySegment var0)
static MemorySegment getSendInfoToMemorySegment getSendInfoTo(MemorySegment var0)
static int getSendInfoToLenint getSendInfoToLen(MemorySegment var0)
static long getSizeTlong getSizeT(MemorySegment var0, long var1)
static MemorySegment getSockaddrDataMemorySegment getSockaddrData(MemorySegment var0)
static int getSockaddrFamilyint getSockaddrFamily(MemorySegment var0)
static byte getSockaddrLenbyte getSockaddrLen(MemorySegment var0)
static int getSockaddrStorageFamilyint getSockaddrStorageFamily(MemorySegment var0)
static long getTimespecNseclong getTimespecNsec(MemorySegment var0)
static long getTimespecSeclong getTimespecSec(MemorySegment var0)
static long getVarintlong getVarint(MemorySegment var0, long var1, MemorySegment var3)
static void h3ConfigEnableExtendedConnectvoid h3ConfigEnableExtendedConnect(MemorySegment var0, boolean var1)
static void h3ConfigFreevoid h3ConfigFree(MemorySegment var0)
static MemorySegment h3ConfigNewMemorySegment h3ConfigNew()
static void h3ConfigSetMaxFieldSectionSizevoid h3ConfigSetMaxFieldSectionSize(MemorySegment var0, long var1)
static void h3ConfigSetQpackBlockedStreamsvoid h3ConfigSetQpackBlockedStreams(MemorySegment var0, long var1)
static void h3ConfigSetQpackMaxTableCapacityvoid h3ConfigSetQpackMaxTableCapacity(MemorySegment var0, long var1)
static void h3ConnFreevoid h3ConnFree(MemorySegment var0)
static MemorySegment h3ConnNewWithTransportMemorySegment h3ConnNewWithTransport(MemorySegment var0, MemorySegment var1)
static long h3ConnPolllong h3ConnPoll(MemorySegment var0, MemorySegment var1, MemorySegment var2)
static void h3ConnStatsvoid h3ConnStats(MemorySegment var0, MemorySegment var1)
static boolean h3DgramEnabledByPeerboolean h3DgramEnabledByPeer(MemorySegment var0, MemorySegment var1)
static int h3EventForEachHeaderint h3EventForEachHeader(MemorySegment var0, MemorySegment var1, MemorySegment var2)
static void h3EventFreevoid h3EventFree(MemorySegment var0)
static boolean h3EventHeadersHasMoreFramesboolean h3EventHeadersHasMoreFrames(MemorySegment var0)
static int h3EventTypeint h3EventType(MemorySegment var0)
static boolean h3ExtendedConnectEnabledByPeerboolean h3ExtendedConnectEnabledByPeer(MemorySegment var0)
static int h3ForEachSettingint h3ForEachSetting(MemorySegment var0, MemorySegment var1, MemorySegment var2)
static int h3ParseExtensiblePriorityint h3ParseExtensiblePriority(MemorySegment var0, long var1, MemorySegment var3)
static long h3RecvBodylong h3RecvBody(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, long var5)
static int h3SendAdditionalHeadersint h3SendAdditionalHeaders(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, long var5, boolean var7, boolean var8)
static long h3SendBodylong h3SendBody(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, long var5, boolean var7)
static int h3SendGoawayint h3SendGoaway(MemorySegment var0, MemorySegment var1, long var2)
static int h3SendPriorityUpdateForRequestint h3SendPriorityUpdateForRequest(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4)
static long h3SendRequestlong h3SendRequest(MemorySegment var0, MemorySegment var1, MemorySegment var2, long var3, boolean var5)
static int h3SendResponseint h3SendResponse(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, long var5, boolean var7)
static int h3SendResponseWithPriorityint h3SendResponseWithPriority(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, long var5, MemorySegment var7, boolean var8)
static int h3TakeLastPriorityUpdateint h3TakeLastPriorityUpdate(MemorySegment var0, long var1, MemorySegment var3, MemorySegment var4)
static int headerInfoint headerInfo(MemorySegment var0, long var1, long var3, MemorySegment var5, MemorySegment var6, MemorySegment var7, MemorySegment var8, MemorySegment var9, MemorySegment var10, MemorySegment var11, MemorySegment var12)
if if(SOCKADDR_STORAGE_LEN != null)
if if(var3 != 0 && var3 != 1)
if if(var3 == null)
static long negotiateVersionlong negotiateVersion(MemorySegment var0, long var1, MemorySegment var3, long var4, MemorySegment var6, long var7)
static void pathEventClosedvoid pathEventClosed(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4)
static void pathEventFailedValidationvoid pathEventFailedValidation(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4)
static void pathEventFreevoid pathEventFree(MemorySegment var0)
static void pathEventNewvoid pathEventNew(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4)
static void pathEventPeerMigratedvoid pathEventPeerMigrated(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4)
static void pathEventReusedSourceConnectionIdvoid pathEventReusedSourceConnectionId(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4, MemorySegment var5, MemorySegment var6, MemorySegment var7, MemorySegment var8, MemorySegment var9)
static int pathEventTypeint pathEventType(MemorySegment var0)
static void pathEventValidatedvoid pathEventValidated(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4)
static int putVarintint putVarint(MemorySegment var0, long var1, long var3)
static long retrylong retry(MemorySegment var0, long var1, MemorySegment var3, long var4, MemorySegment var6, long var7, MemorySegment var9, long var10, int var12, MemorySegment var13, long var14)
static void setRecvInfoFromvoid setRecvInfoFrom(MemorySegment var0, MemorySegment var1)
static void setRecvInfoFromLenvoid setRecvInfoFromLen(MemorySegment var0, int var1)
static void setRecvInfoTovoid setRecvInfoTo(MemorySegment var0, MemorySegment var1)
static void setRecvInfoToLenvoid setRecvInfoToLen(MemorySegment var0, int var1)
static void setSendInfoFromLenvoid setSendInfoFromLen(MemorySegment var0, int var1)
static void setSendInfoToLenvoid setSendInfoToLen(MemorySegment var0, int var1)
static void setSizeTvoid setSizeT(MemorySegment var0, long var1, long var3)
static void setSockaddrFamilyvoid setSockaddrFamily(MemorySegment var0, int var1)
static void setSockaddrLenvoid setSockaddrLen(MemorySegment var0, byte var1)
static void setSockaddrStorageFamilyvoid setSockaddrStorageFamily(MemorySegment var0, int var1)
static void setTimespecNsecvoid setTimespecNsec(MemorySegment var0, long var1)
static void setTimespecSecvoid setTimespecSec(MemorySegment var0, long var1)
static void socketAddrIterFreevoid socketAddrIterFree(MemorySegment var0)
static boolean socketAddrIterNextboolean socketAddrIterNext(MemorySegment var0, MemorySegment var1, MemorySegment var2)
static void streamIterFreevoid streamIterFree(MemorySegment var0)
static boolean streamIterNextboolean streamIterNext(MemorySegment var0, MemorySegment var1)
switch switch(C_SIZE_T)
return switchreturn switch(C_SIZE_T)
return switchreturn switch(PLATFORM)
switch switch(PLATFORM)
return switchreturn switch(PLATFORM)
switch switch(PLATFORM)
return switchreturn switch(PLATFORM)
switch switch(PLATFORM)
static MemorySegment versionMemorySegment version()
static boolean versionIsSupportedboolean versionIsSupported(int var0)

Исходный код

Показать/скрыть 
class="kw">package com.hypixel.hytale.lib.quiche;

class="kw">import com.hypixel.hytale.sneakythrow.SneakyThrow;
class="kw">import java.io.IOException;
class="kw">import java.io.InputStream;
class="kw">import java.lang.foreign.AddressLayout;
class="kw">import java.lang.foreign.Arena;
class="kw">import java.lang.foreign.FunctionDescriptor;
class="kw">import java.lang.foreign.Linker;
class="kw">import java.lang.foreign.MemoryLayout;
class="kw">import java.lang.foreign.MemorySegment;
class="kw">import java.lang.foreign.StructLayout;
class="kw">import java.lang.foreign.SymbolLookup;
class="kw">import java.lang.foreign.ValueLayout;
class="kw">import java.lang.foreign.MemoryLayout.PathElement;
class="kw">import java.lang.foreign.ValueLayout.OfBoolean;
class="kw">import java.lang.foreign.ValueLayout.OfByte;
class="kw">import java.lang.foreign.ValueLayout.OfInt;
class="kw">import java.lang.foreign.ValueLayout.OfLong;
class="kw">import java.lang.foreign.ValueLayout.OfShort;
class="kw">import java.lang.invoke.MethodHandle;
class="kw">import java.lang.invoke.VarHandle;
class="kw">import java.nio.file.Files;
class="kw">import java.nio.file.Path;
class="kw">import java.nio.file.StandardCopyOption;
class="kw">import java.util.Locale;

class="kw">public class QuicheNative {
   class="kw">public class="kw">static class="kw">final int QUICHE_MAX_CONN_ID_LEN = 20;
   class="kw">public class="kw">static class="kw">final int QUICHE_SHUTDOWN_READ = 0;
   class="kw">public class="kw">static class="kw">final int QUICHE_SHUTDOWN_WRITE = 1;
   class="kw">private class="kw">static class="kw">final Linker LINKER = Linker.nativeLinker();
   class="kw">private class="kw">static class="kw">final Arena GLOBAL_ARENA = Arena.global();
   class="kw">private class="kw">static class="kw">final SymbolLookup LOOKUP;
   class="kw">public class="kw">static class="kw">final QuicheNative.Platform PLATFORM;
   class="kw">public class="kw">static class="kw">final AddressLayout C_POINTER;
   class="kw">public class="kw">static class="kw">final OfInt C_INT;
   class="kw">public class="kw">static class="kw">final OfLong C_LONG;
   class="kw">public class="kw">static class="kw">final OfByte C_BYTE;
   class="kw">public class="kw">static class="kw">final OfBoolean C_BOOL;
   class="kw">public class="kw">static class="kw">final OfShort C_SHORT;
   class="kw">public class="kw">static class="kw">final ValueLayout C_SIZE_T;
   class="kw">public class="kw">static class="kw">final StructLayout SOCKADDR_STORAGE_LAYOUT;
   class="kw">public class="kw">static class="kw">final StructLayout SOCKADDR_LAYOUT;
   class="kw">public class="kw">static class="kw">final StructLayout TIMESPEC_LAYOUT;
   class="kw">public class="kw">static class="kw">final StructLayout RECV_INFO_LAYOUT;
   class="kw">public class="kw">static class="kw">final StructLayout SEND_INFO_LAYOUT;
   class="kw">public class="kw">static class="kw">final VarHandle SOCKADDR_FAMILY;
   class="kw">public class="kw">static class="kw">final VarHandle SOCKADDR_STORAGE_FAMILY;
   class="kw">public class="kw">static class="kw">final VarHandle SOCKADDR_STORAGE_LEN;
   class="kw">public class="kw">static class="kw">final long SOCKADDR_STORAGE_DATA_OFFSET;
   class="kw">private class="kw">static class="kw">final VarHandle TIMESPEC_SEC;
   class="kw">private class="kw">static class="kw">final VarHandle TIMESPEC_NSEC;
   class="kw">private class="kw">static class="kw">final VarHandle RECV_INFO_FROM;
   class="kw">private class="kw">static class="kw">final VarHandle RECV_INFO_FROM_LEN;
   class="kw">private class="kw">static class="kw">final VarHandle RECV_INFO_TO;
   class="kw">private class="kw">static class="kw">final VarHandle RECV_INFO_TO_LEN;
   class="kw">private class="kw">static class="kw">final long SEND_INFO_FROM_OFFSET;
   class="kw">private class="kw">static class="kw">final VarHandle SEND_INFO_FROM_LEN;
   class="kw">private class="kw">static class="kw">final long SEND_INFO_TO_OFFSET;
   class="kw">private class="kw">static class="kw">final VarHandle SEND_INFO_TO_LEN;
   class="kw">private class="kw">static class="kw">final long SEND_INFO_AT_OFFSET;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_VERSION;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_ENABLE_DEBUG_LOGGING;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_PUT_VARINT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_GET_VARINT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_NEW;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_LOAD_CERT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_LOAD_CERT_CHAIN_FROM_PEM_FILE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_LOAD_PRIV_KEY;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_LOAD_PRIV_KEY_FROM_PEM_FILE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_LOAD_VERIFY_LOCATIONS_FROM_FILE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_LOAD_VERIFY_LOCATIONS_FROM_DIRECTORY;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_VERIFY_PEER;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_VERIFY_PEER_OPTIONAL;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_GREASE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_DISCOVER_PMTU;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_LOG_KEYS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_ENABLE_EARLY_DATA;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_APPLICATION_PROTOS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_MAX_AMPLIFICATION_FACTOR;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_MAX_IDLE_TIMEOUT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_MAX_RECV_UDP_PAYLOAD_SIZE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_MAX_SEND_UDP_PAYLOAD_SIZE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_INITIAL_MAX_DATA;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_INITIAL_MAX_STREAM_DATA_UNI;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_INITIAL_MAX_STREAMS_BIDI;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_INITIAL_MAX_STREAMS_UNI;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_ACK_DELAY_EXPONENT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_MAX_ACK_DELAY;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_DISABLE_ACTIVE_MIGRATION;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_CC_ALGORITHM_NAME;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_INITIAL_CONGESTION_WINDOW_PACKETS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_CC_ALGORITHM;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_ENABLE_HYSTART;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_ENABLE_PACING;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_MAX_PACING_RATE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_ENABLE_DGRAM;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_MAX_CONNECTION_WINDOW;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_MAX_STREAM_WINDOW;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_ACTIVE_CONNECTION_ID_LIMIT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_STATELESS_RESET_TOKEN;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_DISABLE_DCID_REUSE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_SET_TICKET_KEY;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONFIG_FREE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_HEADER_INFO;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_ACCEPT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONNECT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_NEGOTIATE_VERSION;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_RETRY;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_VERSION_IS_SUPPORTED;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_NEW_WITH_TLS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SET_KEYLOG_PATH;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SET_QLOG_PATH;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SET_SESSION;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SET_MAX_IDLE_TIMEOUT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_RECV;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SEND;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SEND_QUANTUM;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SEND_ON_PATH;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SEND_QUANTUM_ON_PATH;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_TIMEOUT_AS_NANOS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_TIMEOUT_AS_MILLIS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_ON_TIMEOUT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_CLOSE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_FREE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_STREAM_RECV;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_STREAM_SEND;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_STREAM_PRIORITY;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_STREAM_SHUTDOWN;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_STREAM_CAPACITY;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_STREAM_READABLE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_STREAM_READABLE_NEXT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_STREAM_WRITABLE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_STREAM_WRITABLE_NEXT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_STREAM_FINISHED;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_READABLE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_WRITABLE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_STREAM_ITER_NEXT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_STREAM_ITER_FREE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_MAX_SEND_UDP_PAYLOAD_SIZE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_IS_ESTABLISHED;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_IS_RESUMED;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_IS_IN_EARLY_DATA;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_IS_READABLE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_IS_DRAINING;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_IS_CLOSED;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_IS_TIMED_OUT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_IS_SERVER;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_PEER_STREAMS_LEFT_BIDI;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_PEER_STREAMS_LEFT_UNI;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_TRACE_ID;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SOURCE_ID;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_DESTINATION_ID;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_APPLICATION_PROTO;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_PEER_CERT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SESSION;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SERVER_NAME;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_PEER_ERROR;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_LOCAL_ERROR;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_STATS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_PEER_TRANSPORT_PARAMS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_PATH_STATS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SOURCE_IDS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONNECTION_ID_ITER_NEXT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONNECTION_ID_ITER_FREE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_RETIRED_SCIDS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_AVAILABLE_DCIDS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SCIDS_LEFT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_ACTIVE_SCIDS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_NEW_SCID;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_RETIRE_DCID;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_PROBE_PATH;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_MIGRATE_SOURCE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_MIGRATE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_PATH_EVENT_NEXT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_PATH_EVENT_TYPE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_PATH_EVENT_NEW;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_PATH_EVENT_VALIDATED;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_PATH_EVENT_FAILED_VALIDATION;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_PATH_EVENT_CLOSED;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_PATH_EVENT_REUSED_SOURCE_CONNECTION_ID;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_PATH_EVENT_PEER_MIGRATED;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_PATH_EVENT_FREE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_PATHS_ITER;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_SOCKET_ADDR_ITER_NEXT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_SOCKET_ADDR_ITER_FREE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_IS_PATH_VALIDATED;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_DGRAM_MAX_WRITABLE_LEN;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_DGRAM_RECV_FRONT_LEN;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_DGRAM_RECV_QUEUE_LEN;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_DGRAM_RECV_QUEUE_BYTE_SIZE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_DGRAM_SEND_QUEUE_LEN;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_DGRAM_SEND_QUEUE_BYTE_SIZE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_DGRAM_RECV;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_DGRAM_SEND;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_DGRAM_PURGE_OUTGOING;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_IS_DGRAM_SEND_QUEUE_FULL;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_IS_DGRAM_RECV_QUEUE_FULL;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SEND_ACK_ELICITING;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_CONN_SEND_ACK_ELICITING_ON_PATH;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_CONFIG_NEW;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_CONFIG_SET_MAX_FIELD_SECTION_SIZE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_CONFIG_SET_QPACK_MAX_TABLE_CAPACITY;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_CONFIG_SET_QPACK_BLOCKED_STREAMS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_CONFIG_ENABLE_EXTENDED_CONNECT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_CONFIG_FREE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_CONN_NEW_WITH_TRANSPORT;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_CONN_POLL;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_EVENT_TYPE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_EVENT_FOR_EACH_HEADER;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_FOR_EACH_SETTING;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_EVENT_HEADERS_HAS_MORE_FRAMES;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_EXTENDED_CONNECT_ENABLED_BY_PEER;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_EVENT_FREE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_SEND_REQUEST;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_SEND_RESPONSE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_SEND_RESPONSE_WITH_PRIORITY;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_SEND_ADDITIONAL_HEADERS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_SEND_BODY;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_RECV_BODY;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_SEND_GOAWAY;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_PARSE_EXTENSIBLE_PRIORITY;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_SEND_PRIORITY_UPDATE_FOR_REQUEST;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_TAKE_LAST_PRIORITY_UPDATE;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_DGRAM_ENABLED_BY_PEER;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_CONN_STATS;
   class="kw">public class="kw">static class="kw">final MethodHandle QUICHE_H3_CONN_FREE;

   class="kw">public QuicheNative() {
   }

   class="kw">public class="kw">static void setSizeT(MemorySegment var0, long var1, long var3) {
      class="kw">switch (C_SIZE_T) {
         case OfLong var7:
            var0.set(var7, var1, var3);
            break;
         case OfInt var8:
            var0.set(var8, var1, (int)var3);
            break;
         class="kw">default:
            throw new UnsupportedOperationException("Unsupported size_t layout: " + C_SIZE_T);
      }
   }

   class="kw">public class="kw">static long getSizeT(MemorySegment var0, long var1) {
      class="kw">return class="kw">switch (C_SIZE_T) {
         case OfLong var5 -> var0.get(var5, var1);
         case OfInt var6 -> Integer.toUnsignedLong(var0.get(var6, var1));
         class="kw">default -> throw new UnsupportedOperationException("Unsupported size_t layout: " + C_SIZE_T);
      };
   }

   class="kw">public class="kw">static int getSockaddrFamily(MemorySegment var0) {
      class="kw">return class="kw">switch (PLATFORM) {
         case LINUX, WINDOWS -> Short.toUnsignedInt((short)SOCKADDR_FAMILY.get((MemorySegment)var0, (long)0L));
         case MACOS -> Byte.toUnsignedInt((byte)SOCKADDR_FAMILY.get((MemorySegment)var0, (long)0L));
      };
   }

   class="kw">public class="kw">static void setSockaddrFamily(MemorySegment var0, int var1) {
      class="kw">switch (PLATFORM) {
         case LINUX:
         case WINDOWS:
            SOCKADDR_FAMILY.set((MemorySegment)var0, (long)0L, (short)((short)var1));
            break;
         case MACOS:
            SOCKADDR_FAMILY.set((MemorySegment)var0, (long)0L, (byte)((byte)var1));
      }
   }

   class="kw">public class="kw">static byte getSockaddrLen(MemorySegment var0) {
      class="kw">return SOCKADDR_STORAGE_LEN == null ? 0 : (byte)SOCKADDR_STORAGE_LEN.get((MemorySegment)var0, (long)0L);
   }

   class="kw">public class="kw">static void setSockaddrLen(MemorySegment var0, byte var1) {
      if (SOCKADDR_STORAGE_LEN != null) {
         SOCKADDR_STORAGE_LEN.set((MemorySegment)var0, (long)0L, (byte)var1);
      }
   }

   class="kw">public class="kw">static MemorySegment getSockaddrData(MemorySegment var0) {
      class="kw">return var0.asSlice(SOCKADDR_STORAGE_DATA_OFFSET, SOCKADDR_LAYOUT.byteSize() - SOCKADDR_STORAGE_DATA_OFFSET);
   }

   class="kw">public class="kw">static int getSockaddrStorageFamily(MemorySegment var0) {
      class="kw">return class="kw">switch (PLATFORM) {
         case LINUX, WINDOWS -> Short.toUnsignedInt((short)SOCKADDR_STORAGE_FAMILY.get((MemorySegment)var0, (long)0L));
         case MACOS -> Byte.toUnsignedInt((byte)SOCKADDR_STORAGE_FAMILY.get((MemorySegment)var0, (long)0L));
      };
   }

   class="kw">public class="kw">static void setSockaddrStorageFamily(MemorySegment var0, int var1) {
      class="kw">switch (PLATFORM) {
         case LINUX:
         case WINDOWS:
            SOCKADDR_STORAGE_FAMILY.set((MemorySegment)var0, (long)0L, (short)((short)var1));
            break;
         case MACOS:
            SOCKADDR_STORAGE_FAMILY.set((MemorySegment)var0, (long)0L, (byte)((byte)var1));
      }
   }

   class="kw">public class="kw">static long getTimespecSec(MemorySegment var0) {
      class="kw">return (long)TIMESPEC_SEC.get((MemorySegment)var0, (long)0L);
   }

   class="kw">public class="kw">static void setTimespecSec(MemorySegment var0, long var1) {
      TIMESPEC_SEC.set((MemorySegment)var0, (long)0L, (long)var1);
   }

   class="kw">public class="kw">static long getTimespecNsec(MemorySegment var0) {
      class="kw">return class="kw">switch (PLATFORM) {
         case LINUX, MACOS -> (long)TIMESPEC_NSEC.get((MemorySegment)var0, (long)0L);
         case WINDOWS -> Integer.toUnsignedLong((int)TIMESPEC_NSEC.get((MemorySegment)var0, (long)0L));
      };
   }

   class="kw">public class="kw">static void setTimespecNsec(MemorySegment var0, long var1) {
      class="kw">switch (PLATFORM) {
         case LINUX:
         case MACOS:
            TIMESPEC_NSEC.set((MemorySegment)var0, (long)0L, (long)var1);
            break;
         case WINDOWS:
            TIMESPEC_NSEC.set((MemorySegment)var0, (long)0L, (int)((int)var1));
      }
   }

   class="kw">public class="kw">static MemorySegment getRecvInfoFrom(MemorySegment var0) {
      class="kw">return (MemorySegment)RECV_INFO_FROM.get((MemorySegment)var0, (long)0L);
   }

   class="kw">public class="kw">static void setRecvInfoFrom(MemorySegment var0, MemorySegment var1) {
      RECV_INFO_FROM.set((MemorySegment)var0, (long)0L, (MemorySegment)var1);
   }

   class="kw">public class="kw">static int getRecvInfoFromLen(MemorySegment var0) {
      class="kw">return (int)RECV_INFO_FROM_LEN.get((MemorySegment)var0, (long)0L);
   }

   class="kw">public class="kw">static void setRecvInfoFromLen(MemorySegment var0, int var1) {
      RECV_INFO_FROM_LEN.set((MemorySegment)var0, (long)0L, (int)var1);
   }

   class="kw">public class="kw">static MemorySegment getRecvInfoTo(MemorySegment var0) {
      class="kw">return (MemorySegment)RECV_INFO_TO.get((MemorySegment)var0, (long)0L);
   }

   class="kw">public class="kw">static void setRecvInfoTo(MemorySegment var0, MemorySegment var1) {
      RECV_INFO_TO.set((MemorySegment)var0, (long)0L, (MemorySegment)var1);
   }

   class="kw">public class="kw">static int getRecvInfoToLen(MemorySegment var0) {
      class="kw">return (int)RECV_INFO_TO_LEN.get((MemorySegment)var0, (long)0L);
   }

   class="kw">public class="kw">static void setRecvInfoToLen(MemorySegment var0, int var1) {
      RECV_INFO_TO_LEN.set((MemorySegment)var0, (long)0L, (int)var1);
   }

   class="kw">public class="kw">static MemorySegment getSendInfoFrom(MemorySegment var0) {
      class="kw">return var0.asSlice(SEND_INFO_FROM_OFFSET, SOCKADDR_STORAGE_LAYOUT);
   }

   class="kw">public class="kw">static int getSendInfoFromLen(MemorySegment var0) {
      class="kw">return (int)SEND_INFO_FROM_LEN.get((MemorySegment)var0, (long)0L);
   }

   class="kw">public class="kw">static void setSendInfoFromLen(MemorySegment var0, int var1) {
      SEND_INFO_FROM_LEN.set((MemorySegment)var0, (long)0L, (int)var1);
   }

   class="kw">public class="kw">static MemorySegment getSendInfoTo(MemorySegment var0) {
      class="kw">return var0.asSlice(SEND_INFO_TO_OFFSET, SOCKADDR_STORAGE_LAYOUT);
   }

   class="kw">public class="kw">static int getSendInfoToLen(MemorySegment var0) {
      class="kw">return (int)SEND_INFO_TO_LEN.get((MemorySegment)var0, (long)0L);
   }

   class="kw">public class="kw">static void setSendInfoToLen(MemorySegment var0, int var1) {
      SEND_INFO_TO_LEN.set((MemorySegment)var0, (long)0L, (int)var1);
   }

   class="kw">public class="kw">static MemorySegment getSendInfoAt(MemorySegment var0) {
      class="kw">return var0.asSlice(SEND_INFO_AT_OFFSET, TIMESPEC_LAYOUT);
   }

   class="kw">private class="kw">static MethodHandle downcall(String var0, FunctionDescriptor var1) {
      class="kw">return LINKER.downcallHandle(LOOKUP.find(var0).orElseThrow(), var1);
   }

   class="kw">public class="kw">static MemorySegment version() {
      try {
         class="kw">return (MemorySegment)QUICHE_VERSION.invokeExact();
      } catch (Throwable var1) {
         throw SneakyThrow.sneakyThrow(var1);
      }
   }

   class="kw">public class="kw">static int enableDebugLogging(MemorySegment var0, MemorySegment var1) {
      try {
         class="kw">return (int)QUICHE_ENABLE_DEBUG_LOGGING.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static int putVarint(MemorySegment var0, long var1, long var3) {
      try {
         class="kw">return (int)QUICHE_PUT_VARINT.invokeExact((MemorySegment)var0, (long)var1, (long)var3);
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static long getVarint(MemorySegment var0, long var1, MemorySegment var3) {
      try {
         class="kw">return (long)QUICHE_GET_VARINT.invokeExact((MemorySegment)var0, (long)var1, (MemorySegment)var3);
      } catch (Throwable var5) {
         throw SneakyThrow.sneakyThrow(var5);
      }
   }

   class="kw">public class="kw">static MemorySegment configNew(int var0) {
      try {
         class="kw">return (MemorySegment)QUICHE_CONFIG_NEW.invokeExact((int)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static int configLoadCert(MemorySegment var0, MemorySegment var1, long var2) {
      try {
         class="kw">return (int)QUICHE_CONFIG_LOAD_CERT.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2);
      } catch (Throwable var5) {
         throw SneakyThrow.sneakyThrow(var5);
      }
   }

   class="kw">public class="kw">static int configLoadCertChainFromPemFile(MemorySegment var0, MemorySegment var1) {
      try {
         class="kw">return (int)QUICHE_CONFIG_LOAD_CERT_CHAIN_FROM_PEM_FILE.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static int configLoadPrivKey(MemorySegment var0, MemorySegment var1, long var2) {
      try {
         class="kw">return (int)QUICHE_CONFIG_LOAD_PRIV_KEY.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2);
      } catch (Throwable var5) {
         throw SneakyThrow.sneakyThrow(var5);
      }
   }

   class="kw">public class="kw">static int configLoadPrivKeyFromPemFile(MemorySegment var0, MemorySegment var1) {
      try {
         class="kw">return (int)QUICHE_CONFIG_LOAD_PRIV_KEY_FROM_PEM_FILE.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static int configLoadVerifyLocationsFromFile(MemorySegment var0, MemorySegment var1) {
      try {
         class="kw">return (int)QUICHE_CONFIG_LOAD_VERIFY_LOCATIONS_FROM_FILE.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static int configLoadVerifyLocationsFromDirectory(MemorySegment var0, MemorySegment var1) {
      try {
         class="kw">return (int)QUICHE_CONFIG_LOAD_VERIFY_LOCATIONS_FROM_DIRECTORY.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static void configVerifyPeer(MemorySegment var0, boolean var1) {
      try {
         QUICHE_CONFIG_VERIFY_PEER.invokeExact((MemorySegment)var0, (boolean)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static void configVerifyPeerOptional(MemorySegment var0) {
      try {
         QUICHE_CONFIG_VERIFY_PEER_OPTIONAL.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static void configGrease(MemorySegment var0, boolean var1) {
      try {
         QUICHE_CONFIG_GREASE.invokeExact((MemorySegment)var0, (boolean)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static void configDiscoverPmtu(MemorySegment var0, boolean var1) {
      try {
         QUICHE_CONFIG_DISCOVER_PMTU.invokeExact((MemorySegment)var0, (boolean)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static void configLogKeys(MemorySegment var0) {
      try {
         QUICHE_CONFIG_LOG_KEYS.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static void configEnableEarlyData(MemorySegment var0) {
      try {
         QUICHE_CONFIG_ENABLE_EARLY_DATA.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static int configSetApplicationProtos(MemorySegment var0, MemorySegment var1, long var2) {
      try {
         class="kw">return (int)QUICHE_CONFIG_SET_APPLICATION_PROTOS.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2);
      } catch (Throwable var5) {
         throw SneakyThrow.sneakyThrow(var5);
      }
   }

   class="kw">public class="kw">static void configSetMaxAmplificationFactor(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_MAX_AMPLIFICATION_FACTOR.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetMaxIdleTimeout(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_MAX_IDLE_TIMEOUT.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetMaxRecvUdpPayloadSize(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_MAX_RECV_UDP_PAYLOAD_SIZE.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetMaxSendUdpPayloadSize(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_MAX_SEND_UDP_PAYLOAD_SIZE.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetInitialMaxData(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_INITIAL_MAX_DATA.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetInitialMaxStreamDataBidiLocal(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetInitialMaxStreamDataBidiRemote(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetInitialMaxStreamDataUni(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_INITIAL_MAX_STREAM_DATA_UNI.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetInitialMaxStreamsBidi(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_INITIAL_MAX_STREAMS_BIDI.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetInitialMaxStreamsUni(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_INITIAL_MAX_STREAMS_UNI.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetAckDelayExponent(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_ACK_DELAY_EXPONENT.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetMaxAckDelay(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_MAX_ACK_DELAY.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetDisableActiveMigration(MemorySegment var0, boolean var1) {
      try {
         QUICHE_CONFIG_SET_DISABLE_ACTIVE_MIGRATION.invokeExact((MemorySegment)var0, (boolean)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static int configSetCcAlgorithmName(MemorySegment var0, MemorySegment var1) {
      try {
         class="kw">return (int)QUICHE_CONFIG_SET_CC_ALGORITHM_NAME.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static void configSetInitialCongestionWindowPackets(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_INITIAL_CONGESTION_WINDOW_PACKETS.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetCcAlgorithm(MemorySegment var0, int var1) {
      try {
         QUICHE_CONFIG_SET_CC_ALGORITHM.invokeExact((MemorySegment)var0, (int)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static void configEnableHystart(MemorySegment var0, boolean var1) {
      try {
         QUICHE_CONFIG_ENABLE_HYSTART.invokeExact((MemorySegment)var0, (boolean)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static void configEnablePacing(MemorySegment var0, boolean var1) {
      try {
         QUICHE_CONFIG_ENABLE_PACING.invokeExact((MemorySegment)var0, (boolean)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static void configSetMaxPacingRate(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_MAX_PACING_RATE.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configEnableDgram(MemorySegment var0, boolean var1, long var2, long var4) {
      try {
         QUICHE_CONFIG_ENABLE_DGRAM.invokeExact((MemorySegment)var0, (boolean)var1, (long)var2, (long)var4);
      } catch (Throwable var7) {
         throw SneakyThrow.sneakyThrow(var7);
      }
   }

   class="kw">public class="kw">static void configSetMaxConnectionWindow(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_MAX_CONNECTION_WINDOW.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetMaxStreamWindow(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_MAX_STREAM_WINDOW.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetActiveConnectionIdLimit(MemorySegment var0, long var1) {
      try {
         QUICHE_CONFIG_SET_ACTIVE_CONNECTION_ID_LIMIT.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void configSetStatelessResetToken(MemorySegment var0, MemorySegment var1) {
      try {
         QUICHE_CONFIG_SET_STATELESS_RESET_TOKEN.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static void configSetDisableDcidReuse(MemorySegment var0, boolean var1) {
      try {
         QUICHE_CONFIG_SET_DISABLE_DCID_REUSE.invokeExact((MemorySegment)var0, (boolean)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static int configSetTicketKey(MemorySegment var0, MemorySegment var1, long var2) {
      try {
         class="kw">return (int)QUICHE_CONFIG_SET_TICKET_KEY.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2);
      } catch (Throwable var5) {
         throw SneakyThrow.sneakyThrow(var5);
      }
   }

   class="kw">public class="kw">static void configFree(MemorySegment var0) {
      try {
         QUICHE_CONFIG_FREE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static int headerInfo(
      MemorySegment var0,
      long var1,
      long var3,
      MemorySegment var5,
      MemorySegment var6,
      MemorySegment var7,
      MemorySegment var8,
      MemorySegment var9,
      MemorySegment var10,
      MemorySegment var11,
      MemorySegment var12
   ) {
      try {
         class="kw">return (int)QUICHE_HEADER_INFO.invokeExact(
            (MemorySegment)var0,
            (long)var1,
            (long)var3,
            (MemorySegment)var5,
            (MemorySegment)var6,
            (MemorySegment)var7,
            (MemorySegment)var8,
            (MemorySegment)var9,
            (MemorySegment)var10,
            (MemorySegment)var11,
            (MemorySegment)var12
         );
      } catch (Throwable var14) {
         throw SneakyThrow.sneakyThrow(var14);
      }
   }

   class="kw">public class="kw">static MemorySegment accept(
      MemorySegment var0, long var1, MemorySegment var3, long var4, MemorySegment var6, int var7, MemorySegment var8, int var9, MemorySegment var10
   ) {
      try {
         class="kw">return (MemorySegment)QUICHE_ACCEPT.invokeExact(
            (MemorySegment)var0,
            (long)var1,
            (MemorySegment)var3,
            (long)var4,
            (MemorySegment)var6,
            (int)var7,
            (MemorySegment)var8,
            (int)var9,
            (MemorySegment)var10
         );
      } catch (Throwable var12) {
         throw SneakyThrow.sneakyThrow(var12);
      }
   }

   class="kw">public class="kw">static MemorySegment connect(
      MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, int var5, MemorySegment var6, int var7, MemorySegment var8
   ) {
      try {
         class="kw">return (MemorySegment)QUICHE_CONNECT.invokeExact(
            (MemorySegment)var0, (MemorySegment)var1, (long)var2, (MemorySegment)var4, (int)var5, (MemorySegment)var6, (int)var7, (MemorySegment)var8
         );
      } catch (Throwable var10) {
         throw SneakyThrow.sneakyThrow(var10);
      }
   }

   class="kw">public class="kw">static long negotiateVersion(MemorySegment var0, long var1, MemorySegment var3, long var4, MemorySegment var6, long var7) {
      try {
         class="kw">return (long)QUICHE_NEGOTIATE_VERSION.invokeExact((MemorySegment)var0, (long)var1, (MemorySegment)var3, (long)var4, (MemorySegment)var6, (long)var7);
      } catch (Throwable var10) {
         throw SneakyThrow.sneakyThrow(var10);
      }
   }

   class="kw">public class="kw">static long retry(
      MemorySegment var0,
      long var1,
      MemorySegment var3,
      long var4,
      MemorySegment var6,
      long var7,
      MemorySegment var9,
      long var10,
      int var12,
      MemorySegment var13,
      long var14
   ) {
      try {
         class="kw">return (long)QUICHE_RETRY.invokeExact(
            (MemorySegment)var0,
            (long)var1,
            (MemorySegment)var3,
            (long)var4,
            (MemorySegment)var6,
            (long)var7,
            (MemorySegment)var9,
            (long)var10,
            (int)var12,
            (MemorySegment)var13,
            (long)var14
         );
      } catch (Throwable var17) {
         throw SneakyThrow.sneakyThrow(var17);
      }
   }

   class="kw">public class="kw">static boolean versionIsSupported(int var0) {
      try {
         class="kw">return (boolean)QUICHE_VERSION_IS_SUPPORTED.invokeExact((int)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static MemorySegment connNewWithTls(
      MemorySegment var0,
      long var1,
      MemorySegment var3,
      long var4,
      MemorySegment var6,
      int var7,
      MemorySegment var8,
      int var9,
      MemorySegment var10,
      MemorySegment var11,
      boolean var12
   ) {
      try {
         class="kw">return (MemorySegment)QUICHE_CONN_NEW_WITH_TLS.invokeExact(
            (MemorySegment)var0,
            (long)var1,
            (MemorySegment)var3,
            (long)var4,
            (MemorySegment)var6,
            (int)var7,
            (MemorySegment)var8,
            (int)var9,
            (MemorySegment)var10,
            (MemorySegment)var11,
            (boolean)var12
         );
      } catch (Throwable var14) {
         throw SneakyThrow.sneakyThrow(var14);
      }
   }

   class="kw">public class="kw">static boolean connSetKeylogPath(MemorySegment var0, MemorySegment var1) {
      try {
         class="kw">return (boolean)QUICHE_CONN_SET_KEYLOG_PATH.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static boolean connSetQlogPath(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3) {
      try {
         class="kw">return (boolean)QUICHE_CONN_SET_QLOG_PATH.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2, (MemorySegment)var3);
      } catch (Throwable var5) {
         throw SneakyThrow.sneakyThrow(var5);
      }
   }

   class="kw">public class="kw">static int connSetSession(MemorySegment var0, MemorySegment var1, long var2) {
      try {
         class="kw">return (int)QUICHE_CONN_SET_SESSION.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2);
      } catch (Throwable var5) {
         throw SneakyThrow.sneakyThrow(var5);
      }
   }

   class="kw">public class="kw">static int connSetMaxIdleTimeout(MemorySegment var0, long var1) {
      try {
         class="kw">return (int)QUICHE_CONN_SET_MAX_IDLE_TIMEOUT.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static long connRecv(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4) {
      try {
         class="kw">return (long)QUICHE_CONN_RECV.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2, (MemorySegment)var4);
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static long connSend(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4) {
      try {
         class="kw">return (long)QUICHE_CONN_SEND.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2, (MemorySegment)var4);
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static long connSendQuantum(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_SEND_QUANTUM.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connSendOnPath(
      MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, int var5, MemorySegment var6, int var7, MemorySegment var8
   ) {
      try {
         class="kw">return (long)QUICHE_CONN_SEND_ON_PATH.invokeExact(
            (MemorySegment)var0, (MemorySegment)var1, (long)var2, (MemorySegment)var4, (int)var5, (MemorySegment)var6, (int)var7, (MemorySegment)var8
         );
      } catch (Throwable var10) {
         throw SneakyThrow.sneakyThrow(var10);
      }
   }

   class="kw">public class="kw">static long connSendQuantumOnPath(MemorySegment var0, MemorySegment var1, int var2, MemorySegment var3, int var4) {
      try {
         class="kw">return (long)QUICHE_CONN_SEND_QUANTUM_ON_PATH.invokeExact((MemorySegment)var0, (MemorySegment)var1, (int)var2, (MemorySegment)var3, (int)var4);
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static long connTimeoutAsNanos(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_TIMEOUT_AS_NANOS.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connTimeoutAsMillis(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_TIMEOUT_AS_MILLIS.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static void connOnTimeout(MemorySegment var0) {
      try {
         QUICHE_CONN_ON_TIMEOUT.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static int connClose(MemorySegment var0, boolean var1, long var2, MemorySegment var4, long var5) {
      try {
         class="kw">return (int)QUICHE_CONN_CLOSE.invokeExact((MemorySegment)var0, (boolean)var1, (long)var2, (MemorySegment)var4, (long)var5);
      } catch (Throwable var8) {
         throw SneakyThrow.sneakyThrow(var8);
      }
   }

   class="kw">public class="kw">static void connFree(MemorySegment var0) {
      try {
         QUICHE_CONN_FREE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connStreamRecv(MemorySegment var0, long var1, MemorySegment var3, long var4, MemorySegment var6, MemorySegment var7) {
      try {
         class="kw">return (long)QUICHE_CONN_STREAM_RECV.invokeExact(
            (MemorySegment)var0, (long)var1, (MemorySegment)var3, (long)var4, (MemorySegment)var6, (MemorySegment)var7
         );
      } catch (Throwable var9) {
         throw SneakyThrow.sneakyThrow(var9);
      }
   }

   class="kw">public class="kw">static long connStreamSend(MemorySegment var0, long var1, MemorySegment var3, long var4, boolean var6, MemorySegment var7) {
      try {
         class="kw">return (long)QUICHE_CONN_STREAM_SEND.invokeExact((MemorySegment)var0, (long)var1, (MemorySegment)var3, (long)var4, (boolean)var6, (MemorySegment)var7);
      } catch (Throwable var9) {
         throw SneakyThrow.sneakyThrow(var9);
      }
   }

   class="kw">public class="kw">static int connStreamPriority(MemorySegment var0, long var1, byte var3, boolean var4) {
      try {
         class="kw">return (int)QUICHE_CONN_STREAM_PRIORITY.invokeExact((MemorySegment)var0, (long)var1, (byte)var3, (boolean)var4);
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static int connStreamShutdown(MemorySegment var0, long var1, int var3, long var4) {
      if (var3 != 0 && var3 != 1) {
         throw new IllegalArgumentException("Invalid shutdown direction: " + var3);
      }

      try {
         class="kw">return (int)QUICHE_CONN_STREAM_SHUTDOWN.invokeExact((MemorySegment)var0, (long)var1, (int)var3, (long)var4);
      } catch (Throwable var7) {
         throw SneakyThrow.sneakyThrow(var7);
      }
   }

   class="kw">public class="kw">static long connStreamCapacity(MemorySegment var0, long var1) {
      try {
         class="kw">return (long)QUICHE_CONN_STREAM_CAPACITY.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static boolean connStreamReadable(MemorySegment var0, long var1) {
      try {
         class="kw">return (boolean)QUICHE_CONN_STREAM_READABLE.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static long connStreamReadableNext(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_STREAM_READABLE_NEXT.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static int connStreamWritable(MemorySegment var0, long var1, long var3) {
      try {
         class="kw">return (int)QUICHE_CONN_STREAM_WRITABLE.invokeExact((MemorySegment)var0, (long)var1, (long)var3);
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static long connStreamWritableNext(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_STREAM_WRITABLE_NEXT.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static boolean connStreamFinished(MemorySegment var0, long var1) {
      try {
         class="kw">return (boolean)QUICHE_CONN_STREAM_FINISHED.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static MemorySegment connReadable(MemorySegment var0) {
      try {
         class="kw">return (MemorySegment)QUICHE_CONN_READABLE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static MemorySegment connWritable(MemorySegment var0) {
      try {
         class="kw">return (MemorySegment)QUICHE_CONN_WRITABLE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static boolean streamIterNext(MemorySegment var0, MemorySegment var1) {
      try {
         class="kw">return (boolean)QUICHE_STREAM_ITER_NEXT.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static void streamIterFree(MemorySegment var0) {
      try {
         QUICHE_STREAM_ITER_FREE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connMaxSendUdpPayloadSize(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_MAX_SEND_UDP_PAYLOAD_SIZE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static boolean connIsEstablished(MemorySegment var0) {
      try {
         class="kw">return (boolean)QUICHE_CONN_IS_ESTABLISHED.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static boolean connIsResumed(MemorySegment var0) {
      try {
         class="kw">return (boolean)QUICHE_CONN_IS_RESUMED.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static boolean connIsInEarlyData(MemorySegment var0) {
      try {
         class="kw">return (boolean)QUICHE_CONN_IS_IN_EARLY_DATA.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static boolean connIsReadable(MemorySegment var0) {
      try {
         class="kw">return (boolean)QUICHE_CONN_IS_READABLE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static boolean connIsDraining(MemorySegment var0) {
      try {
         class="kw">return (boolean)QUICHE_CONN_IS_DRAINING.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static boolean connIsClosed(MemorySegment var0) {
      try {
         class="kw">return (boolean)QUICHE_CONN_IS_CLOSED.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static boolean connIsTimedOut(MemorySegment var0) {
      try {
         class="kw">return (boolean)QUICHE_CONN_IS_TIMED_OUT.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static boolean connIsServer(MemorySegment var0) {
      try {
         class="kw">return (boolean)QUICHE_CONN_IS_SERVER.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connPeerStreamsLeftBidi(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_PEER_STREAMS_LEFT_BIDI.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connPeerStreamsLeftUni(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_PEER_STREAMS_LEFT_UNI.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static void connTraceId(MemorySegment var0, MemorySegment var1, MemorySegment var2) {
      try {
         QUICHE_CONN_TRACE_ID.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void connSourceId(MemorySegment var0, MemorySegment var1, MemorySegment var2) {
      try {
         QUICHE_CONN_SOURCE_ID.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void connDestinationId(MemorySegment var0, MemorySegment var1, MemorySegment var2) {
      try {
         QUICHE_CONN_DESTINATION_ID.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void connApplicationProto(MemorySegment var0, MemorySegment var1, MemorySegment var2) {
      try {
         QUICHE_CONN_APPLICATION_PROTO.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void connPeerCert(MemorySegment var0, MemorySegment var1, MemorySegment var2) {
      try {
         QUICHE_CONN_PEER_CERT.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void connSession(MemorySegment var0, MemorySegment var1, MemorySegment var2) {
      try {
         QUICHE_CONN_SESSION.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void connServerName(MemorySegment var0, MemorySegment var1, MemorySegment var2) {
      try {
         QUICHE_CONN_SERVER_NAME.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static boolean connPeerError(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4) {
      try {
         class="kw">return (boolean)QUICHE_CONN_PEER_ERROR.invokeExact(
            (MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2, (MemorySegment)var3, (MemorySegment)var4
         );
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static boolean connLocalError(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4) {
      try {
         class="kw">return (boolean)QUICHE_CONN_LOCAL_ERROR.invokeExact(
            (MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2, (MemorySegment)var3, (MemorySegment)var4
         );
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static void connStats(MemorySegment var0, MemorySegment var1) {
      try {
         QUICHE_CONN_STATS.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static boolean connPeerTransportParams(MemorySegment var0, MemorySegment var1) {
      try {
         class="kw">return (boolean)QUICHE_CONN_PEER_TRANSPORT_PARAMS.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static int connPathStats(MemorySegment var0, long var1, MemorySegment var3) {
      try {
         class="kw">return (int)QUICHE_CONN_PATH_STATS.invokeExact((MemorySegment)var0, (long)var1, (MemorySegment)var3);
      } catch (Throwable var5) {
         throw SneakyThrow.sneakyThrow(var5);
      }
   }

   class="kw">public class="kw">static MemorySegment connSourceIds(MemorySegment var0) {
      try {
         class="kw">return (MemorySegment)QUICHE_CONN_SOURCE_IDS.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static boolean connectionIdIterNext(MemorySegment var0, MemorySegment var1, MemorySegment var2) {
      try {
         class="kw">return (boolean)QUICHE_CONNECTION_ID_ITER_NEXT.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void connectionIdIterFree(MemorySegment var0) {
      try {
         QUICHE_CONNECTION_ID_ITER_FREE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connRetiredScids(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_RETIRED_SCIDS.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connAvailableDcids(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_AVAILABLE_DCIDS.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connScidsLeft(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_SCIDS_LEFT.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connActiveScids(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_ACTIVE_SCIDS.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static int connNewScid(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, boolean var5, MemorySegment var6) {
      try {
         class="kw">return (int)QUICHE_CONN_NEW_SCID.invokeExact(
            (MemorySegment)var0, (MemorySegment)var1, (long)var2, (MemorySegment)var4, (boolean)var5, (MemorySegment)var6
         );
      } catch (Throwable var8) {
         throw SneakyThrow.sneakyThrow(var8);
      }
   }

   class="kw">public class="kw">static int connRetireDcid(MemorySegment var0, long var1) {
      try {
         class="kw">return (int)QUICHE_CONN_RETIRE_DCID.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static int connProbePath(MemorySegment var0, MemorySegment var1, int var2, MemorySegment var3, int var4, MemorySegment var5) {
      try {
         class="kw">return (int)QUICHE_CONN_PROBE_PATH.invokeExact(
            (MemorySegment)var0, (MemorySegment)var1, (int)var2, (MemorySegment)var3, (int)var4, (MemorySegment)var5
         );
      } catch (Throwable var7) {
         throw SneakyThrow.sneakyThrow(var7);
      }
   }

   class="kw">public class="kw">static int connMigrateSource(MemorySegment var0, MemorySegment var1, int var2, MemorySegment var3) {
      try {
         class="kw">return (int)QUICHE_CONN_MIGRATE_SOURCE.invokeExact((MemorySegment)var0, (MemorySegment)var1, (int)var2, (MemorySegment)var3);
      } catch (Throwable var5) {
         throw SneakyThrow.sneakyThrow(var5);
      }
   }

   class="kw">public class="kw">static int connMigrate(MemorySegment var0, MemorySegment var1, int var2, MemorySegment var3, int var4, MemorySegment var5) {
      try {
         class="kw">return (int)QUICHE_CONN_MIGRATE.invokeExact((MemorySegment)var0, (MemorySegment)var1, (int)var2, (MemorySegment)var3, (int)var4, (MemorySegment)var5);
      } catch (Throwable var7) {
         throw SneakyThrow.sneakyThrow(var7);
      }
   }

   class="kw">public class="kw">static MemorySegment connPathEventNext(MemorySegment var0) {
      try {
         class="kw">return (MemorySegment)QUICHE_CONN_PATH_EVENT_NEXT.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static int pathEventType(MemorySegment var0) {
      try {
         class="kw">return (int)QUICHE_PATH_EVENT_TYPE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static void pathEventNew(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4) {
      try {
         QUICHE_PATH_EVENT_NEW.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2, (MemorySegment)var3, (MemorySegment)var4);
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static void pathEventValidated(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4) {
      try {
         QUICHE_PATH_EVENT_VALIDATED.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2, (MemorySegment)var3, (MemorySegment)var4);
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static void pathEventFailedValidation(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4) {
      try {
         QUICHE_PATH_EVENT_FAILED_VALIDATION.invokeExact(
            (MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2, (MemorySegment)var3, (MemorySegment)var4
         );
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static void pathEventClosed(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4) {
      try {
         QUICHE_PATH_EVENT_CLOSED.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2, (MemorySegment)var3, (MemorySegment)var4);
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static void pathEventReusedSourceConnectionId(
      MemorySegment var0,
      MemorySegment var1,
      MemorySegment var2,
      MemorySegment var3,
      MemorySegment var4,
      MemorySegment var5,
      MemorySegment var6,
      MemorySegment var7,
      MemorySegment var8,
      MemorySegment var9
   ) {
      try {
         QUICHE_PATH_EVENT_REUSED_SOURCE_CONNECTION_ID.invokeExact(
            (MemorySegment)var0,
            (MemorySegment)var1,
            (MemorySegment)var2,
            (MemorySegment)var3,
            (MemorySegment)var4,
            (MemorySegment)var5,
            (MemorySegment)var6,
            (MemorySegment)var7,
            (MemorySegment)var8,
            (MemorySegment)var9
         );
      } catch (Throwable var11) {
         throw SneakyThrow.sneakyThrow(var11);
      }
   }

   class="kw">public class="kw">static void pathEventPeerMigrated(MemorySegment var0, MemorySegment var1, MemorySegment var2, MemorySegment var3, MemorySegment var4) {
      try {
         QUICHE_PATH_EVENT_PEER_MIGRATED.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2, (MemorySegment)var3, (MemorySegment)var4);
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static void pathEventFree(MemorySegment var0) {
      try {
         QUICHE_PATH_EVENT_FREE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static MemorySegment connPathsIter(MemorySegment var0, MemorySegment var1, long var2) {
      try {
         class="kw">return (MemorySegment)QUICHE_CONN_PATHS_ITER.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2);
      } catch (Throwable var5) {
         throw SneakyThrow.sneakyThrow(var5);
      }
   }

   class="kw">public class="kw">static boolean socketAddrIterNext(MemorySegment var0, MemorySegment var1, MemorySegment var2) {
      try {
         class="kw">return (boolean)QUICHE_SOCKET_ADDR_ITER_NEXT.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void socketAddrIterFree(MemorySegment var0) {
      try {
         QUICHE_SOCKET_ADDR_ITER_FREE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static int connIsPathValidated(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, long var5) {
      try {
         class="kw">return (int)QUICHE_CONN_IS_PATH_VALIDATED.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2, (MemorySegment)var4, (long)var5);
      } catch (Throwable var8) {
         throw SneakyThrow.sneakyThrow(var8);
      }
   }

   class="kw">public class="kw">static long connDgramMaxWritableLen(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_DGRAM_MAX_WRITABLE_LEN.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connDgramRecvFrontLen(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_DGRAM_RECV_FRONT_LEN.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connDgramRecvQueueLen(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_DGRAM_RECV_QUEUE_LEN.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connDgramRecvQueueByteSize(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_DGRAM_RECV_QUEUE_BYTE_SIZE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connDgramSendQueueLen(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_DGRAM_SEND_QUEUE_LEN.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connDgramSendQueueByteSize(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_DGRAM_SEND_QUEUE_BYTE_SIZE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connDgramRecv(MemorySegment var0, MemorySegment var1, long var2) {
      try {
         class="kw">return (long)QUICHE_CONN_DGRAM_RECV.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2);
      } catch (Throwable var5) {
         throw SneakyThrow.sneakyThrow(var5);
      }
   }

   class="kw">public class="kw">static long connDgramSend(MemorySegment var0, MemorySegment var1, long var2) {
      try {
         class="kw">return (long)QUICHE_CONN_DGRAM_SEND.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2);
      } catch (Throwable var5) {
         throw SneakyThrow.sneakyThrow(var5);
      }
   }

   class="kw">public class="kw">static void connDgramPurgeOutgoing(MemorySegment var0, MemorySegment var1) {
      try {
         QUICHE_CONN_DGRAM_PURGE_OUTGOING.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static boolean connIsDgramSendQueueFull(MemorySegment var0) {
      try {
         class="kw">return (boolean)QUICHE_CONN_IS_DGRAM_SEND_QUEUE_FULL.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static boolean connIsDgramRecvQueueFull(MemorySegment var0) {
      try {
         class="kw">return (boolean)QUICHE_CONN_IS_DGRAM_RECV_QUEUE_FULL.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connSendAckEliciting(MemorySegment var0) {
      try {
         class="kw">return (long)QUICHE_CONN_SEND_ACK_ELICITING.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long connSendAckElicitingOnPath(MemorySegment var0, MemorySegment var1, int var2, MemorySegment var3, int var4) {
      try {
         class="kw">return (long)QUICHE_CONN_SEND_ACK_ELICITING_ON_PATH.invokeExact((MemorySegment)var0, (MemorySegment)var1, (int)var2, (MemorySegment)var3, (int)var4);
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static MemorySegment h3ConfigNew() {
      try {
         class="kw">return (MemorySegment)QUICHE_H3_CONFIG_NEW.invokeExact();
      } catch (Throwable var1) {
         throw SneakyThrow.sneakyThrow(var1);
      }
   }

   class="kw">public class="kw">static void h3ConfigSetMaxFieldSectionSize(MemorySegment var0, long var1) {
      try {
         QUICHE_H3_CONFIG_SET_MAX_FIELD_SECTION_SIZE.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void h3ConfigSetQpackMaxTableCapacity(MemorySegment var0, long var1) {
      try {
         QUICHE_H3_CONFIG_SET_QPACK_MAX_TABLE_CAPACITY.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void h3ConfigSetQpackBlockedStreams(MemorySegment var0, long var1) {
      try {
         QUICHE_H3_CONFIG_SET_QPACK_BLOCKED_STREAMS.invokeExact((MemorySegment)var0, (long)var1);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static void h3ConfigEnableExtendedConnect(MemorySegment var0, boolean var1) {
      try {
         QUICHE_H3_CONFIG_ENABLE_EXTENDED_CONNECT.invokeExact((MemorySegment)var0, (boolean)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static void h3ConfigFree(MemorySegment var0) {
      try {
         QUICHE_H3_CONFIG_FREE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static MemorySegment h3ConnNewWithTransport(MemorySegment var0, MemorySegment var1) {
      try {
         class="kw">return (MemorySegment)QUICHE_H3_CONN_NEW_WITH_TRANSPORT.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static long h3ConnPoll(MemorySegment var0, MemorySegment var1, MemorySegment var2) {
      try {
         class="kw">return (long)QUICHE_H3_CONN_POLL.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static int h3EventType(MemorySegment var0) {
      try {
         class="kw">return (int)QUICHE_H3_EVENT_TYPE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static int h3EventForEachHeader(MemorySegment var0, MemorySegment var1, MemorySegment var2) {
      try {
         class="kw">return (int)QUICHE_H3_EVENT_FOR_EACH_HEADER.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static int h3ForEachSetting(MemorySegment var0, MemorySegment var1, MemorySegment var2) {
      try {
         class="kw">return (int)QUICHE_H3_FOR_EACH_SETTING.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2);
      } catch (Throwable var4) {
         throw SneakyThrow.sneakyThrow(var4);
      }
   }

   class="kw">public class="kw">static boolean h3EventHeadersHasMoreFrames(MemorySegment var0) {
      try {
         class="kw">return (boolean)QUICHE_H3_EVENT_HEADERS_HAS_MORE_FRAMES.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static boolean h3ExtendedConnectEnabledByPeer(MemorySegment var0) {
      try {
         class="kw">return (boolean)QUICHE_H3_EXTENDED_CONNECT_ENABLED_BY_PEER.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static void h3EventFree(MemorySegment var0) {
      try {
         QUICHE_H3_EVENT_FREE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">public class="kw">static long h3SendRequest(MemorySegment var0, MemorySegment var1, MemorySegment var2, long var3, boolean var5) {
      try {
         class="kw">return (long)QUICHE_H3_SEND_REQUEST.invokeExact((MemorySegment)var0, (MemorySegment)var1, (MemorySegment)var2, (long)var3, (boolean)var5);
      } catch (Throwable var7) {
         throw SneakyThrow.sneakyThrow(var7);
      }
   }

   class="kw">public class="kw">static int h3SendResponse(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, long var5, boolean var7) {
      try {
         class="kw">return (int)QUICHE_H3_SEND_RESPONSE.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2, (MemorySegment)var4, (long)var5, (boolean)var7);
      } catch (Throwable var9) {
         throw SneakyThrow.sneakyThrow(var9);
      }
   }

   class="kw">public class="kw">static int h3SendResponseWithPriority(
      MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, long var5, MemorySegment var7, boolean var8
   ) {
      try {
         class="kw">return (int)QUICHE_H3_SEND_RESPONSE_WITH_PRIORITY.invokeExact(
            (MemorySegment)var0, (MemorySegment)var1, (long)var2, (MemorySegment)var4, (long)var5, (MemorySegment)var7, (boolean)var8
         );
      } catch (Throwable var10) {
         throw SneakyThrow.sneakyThrow(var10);
      }
   }

   class="kw">public class="kw">static int h3SendAdditionalHeaders(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, long var5, boolean var7, boolean var8) {
      try {
         class="kw">return (int)QUICHE_H3_SEND_ADDITIONAL_HEADERS.invokeExact(
            (MemorySegment)var0, (MemorySegment)var1, (long)var2, (MemorySegment)var4, (long)var5, (boolean)var7, (boolean)var8
         );
      } catch (Throwable var10) {
         throw SneakyThrow.sneakyThrow(var10);
      }
   }

   class="kw">public class="kw">static long h3SendBody(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, long var5, boolean var7) {
      try {
         class="kw">return (long)QUICHE_H3_SEND_BODY.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2, (MemorySegment)var4, (long)var5, (boolean)var7);
      } catch (Throwable var9) {
         throw SneakyThrow.sneakyThrow(var9);
      }
   }

   class="kw">public class="kw">static long h3RecvBody(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4, long var5) {
      try {
         class="kw">return (long)QUICHE_H3_RECV_BODY.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2, (MemorySegment)var4, (long)var5);
      } catch (Throwable var8) {
         throw SneakyThrow.sneakyThrow(var8);
      }
   }

   class="kw">public class="kw">static int h3SendGoaway(MemorySegment var0, MemorySegment var1, long var2) {
      try {
         class="kw">return (int)QUICHE_H3_SEND_GOAWAY.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2);
      } catch (Throwable var5) {
         throw SneakyThrow.sneakyThrow(var5);
      }
   }

   class="kw">public class="kw">static int h3ParseExtensiblePriority(MemorySegment var0, long var1, MemorySegment var3) {
      try {
         class="kw">return (int)QUICHE_H3_PARSE_EXTENSIBLE_PRIORITY.invokeExact((MemorySegment)var0, (long)var1, (MemorySegment)var3);
      } catch (Throwable var5) {
         throw SneakyThrow.sneakyThrow(var5);
      }
   }

   class="kw">public class="kw">static int h3SendPriorityUpdateForRequest(MemorySegment var0, MemorySegment var1, long var2, MemorySegment var4) {
      try {
         class="kw">return (int)QUICHE_H3_SEND_PRIORITY_UPDATE_FOR_REQUEST.invokeExact((MemorySegment)var0, (MemorySegment)var1, (long)var2, (MemorySegment)var4);
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static int h3TakeLastPriorityUpdate(MemorySegment var0, long var1, MemorySegment var3, MemorySegment var4) {
      try {
         class="kw">return (int)QUICHE_H3_TAKE_LAST_PRIORITY_UPDATE.invokeExact((MemorySegment)var0, (long)var1, (MemorySegment)var3, (MemorySegment)var4);
      } catch (Throwable var6) {
         throw SneakyThrow.sneakyThrow(var6);
      }
   }

   class="kw">public class="kw">static boolean h3DgramEnabledByPeer(MemorySegment var0, MemorySegment var1) {
      try {
         class="kw">return (boolean)QUICHE_H3_DGRAM_ENABLED_BY_PEER.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static void h3ConnStats(MemorySegment var0, MemorySegment var1) {
      try {
         QUICHE_H3_CONN_STATS.invokeExact((MemorySegment)var0, (MemorySegment)var1);
      } catch (Throwable var3) {
         throw SneakyThrow.sneakyThrow(var3);
      }
   }

   class="kw">public class="kw">static void h3ConnFree(MemorySegment var0) {
      try {
         QUICHE_H3_CONN_FREE.invokeExact((MemorySegment)var0);
      } catch (Throwable var2) {
         throw SneakyThrow.sneakyThrow(var2);
      }
   }

   class="kw">static {
      String var0 = System.getProperty("os.name").toLowerCase(Locale.ROOT);
      String var1 = System.getProperty("os.arch").toLowerCase(Locale.ROOT);
      if (var0.contains("linux")) {
         PLATFORM = QuicheNative.Platform.LINUX;
      } else if (!var0.contains("mac") && !var0.contains("darwin")) {
         if (!var0.contains("win")) {
            throw new UnsupportedOperationException("Unsupported OS: " + var0);
         }

         PLATFORM = QuicheNative.Platform.WINDOWS;
      } else {
         PLATFORM = QuicheNative.Platform.MACOS;
      }
      String var2 = class="kw">switch (PLATFORM) {
         case LINUX -> {
            if (!"amd64".equals(var1) && !"x86_64".equals(var1)) {
               throw new UnsupportedOperationException("Unsupported Linux architecture: " + var1);
            }

            yield "/class="kw">native/linux-x64/libquiche.so";
         }
         case MACOS -> {
            if (!"aarch64".equals(var1)) {
               throw new UnsupportedOperationException("Unsupported macOS architecture: " + var1);
            }

            yield "/class="kw">native/osx-arm64/libquiche.dylib";
         }
         case WINDOWS -> {
            if (!"amd64".equals(var1) && !"x86_64".equals(var1)) {
               throw new UnsupportedOperationException("Unsupported Windows architecture: " + var1);
            }

            yield "/class="kw">native/win-x64/quiche.dll";
         }
      };

      try (InputStream var3 = QuicheNative.class.getResourceAsStream(var2)) {
         if (var3 == null) {
            throw new IllegalStateException("Native library not found on classpath: " + var2);
         }

         Path var4 = Files.createTempDirectory("quiche-class="kw">native");
         Path var5 = var4.resolve(Path.of(var2).getFileName());
         Files.copy(var3, var5, StandardCopyOption.REPLACE_EXISTING);
         var5.toFile().deleteOnExit();
         var4.toFile().deleteOnExit();
         LOOKUP = SymbolLookup.libraryLookup(var5, GLOBAL_ARENA);
      } catch (IOException var8) {
         throw new ExceptionInInitializerError(var8);
      }

      C_POINTER = ValueLayout.ADDRESS;
      C_INT = ValueLayout.JAVA_INT;
      C_LONG = ValueLayout.JAVA_LONG;
      C_BYTE = ValueLayout.JAVA_BYTE;
      C_BOOL = ValueLayout.JAVA_BOOLEAN;
      C_SHORT = ValueLayout.JAVA_SHORT;
      C_SIZE_T = (ValueLayout)LINKER.canonicalLayouts().get("size_t");

      SOCKADDR_STORAGE_LAYOUT = class="kw">switch (PLATFORM) {
         case LINUX -> MemoryLayout.structLayout(
               C_SHORT.withName("ss_family"), MemoryLayout.sequenceLayout(118L, C_BYTE).withName("__ss_padding"), C_LONG.withName("__ss_align")
            )
            .withName("sockaddr_storage");
         case MACOS -> MemoryLayout.structLayout(
               C_BYTE.withName("ss_len"),
               C_BYTE.withName("ss_family"),
               MemoryLayout.sequenceLayout(6L, C_BYTE).withName("__ss_pad1"),
               C_LONG.withName("__ss_align"),
               MemoryLayout.sequenceLayout(112L, C_BYTE).withName("__ss_pad2")
            )
            .withName("sockaddr_storage");
         case WINDOWS -> MemoryLayout.structLayout(
               C_SHORT.withName("ss_family"),
               MemoryLayout.sequenceLayout(6L, C_BYTE).withName("__ss_pad1"),
               C_LONG.withName("__ss_align"),
               MemoryLayout.sequenceLayout(112L, C_BYTE).withName("__ss_pad2")
            )
            .withName("sockaddr_storage");
      };

      SOCKADDR_LAYOUT = class="kw">switch (PLATFORM) {
         case LINUX, WINDOWS -> MemoryLayout.structLayout(C_SHORT.withName("sa_family"), MemoryLayout.sequenceLayout(14L, C_BYTE).withName("sa_data"))
            .withName("sockaddr");
         case MACOS -> MemoryLayout.structLayout(
               C_BYTE.withName("sa_len"), C_BYTE.withName("sa_family"), MemoryLayout.sequenceLayout(14L, C_BYTE).withName("sa_data")
            )
            .withName("sockaddr");
      };

      TIMESPEC_LAYOUT = class="kw">switch (PLATFORM) {
         case LINUX, MACOS -> MemoryLayout.structLayout(C_LONG.withName("tv_sec"), C_LONG.withName("tv_nsec")).withName("timespec");
         case WINDOWS -> MemoryLayout.structLayout(C_LONG.withName("tv_sec"), C_INT.withName("tv_nsec"), MemoryLayout.paddingLayout(4L)).withName("timespec");
      };
      RECV_INFO_LAYOUT = MemoryLayout.structLayout(
            C_POINTER.withName("from"),
            C_INT.withName("from_len"),
            MemoryLayout.paddingLayout(4L),
            C_POINTER.withName("to"),
            C_INT.withName("to_len"),
            MemoryLayout.paddingLayout(4L)
         )
         .withName("quiche_recv_info");
      SEND_INFO_LAYOUT = MemoryLayout.structLayout(
            SOCKADDR_STORAGE_LAYOUT.withName("from"),
            C_INT.withName("from_len"),
            MemoryLayout.paddingLayout(4L),
            SOCKADDR_STORAGE_LAYOUT.withName("to"),
            C_INT.withName("to_len"),
            MemoryLayout.paddingLayout(4L),
            TIMESPEC_LAYOUT.withName("at")
         )
         .withName("quiche_send_info");
      SOCKADDR_FAMILY = SOCKADDR_LAYOUT.varHandle(PathElement.groupElement("sa_family"));
      SOCKADDR_STORAGE_FAMILY = SOCKADDR_STORAGE_LAYOUT.varHandle(PathElement.groupElement("ss_family"));
      SOCKADDR_STORAGE_LEN = PLATFORM == QuicheNative.Platform.MACOS ? SOCKADDR_STORAGE_LAYOUT.varHandle(PathElement.groupElement("ss_len")) : null;
      SOCKADDR_STORAGE_DATA_OFFSET = SOCKADDR_STORAGE_LAYOUT.byteOffset(PathElement.groupElement("ss_family"))
         + SOCKADDR_STORAGE_LAYOUT.select(PathElement.groupElement("ss_family")).byteSize();
      TIMESPEC_SEC = TIMESPEC_LAYOUT.varHandle(PathElement.groupElement("tv_sec"));
      TIMESPEC_NSEC = TIMESPEC_LAYOUT.varHandle(PathElement.groupElement("tv_nsec"));
      RECV_INFO_FROM = RECV_INFO_LAYOUT.varHandle(PathElement.groupElement("from"));
      RECV_INFO_FROM_LEN = RECV_INFO_LAYOUT.varHandle(PathElement.groupElement("from_len"));
      RECV_INFO_TO = RECV_INFO_LAYOUT.varHandle(PathElement.groupElement("to"));
      RECV_INFO_TO_LEN = RECV_INFO_LAYOUT.varHandle(PathElement.groupElement("to_len"));
      SEND_INFO_FROM_OFFSET = SEND_INFO_LAYOUT.byteOffset(PathElement.groupElement("from"));
      SEND_INFO_FROM_LEN = SEND_INFO_LAYOUT.varHandle(PathElement.groupElement("from_len"));
      SEND_INFO_TO_OFFSET = SEND_INFO_LAYOUT.byteOffset(PathElement.groupElement("to"));
      SEND_INFO_TO_LEN = SEND_INFO_LAYOUT.varHandle(PathElement.groupElement("to_len"));
      SEND_INFO_AT_OFFSET = SEND_INFO_LAYOUT.byteOffset(PathElement.groupElement("at"));
      QUICHE_VERSION = downcall("quiche_version", FunctionDescriptor.of(C_POINTER));
      QUICHE_ENABLE_DEBUG_LOGGING = downcall("quiche_enable_debug_logging", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER));
      QUICHE_PUT_VARINT = downcall("quiche_put_varint", FunctionDescriptor.of(C_INT, C_POINTER, C_LONG, C_LONG));
      QUICHE_GET_VARINT = downcall("quiche_get_varint", FunctionDescriptor.of(C_LONG, C_POINTER, C_LONG, C_POINTER));
      QUICHE_CONFIG_NEW = downcall("quiche_config_new", FunctionDescriptor.of(C_POINTER, C_INT));
      QUICHE_CONFIG_LOAD_CERT = downcall("quiche_config_load_cert", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_LONG));
      QUICHE_CONFIG_LOAD_CERT_CHAIN_FROM_PEM_FILE = downcall("quiche_config_load_cert_chain_from_pem_file", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER));
      QUICHE_CONFIG_LOAD_PRIV_KEY = downcall("quiche_config_load_priv_key", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_LONG));
      QUICHE_CONFIG_LOAD_PRIV_KEY_FROM_PEM_FILE = downcall("quiche_config_load_priv_key_from_pem_file", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER));
      QUICHE_CONFIG_LOAD_VERIFY_LOCATIONS_FROM_FILE = downcall(
         "quiche_config_load_verify_locations_from_file", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER)
      );
      QUICHE_CONFIG_LOAD_VERIFY_LOCATIONS_FROM_DIRECTORY = downcall(
         "quiche_config_load_verify_locations_from_directory", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER)
      );
      QUICHE_CONFIG_VERIFY_PEER = downcall("quiche_config_verify_peer", FunctionDescriptor.ofVoid(C_POINTER, C_BOOL));
      QUICHE_CONFIG_VERIFY_PEER_OPTIONAL = downcall("quiche_config_verify_peer_optional", FunctionDescriptor.ofVoid(C_POINTER));
      QUICHE_CONFIG_GREASE = downcall("quiche_config_grease", FunctionDescriptor.ofVoid(C_POINTER, C_BOOL));
      QUICHE_CONFIG_DISCOVER_PMTU = downcall("quiche_config_discover_pmtu", FunctionDescriptor.ofVoid(C_POINTER, C_BOOL));
      QUICHE_CONFIG_LOG_KEYS = downcall("quiche_config_log_keys", FunctionDescriptor.ofVoid(C_POINTER));
      QUICHE_CONFIG_ENABLE_EARLY_DATA = downcall("quiche_config_enable_early_data", FunctionDescriptor.ofVoid(C_POINTER));
      QUICHE_CONFIG_SET_APPLICATION_PROTOS = downcall("quiche_config_set_application_protos", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_LONG));
      QUICHE_CONFIG_SET_MAX_AMPLIFICATION_FACTOR = downcall("quiche_config_set_max_amplification_factor", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_CONFIG_SET_MAX_IDLE_TIMEOUT = downcall("quiche_config_set_max_idle_timeout", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_CONFIG_SET_MAX_RECV_UDP_PAYLOAD_SIZE = downcall("quiche_config_set_max_recv_udp_payload_size", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_CONFIG_SET_MAX_SEND_UDP_PAYLOAD_SIZE = downcall("quiche_config_set_max_send_udp_payload_size", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_CONFIG_SET_INITIAL_MAX_DATA = downcall("quiche_config_set_initial_max_data", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_CONFIG_SET_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL = downcall(
         "quiche_config_set_initial_max_stream_data_bidi_local", FunctionDescriptor.ofVoid(C_POINTER, C_LONG)
      );
      QUICHE_CONFIG_SET_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE = downcall(
         "quiche_config_set_initial_max_stream_data_bidi_remote", FunctionDescriptor.ofVoid(C_POINTER, C_LONG)
      );
      QUICHE_CONFIG_SET_INITIAL_MAX_STREAM_DATA_UNI = downcall("quiche_config_set_initial_max_stream_data_uni", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_CONFIG_SET_INITIAL_MAX_STREAMS_BIDI = downcall("quiche_config_set_initial_max_streams_bidi", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_CONFIG_SET_INITIAL_MAX_STREAMS_UNI = downcall("quiche_config_set_initial_max_streams_uni", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_CONFIG_SET_ACK_DELAY_EXPONENT = downcall("quiche_config_set_ack_delay_exponent", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_CONFIG_SET_MAX_ACK_DELAY = downcall("quiche_config_set_max_ack_delay", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_CONFIG_SET_DISABLE_ACTIVE_MIGRATION = downcall("quiche_config_set_disable_active_migration", FunctionDescriptor.ofVoid(C_POINTER, C_BOOL));
      QUICHE_CONFIG_SET_CC_ALGORITHM_NAME = downcall("quiche_config_set_cc_algorithm_name", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER));
      QUICHE_CONFIG_SET_INITIAL_CONGESTION_WINDOW_PACKETS = downcall(
         "quiche_config_set_initial_congestion_window_packets", FunctionDescriptor.ofVoid(C_POINTER, C_LONG)
      );
      QUICHE_CONFIG_SET_CC_ALGORITHM = downcall("quiche_config_set_cc_algorithm", FunctionDescriptor.ofVoid(C_POINTER, C_INT));
      QUICHE_CONFIG_ENABLE_HYSTART = downcall("quiche_config_enable_hystart", FunctionDescriptor.ofVoid(C_POINTER, C_BOOL));
      QUICHE_CONFIG_ENABLE_PACING = downcall("quiche_config_enable_pacing", FunctionDescriptor.ofVoid(C_POINTER, C_BOOL));
      QUICHE_CONFIG_SET_MAX_PACING_RATE = downcall("quiche_config_set_max_pacing_rate", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_CONFIG_ENABLE_DGRAM = downcall("quiche_config_enable_dgram", FunctionDescriptor.ofVoid(C_POINTER, C_BOOL, C_LONG, C_LONG));
      QUICHE_CONFIG_SET_MAX_CONNECTION_WINDOW = downcall("quiche_config_set_max_connection_window", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_CONFIG_SET_MAX_STREAM_WINDOW = downcall("quiche_config_set_max_stream_window", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_CONFIG_SET_ACTIVE_CONNECTION_ID_LIMIT = downcall("quiche_config_set_active_connection_id_limit", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_CONFIG_SET_STATELESS_RESET_TOKEN = downcall("quiche_config_set_stateless_reset_token", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER));
      QUICHE_CONFIG_SET_DISABLE_DCID_REUSE = downcall("quiche_config_set_disable_dcid_reuse", FunctionDescriptor.ofVoid(C_POINTER, C_BOOL));
      QUICHE_CONFIG_SET_TICKET_KEY = downcall("quiche_config_set_ticket_key", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_LONG));
      QUICHE_CONFIG_FREE = downcall("quiche_config_free", FunctionDescriptor.ofVoid(C_POINTER));
      QUICHE_HEADER_INFO = downcall(
         "quiche_header_info",
         FunctionDescriptor.of(C_INT, C_POINTER, C_LONG, C_LONG, C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER)
      );
      QUICHE_ACCEPT = downcall(
         "quiche_accept", FunctionDescriptor.of(C_POINTER, C_POINTER, C_LONG, C_POINTER, C_LONG, C_POINTER, C_INT, C_POINTER, C_INT, C_POINTER)
      );
      QUICHE_CONNECT = downcall("quiche_connect", FunctionDescriptor.of(C_POINTER, C_POINTER, C_POINTER, C_LONG, C_POINTER, C_INT, C_POINTER, C_INT, C_POINTER));
      QUICHE_NEGOTIATE_VERSION = downcall("quiche_negotiate_version", FunctionDescriptor.of(C_LONG, C_POINTER, C_LONG, C_POINTER, C_LONG, C_POINTER, C_LONG));
      QUICHE_RETRY = downcall(
         "quiche_retry", FunctionDescriptor.of(C_LONG, C_POINTER, C_LONG, C_POINTER, C_LONG, C_POINTER, C_LONG, C_POINTER, C_LONG, C_INT, C_POINTER, C_LONG)
      );
      QUICHE_VERSION_IS_SUPPORTED = downcall("quiche_version_is_supported", FunctionDescriptor.of(C_BOOL, C_INT));
      QUICHE_CONN_NEW_WITH_TLS = downcall(
         "quiche_conn_new_with_tls",
         FunctionDescriptor.of(C_POINTER, C_POINTER, C_LONG, C_POINTER, C_LONG, C_POINTER, C_INT, C_POINTER, C_INT, C_POINTER, C_POINTER, C_BOOL)
      );
      QUICHE_CONN_SET_KEYLOG_PATH = downcall("quiche_conn_set_keylog_path", FunctionDescriptor.of(C_BOOL, C_POINTER, C_POINTER));
      QUICHE_CONN_SET_QLOG_PATH = downcall("quiche_conn_set_qlog_path", FunctionDescriptor.of(C_BOOL, C_POINTER, C_POINTER, C_POINTER, C_POINTER));
      QUICHE_CONN_SET_SESSION = downcall("quiche_conn_set_session", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_LONG));
      QUICHE_CONN_SET_MAX_IDLE_TIMEOUT = downcall("quiche_conn_set_max_idle_timeout", FunctionDescriptor.of(C_INT, C_POINTER, C_LONG));
      QUICHE_CONN_RECV = downcall("quiche_conn_recv", FunctionDescriptor.of(C_LONG, C_POINTER, C_POINTER, C_LONG, C_POINTER));
      QUICHE_CONN_SEND = downcall("quiche_conn_send", FunctionDescriptor.of(C_LONG, C_POINTER, C_POINTER, C_LONG, C_POINTER));
      QUICHE_CONN_SEND_QUANTUM = downcall("quiche_conn_send_quantum", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_SEND_ON_PATH = downcall(
         "quiche_conn_send_on_path", FunctionDescriptor.of(C_LONG, C_POINTER, C_POINTER, C_LONG, C_POINTER, C_INT, C_POINTER, C_INT, C_POINTER)
      );
      QUICHE_CONN_SEND_QUANTUM_ON_PATH = downcall(
         "quiche_conn_send_quantum_on_path", FunctionDescriptor.of(C_LONG, C_POINTER, C_POINTER, C_INT, C_POINTER, C_INT)
      );
      QUICHE_CONN_TIMEOUT_AS_NANOS = downcall("quiche_conn_timeout_as_nanos", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_TIMEOUT_AS_MILLIS = downcall("quiche_conn_timeout_as_millis", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_ON_TIMEOUT = downcall("quiche_conn_on_timeout", FunctionDescriptor.ofVoid(C_POINTER));
      QUICHE_CONN_CLOSE = downcall("quiche_conn_close", FunctionDescriptor.of(C_INT, C_POINTER, C_BOOL, C_LONG, C_POINTER, C_LONG));
      QUICHE_CONN_FREE = downcall("quiche_conn_free", FunctionDescriptor.ofVoid(C_POINTER));
      QUICHE_CONN_STREAM_RECV = downcall("quiche_conn_stream_recv", FunctionDescriptor.of(C_LONG, C_POINTER, C_LONG, C_POINTER, C_LONG, C_POINTER, C_POINTER));
      QUICHE_CONN_STREAM_SEND = downcall("quiche_conn_stream_send", FunctionDescriptor.of(C_LONG, C_POINTER, C_LONG, C_POINTER, C_LONG, C_BOOL, C_POINTER));
      QUICHE_CONN_STREAM_PRIORITY = downcall("quiche_conn_stream_priority", FunctionDescriptor.of(C_INT, C_POINTER, C_LONG, C_BYTE, C_BOOL));
      QUICHE_CONN_STREAM_SHUTDOWN = downcall("quiche_conn_stream_shutdown", FunctionDescriptor.of(C_INT, C_POINTER, C_LONG, C_INT, C_LONG));
      QUICHE_CONN_STREAM_CAPACITY = downcall("quiche_conn_stream_capacity", FunctionDescriptor.of(C_LONG, C_POINTER, C_LONG));
      QUICHE_CONN_STREAM_READABLE = downcall("quiche_conn_stream_readable", FunctionDescriptor.of(C_BOOL, C_POINTER, C_LONG));
      QUICHE_CONN_STREAM_READABLE_NEXT = downcall("quiche_conn_stream_readable_next", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_STREAM_WRITABLE = downcall("quiche_conn_stream_writable", FunctionDescriptor.of(C_INT, C_POINTER, C_LONG, C_LONG));
      QUICHE_CONN_STREAM_WRITABLE_NEXT = downcall("quiche_conn_stream_writable_next", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_STREAM_FINISHED = downcall("quiche_conn_stream_finished", FunctionDescriptor.of(C_BOOL, C_POINTER, C_LONG));
      QUICHE_CONN_READABLE = downcall("quiche_conn_readable", FunctionDescriptor.of(C_POINTER, C_POINTER));
      QUICHE_CONN_WRITABLE = downcall("quiche_conn_writable", FunctionDescriptor.of(C_POINTER, C_POINTER));
      QUICHE_STREAM_ITER_NEXT = downcall("quiche_stream_iter_next", FunctionDescriptor.of(C_BOOL, C_POINTER, C_POINTER));
      QUICHE_STREAM_ITER_FREE = downcall("quiche_stream_iter_free", FunctionDescriptor.ofVoid(C_POINTER));
      QUICHE_CONN_MAX_SEND_UDP_PAYLOAD_SIZE = downcall("quiche_conn_max_send_udp_payload_size", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_IS_ESTABLISHED = downcall("quiche_conn_is_established", FunctionDescriptor.of(C_BOOL, C_POINTER));
      QUICHE_CONN_IS_RESUMED = downcall("quiche_conn_is_resumed", FunctionDescriptor.of(C_BOOL, C_POINTER));
      QUICHE_CONN_IS_IN_EARLY_DATA = downcall("quiche_conn_is_in_early_data", FunctionDescriptor.of(C_BOOL, C_POINTER));
      QUICHE_CONN_IS_READABLE = downcall("quiche_conn_is_readable", FunctionDescriptor.of(C_BOOL, C_POINTER));
      QUICHE_CONN_IS_DRAINING = downcall("quiche_conn_is_draining", FunctionDescriptor.of(C_BOOL, C_POINTER));
      QUICHE_CONN_IS_CLOSED = downcall("quiche_conn_is_closed", FunctionDescriptor.of(C_BOOL, C_POINTER));
      QUICHE_CONN_IS_TIMED_OUT = downcall("quiche_conn_is_timed_out", FunctionDescriptor.of(C_BOOL, C_POINTER));
      QUICHE_CONN_IS_SERVER = downcall("quiche_conn_is_server", FunctionDescriptor.of(C_BOOL, C_POINTER));
      QUICHE_CONN_PEER_STREAMS_LEFT_BIDI = downcall("quiche_conn_peer_streams_left_bidi", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_PEER_STREAMS_LEFT_UNI = downcall("quiche_conn_peer_streams_left_uni", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_TRACE_ID = downcall("quiche_conn_trace_id", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER, C_POINTER));
      QUICHE_CONN_SOURCE_ID = downcall("quiche_conn_source_id", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER, C_POINTER));
      QUICHE_CONN_DESTINATION_ID = downcall("quiche_conn_destination_id", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER, C_POINTER));
      QUICHE_CONN_APPLICATION_PROTO = downcall("quiche_conn_application_proto", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER, C_POINTER));
      QUICHE_CONN_PEER_CERT = downcall("quiche_conn_peer_cert", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER, C_POINTER));
      QUICHE_CONN_SESSION = downcall("quiche_conn_session", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER, C_POINTER));
      QUICHE_CONN_SERVER_NAME = downcall("quiche_conn_server_name", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER, C_POINTER));
      QUICHE_CONN_PEER_ERROR = downcall("quiche_conn_peer_error", FunctionDescriptor.of(C_BOOL, C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER));
      QUICHE_CONN_LOCAL_ERROR = downcall("quiche_conn_local_error", FunctionDescriptor.of(C_BOOL, C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER));
      QUICHE_CONN_STATS = downcall("quiche_conn_stats", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER));
      QUICHE_CONN_PEER_TRANSPORT_PARAMS = downcall("quiche_conn_peer_transport_params", FunctionDescriptor.of(C_BOOL, C_POINTER, C_POINTER));
      QUICHE_CONN_PATH_STATS = downcall("quiche_conn_path_stats", FunctionDescriptor.of(C_INT, C_POINTER, C_LONG, C_POINTER));
      QUICHE_CONN_SOURCE_IDS = downcall("quiche_conn_source_ids", FunctionDescriptor.of(C_POINTER, C_POINTER));
      QUICHE_CONNECTION_ID_ITER_NEXT = downcall("quiche_connection_id_iter_next", FunctionDescriptor.of(C_BOOL, C_POINTER, C_POINTER, C_POINTER));
      QUICHE_CONNECTION_ID_ITER_FREE = downcall("quiche_connection_id_iter_free", FunctionDescriptor.ofVoid(C_POINTER));
      QUICHE_CONN_RETIRED_SCIDS = downcall("quiche_conn_retired_scids", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_AVAILABLE_DCIDS = downcall("quiche_conn_available_dcids", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_SCIDS_LEFT = downcall("quiche_conn_scids_left", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_ACTIVE_SCIDS = downcall("quiche_conn_active_scids", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_NEW_SCID = downcall("quiche_conn_new_scid", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_LONG, C_POINTER, C_BOOL, C_POINTER));
      QUICHE_CONN_RETIRE_DCID = downcall("quiche_conn_retire_dcid", FunctionDescriptor.of(C_INT, C_POINTER, C_LONG));
      QUICHE_CONN_PROBE_PATH = downcall("quiche_conn_probe_path", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_INT, C_POINTER, C_INT, C_POINTER));
      QUICHE_CONN_MIGRATE_SOURCE = downcall("quiche_conn_migrate_source", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_INT, C_POINTER));
      QUICHE_CONN_MIGRATE = downcall("quiche_conn_migrate", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_INT, C_POINTER, C_INT, C_POINTER));
      QUICHE_CONN_PATH_EVENT_NEXT = downcall("quiche_conn_path_event_next", FunctionDescriptor.of(C_POINTER, C_POINTER));
      QUICHE_PATH_EVENT_TYPE = downcall("quiche_path_event_type", FunctionDescriptor.of(C_INT, C_POINTER));
      QUICHE_PATH_EVENT_NEW = downcall("quiche_path_event_new", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER));
      QUICHE_PATH_EVENT_VALIDATED = downcall("quiche_path_event_validated", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER));
      QUICHE_PATH_EVENT_FAILED_VALIDATION = downcall(
         "quiche_path_event_failed_validation", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER)
      );
      QUICHE_PATH_EVENT_CLOSED = downcall("quiche_path_event_closed", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER));
      QUICHE_PATH_EVENT_REUSED_SOURCE_CONNECTION_ID = downcall(
         "quiche_path_event_reused_source_connection_id",
         FunctionDescriptor.ofVoid(C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER)
      );
      QUICHE_PATH_EVENT_PEER_MIGRATED = downcall(
         "quiche_path_event_peer_migrated", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER)
      );
      QUICHE_PATH_EVENT_FREE = downcall("quiche_path_event_free", FunctionDescriptor.ofVoid(C_POINTER));
      QUICHE_CONN_PATHS_ITER = downcall("quiche_conn_paths_iter", FunctionDescriptor.of(C_POINTER, C_POINTER, C_POINTER, C_LONG));
      QUICHE_SOCKET_ADDR_ITER_NEXT = downcall("quiche_socket_addr_iter_next", FunctionDescriptor.of(C_BOOL, C_POINTER, C_POINTER, C_POINTER));
      QUICHE_SOCKET_ADDR_ITER_FREE = downcall("quiche_socket_addr_iter_free", FunctionDescriptor.ofVoid(C_POINTER));
      QUICHE_CONN_IS_PATH_VALIDATED = downcall("quiche_conn_is_path_validated", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_LONG, C_POINTER, C_LONG));
      QUICHE_CONN_DGRAM_MAX_WRITABLE_LEN = downcall("quiche_conn_dgram_max_writable_len", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_DGRAM_RECV_FRONT_LEN = downcall("quiche_conn_dgram_recv_front_len", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_DGRAM_RECV_QUEUE_LEN = downcall("quiche_conn_dgram_recv_queue_len", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_DGRAM_RECV_QUEUE_BYTE_SIZE = downcall("quiche_conn_dgram_recv_queue_byte_size", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_DGRAM_SEND_QUEUE_LEN = downcall("quiche_conn_dgram_send_queue_len", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_DGRAM_SEND_QUEUE_BYTE_SIZE = downcall("quiche_conn_dgram_send_queue_byte_size", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_DGRAM_RECV = downcall("quiche_conn_dgram_recv", FunctionDescriptor.of(C_LONG, C_POINTER, C_POINTER, C_LONG));
      QUICHE_CONN_DGRAM_SEND = downcall("quiche_conn_dgram_send", FunctionDescriptor.of(C_LONG, C_POINTER, C_POINTER, C_LONG));
      QUICHE_CONN_DGRAM_PURGE_OUTGOING = downcall("quiche_conn_dgram_purge_outgoing", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER));
      QUICHE_CONN_IS_DGRAM_SEND_QUEUE_FULL = downcall("quiche_conn_is_dgram_send_queue_full", FunctionDescriptor.of(C_BOOL, C_POINTER));
      QUICHE_CONN_IS_DGRAM_RECV_QUEUE_FULL = downcall("quiche_conn_is_dgram_recv_queue_full", FunctionDescriptor.of(C_BOOL, C_POINTER));
      QUICHE_CONN_SEND_ACK_ELICITING = downcall("quiche_conn_send_ack_eliciting", FunctionDescriptor.of(C_LONG, C_POINTER));
      QUICHE_CONN_SEND_ACK_ELICITING_ON_PATH = downcall(
         "quiche_conn_send_ack_eliciting_on_path", FunctionDescriptor.of(C_LONG, C_POINTER, C_POINTER, C_INT, C_POINTER, C_INT)
      );
      QUICHE_H3_CONFIG_NEW = downcall("quiche_h3_config_new", FunctionDescriptor.of(C_POINTER));
      QUICHE_H3_CONFIG_SET_MAX_FIELD_SECTION_SIZE = downcall("quiche_h3_config_set_max_field_section_size", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_H3_CONFIG_SET_QPACK_MAX_TABLE_CAPACITY = downcall("quiche_h3_config_set_qpack_max_table_capacity", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_H3_CONFIG_SET_QPACK_BLOCKED_STREAMS = downcall("quiche_h3_config_set_qpack_blocked_streams", FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
      QUICHE_H3_CONFIG_ENABLE_EXTENDED_CONNECT = downcall("quiche_h3_config_enable_extended_connect", FunctionDescriptor.ofVoid(C_POINTER, C_BOOL));
      QUICHE_H3_CONFIG_FREE = downcall("quiche_h3_config_free", FunctionDescriptor.ofVoid(C_POINTER));
      QUICHE_H3_CONN_NEW_WITH_TRANSPORT = downcall("quiche_h3_conn_new_with_transport", FunctionDescriptor.of(C_POINTER, C_POINTER, C_POINTER));
      QUICHE_H3_CONN_POLL = downcall("quiche_h3_conn_poll", FunctionDescriptor.of(C_LONG, C_POINTER, C_POINTER, C_POINTER));
      QUICHE_H3_EVENT_TYPE = downcall("quiche_h3_event_type", FunctionDescriptor.of(C_INT, C_POINTER));
      QUICHE_H3_EVENT_FOR_EACH_HEADER = downcall("quiche_h3_event_for_each_header", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_POINTER));
      QUICHE_H3_FOR_EACH_SETTING = downcall("quiche_h3_for_each_setting", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_POINTER));
      QUICHE_H3_EVENT_HEADERS_HAS_MORE_FRAMES = downcall("quiche_h3_event_headers_has_more_frames", FunctionDescriptor.of(C_BOOL, C_POINTER));
      QUICHE_H3_EXTENDED_CONNECT_ENABLED_BY_PEER = downcall("quiche_h3_extended_connect_enabled_by_peer", FunctionDescriptor.of(C_BOOL, C_POINTER));
      QUICHE_H3_EVENT_FREE = downcall("quiche_h3_event_free", FunctionDescriptor.ofVoid(C_POINTER));
      QUICHE_H3_SEND_REQUEST = downcall("quiche_h3_send_request", FunctionDescriptor.of(C_LONG, C_POINTER, C_POINTER, C_POINTER, C_LONG, C_BOOL));
      QUICHE_H3_SEND_RESPONSE = downcall("quiche_h3_send_response", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_LONG, C_POINTER, C_LONG, C_BOOL));
      QUICHE_H3_SEND_RESPONSE_WITH_PRIORITY = downcall(
         "quiche_h3_send_response_with_priority", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_LONG, C_POINTER, C_LONG, C_POINTER, C_BOOL)
      );
      QUICHE_H3_SEND_ADDITIONAL_HEADERS = downcall(
         "quiche_h3_send_additional_headers", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_LONG, C_POINTER, C_LONG, C_BOOL, C_BOOL)
      );
      QUICHE_H3_SEND_BODY = downcall("quiche_h3_send_body", FunctionDescriptor.of(C_LONG, C_POINTER, C_POINTER, C_LONG, C_POINTER, C_LONG, C_BOOL));
      QUICHE_H3_RECV_BODY = downcall("quiche_h3_recv_body", FunctionDescriptor.of(C_LONG, C_POINTER, C_POINTER, C_LONG, C_POINTER, C_LONG));
      QUICHE_H3_SEND_GOAWAY = downcall("quiche_h3_send_goaway", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_LONG));
      QUICHE_H3_PARSE_EXTENSIBLE_PRIORITY = downcall("quiche_h3_parse_extensible_priority", FunctionDescriptor.of(C_INT, C_POINTER, C_LONG, C_POINTER));
      QUICHE_H3_SEND_PRIORITY_UPDATE_FOR_REQUEST = downcall(
         "quiche_h3_send_priority_update_for_request", FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER, C_LONG, C_POINTER)
      );
      QUICHE_H3_TAKE_LAST_PRIORITY_UPDATE = downcall(
         "quiche_h3_take_last_priority_update", FunctionDescriptor.of(C_INT, C_POINTER, C_LONG, C_POINTER, C_POINTER)
      );
      QUICHE_H3_DGRAM_ENABLED_BY_PEER = downcall("quiche_h3_dgram_enabled_by_peer", FunctionDescriptor.of(C_BOOL, C_POINTER, C_POINTER));
      QUICHE_H3_CONN_STATS = downcall("quiche_h3_conn_stats", FunctionDescriptor.ofVoid(C_POINTER, C_POINTER));
      QUICHE_H3_CONN_FREE = downcall("quiche_h3_conn_free", FunctionDescriptor.ofVoid(C_POINTER));
   }

   class="kw">public enum Platform {
      LINUX,
      MACOS,
      WINDOWS;

      Platform() {
      }
   }

   class="kw">public enum QuicheError {
      DONE(-1),
      BUFFER_TOO_SHORT(-2),
      UNKNOWN_VERSION(-3),
      INVALID_FRAME(-4),
      INVALID_PACKET(-5),
      INVALID_STATE(-6),
      INVALID_STREAM_STATE(-7),
      INVALID_TRANSPORT_PARAM(-8),
      CRYPTO_FAIL(-9),
      TLS_FAIL(-10),
      FLOW_CONTROL(-11),
      STREAM_LIMIT(-12),
      FINAL_SIZE(-13),
      CONGESTION_CONTROL(-14),
      STREAM_STOPPED(-15),
      STREAM_RESET(-16),
      ID_LIMIT(-17),
      OUT_OF_IDENTIFIERS(-18),
      KEY_UPDATE(-19),
      CRYPTO_BUFFER_EXCEEDED(-20),
      INVALID_ACK_RANGE(-21),
      OPTIMISTIC_ACK_DETECTED(-22);

      class="kw">private class="kw">static class="kw">final QuicheNative.QuicheError[] BY_CODE;
      class="kw">private class="kw">final int code;

      QuicheError(int nullxx) {
         this.code = nullxx;
      }

      class="kw">public int code() {
         class="kw">return this.code;
      }

      class="kw">public class="kw">static QuicheNative.QuicheError fromCode(int var0) {
         int var1 = -var0 - 1;
         class="kw">return var1 >= 0 && var1 < BY_CODE.length ? BY_CODE[var1] : null;
      }

      class="kw">static {
         QuicheNative.QuicheError[] var0 = values();
         BY_CODE = new QuicheNative.QuicheError[var0.length];

         for (QuicheNative.QuicheError var4 : var0) {
            BY_CODE[-var4.code - 1] = var4;
         }
      }
   }
}
last Загружено: 2026-09-03 в 20:47:25