class="kw">package com.hypixel.hytale.protocol.io;

class="kw">import com.github.luben.zstd.Zstd;
class="kw">import com.hypixel.hytale.protocol.Packet;
class="kw">import com.hypixel.hytale.protocol.PacketRegistry;
class="kw">import io.netty.buffer.ByteBuf;
class="kw">import io.netty.buffer.ByteBufAllocator;
class="kw">import io.netty.buffer.Unpooled;
class="kw">import java.lang.foreign.Arena;
class="kw">import java.lang.foreign.MemorySegment;
class="kw">import java.lang.foreign.ValueLayout;
class="kw">import java.lang.foreign.ValueLayout.OfBoolean;
class="kw">import java.lang.foreign.ValueLayout.OfByte;
class="kw">import java.lang.foreign.ValueLayout.OfDouble;
class="kw">import java.lang.foreign.ValueLayout.OfFloat;
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.nio.ByteBuffer;
class="kw">import java.nio.ByteOrder;
class="kw">import java.nio.charset.Charset;
class="kw">import java.nio.charset.StandardCharsets;
class="kw">import java.util.UUID;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Matrix4f;
class="kw">import org.joml.Matrix4fc;
class="kw">import org.joml.Quaternionf;
class="kw">import org.joml.Quaternionfc;
class="kw">import org.joml.Vector2f;
class="kw">import org.joml.Vector2fc;
class="kw">import org.joml.Vector3f;
class="kw">import org.joml.Vector3fc;
class="kw">import org.joml.Vector4f;
class="kw">import org.joml.Vector4fc;

