class="kw">package com.hypixel.hytale.server.core.modules.entitystats;

class="kw">import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.codecs.map.MapCodec;
class="kw">import com.hypixel.hytale.common.util.ArrayUtil;
class="kw">import com.hypixel.hytale.component.Component;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.protocol.ChangeStatBehaviour;
class="kw">import com.hypixel.hytale.protocol.EntityStatOp;
class="kw">import com.hypixel.hytale.protocol.EntityStatUpdate;
class="kw">import com.hypixel.hytale.protocol.ValueType;
class="kw">import com.hypixel.hytale.server.core.entity.StatModifiersManager;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.asset.EntityStatType;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.modifier.Modifier;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.modifier.StaticModifier;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import it.unimi.dsi.fastutil.floats.FloatArrayList;
class="kw">import it.unimi.dsi.fastutil.floats.FloatList;
class="kw">import it.unimi.dsi.fastutil.ints.Int2FloatMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMaps;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collection;
class="kw">import java.util.HashMap;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class EntityStatMap class="kw">implements Component<EntityStore> {
   class="kw">public class="kw">static class="kw">final int VERSION = 5;
   class="kw">public class="kw">static class="kw">final BuilderCodec<EntityStatMap> CODEC = BuilderCodec.builder(EntityStatMap.class, EntityStatMap::new)
      .legacyVersioned()
      .codecVersion(5)
      .addField(new KeyedCodec<>("Stats", new MapCodec<>(EntityStatValue.CODEC, HashMap::new, false)), (var0, var1) -> var0.unknown = var1, var0 -> {
         HashMap var1 = new HashMap<>();
         if (var0.unknown != null) {
            var1.putAll(var0.unknown);
         }

         for (EntityStatValue var5 : var0.values) {
            if (var5 != null) {
               var1.putIfAbsent(var5.getId(), var5);
            }
         }

         class="kw">return var1;
      })
      .afterDecode(var0 -> {
         var0.values = EntityStatValue.EMPTY_ARRAY;
         var0.update();
      })
      .build();
   @Nonnull
   class="kw">private class="kw">final StatModifiersManager statModifiersManager = new StatModifiersManager();
   class="kw">private Map<String, EntityStatValue> unknown;
   @Nonnull
   class="kw">private EntityStatValue[] values = EntityStatValue.EMPTY_ARRAY;
   float[] tempRegenerationValues = ArrayUtil.EMPTY_FLOAT_ARRAY;
   @Nonnull
   class="kw">public class="kw">final Int2ObjectMap<List<EntityStatUpdate>> selfUpdates = new Int2ObjectOpenHashMap();
   @Nonnull
   class="kw">public class="kw">final Int2ObjectMap<FloatList> selfStatValues = new Int2ObjectOpenHashMap();
   @Nonnull
   class="kw">public class="kw">final Int2ObjectMap<List<EntityStatUpdate>> otherUpdates = new Int2ObjectOpenHashMap();
   class="kw">protected boolean isSelfNetworkOutdated;
   class="kw">protected boolean isNetworkOutdated;
   @Nullable
   class="kw">private class="kw">transient Int2ObjectMap<StatChangeDirection> suppressedStatChanges;

   class="kw">public class="kw">static ComponentType<EntityStore, EntityStatMap> getComponentType() {
      class="kw">return EntityStatsModule.get().getEntityStatMapComponentType();
   }

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

   @Nonnull
   class="kw">public StatModifiersManager getStatModifiersManager() {
      class="kw">return this.statModifiersManager;
   }

   class="kw">public int size() {
      class="kw">return this.values.length;
   }

   @Nullable
   class="kw">public EntityStatValue get(int var1) {
      class="kw">return var1 >= this.values.length ? null : this.values[var1];
   }

   @Deprecated
   @Nullable
   class="kw">public EntityStatValue get(String var1) {
      class="kw">return this.get(EntityStatType.getAssetMap().getIndex(var1));
   }

   class="kw">public void update() {
      IndexedLookupTableAssetMap var1 = EntityStatType.getAssetMap();

