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

class="kw">import com.hypixel.hytale.protocol.io.PacketIO;
class="kw">import com.hypixel.hytale.protocol.io.ProtocolException;
class="kw">import com.hypixel.hytale.protocol.io.ReadCursor;
class="kw">import com.hypixel.hytale.protocol.io.VarInt;
class="kw">import java.lang.foreign.MemorySegment;
class="kw">import java.util.Arrays;
class="kw">import java.util.Objects;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class Fluid {
   class="kw">public class="kw">static class="kw">final int NULLABLE_BIT_FIELD_SIZE = 1;
   class="kw">public class="kw">static class="kw">final int FIXED_BLOCK_SIZE = 23;
   class="kw">public class="kw">static class="kw">final int VARIABLE_FIELD_COUNT = 6;
   class="kw">public class="kw">static class="kw">final int VARIABLE_BLOCK_START = 47;
   class="kw">public class="kw">static class="kw">final int MAX_SIZE = 1677721600;
   @Nullable
   class="kw">public String id;
   class="kw">public int maxFluidLevel;
   @Nullable
   class="kw">public BlockTextures[] cubeTextures;
   class="kw">public boolean requiresAlphaBlending;
   @Nonnull
   class="kw">public Opacity opacity = Opacity.Solid;
   @Nullable
   class="kw">public ShaderType[] shaderEffect;
   @Nullable
   class="kw">public ColorLight light;
   @Nullable
   class="kw">public ModelParticle[] particles;
   @Nonnull
   class="kw">public FluidDrawType drawType = FluidDrawType.None;
   class="kw">public int fluidFXIndex;
   class="kw">public int blockSoundSetIndex;
   @Nullable
   class="kw">public String blockParticleSetId;
   @Nullable
   class="kw">public Color particleColor;
   @Nullable
   class="kw">public int[] tagIndexes;

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

   class="kw">public Fluid(
      @Nullable String var1,
      int var2,
      @Nullable BlockTextures[] var3,
      boolean var4,
      @Nonnull Opacity var5,
      @Nullable ShaderType[] var6,
      @Nullable ColorLight var7,
      @Nullable ModelParticle[] var8,
      @Nonnull FluidDrawType var9,
      int var10,
      int var11,
      @Nullable String var12,
      @Nullable Color var13,
      @Nullable int[] var14
   ) {
      this.id = var1;
      this.maxFluidLevel = var2;
      this.cubeTextures = var3;
      this.requiresAlphaBlending = var4;
      this.opacity = var5;
      this.shaderEffect = var6;
      this.light = var7;
      this.particles = var8;
      this.drawType = var9;
      this.fluidFXIndex = var10;
      this.blockSoundSetIndex = var11;
      this.blockParticleSetId = var12;
      this.particleColor = var13;
      this.tagIndexes = var14;
   }

   class="kw">public Fluid(@Nonnull Fluid var1) {
      this.id = var1.id;
      this.maxFluidLevel = var1.maxFluidLevel;
      this.cubeTextures = var1.cubeTextures;
      this.requiresAlphaBlending = var1.requiresAlphaBlending;
      this.opacity = var1.opacity;
      this.shaderEffect = var1.shaderEffect;
      this.light = var1.light;
      this.particles = var1.particles;
      this.drawType = var1.drawType;
      this.fluidFXIndex = var1.fluidFXIndex;
      this.blockSoundSetIndex = var1.blockSoundSetIndex;
      this.blockParticleSetId = var1.blockParticleSetId;
      this.particleColor = var1.particleColor;
      this.tagIndexes = var1.tagIndexes;
   }

   class="kw">public class="kw">static void requireBounds(MemorySegment var0, int var1) {
      if (var1 < 0) {
         throw ProtocolException.invalidOffset("Fluid", var1, (int)var0.byteSize());
      }

      long var2 = var1 + 47L;
      if (var2 > var0.byteSize()) {
         throw ProtocolException.bufferTooSmall("Fluid", (int)Math.min(var2, 2147483647L), (int)var0.byteSize());
      }
   }