class="kw">public class="kw">final class PacketIO {
   class="kw">public class="kw">static class="kw">final int FRAME_HEADER_SIZE = 4;
   class="kw">public class="kw">static class="kw">final int PACKET_HEADER_SIZE = 8;
   class="kw">public class="kw">static class="kw">final Charset UTF8 = StandardCharsets.UTF_8;
   class="kw">public class="kw">static class="kw">final Charset ASCII = StandardCharsets.US_ASCII;
   class="kw">public class="kw">static class="kw">final OfBoolean PROTO_BOOL = ValueLayout.JAVA_BOOLEAN.withOrder(ByteOrder.LITTLE_ENDIAN);
   class="kw">public class="kw">static class="kw">final OfByte PROTO_BYTE = ValueLayout.JAVA_BYTE.withOrder(ByteOrder.LITTLE_ENDIAN);
   class="kw">public class="kw">static class="kw">final OfShort PROTO_SHORT = ValueLayout.JAVA_SHORT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
   class="kw">public class="kw">static class="kw">final OfInt PROTO_INT = ValueLayout.JAVA_INT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
   class="kw">public class="kw">static class="kw">final OfLong PROTO_LONG = ValueLayout.JAVA_LONG_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
   class="kw">public class="kw">static class="kw">final OfFloat PROTO_FLOAT = ValueLayout.JAVA_FLOAT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
   class="kw">public class="kw">static class="kw">final OfDouble PROTO_DOUBLE = ValueLayout.JAVA_DOUBLE_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
   class="kw">public class="kw">static class="kw">final OfLong UUID_LONG = ValueLayout.JAVA_LONG_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN);
   class="kw">public class="kw">static class="kw">final Vector2fc ZERO_VECTOR2 = new Vector2f();
   class="kw">public class="kw">static class="kw">final Vector3fc ZERO_VECTOR3 = new Vector3f();
   class="kw">public class="kw">static class="kw">final Vector4fc ZERO_VECTOR4 = new Vector4f();
   class="kw">public class="kw">static class="kw">final Quaternionfc ZERO_QUATERNION = new Quaternionf(0.0F, 0.0F, 0.0F, 0.0F);
   class="kw">public class="kw">static class="kw">final Matrix4fc ZERO_MATRIX = new Matrix4f().zero();
   class="kw">private class="kw">static class="kw">final int COMPRESSION_LEVEL = Integer.getInteger("hytale.protocol.compressionLevel", Zstd.defaultCompressionLevel());
   class="kw">private class="kw">static class="kw">final byte[] EMPTY_PAYLOAD = new byte[0];

   class="kw">private PacketIO() {
   }

   @Nonnull
   class="kw">public class="kw">static byte[] readBytes(@Nonnull ByteBuf var0, int var1, int var2) {
      byte[] var3 = new byte[var2];
      var0.getBytes(var1, var3);
      class="kw">return var3;
   }

   @Nonnull
   class="kw">public class="kw">static String readFixedAsciiString(@Nonnull ByteBuf var0, int var1, int var2) {
      byte[] var3 = new byte[var2];
      var0.getBytes(var1, var3);
      int var4 = 0;

      while (var4 < var2 && var3[var4] != 0) {
         var4++;
      }

      class="kw">return new String(var3, 0, var4, StandardCharsets.US_ASCII);
   }

   @Nonnull
   class="kw">public class="kw">static String readFixedString(@Nonnull ByteBuf var0, int var1, int var2) {
      byte[] var3 = new byte[var2];
      var0.getBytes(var1, var3);
      int var4 = 0;

      while (var4 < var2 && var3[var4] != 0) {
         var4++;
      }

      class="kw">return new String(var3, 0, var4, StandardCharsets.UTF_8);
   }

   @Nonnull
   class="kw">public class="kw">static String readFixedAsciiString(@Nonnull MemorySegment var0, int var1, int var2) {
      byte[] var3 = new byte[var2];
      MemorySegment.copy(var0, PROTO_BYTE, var1, var3, 0, var2);
      int var4 = 0;

      while (var4 < var2 && var3[var4] != 0) {
         var4++;
      }

      class="kw">return new String(var3, 0, var4, StandardCharsets.US_ASCII);
   }

   @Nonnull
   class="kw">public class="kw">static String readFixedString(@Nonnull MemorySegment var0, int var1, int var2) {
      byte[] var3 = new byte[var2];
      MemorySegment.copy(var0, PROTO_BYTE, var1, var3, 0, var2);
      int var4 = 0;

      while (var4 < var2 && var3[var4] != 0) {
         var4++;
      }

      class="kw">return new String(var3, 0, var4, StandardCharsets.UTF_8);
   }

   @Nonnull
   class="kw">public class="kw">static String readVarString(@Nonnull ByteBuf var0, int var1) {
      class="kw">return readVarString(var0, var1, StandardCharsets.UTF_8);
   }

   @Nonnull
   class="kw">public class="kw">static String readVarString(@Nonnull ByteBuf var0, int var1, Charset var2) {
      int var3 = VarInt.peek(var0, var1);
      int var4 = VarInt.length(var0, var1);
      byte[] var5 = new byte[var3];
      var0.getBytes(var1 + var4, var5);
      class="kw">return new String(var5, var2);
   }

   @Nonnull
   class="kw">public class="kw">static String readValidatedAsciiString(@Nonnull ByteBuf var0, int var1, int var2, @Nonnull String var3) {
      byte[] var4 = new byte[var2];
      var0.getBytes(var1, var4);

      for (int var5 = 0; var5 < var2; var5++) {
         if ((var4[var5] & 255) > 127) {
            throw ProtocolException.invalidAsciiString(var3);
         }
      }

      class="kw">return new String(var4, StandardCharsets.US_ASCII);
   }

   @Nonnull
   class="kw">public class="kw">static String readVarString(String var0, @Nonnull MemorySegment var1, int var2, int var3, int var4) {
      class="kw">return readVarString(var0, var1, var2, var3, var4, VarInt.getWithLength(var1, var2));
   }

   @Nonnull
   class="kw">public class="kw">static String readVarString(String var0, @Nonnull MemorySegment var1, int var2, int var3, int var4, long var5) {
      int var7 = (int)var5;
      if (var7 == -1) {
         throw ProtocolException.invalidVarInt(var0);
      } else if (var7 > var4) {
         throw ProtocolException.stringTooLong(var0, var7, var4);
      } else if (var7 < var3) {
         throw ProtocolException.stringTooShort(var0, var7, var3);
      } else {
         int var8 = (int)(var5 >>> 32);
         if (var2 + var7 + var8 > var1.byteSize()) {
            throw ProtocolException.bufferTooSmall(var0, var7 + var8, (int)(var1.byteSize() - var2));
         } else {
            byte[] var9 = new byte[var7];
            MemorySegment.copy(var1, PROTO_BYTE, var2 + var8, var9, 0, var7);
            if (!isWellFormedUtf8(var9)) {
               throw ProtocolException.malformedString(var0);
            } else {
               class="kw">return new String(var9, UTF8);
            }
         }
      }
   }

   class="kw">public class="kw">static boolean isWellFormedUtf8(@Nonnull byte[] var0) {
      int var1 = 0;

      while (var1 < var0.length) {
         int var2 = var0[var1] & 255;
         if (var2 >= 128) {
            if (var2 >= 194 && var2 <= 244) {
               int var3;
               int var4;
               int var5;
               if (var2 < 224) {
                  var3 = 128;
                  var4 = 191;
                  var5 = 1;
               } else if (var2 < 240) {
                  var3 = var2 == 224 ? 160 : 128;
                  var4 = var2 == 237 ? 159 : 191;
                  var5 = 2;
               } else {
                  var3 = var2 == 240 ? 144 : 128;
                  var4 = var2 == 244 ? 143 : 191;
                  var5 = 3;
               }

               if (var1 + var5 >= var0.length) {
                  class="kw">return false;
               }

               int var6 = var0[var1 + 1] & 255;
               if (var6 >= var3 && var6 <= var4) {
                  for (int var7 = 2; var7 <= var5; var7++) {
                     int var8 = var0[var1 + var7] & 255;
                     if (var8 < 128 || var8 > 191) {
                        class="kw">return false;
                     }
                  }

                  var1 += var5 + 1;
                  class="kw">continue;
               }

               class="kw">return false;
            }

            class="kw">return false;
         } else {
            var1++;
         }
      }

      class="kw">return true;
   }

   @Nonnull
   class="kw">public class="kw">static String readVarString(String var0, @Nonnull MemorySegment var1, int var2, int var3) {
      class="kw">return readVarString(var0, var1, var2, 0, var3);
   }

   @Nonnull
   class="kw">public class="kw">static String readValidatedAsciiString(String var0, @Nonnull MemorySegment var1, int var2, int var3, int var4) {
      class="kw">return readValidatedAsciiString(var0, var1, var2, var3, var4, VarInt.getWithLength(var1, var2));
   }

   @Nonnull
   class="kw">public class="kw">static String readValidatedAsciiString(String var0, @Nonnull MemorySegment var1, int var2, int var3, int var4, long var5) {
      int var7 = (int)var5;
      if (var7 == -1) {
         throw ProtocolException.invalidVarInt(var0);
      }

      if (var7 > var4) {
         throw ProtocolException.stringTooLong(var0, var7, var4);
      }

      if (var7 < var3) {
         throw ProtocolException.stringTooShort(var0, var7, var3);
      }

      int var8 = (int)(var5 >>> 32);
      if (var2 + var7 + var8 > var1.byteSize()) {
         throw ProtocolException.bufferTooSmall(var0, var7 + var8, (int)(var1.byteSize() - var2));
      }

      byte[] var9 = new byte[var7];
      MemorySegment.copy(var1, PROTO_BYTE, var2 + var8, var9, 0, var7);

      for (int var10 = 0; var10 < var7; var10++) {
         if ((var9[var10] & 255) > 127) {
            throw ProtocolException.invalidAsciiString(var0);
         }
      }

      class="kw">return new String(var9, StandardCharsets.US_ASCII);
   }

   @Nonnull
   class="kw">public class="kw">static String readValidatedAsciiString(String var0, @Nonnull MemorySegment var1, int var2, int var3) {
      class="kw">return readValidatedAsciiString(var0, var1, var2, 0, var3);
   }

   class="kw">public class="kw">static float requireFinite(float var0, @Nonnull String var1) {
      if (!Float.isFinite(var0)) {
         throw ProtocolException.valueNotFinite(var1, var0);
      } else {
         class="kw">return var0;
      }
   }

   class="kw">public class="kw">static double requireFinite(double var0, @Nonnull String var2) {
      if (!Double.isFinite(var0)) {
         throw ProtocolException.valueNotFinite(var2, var0);
      } else {
         class="kw">return var0;
      }
   }

   class="kw">public class="kw">static boolean isFinite(float var0) {
      class="kw">return Float.isFinite(var0);
   }

   class="kw">public class="kw">static boolean isFinite(double var0) {
      class="kw">return Double.isFinite(var0);
   }

   class="kw">public class="kw">static boolean isFinite(@Nonnull Vector2fc var0) {
      class="kw">return Float.isFinite(var0.x()) && Float.isFinite(var0.y());
   }

   class="kw">public class="kw">static boolean isFinite(@Nonnull Vector3fc var0) {
      class="kw">return Float.isFinite(var0.x()) && Float.isFinite(var0.y()) && Float.isFinite(var0.z());
   }

   class="kw">public class="kw">static boolean isFinite(@Nonnull Vector4fc var0) {
      class="kw">return Float.isFinite(var0.x()) && Float.isFinite(var0.y()) && Float.isFinite(var0.z()) && Float.isFinite(var0.w());
   }

   class="kw">public class="kw">static boolean isFinite(@Nonnull Quaternionfc var0) {
      class="kw">return Float.isFinite(var0.x()) && Float.isFinite(var0.y()) && Float.isFinite(var0.z()) && Float.isFinite(var0.w());
   }

   class="kw">public class="kw">static boolean isFinite(@Nonnull Matrix4fc var0) {
      class="kw">return Float.isFinite(var0.m00())
         && Float.isFinite(var0.m01())
         && Float.isFinite(var0.m02())
         && Float.isFinite(var0.m03())
         && Float.isFinite(var0.m10())
         && Float.isFinite(var0.m11())
         && Float.isFinite(var0.m12())
         && Float.isFinite(var0.m13())
         && Float.isFinite(var0.m20())
         && Float.isFinite(var0.m21())
         && Float.isFinite(var0.m22())
         && Float.isFinite(var0.m23())
         && Float.isFinite(var0.m30())
         && Float.isFinite(var0.m31())
         && Float.isFinite(var0.m32())
         && Float.isFinite(var0.m33());
   }

   @Nonnull
   class="kw">public class="kw">static Vector2fc requireFinite(@Nonnull Vector2fc var0, @Nonnull String var1) {
      if (!isFinite(var0)) {
         throw ProtocolException.valueNotFinite(var1, var0);
      } else {
         class="kw">return var0;
      }
   }

   @Nonnull
   class="kw">public class="kw">static Vector3fc requireFinite(@Nonnull Vector3fc var0, @Nonnull String var1) {
      if (!isFinite(var0)) {
         throw ProtocolException.valueNotFinite(var1, var0);
      } else {
         class="kw">return var0;
      }
   }

   @Nonnull
   class="kw">public class="kw">static Vector4fc requireFinite(@Nonnull Vector4fc var0, @Nonnull String var1) {
      if (!isFinite(var0)) {
         throw ProtocolException.valueNotFinite(var1, var0);
      } else {
         class="kw">return var0;
      }
   }

   @Nonnull
   class="kw">public class="kw">static Quaternionfc requireFinite(@Nonnull Quaternionfc var0, @Nonnull String var1) {
      if (!isFinite(var0)) {
         throw ProtocolException.valueNotFinite(var1, var0);
      } else {
         class="kw">return var0;
      }
   }

   @Nonnull
   class="kw">public class="kw">static Matrix4fc requireFinite(@Nonnull Matrix4fc var0, @Nonnull String var1) {
      if (!isFinite(var0)) {
         throw ProtocolException.valueNotFinite(var1, var0);
      } else {
         class="kw">return var0;
      }
   }

   class="kw">public class="kw">static int utf8ByteLength(@Nonnull String var0) {
      int var1 = 0;

      for (int var2 = 0; var2 < var0.length(); var2++) {
         char var3 = var0.charAt(var2);
         if (var3 < 128) {
            var1++;
         } else if (var3 < 2048) {
            var1 += 2;
         } else if (Character.isHighSurrogate(var3)) {
            var1 += 4;
            var2++;
         } else {
            var1 += 3;
         }
      }

      class="kw">return var1;
   }

   class="kw">public class="kw">static int stringSize(@Nonnull String var0) {
      int var1 = utf8ByteLength(var0);
      class="kw">return VarInt.size(var1) + var1;
   }

   class="kw">public class="kw">static void writeFixedAsciiString(@Nonnull ByteBuf var0, @Nullable String var1, int var2) {
      if (var1 != null) {
         byte[] var3 = var1.getBytes(StandardCharsets.US_ASCII);
         if (var3.length > var2) {
            throw new ProtocolException("Fixed ASCII string exceeds length: " + var3.length + " > " + var2);
         }

         var0.writeBytes(var3);
         var0.writeZero(var2 - var3.length);
      } else {
         var0.writeZero(var2);
      }
   }

   class="kw">public class="kw">static void writeFixedString(@Nonnull ByteBuf var0, @Nullable String var1, int var2) {
      if (var1 != null) {
         byte[] var3 = var1.getBytes(StandardCharsets.UTF_8);
         if (var3.length > var2) {
            throw new ProtocolException("Fixed UTF-8 string exceeds length: " + var3.length + " > " + var2);
         }

         var0.writeBytes(var3);
         var0.writeZero(var2 - var3.length);
      } else {
         var0.writeZero(var2);
      }
   }

   class="kw">public class="kw">static void writeVarString(@Nonnull ByteBuf var0, @Nonnull String var1, int var2) {
      byte[] var3 = var1.getBytes(StandardCharsets.UTF_8);
      if (var3.length > var2) {
         throw new ProtocolException("String exceeds max bytes: " + var3.length + " > " + var2);
      }

      VarInt.write(var0, var3.length);
      var0.writeBytes(var3);
   }

   class="kw">public class="kw">static void writeVarAsciiString(@Nonnull ByteBuf var0, @Nonnull String var1, int var2) {
      byte[] var3 = var1.getBytes(StandardCharsets.US_ASCII);
      if (var3.length > var2) {
         throw new ProtocolException("String exceeds max bytes: " + var3.length + " > " + var2);
      }

      VarInt.write(var0, var3.length);
      var0.writeBytes(var3);
   }

   class="kw">public class="kw">static int writeVarString(@Nonnull MemorySegment var0, int var1, @Nonnull String var2, int var3) {
      byte[] var4 = var2.getBytes(UTF8);
      if (var4.length > var3) {
         throw new ProtocolException("String exceeds max bytes: " + var4.length + " > " + var3);
      }

      int var5 = VarInt.set(var0, var1, var4.length);
      MemorySegment.copy(var4, 0, var0, ValueLayout.JAVA_BYTE, var1 + var5, var4.length);
      class="kw">return var5 + var4.length;
   }

   class="kw">public class="kw">static int writeVarAsciiString(@Nonnull MemorySegment var0, int var1, @Nonnull String var2, int var3) {
      byte[] var4 = var2.getBytes(ASCII);
      if (var4.length > var3) {
         throw new ProtocolException("String exceeds max bytes: " + var4.length + " > " + var3);
      }

      int var5 = VarInt.set(var0, var1, var4.length);
      MemorySegment.copy(var4, 0, var0, ValueLayout.JAVA_BYTE, var1 + var5, var4.length);
      class="kw">return var5 + var4.length;
   }

   @Nonnull
   class="kw">public class="kw">static Vector2f readVector2f(@Nonnull MemorySegment var0, int var1) {
      class="kw">return new Vector2f(var0.get(PROTO_FLOAT, var1), var0.get(PROTO_FLOAT, var1 + 4));
   }

   @Nonnull
   class="kw">public class="kw">static Vector3f readVector3f(@Nonnull MemorySegment var0, int var1) {
      class="kw">return new Vector3f(var0.get(PROTO_FLOAT, var1), var0.get(PROTO_FLOAT, var1 + 4), var0.get(PROTO_FLOAT, var1 + 8));
   }

   @Nonnull
   class="kw">public class="kw">static Vector4f readVector4f(@Nonnull MemorySegment var0, int var1) {
      class="kw">return new Vector4f(var0.get(PROTO_FLOAT, var1), var0.get(PROTO_FLOAT, var1 + 4), var0.get(PROTO_FLOAT, var1 + 8), var0.get(PROTO_FLOAT, var1 + 12));
   }

   @Nonnull
   class="kw">public class="kw">static Quaternionf readQuaternionf(@Nonnull MemorySegment var0, int var1) {
      class="kw">return new Quaternionf(var0.get(PROTO_FLOAT, var1), var0.get(PROTO_FLOAT, var1 + 4), var0.get(PROTO_FLOAT, var1 + 8), var0.get(PROTO_FLOAT, var1 + 12));
   }

   class="kw">public class="kw">static void writeVector2f(@Nonnull MemorySegment var0, int var1, @Nonnull Vector2fc var2) {
      var0.set(PROTO_FLOAT, var1, var2.x());
      var0.set(PROTO_FLOAT, var1 + 4, var2.y());
   }

   class="kw">public class="kw">static void writeVector3f(@Nonnull MemorySegment var0, int var1, @Nonnull Vector3fc var2) {
      var0.set(PROTO_FLOAT, var1, var2.x());
      var0.set(PROTO_FLOAT, var1 + 4, var2.y());
      var0.set(PROTO_FLOAT, var1 + 8, var2.z());
   }

   class="kw">public class="kw">static void writeVector4f(@Nonnull MemorySegment var0, int var1, @Nonnull Vector4fc var2) {
      var0.set(PROTO_FLOAT, var1, var2.x());
      var0.set(PROTO_FLOAT, var1 + 4, var2.y());
      var0.set(PROTO_FLOAT, var1 + 8, var2.z());
      var0.set(PROTO_FLOAT, var1 + 12, var2.w());
   }

   class="kw">public class="kw">static void writeQuaternionf(@Nonnull MemorySegment var0, int var1, @Nonnull Quaternionfc var2) {
      var0.set(PROTO_FLOAT, var1, var2.x());
      var0.set(PROTO_FLOAT, var1 + 4, var2.y());
      var0.set(PROTO_FLOAT, var1 + 8, var2.z());
      var0.set(PROTO_FLOAT, var1 + 12, var2.w());
   }

   class="kw">public class="kw">static void writeFixedAsciiString(@Nonnull MemorySegment var0, int var1, @Nullable String var2, int var3) {
      if (var2 != null) {
         byte[] var4 = var2.getBytes(StandardCharsets.US_ASCII);
         if (var4.length > var3) {
            throw new ProtocolException("Fixed ASCII string exceeds length: " + var4.length + " > " + var3);
         }

         MemorySegment.copy(var4, 0, var0, PROTO_BYTE, var1, var4.length);
         var0.asSlice(var1 + var4.length, var3 - var4.length).fill((byte)0);
      } else {
         var0.asSlice(var1, var3).fill((byte)0);
      }
   }

   class="kw">public class="kw">static void writeFixedString(@Nonnull MemorySegment var0, int var1, @Nullable String var2, int var3) {
      if (var2 != null) {
         byte[] var4 = var2.getBytes(StandardCharsets.UTF_8);
         if (var4.length > var3) {
            throw new ProtocolException("Fixed UTF-8 string exceeds length: " + var4.length + " > " + var3);
         }

         MemorySegment.copy(var4, 0, var0, PROTO_BYTE, var1, var4.length);
         var0.asSlice(var1 + var4.length, var3 - var4.length).fill((byte)0);
      } else {
         var0.asSlice(var1, var3).fill((byte)0);
      }
   }

   @Nonnull
   class="kw">public class="kw">static UUID readUUID(@Nonnull ByteBuf var0, int var1) {
      long var2 = var0.getLong(var1);
      long var4 = var0.getLong(var1 + 8);
      class="kw">return new UUID(var2, var4);
   }

   class="kw">public class="kw">static void writeUUID(@Nonnull ByteBuf var0, @Nonnull UUID var1) {
      var0.writeLong(var1.getMostSignificantBits());
      var0.writeLong(var1.getLeastSignificantBits());
   }

   @Nonnull
   class="kw">public class="kw">static UUID readUUID(@Nonnull MemorySegment var0, int var1) {
      long var2 = var0.get(UUID_LONG, var1);
      long var4 = var0.get(UUID_LONG, var1 + 8);
      class="kw">return new UUID(var2, var4);
   }

   class="kw">public class="kw">static void writeUUID(@Nonnull MemorySegment var0, int var1, @Nonnull UUID var2) {
      var0.set(UUID_LONG, var1, var2.getMostSignificantBits());
      var0.set(UUID_LONG, var1 + 8, var2.getLeastSignificantBits());
   }

   class="kw">public class="kw">static float halfToFloat(short var0) {
      int var1 = var0 & '\uffff';
      int var2 = var1 >>> 15 & 1;
      int var3 = var1 >>> 10 & 31;
      int var4 = var1 & 1023;
      if (var3 == 0) {
         if (var4 == 0) {
            class="kw">return var2 == 0 ? 0.0F : -0.0F;
         }

         for (var3 = 1; (var4 & 1024) == 0; var3--) {
            var4 <<= 1;
         }

         var4 &= 1023;
      } else if (var3 == 31) {
         class="kw">return var4 == 0 ? (var2 == 0 ? Float.POSITIVE_INFINITY : Float.NEGATIVE_INFINITY) : Float.NaN;
      }

      int var5 = var2 << 31 | var3 + 112 << 23 | var4 << 13;
      class="kw">return Float.intBitsToFloat(var5);
   }

   class="kw">public class="kw">static short floatToHalf(float var0) {
      int var1 = Float.floatToRawIntBits(var0);
      int var2 = var1 >>> 16 & 32768;
      int var3 = (var1 & 2147483647) + 4096;
      if (var3 >= 1199570944) {
         if ((var1 & 2147483647) >= 1199570944) {
            class="kw">return var3 < 2139095040 ? (short)(var2 | 31744) : (short)(var2 | 31744 | (var1 & 8388607) >>> 13);
         } else {
            class="kw">return (short)(var2 | 31743);
         }
      } else {
         if (var3 >= 947912704) {
            class="kw">return (short)(var2 | var3 - 939524096 >>> 13);
         }

         if (var3 < 855638016) {
            class="kw">return (short)var2;
         }

         var3 = (var1 & 2147483647) >>> 23;
         class="kw">return (short)(var2 | (var1 & 8388607 | 8388608) + (8388608 >>> var3 - 102) >>> 126 - var3);
      }
   }

   class="kw">private class="kw">static int compressToBuffer(@Nonnull ByteBuf var0, @Nonnull ByteBuf var1, int var2, int var3) {
      if (var0.isDirect() && var1.isDirect()) {
         class="kw">return Zstd.compress(var1.nioBuffer(var2, var3), var0.nioBuffer(), COMPRESSION_LEVEL);
      }

      int var4 = var0.readableBytes();
      byte[] var5 = new byte[var4];
      var0.getBytes(var0.readerIndex(), var5);
      byte[] var6 = Zstd.compress(var5, COMPRESSION_LEVEL);
      var1.setBytes(var2, var6);
      class="kw">return var6.length;
   }

   @Nonnull
   class="kw">private class="kw">static ByteBuf decompressFromBuffer(@Nonnull ByteBufAllocator var0, @Nonnull ByteBuf var1, int var2, int var3, int var4) {
      if (var3 > var4) {
         throw new ProtocolException("Compressed size " + var3 + " exceeds max decompressed size " + var4);
      }

      if (var1.isDirect()) {
         ByteBuffer var12 = var1.nioBuffer(var2, var3);
         long var13 = Zstd.getFrameContentSize(var12);
         if (var13 < 0L) {
            throw new ProtocolException("Invalid Zstd frame or unknown content size");
         }

         if (var13 > var4) {
            throw new ProtocolException("Decompressed size " + var13 + " exceeds maximum " + var4);
         }

         ByteBuf var14 = var0.directBuffer((int)var13);

         try {
            ByteBuffer var9 = var14.nioBuffer(0, (int)var13);
            int var10 = Zstd.decompress(var9, var12);
            if (Zstd.isError(var10)) {
               throw new ProtocolException("Zstd decompression failed: " + Zstd.getErrorName(var10));
            }

            var14.writerIndex(var10);
            class="kw">return var14;
         } catch (Exception var11) {
            var14.release();
            throw var11;
         }
      } else {
         byte[] var5 = new byte[var3];
         var1.getBytes(var2, var5);
         long var6 = Zstd.getFrameContentSize(var5);
         if (var6 < 0L) {
            throw new ProtocolException("Invalid Zstd frame or unknown content size");
         }

         if (var6 > var4) {
            throw new ProtocolException("Decompressed size " + var6 + " exceeds maximum " + var4);
         }

         byte[] var8 = Zstd.decompress(var5, (int)var6);
         class="kw">return Unpooled.wrappedBuffer(var8);
      }
   }

   class="kw">private class="kw">static MemorySegment decompressFromBuffer(
      @Nonnull MemorySegment var0, @Nonnull Arena var1, @Nonnull MemorySegment var2, int var3, int var4, int var5
   ) {
      if (var4 > var5) {
         throw new ProtocolException("Compressed size " + var4 + " exceeds max decompressed size " + var5);
      } else {
         MemorySegment var6 = var2.asSlice(var3, var4);
         long var7 = ZstdNative.getFrameContentSize(var6, var4);
         if (var7 < 0L) {
            throw new ProtocolException("Invalid Zstd frame or unknown content size");
         } else if (var7 > var5) {
            throw new ProtocolException("Decompressed size " + var7 + " exceeds maximum " + var5);
         } else {
            MemorySegment var9 = var1.allocate((int)var7);
            long var10 = ZstdNative.decompressDCtx(var0, var9, var9.byteSize(), var6, var4);
            if (ZstdNative.isError(var10)) {
               throw new ProtocolException("Decompression failed with error code: " + ZstdNative.getErrorName(var10));
            } else {
               class="kw">return var9;
            }
         }
      }
   }

   class="kw">public class="kw">static void writeFramedPacket(
      @Nonnull Packet var0, @Nonnull Class<? class="kw">extends Packet> var1, @Nonnull ByteBuf var2, @Nonnull ByteBufAllocator var3, @Nonnull PacketStatsRecorder var4
   ) {
      Integer var5 = PacketRegistry.getId(var1);
      if (var5 == null) {
         throw new ProtocolException("Unknown packet type: " + var1.getName());
      }

      PacketRegistry.PacketInfo var6 = PacketRegistry.getToClientPacketById(var5);
      writeFramedPacketWithInfo(var0, var6, var2, var3, var4);
   }

   class="kw">public class="kw">static void writeFramedPacketWithInfo(
      @Nonnull Packet var0, @Nonnull PacketRegistry.PacketInfo var1, @Nonnull ByteBuf var2, @Nonnull ByteBufAllocator var3, @Nonnull PacketStatsRecorder var4
   ) {
      int var5 = var2.writerIndex();
      var2.writeIntLE(0);
      var2.writeIntLE(var1.id());
      if (var1.compressed()) {
         writeCompressed(var0, var1, var1.id(), var2, var3, var4, var5);
      } else {
         writeUncompressed(var0, var1, var1.id(), var2, var4, var5);
      }
   }

   class="kw">private class="kw">static void writeCompressed(
      @Nonnull Packet var0,
      @Nonnull PacketRegistry.PacketInfo var1,
      int var2,
      @Nonnull ByteBuf var3,
      @Nonnull ByteBufAllocator var4,
      @Nonnull PacketStatsRecorder var5,
      int var6
   ) {
      int var7 = var0.computeSize();
      if (var7 > var1.maxSize()) {
         throw new ProtocolException("Packet " + var1.name() + " serialized to " + var7 + " bytes, exceeds max size " + var1.maxSize());
      }

      if (var7 == 0) {
         var3.setIntLE(var6, 0);
         var5.recordSend(var2, 0, 0);
      } else {
         ByteBuf var8 = var4.buffer(var7);

         try {
            serializeInto(var0, var8, var7);
            int var9 = (int)Zstd.compressBound(var7);
            var3.ensureWritable(var9);
            int var10 = compressToBuffer(var8, var3, var3.writerIndex(), var9);
            if (Zstd.isError(var10)) {
               throw new ProtocolException("Zstd compression failed: " + Zstd.getErrorName(var10));
            }

            if (var10 > 1677721600) {
               throw new ProtocolException("Packet " + var1.name() + " compressed payload size " + var10 + " exceeds protocol maximum");
            }

            var3.writerIndex(var3.writerIndex() + var10);
            var3.setIntLE(var6, var10);
            var5.recordSend(var2, var7, var10);
         } class="kw">finally {
            var8.release();
         }
      }
   }

   class="kw">private class="kw">static void writeUncompressed(
      @Nonnull Packet var0, @Nonnull PacketRegistry.PacketInfo var1, int var2, @Nonnull ByteBuf var3, @Nonnull PacketStatsRecorder var4, int var5
   ) {
      int var6 = var0.computeSize();
      if (var6 > var1.maxSize()) {
         var3.writerIndex(var5);
         throw new ProtocolException("Packet " + var1.name() + " serialized to " + var6 + " bytes, exceeds max size " + var1.maxSize());
      }

      if (var6 > 1677721600) {
         var3.writerIndex(var5);
         throw new ProtocolException("Packet " + var1.name() + " payload size " + var6 + " exceeds protocol maximum");
      }

      int var7 = serializeInto(var0, var3, var6);
      var3.setIntLE(var5, var7);
      var4.recordSend(var2, var7, 0);
   }

   class="kw">private class="kw">static int serializeInto(@Nonnull Packet var0, @Nonnull ByteBuf var1, int var2) {
      if (var2 == 0) {
         class="kw">return 0;
      }

      var1.ensureWritable(var2);
      int var3 = var1.writerIndex();
      int var4;
      if (var1.hasArray()) {
         var4 = var0.serialize(MemorySegment.ofArray(var1.array()).asSlice(var1.arrayOffset() + var3, var2), 0);
      } else if (var1.isDirect() && var1.nioBufferCount() == 1) {
         var4 = var0.serialize(MemorySegment.ofBuffer(var1.nioBuffer(var3, var2)), 0);
      } else {
         byte[] var5 = new byte[var2];
         var4 = var0.serialize(MemorySegment.ofArray(var5), 0);
         var1.setBytes(var3, var5, 0, var4);
      }

      var1.writerIndex(var3 + var4);
      class="kw">return var4;
   }

   @Nonnull
   class="kw">public class="kw">static Packet readFramedPacket(@Nonnull ByteBuf var0, int var1, @Nonnull ByteBufAllocator var2, @Nonnull PacketStatsRecorder var3) {
      int var4 = var0.readIntLE();
      PacketRegistry.PacketInfo var5 = PacketRegistry.getToServerPacketById(var4);
      if (var5 == null) {
         var0.skipBytes(var1);
         throw new ProtocolException("Unknown packet ID: " + var4);
      } else {
         class="kw">return readFramedPacketWithInfo(var0, var1, var2, var5, var3);
      }
   }

   @Nonnull
   class="kw">public class="kw">static Packet readFramedPacketWithInfo(
      @Nonnull ByteBuf var0, int var1, @Nonnull ByteBufAllocator var2, @Nonnull PacketRegistry.PacketInfo var3, @Nonnull PacketStatsRecorder var4
   ) {
      int var7 = 0;
      ByteBuf var5;
      int var6;
      if (var3.compressed() && var1 > 0) {
         try {
            var5 = decompressFromBuffer(var2, var0, var0.readerIndex(), var1, var3.maxSize());
         } catch (ProtocolException var13) {
            var0.skipBytes(var1);
            throw var13;
         }

         var0.skipBytes(var1);
         var6 = var5.readableBytes();
         var7 = var1;
      } else if (var1 > 0) {
         var5 = var0.readRetainedSlice(var1);
         var6 = var1;
      } else {
         var5 = Unpooled.EMPTY_BUFFER;
         var6 = 0;
      }

      try {
         Packet var8 = var3.toObject().deserialize(asSegment(var5, var6), 0);
         var4.recordReceive(var3.id(), var6, var7);
         class="kw">return var8;
      } class="kw">finally {
         if (var1 > 0) {
            var5.release();
         }
      }
   }

   @Nonnull
   class="kw">private class="kw">static MemorySegment asSegment(@Nonnull ByteBuf var0, int var1) {
      if (var1 == 0) {
         class="kw">return MemorySegment.ofArray(EMPTY_PAYLOAD);
      }

      int var2 = var0.readerIndex();
      if (var0.hasArray()) {
         class="kw">return MemorySegment.ofArray(var0.array()).asSlice(var0.arrayOffset() + var2, var1);
      }

      if (var0.isDirect() && var0.nioBufferCount() == 1) {
         class="kw">return MemorySegment.ofBuffer(var0.nioBuffer(var2, var1));
      }

      byte[] var3 = new byte[var1];
      var0.getBytes(var2, var3);
      class="kw">return MemorySegment.ofArray(var3);
   }

   class="kw">public class="kw">static int writeFramedPacket(
      @Nonnull MemorySegment var0,
      @Nonnull Packet var1,
      @Nonnull PacketRegistry.PacketInfo var2,
      @Nonnull MemorySegment var3,
      int var4,
      int var5,
      @Nonnull PacketStatsRecorder var6
   ) {
      var3.set(PROTO_INT, var4 + 4, var2.id());
      int var7 = var4 + 8;
      if (var2.compressed()) {
         try (Arena var16 = Arena.ofConfined()) {
            MemorySegment var9 = var3.asSlice(var7);
            MemorySegment var10 = var16.allocate(var5);
            var1.serialize(var10, 0);
            if (var5 > var2.maxSize()) {
               throw new ProtocolException("Packet " + var2.name() + " serialized to " + var5 + " bytes, exceeds max size " + var2.maxSize());
            }

            long var11 = ZstdNative.compressCCtx(var0, var9, var9.byteSize(), var10, var10.byteSize(), COMPRESSION_LEVEL);
            if (ZstdNative.isError(var11)) {
               throw new ProtocolException("Zstd compression failed: " + ZstdNative.getErrorName(var11));
            }

            if (var11 > 1677721600L) {
               throw new ProtocolException("Packet " + var2.name() + " compressed payload size " + var11 + " exceeds protocol maximum");
            }

            var3.set(PROTO_INT, var4, (int)var11);
            var6.recordSend(var2.id(), var5, (int)var11);
            class="kw">return (int)(var11 + 8L);
         }
      } else {
         int var8 = var1.serialize(var3, var7);
         if (var8 > var2.maxSize()) {
            throw new ProtocolException("Packet " + var2.name() + " serialized to " + var8 + " bytes, exceeds max size " + var2.maxSize());
         }

         if (var8 > 1677721600) {
            throw new ProtocolException("Packet " + var2.name() + " payload size " + var8 + " exceeds protocol maximum");
         }

         var3.set(PROTO_INT, var4, var8);
         var6.recordSend(var2.id(), var8, 0);
         class="kw">return var8 + 8;
      }
   }

   @Nonnull
   class="kw">public class="kw">static Packet readFramedPacket(@Nonnull MemorySegment var0, @Nonnull MemorySegment var1, int var2, @Nonnull PacketStatsRecorder var3) {
      int var4 = var1.get(PROTO_INT, 0L);
      PacketRegistry.PacketInfo var5 = PacketRegistry.getToServerPacketById(var4);
      if (var5 == null) {
         throw new ProtocolException("Unknown packet ID: " + var4);
      } else if (var2 > var5.maxSize()) {
         throw new ProtocolException("Packet " + var5.name() + " payload size " + var2 + " exceeds max size " + var5.maxSize());
      } else {
         class="kw">return readFramedPacketWithInfo(var0, var1, (int)PROTO_INT.byteSize(), var2, var5, var3);
      }
   }

   @Nonnull
   class="kw">public class="kw">static Packet readFramedPacketWithInfo(
      @Nonnull MemorySegment var0, @Nonnull MemorySegment var1, int var2, int var3, @Nonnull PacketRegistry.PacketInfo var4, @Nonnull PacketStatsRecorder var5
   ) {
      int var7 = 0;
      Arena var9 = null;
      int var6;
      MemorySegment var8;
      byte var17;
      if (var4.compressed() && var3 > 0) {
         var9 = Arena.ofConfined();

         try {
            var8 = decompressFromBuffer(var0, var9, var1, var2, var3, var4.maxSize());
         } catch (Throwable var15) {
            var9.close();
            throw var15;
         }

         var6 = (int)var8.byteSize();
         var7 = var3;
         var17 = 0;
      } else {
         var8 = var1.asSlice(var2, var3);
         var17 = 0;
         var6 = var3;
      }

      try {
         Packet var10 = var4.toObject().deserialize(var8, var17);
         var5.recordReceive(var4.id(), var6, var7);
         class="kw">return var10;
      } class="kw">finally {
         if (var9 != null) {
            var9.close();
         }
      }
   }
}