      for (int var2 = 0; var2 < this.values.length; var2++) {
         EntityStatType var3 = var1.getAsset(var2);
         EntityStatValue var4 = this.values[var2];
         if (var3 != null && var4 != null) {
            if (var3.isUnknown()) {
               if (this.unknown == null) {
                  this.unknown = new Object2ObjectOpenHashMap();
               }

               this.unknown.put(var3.getId(), var4);
               this.values[var2] = new EntityStatValue(var2, var3);
            } else if (var4.synchronizeAsset(var2, var3)) {
               this.addInitChange(var2, var4);
            }
         }
      }

      int var7 = var1.getNextIndex();
      int var8 = this.values.length;
      if (var8 <= var7) {
         this.values = Arrays.copyOf(this.values, var7);

         for (int var9 = var8; var9 < var7; var9++) {
            EntityStatType var5 = var1.getAsset(var9);
            if (var5 != null) {
               if (var5.isUnknown()) {
                  EntityStatValue var6 = this.values[var9] = new EntityStatValue(var9, var5);
                  this.addInitChange(var9, var6);
               } else {
                  EntityStatValue var10 = this.unknown == null ? null : this.unknown.remove(var5.getId());
                  if (var10 != null) {
                     var10.synchronizeAsset(var9, var5);
                     this.values[var9] = var10;
                     this.addInitChange(var9, var10);
                  } else {
                     var10 = this.values[var9] = new EntityStatValue(var9, var5);
                     this.addInitChange(var9, var10);
                  }
               }
            }
         }
      }
   }

   @Nullable
   class="kw">public Modifier getModifier(int var1, String var2) {
      EntityStatValue var3 = this.get(var1);
      if (var3 == null) {
         HytaleLogger.getLogger().at(Level.WARNING).log("No EntityStatValue found for index: %d", var1);
         class="kw">return null;
      } else {
         class="kw">return var3.getModifiers() != null ? var3.getModifiers().get(var2) : null;
      }
   }

   @Nullable
   class="kw">public Modifier putModifier(int var1, String var2, Modifier var3) {
      class="kw">return this.putModifier(EntityStatMap.Predictable.NONE, var1, var2, var3);
   }

   @Nullable
   class="kw">public Modifier putModifier(EntityStatMap.Predictable var1, int var2, String var3, Modifier var4) {
      EntityStatValue var5 = this.get(var2);
      if (var5 == null) {
         HytaleLogger.getLogger().at(Level.WARNING).log("No EntityStatValue found for index: %d", var2);
         class="kw">return null;
      } else {
         float var6 = var5.get();
         Modifier var7 = var5.putModifier(var3, var4);
         this.addChange(var1, var2, EntityStatOp.PutModifier, var6, var3, var4);
         class="kw">return var7;
      }
   }

   @Nullable
   class="kw">public Modifier removeModifier(int var1, String var2) {
      class="kw">return this.removeModifier(EntityStatMap.Predictable.NONE, var1, var2);
   }

   @Nullable
   class="kw">public Modifier removeModifier(EntityStatMap.Predictable var1, int var2, String var3) {
      EntityStatValue var4 = this.get(var2);
      if (var4 == null) {
         HytaleLogger.getLogger().at(Level.WARNING).log("No EntityStatValue found for index: %d", var2);
         class="kw">return null;
      }

      float var5 = var4.get();
      Modifier var6 = var4.removeModifier(var3);
      if (var6 != null) {
         this.addChange(var1, var2, EntityStatOp.RemoveModifier, var5, var3, null);
      }

      class="kw">return var6;
   }

   class="kw">public float setStatValue(int var1, float var2) {
      class="kw">return this.setStatValue(EntityStatMap.Predictable.NONE, var1, var2);
   }

   class="kw">public float setStatValue(EntityStatMap.Predictable var1, int var2, float var3) {
      EntityStatValue var4 = this.get(var2);
      if (var4 == null) {
         HytaleLogger.getLogger().at(Level.WARNING).log("No EntityStatValue found for index: %d", var2);
         class="kw">return 0.0F;
      }

      float var5 = var4.get();
      if (this.shouldSuppressChange(var2, var5, var3)) {
         class="kw">return var5;
      }

