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.HashMap;
class="kw">import java.util.Map;
class="kw">import java.util.Objects;
class="kw">import java.util.UUID;
class="kw">import java.util.Map.Entry;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3fc;

class="kw">public class InteractionSyncData {
   class="kw">public class="kw">static class="kw">final int NULLABLE_BIT_FIELD_SIZE = 2;
   class="kw">public class="kw">static class="kw">final int FIXED_BLOCK_SIZE = 157;
   class="kw">public class="kw">static class="kw">final int VARIABLE_FIELD_COUNT = 2;
   class="kw">public class="kw">static class="kw">final int VARIABLE_BLOCK_START = 165;
   class="kw">public class="kw">static class="kw">final int MAX_SIZE = 237568175;
   @Nonnull
   class="kw">public InteractionState state = InteractionState.Finished;
   class="kw">public float progress;
   class="kw">public int operationCounter;
   class="kw">public int rootInteraction;
   class="kw">public int totalForks;
   class="kw">public int entityId;
   class="kw">public int enteredRootInteraction = Integer.MIN_VALUE;
   @Nullable
   class="kw">public BlockPosition blockPosition;
   @Nonnull
   class="kw">public BlockFace blockFace = BlockFace.None;
   @Nullable
   class="kw">public BlockRotation blockRotation;
   class="kw">public int placedBlockId = Integer.MIN_VALUE;
   class="kw">public float chargeValue = -1.0F;
   @Nullable
   class="kw">public Map<InteractionType, Integer> forkCounts;
   class="kw">public int chainingIndex = -1;
   class="kw">public int flagIndex = -1;
   @Nullable
   class="kw">public SelectedHitEntity[] hitEntities;
   @Nullable
   class="kw">public Position attackerPos;
   @Nullable
   class="kw">public Direction attackerRot;
   @Nullable
   class="kw">public Position raycastHit;
   class="kw">public float raycastDistance;
   @Nullable
   class="kw">public Vector3fc raycastNormal;
   @Nonnull
   class="kw">public MovementDirection movementDirection = MovementDirection.None;
   @Nonnull
   class="kw">public ApplyForceState applyForceState = ApplyForceState.Waiting;
   class="kw">public int nextLabel;
   @Nullable
   class="kw">public UUID generatedUUID = null;

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

   class="kw">public InteractionSyncData(
      @Nonnull InteractionState var1,
      float var2,
      int var3,
      int var4,
      int var5,
      int var6,
      int var7,
      @Nullable BlockPosition var8,
      @Nonnull BlockFace var9,
      @Nullable BlockRotation var10,
      int var11,
      float var12,
      @Nullable Map<InteractionType, Integer> var13,
      int var14,
      int var15,
      @Nullable SelectedHitEntity[] var16,
      @Nullable Position var17,
      @Nullable Direction var18,
      @Nullable Position var19,
      float var20,
      @Nullable Vector3fc var21,
      @Nonnull MovementDirection var22,
      @Nonnull ApplyForceState var23,
      int var24,
      @Nullable UUID var25
   ) {
      this.state = var1;
      this.progress = var2;
      this.operationCounter = var3;
      this.rootInteraction = var4;
      this.totalForks = var5;
      this.entityId = var6;
      this.enteredRootInteraction = var7;
      this.blockPosition = var8;
      this.blockFace = var9;
      this.blockRotation = var10;
      this.placedBlockId = var11;
      this.chargeValue = var12;
      this.forkCounts = var13;
      this.chainingIndex = var14;
      this.flagIndex = var15;
      this.hitEntities = var16;
      this.attackerPos = var17;
      this.attackerRot = var18;
      this.raycastHit = var19;
      this.raycastDistance = var20;
      this.raycastNormal = var21;
      this.movementDirection = var22;
      this.applyForceState = var23;
      this.nextLabel = var24;
      this.generatedUUID = var25;
   }