   @Nullable
   class="kw">public class="kw">static String getId(MemorySegment var0) {
      class="kw">return getId(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static String getId(MemorySegment var0, int var1) {
      class="kw">return hasId(var0, var1) ? PacketIO.readVarString("Id", var0, var1 + getValidatedOffset(var0, var1, 23, 47, "Id"), 4096000) : null;
   }

   class="kw">public class="kw">static int getMaxFluidLevel(MemorySegment var0) {
      class="kw">return getMaxFluidLevel(var0, 0);
   }

   class="kw">public class="kw">static int getMaxFluidLevel(MemorySegment var0, int var1) {
      class="kw">return var0.get(PacketIO.PROTO_INT, var1 + 1);
   }

   @Nullable
   class="kw">public class="kw">static BlockTextures[] getCubeTextures(MemorySegment var0) {
      class="kw">return getCubeTextures(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static BlockTextures[] getCubeTextures(MemorySegment var0, int var1) {
      if (!hasCubeTextures(var0, var1)) {
         class="kw">return null;
      }

      ReadCursor var2 = new ReadCursor();
      int var3 = var1 + getValidatedOffset(var0, var1, 27, 47, "CubeTextures");
      long var4 = VarInt.getWithLength(var0, var3);
      if (var4 == -1L) {
         throw ProtocolException.invalidVarInt("CubeTextures");
      }

      int var6 = (int)var4;
      if (var6 > 4096000) {
         throw ProtocolException.arrayTooLong("CubeTextures", var6, 4096000);
      }

      int var7 = (int)(var4 >>> 32);
      if (var3 + var7 + var6 * 29L > var0.byteSize()) {
         throw ProtocolException.bufferTooSmall("CubeTextures", (int)Math.min(var3 + var7 + var6 * 29L, 2147483647L), (int)var0.byteSize());
      }

      var3 += var7;
      BlockTextures[] var8 = new BlockTextures[var6];

      for (int var9 = 0; var9 < var6; var9++) {
         var8[var9] = BlockTextures.toObject(var0, var3, var2);
         var3 = var2.position;
      }

      class="kw">return var8;
   }

   class="kw">public class="kw">static boolean getRequiresAlphaBlending(MemorySegment var0) {
      class="kw">return getRequiresAlphaBlending(var0, 0);
   }

   class="kw">public class="kw">static boolean getRequiresAlphaBlending(MemorySegment var0, int var1) {
      class="kw">return var0.get(PacketIO.PROTO_BOOL, var1 + 5);
   }

   class="kw">public class="kw">static Opacity getOpacity(MemorySegment var0) {
      class="kw">return getOpacity(var0, 0);
   }

   class="kw">public class="kw">static Opacity getOpacity(MemorySegment var0, int var1) {
      class="kw">return Opacity.fromValue(var0.get(PacketIO.PROTO_BYTE, var1 + 6));
   }

   @Nullable
   class="kw">public class="kw">static ShaderType[] getShaderEffect(MemorySegment var0) {
      class="kw">return getShaderEffect(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static ShaderType[] getShaderEffect(MemorySegment var0, int var1) {
      if (!hasShaderEffect(var0, var1)) {
         class="kw">return null;
      }

      int var2 = var1 + getValidatedOffset(var0, var1, 31, 47, "ShaderEffect");
      long var3 = VarInt.getWithLength(var0, var2);
      if (var3 == -1L) {
         throw ProtocolException.invalidVarInt("ShaderEffect");
      }

      int var5 = (int)var3;
      if (var5 > 4096000) {
         throw ProtocolException.arrayTooLong("ShaderEffect", var5, 4096000);
      }

      int var6 = (int)(var3 >>> 32);
      if (var2 + var6 + var5 > var0.byteSize()) {
         throw ProtocolException.bufferTooSmall("ShaderEffect", Math.min(var2 + var6 + var5, Integer.MAX_VALUE), (int)var0.byteSize());
      }

      var2 += var6;
      ShaderType[] var7 = new ShaderType[var5];

      for (int var8 = 0; var8 < var5; var8++) {
         var7[var8] = ShaderType.fromValue(var0.get(PacketIO.PROTO_BYTE, var2 + var8 * 1));
      }

      class="kw">return var7;
   }

   @Nullable
   class="kw">public class="kw">static ColorLight getLight(MemorySegment var0) {
      class="kw">return getLight(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static ColorLight getLight(MemorySegment var0, int var1) {
      class="kw">return hasLight(var0, var1) ? ColorLight.toObject(var0, var1 + 7) : null;
   }

   @Nullable
   class="kw">public class="kw">static ModelParticle[] getParticles(MemorySegment var0) {
      class="kw">return getParticles(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static ModelParticle[] getParticles(MemorySegment var0, int var1) {
      if (!hasParticles(var0, var1)) {
         class="kw">return null;
      }

      ReadCursor var2 = new ReadCursor();
      int var3 = var1 + getValidatedOffset(var0, var1, 35, 47, "Particles");
      long var4 = VarInt.getWithLength(var0, var3);
      if (var4 == -1L) {
         throw ProtocolException.invalidVarInt("Particles");
      }

      int var6 = (int)var4;
      if (var6 > 4096000) {
         throw ProtocolException.arrayTooLong("Particles", var6, 4096000);
      }

      int var7 = (int)(var4 >>> 32);
      if (var3 + var7 + var6 * 42L > var0.byteSize()) {
         throw ProtocolException.bufferTooSmall("Particles", (int)Math.min(var3 + var7 + var6 * 42L, 2147483647L), (int)var0.byteSize());
      }

      var3 += var7;
      ModelParticle[] var8 = new ModelParticle[var6];

      for (int var9 = 0; var9 < var6; var9++) {
         var8[var9] = ModelParticle.toObject(var0, var3, var2);
         var3 = var2.position;
      }

      class="kw">return var8;
   }

   class="kw">public class="kw">static FluidDrawType getDrawType(MemorySegment var0) {
      class="kw">return getDrawType(var0, 0);
   }

   class="kw">public class="kw">static FluidDrawType getDrawType(MemorySegment var0, int var1) {
      class="kw">return FluidDrawType.fromValue(var0.get(PacketIO.PROTO_BYTE, var1 + 11));
   }

   class="kw">public class="kw">static int getFluidFXIndex(MemorySegment var0) {
      class="kw">return getFluidFXIndex(var0, 0);
   }

   class="kw">public class="kw">static int getFluidFXIndex(MemorySegment var0, int var1) {
      class="kw">return var0.get(PacketIO.PROTO_INT, var1 + 12);
   }

   class="kw">public class="kw">static int getBlockSoundSetIndex(MemorySegment var0) {
      class="kw">return getBlockSoundSetIndex(var0, 0);
   }

   class="kw">public class="kw">static int getBlockSoundSetIndex(MemorySegment var0, int var1) {
      class="kw">return var0.get(PacketIO.PROTO_INT, var1 + 16);
   }

   @Nullable
   class="kw">public class="kw">static String getBlockParticleSetId(MemorySegment var0) {
      class="kw">return getBlockParticleSetId(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static String getBlockParticleSetId(MemorySegment var0, int var1) {
      class="kw">return hasBlockParticleSetId(var0, var1)
         ? PacketIO.readVarString("BlockParticleSetId", var0, var1 + getValidatedOffset(var0, var1, 39, 47, "BlockParticleSetId"), 4096000)
         : null;
   }

   @Nullable
   class="kw">public class="kw">static Color getParticleColor(MemorySegment var0) {
      class="kw">return getParticleColor(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static Color getParticleColor(MemorySegment var0, int var1) {
      class="kw">return hasParticleColor(var0, var1) ? Color.toObject(var0, var1 + 20) : null;
   }

   @Nullable
   class="kw">public class="kw">static int[] getTagIndexes(MemorySegment var0) {
      class="kw">return getTagIndexes(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static int[] getTagIndexes(MemorySegment var0, int var1) {
      if (!hasTagIndexes(var0, var1)) {
         class="kw">return null;
      }

      int var2 = var1 + getValidatedOffset(var0, var1, 43, 47, "TagIndexes");
      long var3 = VarInt.getWithLength(var0, var2);
      if (var3 == -1L) {
         throw ProtocolException.invalidVarInt("TagIndexes");
      }

      int var5 = (int)var3;
      if (var5 > 4096000) {
         throw ProtocolException.arrayTooLong("TagIndexes", var5, 4096000);
      }

      int var6 = (int)(var3 >>> 32);
      if (var2 + var6 + var5 * 4L > var0.byteSize()) {
         throw ProtocolException.bufferTooSmall("TagIndexes", (int)Math.min(var2 + var6 + var5 * 4L, 2147483647L), (int)var0.byteSize());
      }

      var2 += var6;
      int[] var7 = new int[var5];
      MemorySegment.copy(var0, PacketIO.PROTO_INT, var2, var7, 0, var5);
      class="kw">return var7;
   }

   class="kw">public class="kw">static boolean hasLight(MemorySegment var0, int var1) {
      byte var2 = var0.get(PacketIO.PROTO_BYTE, var1 + 0);
      class="kw">return (var2 & 1) != 0;
   }

   class="kw">public class="kw">static boolean hasParticleColor(MemorySegment var0, int var1) {
      byte var2 = var0.get(PacketIO.PROTO_BYTE, var1 + 0);
      class="kw">return (var2 & 2) != 0;
   }

   class="kw">public class="kw">static boolean hasId(MemorySegment var0, int var1) {
      byte var2 = var0.get(PacketIO.PROTO_BYTE, var1 + 0);
      class="kw">return (var2 & 4) != 0;
   }

   class="kw">public class="kw">static boolean hasCubeTextures(MemorySegment var0, int var1) {
      byte var2 = var0.get(PacketIO.PROTO_BYTE, var1 + 0);
      class="kw">return (var2 & 8) != 0;
   }

   class="kw">public class="kw">static boolean hasShaderEffect(MemorySegment var0, int var1) {
      byte var2 = var0.get(PacketIO.PROTO_BYTE, var1 + 0);
      class="kw">return (var2 & 16) != 0;
   }

   class="kw">public class="kw">static boolean hasParticles(MemorySegment var0, int var1) {
      byte var2 = var0.get(PacketIO.PROTO_BYTE, var1 + 0);
      class="kw">return (var2 & 32) != 0;
   }

   class="kw">public class="kw">static boolean hasBlockParticleSetId(MemorySegment var0, int var1) {
      byte var2 = var0.get(PacketIO.PROTO_BYTE, var1 + 0);
      class="kw">return (var2 & 64) != 0;
   }

   class="kw">public class="kw">static boolean hasTagIndexes(MemorySegment var0, int var1) {
      byte var2 = var0.get(PacketIO.PROTO_BYTE, var1 + 0);
      class="kw">return (var2 & 128) != 0;
   }

   class="kw">private class="kw">static int getValidatedOffset(MemorySegment var0, int var1, int var2, int var3, String var4) {
      int var5 = var0.get(PacketIO.PROTO_INT, var1 + var2);
      if (var5 >= 0 && var5 <= var0.byteSize() - var1 - var3) {
         class="kw">return var3 + var5;
      } else {
         throw ProtocolException.invalidOffset(var4, var5, (int)var0.byteSize());
      }
   }

   class="kw">private class="kw">static void requireSlot(MemorySegment var0, int var1, int var2, String var3) {
      int var4 = var0.get(PacketIO.PROTO_INT, var1);
      if (var4 != var2) {
         throw ProtocolException.nonCanonicalLayout(var3, var4, var2);
      }
   }

   class="kw">public class="kw">static Fluid toObject(MemorySegment var0) {
      class="kw">return toObject(var0, 0, null);
   }

   class="kw">public class="kw">static Fluid toObject(MemorySegment var0, int var1) {
      class="kw">return toObject(var0, var1, null);
   }

   class="kw">public class="kw">static Fluid toObject(MemorySegment var0, int var1, @Nullable ReadCursor var2) {
      requireBounds(var0, var1);
      int var3 = var1 + 47;
      int var4 = 0;
      ReadCursor var5 = var2 != null ? var2 : new ReadCursor();
      String var6 = null;
      if (hasId(var0, var1)) {
         requireSlot(var0, var1 + 23, var4, "Id");
         int var7 = var3 + var4;
         long var8 = VarInt.getWithLength(var0, var7);
         var6 = PacketIO.readVarString("Id", var0, var7, 0, 4096000, var8);
         var4 += (int)var8 + (int)(var8 >>> 32);
      } else {
         requireSlot(var0, var1 + 23, -1, "Id");
      }

      BlockTextures[] var17 = null;
      if (hasCubeTextures(var0, var1)) {
         requireSlot(var0, var1 + 27, var4, "CubeTextures");
         int var18 = var3 + var4;
         long var9 = VarInt.getWithLength(var0, var18);
         if (var9 == -1L) {
            throw ProtocolException.invalidVarInt("CubeTextures");
         }

         int var11 = (int)var9;
         if (var11 > 4096000) {
            throw ProtocolException.arrayTooLong("CubeTextures", var11, 4096000);
         }

         int var12 = (int)(var9 >>> 32);
         if (var18 + var12 + var11 * 29L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("CubeTextures", (int)Math.min(var18 + var12 + var11 * 29L, 2147483647L), (int)var0.byteSize());
         }

         var18 += var12;
         var17 = new BlockTextures[var11];

         for (int var13 = 0; var13 < var11; var13++) {
            var17[var13] = BlockTextures.toObject(var0, var18, var5);
            var18 = var5.position;
         }

         var4 = var18 - var3;
      } else {
         requireSlot(var0, var1 + 27, -1, "CubeTextures");
      }

      ShaderType[] var20 = null;
      if (hasShaderEffect(var0, var1)) {
         requireSlot(var0, var1 + 31, var4, "ShaderEffect");
         int var21 = var3 + var4;
         long var10 = VarInt.getWithLength(var0, var21);
         if (var10 == -1L) {
            throw ProtocolException.invalidVarInt("ShaderEffect");
         }

         int var30 = (int)var10;
         if (var30 > 4096000) {
            throw ProtocolException.arrayTooLong("ShaderEffect", var30, 4096000);
         }

         int var35 = (int)(var10 >>> 32);
         if (var21 + var35 + var30 > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("ShaderEffect", Math.min(var21 + var35 + var30, Integer.MAX_VALUE), (int)var0.byteSize());
         }

         var21 += var35;
         var20 = new ShaderType[var30];

         for (int var14 = 0; var14 < var30; var14++) {
            var20[var14] = ShaderType.fromValue(var0.get(PacketIO.PROTO_BYTE, var21 + var14 * 1));
         }

         var4 = var21 + var30 - var3;
      } else {
         requireSlot(var0, var1 + 31, -1, "ShaderEffect");
      }

      ModelParticle[] var23 = null;
      if (hasParticles(var0, var1)) {
         requireSlot(var0, var1 + 35, var4, "Particles");
         int var24 = var3 + var4;
         long var27 = VarInt.getWithLength(var0, var24);
         if (var27 == -1L) {
            throw ProtocolException.invalidVarInt("Particles");
         }

         int var36 = (int)var27;
         if (var36 > 4096000) {
            throw ProtocolException.arrayTooLong("Particles", var36, 4096000);
         }

         int var38 = (int)(var27 >>> 32);
         if (var24 + var38 + var36 * 42L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("Particles", (int)Math.min(var24 + var38 + var36 * 42L, 2147483647L), (int)var0.byteSize());
         }

         var24 += var38;
         var23 = new ModelParticle[var36];

         for (int var15 = 0; var15 < var36; var15++) {
            var23[var15] = ModelParticle.toObject(var0, var24, var5);
            var24 = var5.position;
         }

         var4 = var24 - var3;
      } else {
         requireSlot(var0, var1 + 35, -1, "Particles");
      }

      String var26 = null;
      if (hasBlockParticleSetId(var0, var1)) {
         requireSlot(var0, var1 + 39, var4, "BlockParticleSetId");
         int var28 = var3 + var4;
         long var31 = VarInt.getWithLength(var0, var28);
         var26 = PacketIO.readVarString("BlockParticleSetId", var0, var28, 0, 4096000, var31);
         var4 += (int)var31 + (int)(var31 >>> 32);
      } else {
         requireSlot(var0, var1 + 39, -1, "BlockParticleSetId");
      }

      int[] var29 = null;
      if (hasTagIndexes(var0, var1)) {
         requireSlot(var0, var1 + 43, var4, "TagIndexes");
         int var32 = var3 + var4;
         long var37 = VarInt.getWithLength(var0, var32);
         if (var37 == -1L) {
            throw ProtocolException.invalidVarInt("TagIndexes");
         }

         int var39 = (int)var37;
         if (var39 > 4096000) {
            throw ProtocolException.arrayTooLong("TagIndexes", var39, 4096000);
         }

         int var16 = (int)(var37 >>> 32);
         if (var32 + var16 + var39 * 4L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("TagIndexes", (int)Math.min(var32 + var16 + var39 * 4L, 2147483647L), (int)var0.byteSize());
         }

         var32 += var16;
         var29 = new int[var39];
         MemorySegment.copy(var0, PacketIO.PROTO_INT, var32, var29, 0, var39);
         var4 = var32 + var39 * 4 - var3;
      } else {
         requireSlot(var0, var1 + 43, -1, "TagIndexes");
      }

      Fluid var34 = new Fluid(
         var6,
         var0.get(PacketIO.PROTO_INT, var1 + 1),
         var17,
         var0.get(PacketIO.PROTO_BOOL, var1 + 5),
         Opacity.fromValue(var0.get(PacketIO.PROTO_BYTE, var1 + 6)),
         var20,
         hasLight(var0, var1) ? ColorLight.toObject(var0, var1 + 7) : null,
         var23,
         FluidDrawType.fromValue(var0.get(PacketIO.PROTO_BYTE, var1 + 11)),
         var0.get(PacketIO.PROTO_INT, var1 + 12),
         var0.get(PacketIO.PROTO_INT, var1 + 16),
         var26,
         hasParticleColor(var0, var1) ? Color.toObject(var0, var1 + 20) : null,
         var29
      );
      if (var2 != null) {
         var2.position = var3 + var4;
      }

      class="kw">return var34;
   }

   class="kw">public int serialize(@Nonnull MemorySegment var1, int var2) {
      byte var3 = 0;
      if (this.light != null) {
         var3 = (byte)(var3 | 1);
      }

      if (this.particleColor != null) {
         var3 = (byte)(var3 | 2);
      }

      if (this.id != null) {
         var3 = (byte)(var3 | 4);
      }

      if (this.cubeTextures != null) {
         var3 = (byte)(var3 | 8);
      }

      if (this.shaderEffect != null) {
         var3 = (byte)(var3 | 16);
      }

      if (this.particles != null) {
         var3 = (byte)(var3 | 32);
      }

      if (this.blockParticleSetId != null) {
         var3 = (byte)(var3 | 64);
      }

      if (this.tagIndexes != null) {
         var3 = (byte)(var3 | 128);
      }

      var1.set(PacketIO.PROTO_BYTE, var2 + 0, var3);
      var1.set(PacketIO.PROTO_INT, var2 + 1, this.maxFluidLevel);
      var1.set(PacketIO.PROTO_BOOL, var2 + 5, this.requiresAlphaBlending);
      var1.set(PacketIO.PROTO_BYTE, var2 + 6, (byte)this.opacity.getValue());
      if (this.light != null) {
         this.light.serialize(var1, var2 + 7);
      } else {
         var1.asSlice(var2 + 7, 4L).fill((byte)0);
      }

      var1.set(PacketIO.PROTO_BYTE, var2 + 11, (byte)this.drawType.getValue());
      var1.set(PacketIO.PROTO_INT, var2 + 12, this.fluidFXIndex);
      var1.set(PacketIO.PROTO_INT, var2 + 16, this.blockSoundSetIndex);
      if (this.particleColor != null) {
         this.particleColor.serialize(var1, var2 + 20);
      } else {
         var1.asSlice(var2 + 20, 3L).fill((byte)0);
      }

      int var4 = var2 + 47;
      if (this.id != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 23, var4 - var2 - 47);
         var4 += PacketIO.writeVarString(var1, var4, this.id, 4096000);
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 23, -1);
      }

      if (this.cubeTextures != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 27, var4 - var2 - 47);
         if (this.cubeTextures.length > 4096000) {
            throw ProtocolException.arrayTooLong("CubeTextures", this.cubeTextures.length, 4096000);
         }

         var4 += VarInt.set(var1, var4, this.cubeTextures.length);
         int var5 = 0;

         for (int var6 = 0; var6 < this.cubeTextures.length; var6++) {
            var5 += this.cubeTextures[var6].serialize(var1, var4 + var5);
         }

         var4 += var5;
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 27, -1);
      }

      if (this.shaderEffect != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 31, var4 - var2 - 47);
         if (this.shaderEffect.length > 4096000) {
            throw ProtocolException.arrayTooLong("ShaderEffect", this.shaderEffect.length, 4096000);
         }

         var4 += VarInt.set(var1, var4, this.shaderEffect.length);

         for (int var11 = 0; var11 < this.shaderEffect.length; var11++) {
            var1.set(PacketIO.PROTO_BYTE, var4 + var11 * 1, (byte)this.shaderEffect[var11].getValue());
         }

         var4 += this.shaderEffect.length * 1;
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 31, -1);
      }

      if (this.particles != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 35, var4 - var2 - 47);
         if (this.particles.length > 4096000) {
            throw ProtocolException.arrayTooLong("Particles", this.particles.length, 4096000);
         }

         var4 += VarInt.set(var1, var4, this.particles.length);
         int var12 = 0;

         for (int var13 = 0; var13 < this.particles.length; var13++) {
            var12 += this.particles[var13].serialize(var1, var4 + var12);
         }

         var4 += var12;
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 35, -1);
      }

      if (this.blockParticleSetId != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 39, var4 - var2 - 47);
         var4 += PacketIO.writeVarString(var1, var4, this.blockParticleSetId, 4096000);
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 39, -1);
      }

      if (this.tagIndexes != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 43, var4 - var2 - 47);
         if (this.tagIndexes.length > 4096000) {
            throw ProtocolException.arrayTooLong("TagIndexes", this.tagIndexes.length, 4096000);
         }

         var4 += VarInt.set(var1, var4, this.tagIndexes.length);
         MemorySegment.copy(this.tagIndexes, 0, var1, PacketIO.PROTO_INT, var4, this.tagIndexes.length);
         var4 += this.tagIndexes.length * 4;
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 43, -1);
      }

      class="kw">return var4 - var2;
   }

   class="kw">public int computeSize() {
      int var1 = 47;
      if (this.id != null) {
         var1 += PacketIO.stringSize(this.id);
      }

      if (this.cubeTextures != null) {
         int var2 = 0;

         for (BlockTextures var6 : this.cubeTextures) {
            var2 += var6.computeSize();
         }

         var1 += VarInt.size(this.cubeTextures.length) + var2;
      }

      if (this.shaderEffect != null) {
         var1 += VarInt.size(this.shaderEffect.length) + this.shaderEffect.length * 1;
      }

      if (this.particles != null) {
         int var7 = 0;

         for (ModelParticle var11 : this.particles) {
            var7 += var11.computeSize();
         }

         var1 += VarInt.size(this.particles.length) + var7;
      }

      if (this.blockParticleSetId != null) {
         var1 += PacketIO.stringSize(this.blockParticleSetId);
      }

      if (this.tagIndexes != null) {
         var1 += VarInt.size(this.tagIndexes.length) + this.tagIndexes.length * 4;
      }

      class="kw">return var1;
   }

   class="kw">public Fluid clone() {
      Fluid var1 = new Fluid();
      var1.id = this.id;
      var1.maxFluidLevel = this.maxFluidLevel;
      var1.cubeTextures = this.cubeTextures != null ? Arrays.stream(this.cubeTextures).map(var0 -> var0.clone()).toArray(BlockTextures[]::new) : null;
      var1.requiresAlphaBlending = this.requiresAlphaBlending;
      var1.opacity = this.opacity;
      var1.shaderEffect = this.shaderEffect != null ? Arrays.copyOf(this.shaderEffect, this.shaderEffect.length) : null;
      var1.light = this.light != null ? this.light.clone() : null;
      var1.particles = this.particles != null ? Arrays.stream(this.particles).map(var0 -> var0.clone()).toArray(ModelParticle[]::new) : null;
      var1.drawType = this.drawType;
      var1.fluidFXIndex = this.fluidFXIndex;
      var1.blockSoundSetIndex = this.blockSoundSetIndex;
      var1.blockParticleSetId = this.blockParticleSetId;
      var1.particleColor = this.particleColor != null ? this.particleColor.clone() : null;
      var1.tagIndexes = this.tagIndexes != null ? Arrays.copyOf(this.tagIndexes, this.tagIndexes.length) : null;
      class="kw">return var1;
   }

   @Override
   class="kw">public boolean equals(Object var1) {
      if (this == var1) {
         class="kw">return true;
      } else {
         class="kw">return !(var1 class="kw">instanceof Fluid var2)
            ? false
            : Objects.equals(this.id, var2.id)
               && this.maxFluidLevel == var2.maxFluidLevel
               && Arrays.equals(this.cubeTextures, var2.cubeTextures)
               && this.requiresAlphaBlending == var2.requiresAlphaBlending
               && Objects.equals(this.opacity, var2.opacity)
               && Arrays.equals(this.shaderEffect, var2.shaderEffect)
               && Objects.equals(this.light, var2.light)
               && Arrays.equals(this.particles, var2.particles)
               && Objects.equals(this.drawType, var2.drawType)
               && this.fluidFXIndex == var2.fluidFXIndex
               && this.blockSoundSetIndex == var2.blockSoundSetIndex
               && Objects.equals(this.blockParticleSetId, var2.blockParticleSetId)
               && Objects.equals(this.particleColor, var2.particleColor)
               && Arrays.equals(this.tagIndexes, var2.tagIndexes);
      }
   }

   @Override
   class="kw">public int hashCode() {
      int var1 = 1;
      var1 = 31 * var1 + Objects.hashCode(this.id);
      var1 = 31 * var1 + Integer.hashCode(this.maxFluidLevel);
      var1 = 31 * var1 + Arrays.hashCode(this.cubeTextures);
      var1 = 31 * var1 + Boolean.hashCode(this.requiresAlphaBlending);
      var1 = 31 * var1 + Objects.hashCode(this.opacity);
      var1 = 31 * var1 + Arrays.hashCode(this.shaderEffect);
      var1 = 31 * var1 + Objects.hashCode(this.light);
      var1 = 31 * var1 + Arrays.hashCode(this.particles);
      var1 = 31 * var1 + Objects.hashCode(this.drawType);
      var1 = 31 * var1 + Integer.hashCode(this.fluidFXIndex);
      var1 = 31 * var1 + Integer.hashCode(this.blockSoundSetIndex);
      var1 = 31 * var1 + Objects.hashCode(this.blockParticleSetId);
      var1 = 31 * var1 + Objects.hashCode(this.particleColor);
      class="kw">return 31 * var1 + Arrays.hashCode(this.tagIndexes);
   }
}