      float var6 = var4.set(var3);
      if (var1 != EntityStatMap.Predictable.NONE || var3 != var5) {
         this.addChange(var1, var2, EntityStatOp.Set, var5, var3);
      }

      class="kw">return var6;
   }

   class="kw">public float addStatValue(int var1, float var2) {
      class="kw">return this.addStatValue(EntityStatMap.Predictable.NONE, var1, var2);
   }

   class="kw">public float addStatValue(EntityStatMap.Predictable var1, int var2, float var3) {
      EntityStatValue var4 = this.get(var2);
      if (var4 == null) {
         HytaleLogger.getLogger().at(Level.WARNING).log("No EntityStatValue found for index: %d", var2);
         class="kw">return 0.0F;
      }

      float var5 = var4.get();
      if (this.shouldSuppressChange(var2, var5, var5 + var3)) {
         class="kw">return var5;
      }

      float var6 = var4.set(var5 + var3);
      if (var1 != EntityStatMap.Predictable.NONE || var6 != var5) {
         this.addChange(var1, var2, EntityStatOp.Add, var5, var3);
      }

      class="kw">return var6;
   }

   class="kw">public float subtractStatValue(int var1, float var2) {
      class="kw">return this.addStatValue(var1, -var2);
   }

   class="kw">public float subtractStatValue(EntityStatMap.Predictable var1, int var2, float var3) {
      class="kw">return this.addStatValue(var1, var2, -var3);
   }

   class="kw">public float minStatValue(int var1, float var2) {
      class="kw">return this.minStatValue(EntityStatMap.Predictable.NONE, var1, var2);
   }

   class="kw">public float minStatValue(EntityStatMap.Predictable var1, int var2, float var3) {
      EntityStatValue var4 = this.get(var2);
      if (var4 == null) {
         HytaleLogger.getLogger().at(Level.WARNING).log("No EntityStatValue found for index: %d", var2);
         class="kw">return 0.0F;
      }

      float var5 = var4.get();
      float var6 = Math.min(var5, var3);
      if (this.shouldSuppressChange(var2, var5, var6)) {
         class="kw">return var5;
      }

      float var7 = var4.set(var6);
      if (var1 != EntityStatMap.Predictable.NONE || var7 != var5) {
         this.addChange(var1, var2, EntityStatOp.Min, var5, var3);
      }

      class="kw">return var7;
   }

   class="kw">public float maxStatValue(int var1, float var2) {
      class="kw">return this.maxStatValue(EntityStatMap.Predictable.NONE, var1, var2);
   }

   class="kw">public float maxStatValue(EntityStatMap.Predictable var1, int var2, float var3) {
      EntityStatValue var4 = this.get(var2);
      if (var4 == null) {
         HytaleLogger.getLogger().at(Level.WARNING).log("No EntityStatValue found for index: %d", var2);
         class="kw">return 0.0F;
      }

      float var5 = var4.get();
      float var6 = Math.max(var5, var3);
      if (this.shouldSuppressChange(var2, var5, var6)) {
         class="kw">return var5;
      }

      float var7 = var4.set(var6);
      if (var1 != EntityStatMap.Predictable.NONE || var7 != var5) {
         this.addChange(var1, var2, EntityStatOp.Max, var5, var3);
      }

      class="kw">return var7;
   }

   class="kw">public float minimizeStatValue(int var1) {
      class="kw">return this.minimizeStatValue(EntityStatMap.Predictable.NONE, var1);
   }

   class="kw">public float minimizeStatValue(EntityStatMap.Predictable var1, int var2) {
      EntityStatValue var3 = this.get(var2);
      if (var3 == null) {
         HytaleLogger.getLogger().at(Level.WARNING).log("No EntityStatValue found for index: %d", var2);
         class="kw">return 0.0F;
      }

      float var4 = var3.get();
      if (this.shouldSuppressChange(var2, var4, var3.getMin())) {
         class="kw">return var4;
      }

      float var5 = var3.set(var3.getMin());
      if (var1 != EntityStatMap.Predictable.NONE || var5 != var4) {
         this.addChange(var1, var2, EntityStatOp.Minimize, var4, 0.0F);
      }