   class="kw">public InteractionSyncData(@Nonnull InteractionSyncData var1) {
      this.state = var1.state;
      this.progress = var1.progress;
      this.operationCounter = var1.operationCounter;
      this.rootInteraction = var1.rootInteraction;
      this.totalForks = var1.totalForks;
      this.entityId = var1.entityId;
      this.enteredRootInteraction = var1.enteredRootInteraction;
      this.blockPosition = var1.blockPosition;
      this.blockFace = var1.blockFace;
      this.blockRotation = var1.blockRotation;
      this.placedBlockId = var1.placedBlockId;
      this.chargeValue = var1.chargeValue;
      this.forkCounts = var1.forkCounts;
      this.chainingIndex = var1.chainingIndex;
      this.flagIndex = var1.flagIndex;
      this.hitEntities = var1.hitEntities;
      this.attackerPos = var1.attackerPos;
      this.attackerRot = var1.attackerRot;
      this.raycastHit = var1.raycastHit;
      this.raycastDistance = var1.raycastDistance;
      this.raycastNormal = var1.raycastNormal;
      this.movementDirection = var1.movementDirection;
      this.applyForceState = var1.applyForceState;
      this.nextLabel = var1.nextLabel;
      this.generatedUUID = var1.generatedUUID;
   }

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

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

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

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

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

   class="kw">public class="kw">static float getProgress(MemorySegment var0, int var1) {
      class="kw">return PacketIO.requireFinite(var0.get(PacketIO.PROTO_FLOAT, var1 + 3), "Progress");
   }

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

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

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

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

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

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

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

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

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

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

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

   @Nullable
   class="kw">public class="kw">static BlockPosition getBlockPosition(MemorySegment var0, int var1) {
      class="kw">return hasBlockPosition(var0, var1) ? BlockPosition.toObject(var0, var1 + 27) : null;
   }

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

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

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

   @Nullable
   class="kw">public class="kw">static BlockRotation getBlockRotation(MemorySegment var0, int var1) {
      class="kw">return hasBlockRotation(var0, var1) ? BlockRotation.toObject(var0, var1 + 40) : null;
   }

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

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

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

   class="kw">public class="kw">static float getChargeValue(MemorySegment var0, int var1) {
      class="kw">return PacketIO.requireFinite(var0.get(PacketIO.PROTO_FLOAT, var1 + 47), "ChargeValue");
   }

   @Nullable
   class="kw">public class="kw">static Map<InteractionType, Integer> getForkCounts(MemorySegment var0) {
      class="kw">return getForkCounts(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static Map<InteractionType, Integer> getForkCounts(MemorySegment var0, int var1) {
      if (!hasForkCounts(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         InteractionType var8 = InteractionType.fromValue(var0.get(PacketIO.PROTO_BYTE, var2));
         int var9 = var0.get(PacketIO.PROTO_INT, ++var2);
         var2 += 4;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("ForkCounts", var8);
         }
      }

      class="kw">return var6;
   }

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

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

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

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

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

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

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

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

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

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

      for (int var8 = 0; var8 < var5; var8++) {
         var7[var8] = SelectedHitEntity.toObject(var0, var2 + var8 * 53);
      }

      class="kw">return var7;
   }

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

   @Nullable
   class="kw">public class="kw">static Position getAttackerPos(MemorySegment var0, int var1) {
      class="kw">return hasAttackerPos(var0, var1) ? Position.toObject(var0, var1 + 59) : null;
   }

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

   @Nullable
   class="kw">public class="kw">static Direction getAttackerRot(MemorySegment var0, int var1) {
      class="kw">return hasAttackerRot(var0, var1) ? Direction.toObject(var0, var1 + 83) : null;
   }

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

   @Nullable
   class="kw">public class="kw">static Position getRaycastHit(MemorySegment var0, int var1) {
      class="kw">return hasRaycastHit(var0, var1) ? Position.toObject(var0, var1 + 95) : null;
   }

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

   class="kw">public class="kw">static float getRaycastDistance(MemorySegment var0, int var1) {
      class="kw">return PacketIO.requireFinite(var0.get(PacketIO.PROTO_FLOAT, var1 + 119), "RaycastDistance");
   }

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