      class="kw">return var5;
   }

   class="kw">public float maximizeStatValue(int var1) {
      class="kw">return this.maximizeStatValue(EntityStatMap.Predictable.NONE, var1);
   }

   class="kw">public float maximizeStatValue(EntityStatMap.Predictable var1, int var2) {
      EntityStatValue var3 = this.get(var2);
      if (var3 == null) {
         HytaleLogger.getLogger().at(Level.WARNING).log("No EntityStatValue found for index: %d", var2);
         class="kw">return 0.0F;
      }

      float var4 = var3.get();
      if (this.shouldSuppressChange(var2, var4, var3.getMax())) {
         class="kw">return var4;
      }

      float var5 = var3.set(var3.getMax());
      if (var1 != EntityStatMap.Predictable.NONE || var5 != var4) {
         this.addChange(var1, var2, EntityStatOp.Maximize, var4, 0.0F);
      }

      class="kw">return var5;
   }

   class="kw">public float resetStatValue(int var1) {
      class="kw">return this.resetStatValue(EntityStatMap.Predictable.NONE, var1);
   }

   class="kw">public float resetStatValue(EntityStatMap.Predictable var1, int var2) {
      EntityStatType var3 = EntityStatType.getAssetMap().getAsset(var2);
      if (var3 == null) {
         HytaleLogger.getLogger().at(Level.WARNING).log("No EntityStatType found for index: %d", var2);
         class="kw">return 0.0F;
      }

      EntityStatValue var4 = this.get(var2);
      if (var4 == null) {
         HytaleLogger.getLogger().at(Level.WARNING).log("No EntityStatValue found for index: %d", var2);
         class="kw">return 0.0F;
      }

      float var5 = var4.get();
      float var6;
      class="kw">switch (var3.getResetBehavior()) {
         case InitialValue:
            if (this.shouldSuppressChange(var2, var5, var3.getInitialValue())) {
               class="kw">return var5;
            }

            var6 = var4.set(var3.getInitialValue());
            break;
         case MaxValue:
            if (this.shouldSuppressChange(var2, var5, var4.getMax())) {
               class="kw">return var5;
            }

            var6 = var4.set(var4.getMax());
            break;
         class="kw">default:
            var6 = 0.0F;
      }

      if (var1 != EntityStatMap.Predictable.NONE || var6 != var5) {
         this.addChange(var1, var2, EntityStatOp.Reset, var5, 0.0F);
      }

      class="kw">return var6;
   }

   @Nonnull
   class="kw">public Int2ObjectMap<List<EntityStatUpdate>> getSelfUpdates() {
      class="kw">return this.selfUpdates;
   }

   @Nonnull
   class="kw">public Int2ObjectMap<FloatList> getSelfStatValues() {
      class="kw">return this.selfStatValues;
   }

   @Nonnull
   class="kw">public Int2ObjectMap<EntityStatUpdate[]> consumeSelfUpdates() {
      class="kw">return this.updatesToProtocol(this.selfUpdates);
   }

   class="kw">public void clearUpdates() {
      this.selfUpdates.values().forEach(List::clear);
      this.selfStatValues.values().forEach(List::clear);
      this.otherUpdates.values().forEach(List::clear);
   }

   @Nonnull
   class="kw">public Int2ObjectMap<EntityStatUpdate[]> consumeOtherUpdates() {
      class="kw">return this.updatesToProtocol(this.otherUpdates);
   }

   @Nonnull
   class="kw">private Int2ObjectOpenHashMap<EntityStatUpdate[]> updatesToProtocol(@Nonnull Int2ObjectMap<List<EntityStatUpdate>> var1) {
      Int2ObjectOpenHashMap var2 = new Int2ObjectOpenHashMap(var1.size());
      ObjectIterator var3 = Int2ObjectMaps.fastIterator(var1);

      while (var3.hasNext()) {
         Entry var4 = (Entry<List<EntityStatUpdate>>)var3.next();
         if (!((List)var4.getValue()).isEmpty()) {
            var2.put(var4.getIntKey(), ((List)var4.getValue()).toArray(EntityStatUpdate[]::new));
         }
      }

      class="kw">return var2;
   }

   @Nonnull
   class="kw">public Int2ObjectMap<EntityStatUpdate[]> createInitUpdate(boolean var1) {
      Int2ObjectOpenHashMap var2 = new Int2ObjectOpenHashMap(this.size());

      for (int var3 = 0; var3 < this.size(); var3++) {
         EntityStatValue var4 = this.get(var3);
         if (var4 != null && (EntityStatType.getAssetMap().getAsset(var3).isShared() || var1)) {
            var2.put(var3, new EntityStatUpdate[]{makeInitChange(var4)});
         }
      }

      class="kw">return var2;
   }

   class="kw">public boolean isStatChangeSuppressed(int var1, @Nonnull StatChangeDirection var2) {
      if (this.suppressedStatChanges == null) {
         class="kw">return false;
      }

      StatChangeDirection var3 = (StatChangeDirection)this.suppressedStatChanges.get(var1);
      class="kw">return var3 != null && var3.covers(var2);
   }

   class="kw">public void setStatChangeSuppressed(int var1, @Nonnull StatChangeDirection var2, boolean var3) {
      if (var3) {
         if (this.suppressedStatChanges == null) {
            this.suppressedStatChanges = new Int2ObjectOpenHashMap();
         }

         StatChangeDirection var4 = (StatChangeDirection)this.suppressedStatChanges.get(var1);
         this.suppressedStatChanges.put(var1, var4 == null ? var2 : var4.union(var2));
      } else if (this.suppressedStatChanges != null) {
         StatChangeDirection var6 = (StatChangeDirection)this.suppressedStatChanges.get(var1);
         if (var6 == null) {
            class="kw">return;
         }

         StatChangeDirection var5 = var6.without(var2);
         if (var5 == null) {
            this.suppressedStatChanges.remove(var1);
         } else {
            this.suppressedStatChanges.put(var1, var5);
         }
      }
   }

   class="kw">public boolean consumeSelfNetworkOutdated() {
      boolean var1 = this.isSelfNetworkOutdated;
      this.isSelfNetworkOutdated = false;
      class="kw">return var1;
   }

   class="kw">public boolean consumeNetworkOutdated() {
      boolean var1 = this.isNetworkOutdated;
      this.isNetworkOutdated = false;
      class="kw">return var1;
   }

   class="kw">private boolean shouldSuppressChange(int var1, float var2, float var3) {
      if (var3 > var2) {
         class="kw">return this.isStatChangeSuppressed(var1, StatChangeDirection.RAISE);
      } else {
         class="kw">return var3 < var2 ? this.isStatChangeSuppressed(var1, StatChangeDirection.LOWER) : false;
      }
   }

   class="kw">private void addInitChange(int var1, @Nonnull EntityStatValue var2) {
      this.addChange(EntityStatMap.Predictable.NONE, var1, EntityStatOp.Init, var2.get(), var2.get(), var2.getModifiers());
   }

   class="kw">private void addChange(EntityStatMap.Predictable var1, int var2, @Nonnull EntityStatOp var3, float var4, float var5) {
      this.addChange(var1, var2, var3, var4, var5, null);
   }

   class="kw">private void addChange(EntityStatMap.Predictable var1, int var2, @Nonnull EntityStatOp var3, float var4, float var5, Map<String, Modifier> var6) {
      EntityStatType var7 = EntityStatType.getAssetMap().getAsset(var2);
      if (var7.isShared()) {
         boolean var8 = var1 == EntityStatMap.Predictable.ALL;
         List var9 = (List<EntityStatUpdate>)this.otherUpdates.computeIfAbsent(var2, var0 -> new ObjectArrayList());
         this.tryMergeUpdate(var9, var3, var5, var6, var8);
         this.isNetworkOutdated = true;
      }

      boolean var11 = var1 != EntityStatMap.Predictable.NONE;
      List var12 = (List<EntityStatUpdate>)this.selfUpdates.computeIfAbsent(var2, var0 -> new ObjectArrayList());
      FloatList var10 = (FloatList)this.selfStatValues.computeIfAbsent(var2, var0 -> new FloatArrayList());
      if (this.tryMergeUpdate(var12, var3, var5, var6, var11)) {
         var10.set(var10.size() - 1, this.get(var2).get());
      } else {
         var10.add(var4);
         var10.add(this.get(var2).get());
         this.isSelfNetworkOutdated = true;
      }
   }