   @Nullable
   class="kw">public class="kw">static Vector3fc getRaycastNormal(MemorySegment var0, int var1) {
      class="kw">return hasRaycastNormal(var0, var1) ? PacketIO.requireFinite(PacketIO.readVector3f(var0, var1 + 123), "RaycastNormal") : null;
   }

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

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

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

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

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

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

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

   @Nullable
   class="kw">public class="kw">static UUID getGeneratedUUID(MemorySegment var0, int var1) {
      class="kw">return hasGeneratedUUID(var0, var1) ? PacketIO.readUUID(var0, var1 + 141) : null;
   }

   class="kw">public class="kw">static boolean hasBlockPosition(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 hasBlockRotation(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 hasAttackerPos(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 hasAttackerRot(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 hasRaycastHit(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 hasRaycastNormal(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 hasGeneratedUUID(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 hasForkCounts(MemorySegment var0, int var1) {
      byte var2 = var0.get(PacketIO.PROTO_BYTE, var1 + 0);
      class="kw">return (var2 & 128) != 0;
   }

   class="kw">public class="kw">static boolean hasHitEntities(MemorySegment var0, int var1) {
      byte var2 = var0.get(PacketIO.PROTO_BYTE, var1 + 1);
      class="kw">return (var2 & 1) != 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 InteractionSyncData toObject(MemorySegment var0) {
      class="kw">return toObject(var0, 0, null);
   }

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

   class="kw">public class="kw">static InteractionSyncData toObject(MemorySegment var0, int var1, @Nullable ReadCursor var2) {
      requireBounds(var0, var1);
      int var3 = var1 + 165;
      int var4 = 0;
      Map var5 = null;
      if (hasForkCounts(var0, var1)) {
         requireSlot(var0, var1 + 157, var4, "ForkCounts");
         int var6 = var3 + var4;
         long var7 = VarInt.getWithLength(var0, var6);
         if (var7 == -1L) {
            throw ProtocolException.invalidVarInt("ForkCounts");
         }

         int var9 = (int)var7;
         if (var9 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("ForkCounts", var9, 4096000);
         }

         var6 += (int)(var7 >>> 32);
         if (var6 + var9 * 5L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("ForkCounts", (int)Math.min(var6 + var9 * 5L, 2147483647L), (int)var0.byteSize());
         }

         var5 = new HashMap<>(var9);

         for (int var10 = 0; var10 < var9; var10++) {
            InteractionType var11 = InteractionType.fromValue(var0.get(PacketIO.PROTO_BYTE, var6));
            int var12 = var0.get(PacketIO.PROTO_INT, ++var6);
            var6 += 4;
            if (var5.put(var11, var12) != null) {
               throw ProtocolException.duplicateKey("ForkCounts", var11);
            }
         }

         var4 = var6 - var3;
      } else {
         requireSlot(var0, var1 + 157, -1, "ForkCounts");
      }

      SelectedHitEntity[] var15 = null;
      if (hasHitEntities(var0, var1)) {
         requireSlot(var0, var1 + 161, var4, "HitEntities");
         int var16 = var3 + var4;
         long var8 = VarInt.getWithLength(var0, var16);
         if (var8 == -1L) {
            throw ProtocolException.invalidVarInt("HitEntities");
         }

         int var19 = (int)var8;
         if (var19 > 4096000) {
            throw ProtocolException.arrayTooLong("HitEntities", var19, 4096000);
         }

         int var20 = (int)(var8 >>> 32);
         if (var16 + var20 + var19 * 53L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("HitEntities", (int)Math.min(var16 + var20 + var19 * 53L, 2147483647L), (int)var0.byteSize());
         }

         var16 += var20;
         var15 = new SelectedHitEntity[var19];

         for (int var21 = 0; var21 < var19; var21++) {
            var15[var21] = SelectedHitEntity.toObject(var0, var16 + var21 * 53);
         }

         var4 = var16 + var19 * 53 - var3;
      } else {
         requireSlot(var0, var1 + 161, -1, "HitEntities");
      }

      InteractionSyncData var18 = new InteractionSyncData(
         InteractionState.fromValue(var0.get(PacketIO.PROTO_BYTE, var1 + 2)),
         PacketIO.requireFinite(var0.get(PacketIO.PROTO_FLOAT, var1 + 3), "Progress"),
         var0.get(PacketIO.PROTO_INT, var1 + 7),
         var0.get(PacketIO.PROTO_INT, var1 + 11),
         var0.get(PacketIO.PROTO_INT, var1 + 15),
         var0.get(PacketIO.PROTO_INT, var1 + 19),
         var0.get(PacketIO.PROTO_INT, var1 + 23),
         hasBlockPosition(var0, var1) ? BlockPosition.toObject(var0, var1 + 27) : null,
         BlockFace.fromValue(var0.get(PacketIO.PROTO_BYTE, var1 + 39)),
         hasBlockRotation(var0, var1) ? BlockRotation.toObject(var0, var1 + 40) : null,
         var0.get(PacketIO.PROTO_INT, var1 + 43),
         PacketIO.requireFinite(var0.get(PacketIO.PROTO_FLOAT, var1 + 47), "ChargeValue"),
         var5,
         var0.get(PacketIO.PROTO_INT, var1 + 51),
         var0.get(PacketIO.PROTO_INT, var1 + 55),
         var15,
         hasAttackerPos(var0, var1) ? Position.toObject(var0, var1 + 59) : null,
         hasAttackerRot(var0, var1) ? Direction.toObject(var0, var1 + 83) : null,
         hasRaycastHit(var0, var1) ? Position.toObject(var0, var1 + 95) : null,
         PacketIO.requireFinite(var0.get(PacketIO.PROTO_FLOAT, var1 + 119), "RaycastDistance"),
         hasRaycastNormal(var0, var1) ? PacketIO.requireFinite(PacketIO.readVector3f(var0, var1 + 123), "RaycastNormal") : null,
         MovementDirection.fromValue(var0.get(PacketIO.PROTO_BYTE, var1 + 135)),
         ApplyForceState.fromValue(var0.get(PacketIO.PROTO_BYTE, var1 + 136)),
         var0.get(PacketIO.PROTO_INT, var1 + 137),
         hasGeneratedUUID(var0, var1) ? PacketIO.readUUID(var0, var1 + 141) : null
      );
      if (var2 != null) {
         var2.position = var3 + var4;
      }

      class="kw">return var18;
   }

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

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

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

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

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

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

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

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

      var1.set(PacketIO.PROTO_BYTE, var2 + 0, var3);
      var3 = 0;
      if (this.hitEntities != null) {
         var3 = (byte)(var3 | 1);
      }

      var1.set(PacketIO.PROTO_BYTE, var2 + 1, var3);
      var1.set(PacketIO.PROTO_BYTE, var2 + 2, (byte)this.state.getValue());
      PacketIO.requireFinite(this.progress, "Progress");
      var1.set(PacketIO.PROTO_FLOAT, var2 + 3, this.progress);
      var1.set(PacketIO.PROTO_INT, var2 + 7, this.operationCounter);
      var1.set(PacketIO.PROTO_INT, var2 + 11, this.rootInteraction);
      var1.set(PacketIO.PROTO_INT, var2 + 15, this.totalForks);
      var1.set(PacketIO.PROTO_INT, var2 + 19, this.entityId);
      var1.set(PacketIO.PROTO_INT, var2 + 23, this.enteredRootInteraction);
      if (this.blockPosition != null) {
         this.blockPosition.serialize(var1, var2 + 27);
      } else {
         var1.asSlice(var2 + 27, 12L).fill((byte)0);
      }

      var1.set(PacketIO.PROTO_BYTE, var2 + 39, (byte)this.blockFace.getValue());
      if (this.blockRotation != null) {
         this.blockRotation.serialize(var1, var2 + 40);
      } else {
         var1.asSlice(var2 + 40, 3L).fill((byte)0);
      }

      var1.set(PacketIO.PROTO_INT, var2 + 43, this.placedBlockId);
      PacketIO.requireFinite(this.chargeValue, "ChargeValue");
      var1.set(PacketIO.PROTO_FLOAT, var2 + 47, this.chargeValue);
      var1.set(PacketIO.PROTO_INT, var2 + 51, this.chainingIndex);
      var1.set(PacketIO.PROTO_INT, var2 + 55, this.flagIndex);
      if (this.attackerPos != null) {
         this.attackerPos.serialize(var1, var2 + 59);
      } else {
         var1.asSlice(var2 + 59, 24L).fill((byte)0);
      }

      if (this.attackerRot != null) {
         this.attackerRot.serialize(var1, var2 + 83);
      } else {
         var1.asSlice(var2 + 83, 12L).fill((byte)0);
      }

      if (this.raycastHit != null) {
         this.raycastHit.serialize(var1, var2 + 95);
      } else {
         var1.asSlice(var2 + 95, 24L).fill((byte)0);
      }

      PacketIO.requireFinite(this.raycastDistance, "RaycastDistance");
      var1.set(PacketIO.PROTO_FLOAT, var2 + 119, this.raycastDistance);
      if (this.raycastNormal != null) {
         PacketIO.requireFinite(this.raycastNormal, "RaycastNormal");
         PacketIO.writeVector3f(var1, var2 + 123, this.raycastNormal);
      } else {
         var1.asSlice(var2 + 123, 12L).fill((byte)0);
      }

      var1.set(PacketIO.PROTO_BYTE, var2 + 135, (byte)this.movementDirection.getValue());
      var1.set(PacketIO.PROTO_BYTE, var2 + 136, (byte)this.applyForceState.getValue());
      var1.set(PacketIO.PROTO_INT, var2 + 137, this.nextLabel);
      if (this.generatedUUID != null) {
         PacketIO.writeUUID(var1, var2 + 141, this.generatedUUID);
      } else {
         var1.asSlice(var2 + 141, 16L).fill((byte)0);
      }

      int var4 = var2 + 165;
      if (this.forkCounts != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 157, var4 - var2 - 165);
         if (this.forkCounts.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("ForkCounts", this.forkCounts.size(), 4096000);
         }

         var4 += VarInt.set(var1, var4, this.forkCounts.size());

         for (Entry var6 : this.forkCounts.entrySet()) {
            var1.set(PacketIO.PROTO_BYTE, var4, (byte)var6.getKey().getValue());
            var1.set(PacketIO.PROTO_INT, ++var4, var6.getValue());
            var4 += 4;
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 157, -1);
      }

      if (this.hitEntities != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 161, var4 - var2 - 165);
         if (this.hitEntities.length > 4096000) {
            throw ProtocolException.arrayTooLong("HitEntities", this.hitEntities.length, 4096000);
         }

         var4 += VarInt.set(var1, var4, this.hitEntities.length);
         int var10 = 0;

         for (int var11 = 0; var11 < this.hitEntities.length; var11++) {
            var10 += this.hitEntities[var11].serialize(var1, var4 + var10);
         }

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

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

   class="kw">public int computeSize() {
      int var1 = 165;
      if (this.forkCounts != null) {
         var1 += VarInt.size(this.forkCounts.size()) + this.forkCounts.size() * 5;
      }

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

      class="kw">return var1;
   }

   class="kw">public InteractionSyncData clone() {
      InteractionSyncData var1 = new InteractionSyncData();
      var1.state = this.state;
      var1.progress = this.progress;
      var1.operationCounter = this.operationCounter;
      var1.rootInteraction = this.rootInteraction;
      var1.totalForks = this.totalForks;
      var1.entityId = this.entityId;
      var1.enteredRootInteraction = this.enteredRootInteraction;
      var1.blockPosition = this.blockPosition != null ? this.blockPosition.clone() : null;
      var1.blockFace = this.blockFace;
      var1.blockRotation = this.blockRotation != null ? this.blockRotation.clone() : null;
      var1.placedBlockId = this.placedBlockId;
      var1.chargeValue = this.chargeValue;
      var1.forkCounts = this.forkCounts != null ? new HashMap<>(this.forkCounts) : null;
      var1.chainingIndex = this.chainingIndex;
      var1.flagIndex = this.flagIndex;
      var1.hitEntities = this.hitEntities != null ? Arrays.stream(this.hitEntities).map(var0 -> var0.clone()).toArray(SelectedHitEntity[]::new) : null;
      var1.attackerPos = this.attackerPos != null ? this.attackerPos.clone() : null;
      var1.attackerRot = this.attackerRot != null ? this.attackerRot.clone() : null;
      var1.raycastHit = this.raycastHit != null ? this.raycastHit.clone() : null;
      var1.raycastDistance = this.raycastDistance;
      var1.raycastNormal = this.raycastNormal;
      var1.movementDirection = this.movementDirection;
      var1.applyForceState = this.applyForceState;
      var1.nextLabel = this.nextLabel;
      var1.generatedUUID = this.generatedUUID;
      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 InteractionSyncData var2)
            ? false
            : Objects.equals(this.state, var2.state)
               && this.progress == var2.progress
               && this.operationCounter == var2.operationCounter
               && this.rootInteraction == var2.rootInteraction
               && this.totalForks == var2.totalForks
               && this.entityId == var2.entityId
               && this.enteredRootInteraction == var2.enteredRootInteraction
               && Objects.equals(this.blockPosition, var2.blockPosition)
               && Objects.equals(this.blockFace, var2.blockFace)
               && Objects.equals(this.blockRotation, var2.blockRotation)
               && this.placedBlockId == var2.placedBlockId
               && this.chargeValue == var2.chargeValue
               && Objects.equals(this.forkCounts, var2.forkCounts)
               && this.chainingIndex == var2.chainingIndex
               && this.flagIndex == var2.flagIndex
               && Arrays.equals(this.hitEntities, var2.hitEntities)
               && Objects.equals(this.attackerPos, var2.attackerPos)
               && Objects.equals(this.attackerRot, var2.attackerRot)
               && Objects.equals(this.raycastHit, var2.raycastHit)
               && this.raycastDistance == var2.raycastDistance
               && Objects.equals(this.raycastNormal, var2.raycastNormal)
               && Objects.equals(this.movementDirection, var2.movementDirection)
               && Objects.equals(this.applyForceState, var2.applyForceState)
               && this.nextLabel == var2.nextLabel
               && Objects.equals(this.generatedUUID, var2.generatedUUID);
      }
   }

   @Override
   class="kw">public int hashCode() {
      int var1 = 1;
      var1 = 31 * var1 + Objects.hashCode(this.state);
      var1 = 31 * var1 + Float.hashCode(this.progress);
      var1 = 31 * var1 + Integer.hashCode(this.operationCounter);
      var1 = 31 * var1 + Integer.hashCode(this.rootInteraction);
      var1 = 31 * var1 + Integer.hashCode(this.totalForks);
      var1 = 31 * var1 + Integer.hashCode(this.entityId);
      var1 = 31 * var1 + Integer.hashCode(this.enteredRootInteraction);
      var1 = 31 * var1 + Objects.hashCode(this.blockPosition);
      var1 = 31 * var1 + Objects.hashCode(this.blockFace);
      var1 = 31 * var1 + Objects.hashCode(this.blockRotation);
      var1 = 31 * var1 + Integer.hashCode(this.placedBlockId);
      var1 = 31 * var1 + Float.hashCode(this.chargeValue);
      var1 = 31 * var1 + Objects.hashCode(this.forkCounts);
      var1 = 31 * var1 + Integer.hashCode(this.chainingIndex);
      var1 = 31 * var1 + Integer.hashCode(this.flagIndex);
      var1 = 31 * var1 + Arrays.hashCode(this.hitEntities);
      var1 = 31 * var1 + Objects.hashCode(this.attackerPos);
      var1 = 31 * var1 + Objects.hashCode(this.attackerRot);
      var1 = 31 * var1 + Objects.hashCode(this.raycastHit);
      var1 = 31 * var1 + Float.hashCode(this.raycastDistance);
      var1 = 31 * var1 + Objects.hashCode(this.raycastNormal);
      var1 = 31 * var1 + Objects.hashCode(this.movementDirection);
      var1 = 31 * var1 + Objects.hashCode(this.applyForceState);
      var1 = 31 * var1 + Integer.hashCode(this.nextLabel);
      class="kw">return 31 * var1 + Objects.hashCode(this.generatedUUID);
   }
}