   class="kw">private void addChange(EntityStatMap.Predictable var1, int var2, EntityStatOp var3, float var4, String var5, @Nullable Modifier var6) {
      EntityStatType var7 = EntityStatType.getAssetMap().getAsset(var2);
      com.hypixel.hytale.protocol.Modifier var8 = var6 != null ? var6.toPacket() : null;
      if (var7.isShared()) {
         boolean var9 = var1 == EntityStatMap.Predictable.ALL;
         List var10 = (List<EntityStatUpdate>)this.otherUpdates.computeIfAbsent(var2, var0 -> new ObjectArrayList());
         var10.add(new EntityStatUpdate(var3, var9, 0.0F, null, var5, var8));
         this.isNetworkOutdated = true;
      }

      boolean var12 = var1 != EntityStatMap.Predictable.NONE;
      List var13 = (List<EntityStatUpdate>)this.selfUpdates.computeIfAbsent(var2, var0 -> new ObjectArrayList());
      var13.add(new EntityStatUpdate(var3, var12, 0.0F, null, var5, var8));
      FloatList var11 = (FloatList)this.selfStatValues.computeIfAbsent(var2, var0 -> new FloatArrayList());
      var11.add(var4);
      var11.add(this.get(var2).get());
      this.isSelfNetworkOutdated = true;
   }

   class="kw">private boolean tryMergeUpdate(
      @Nonnull List<EntityStatUpdate> var1, @Nonnull EntityStatOp var2, float var3, @Nullable Map<String, Modifier> var4, boolean var5
   ) {
      EntityStatUpdate var6 = var1.isEmpty() ? null : var1.getLast();
      class="kw">switch (var2) {
         case Init:
            if (!var5 && var6 != null && !var6.predictable && var6.op == EntityStatOp.Init) {
               var6.value = var3;
               class="kw">return true;
            }

            Map var7 = null;
            if (var4 != null) {
               var7 = new Object2ObjectOpenHashMap();

               for (java.util.Map.Entry var9 : var4.entrySet()) {
                  var7.put(var9.getKey(), var9.getValue().toPacket());
               }
            }

            var1.add(new EntityStatUpdate(var2, var5, var3, var7, null, null));
            class="kw">return false;
         case Remove:
            var1.add(new EntityStatUpdate(var2, var5, 0.0F, null, null, null));
         case PutModifier:
         case RemoveModifier:
         class="kw">default:
            class="kw">return false;
         case Add:
            if (var5 || var6 == null || var6.predictable || var6.op != EntityStatOp.Init && var6.op != EntityStatOp.Add && var6.op != EntityStatOp.Set) {
               var1.add(new EntityStatUpdate(var2, var5, var3, null, null, null));
               class="kw">return false;
            }

            var6.value += var3;
            class="kw">return true;
         case Min:
         case Max:
            var1.add(new EntityStatUpdate(var2, var5, var3, null, null, null));
            class="kw">return false;
         case Set:
         case Minimize:
         case Maximize:
         case Reset:
            if (!var5 && var6 != null && !var6.predictable && var6.op != EntityStatOp.Remove) {
               if (var6.op != EntityStatOp.Init) {
                  var6.op = var2;
               }

               var6.value = var3;
               class="kw">return true;
            } else {
               var1.add(new EntityStatUpdate(var2, var5, var3, null, null, null));
               class="kw">return false;
            }
      }
   }

   class="kw">public void processStatChanges(EntityStatMap.Predictable var1, @Nonnull Int2FloatMap var2, ValueType var3, @Nonnull ChangeStatBehaviour var4) {
      ObjectIterator var5 = var2.int2FloatEntrySet().iterator();

      while (var5.hasNext()) {
         it.unimi.dsi.fastutil.ints.Int2FloatMap.Entry var6 = (it.unimi.dsi.fastutil.ints.Int2FloatMap.Entry)var5.next();
         int var7 = var6.getIntKey();
         float var8 = var6.getFloatValue();
         if (var3 == ValueType.Percent) {
            EntityStatValue var9 = this.get(var7);
            if (var9 == null) {
               class="kw">continue;
            }

            var8 = var8 * (var9.getMax() - var9.getMin()) / 100.0F;
         }

         class="kw">switch (var4) {
            case Set:
               this.setStatValue(var1, var7, var8);
               break;
            case Add:
               this.addStatValue(var1, var7, var8);
               break;
            case Min:
               this.minStatValue(var1, var7, var8);
               break;
            case Max:
               this.maxStatValue(var1, var7, var8);
         }
      }
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "EntityStatMap{unknown=" + this.unknown + ", values=" + Arrays.toString(this.values) + "}";
   }

   @Nonnull
   class="kw">public EntityStatMap clone() {
      EntityStatMap var1 = new EntityStatMap();
      var1.unknown = this.unknown;
      var1.update();

      for (int var2 = 0; var2 < this.values.length; var2++) {
         if (this.values[var2] != null) {
            EntityStatValue var3 = this.values[var2];
            var1.values[var2].set(var3.get());
            Map var4 = var3.getModifiers();
            if (var4 != null) {
               for (java.util.Map.Entry var6 : var4.entrySet()) {
                  var1.values[var2].putModifier(var6.getKey(), var6.getValue());
               }
            }
         }
      }

      ObjectIterator var7 = this.selfUpdates.int2ObjectEntrySet().iterator();

      while (var7.hasNext()) {
         Entry var10 = (Entry<List<EntityStatUpdate>>)var7.next();
         var1.selfUpdates.put(var10.getIntKey(), new ObjectArrayList((Collection)var10.getValue()));
      }

      var7 = this.selfStatValues.int2ObjectEntrySet().iterator();

      while (var7.hasNext()) {
         Entry var11 = (Entry<FloatList>)var7.next();
         var1.selfStatValues.put(var11.getIntKey(), new FloatArrayList((FloatList)var11.getValue()));
      }

      var7 = this.otherUpdates.int2ObjectEntrySet().iterator();

      while (var7.hasNext()) {
         Entry var12 = (Entry<List<EntityStatUpdate>>)var7.next();
         var1.otherUpdates.put(var12.getIntKey(), new ObjectArrayList((Collection)var12.getValue()));
      }

      class="kw">return var1;
   }

   @Nonnull
   class="kw">private class="kw">static EntityStatUpdate makeInitChange(@Nonnull EntityStatValue var0) {
      Map var1 = null;
      if (var0.getModifiers() != null) {
         var1 = new Object2ObjectOpenHashMap();

         for (java.util.Map.Entry var3 : var0.getModifiers().entrySet()) {
            var1.put(var3.getKey(), var3.getValue().toPacket());
         }
      }

      class="kw">return new EntityStatUpdate(EntityStatOp.Init, false, var0.get(), var1, null, null);
   }

   @Nullable
   class="kw">public class="kw">static Int2ObjectMap<com.hypixel.hytale.protocol.Modifier[]> toPacket(@Nullable Int2ObjectMap<StaticModifier[]> var0) {
      if (var0 == null) {
         class="kw">return null;
      }

      Int2ObjectOpenHashMap var1 = new Int2ObjectOpenHashMap(var0.size());
      ObjectIterator var2 = var0.int2ObjectEntrySet().iterator();

      while (var2.hasNext()) {
         Entry var3 = (Entry<StaticModifier[]>)var2.next();
         com.hypixel.hytale.protocol.Modifier[] var4 = new com.hypixel.hytale.protocol.Modifier[((StaticModifier[])var3.getValue()).length];

         for (int var5 = 0; var5 < var4.length; var5++) {
            var4[var5] = ((StaticModifier[])var3.getValue())[var5].toPacket();
         }

         var1.put(var3.getIntKey(), var4);
      }

      class="kw">return var1;
   }

   class="kw">public enum Predictable {
      NONE,
      SELF,
      ALL;

      Predictable() {
      }
   }
}