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

class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.common.util.ArrayUtil;
class="kw">import com.hypixel.hytale.component.data.ForEachTaskData;
class="kw">import com.hypixel.hytale.component.data.change.ChangeType;
class="kw">import com.hypixel.hytale.component.data.change.ComponentChange;
class="kw">import com.hypixel.hytale.component.data.change.DataChange;
class="kw">import com.hypixel.hytale.component.data.change.SystemChange;
class="kw">import com.hypixel.hytale.component.data.unknown.UnknownComponents;
class="kw">import com.hypixel.hytale.component.event.EntityEventType;
class="kw">import com.hypixel.hytale.component.event.EntityHolderEventType;
class="kw">import com.hypixel.hytale.component.event.WorldEventType;
class="kw">import com.hypixel.hytale.component.metric.ArchetypeChunkData;
class="kw">import com.hypixel.hytale.component.metric.SystemMetricData;
class="kw">import com.hypixel.hytale.component.query.ExactArchetypeQuery;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.system.ArchetypeChunkSystem;
class="kw">import com.hypixel.hytale.component.system.EcsEvent;
class="kw">import com.hypixel.hytale.component.system.EntityEventSystem;
class="kw">import com.hypixel.hytale.component.system.EntityHolderEventSystem;
class="kw">import com.hypixel.hytale.component.system.HolderSystem;
class="kw">import com.hypixel.hytale.component.system.ISystem;
class="kw">import com.hypixel.hytale.component.system.MetricSystem;
class="kw">import com.hypixel.hytale.component.system.QuerySystem;
class="kw">import com.hypixel.hytale.component.system.RefChangeSystem;
class="kw">import com.hypixel.hytale.component.system.RefSystem;
class="kw">import com.hypixel.hytale.component.system.StoreSystem;
class="kw">import com.hypixel.hytale.component.system.WorldEventSystem;
class="kw">import com.hypixel.hytale.component.system.data.ArchetypeDataSystem;
class="kw">import com.hypixel.hytale.component.system.data.EntityDataSystem;
class="kw">import com.hypixel.hytale.component.system.tick.ArchetypeTickingSystem;
class="kw">import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
class="kw">import com.hypixel.hytale.component.system.tick.TickableSystem;
class="kw">import com.hypixel.hytale.component.system.tick.TickingSystem;
class="kw">import com.hypixel.hytale.component.task.ParallelRangeTask;
class="kw">import com.hypixel.hytale.component.task.ParallelTask;
class="kw">import com.hypixel.hytale.function.consumer.IntBiObjectConsumer;
class="kw">import com.hypixel.hytale.metrics.MetricResults;
class="kw">import com.hypixel.hytale.metrics.MetricsRegistry;
class="kw">import com.hypixel.hytale.metrics.metric.HistoricMetric;
class="kw">import it.unimi.dsi.fastutil.objects.Object2IntMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.lang.invoke.VarHandle;
class="kw">import java.util.ArrayDeque;
class="kw">import java.util.Arrays;
class="kw">import java.util.BitSet;
class="kw">import java.util.Collection;
class="kw">import java.util.Deque;
class="kw">import java.util.List;
class="kw">import java.util.Objects;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import java.util.concurrent.atomic.AtomicLong;
class="kw">import java.util.concurrent.locks.Condition;
class="kw">import java.util.concurrent.locks.Lock;
class="kw">import java.util.function.BiConsumer;
class="kw">import java.util.function.BiPredicate;
class="kw">import java.util.function.Predicate;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class Store<ECS_TYPE> class="kw">implements ComponentAccessor<ECS_TYPE> {
   class="kw">public class="kw">static class="kw">final Store[] EMPTY_ARRAY = new Store[0];
   class="kw">private class="kw">static class="kw">final boolean COUNT_SEQLOCK_RETRIES = Store.class.desiredAssertionStatus();
   @Nonnull
   class="kw">public class="kw">static class="kw">final MetricsRegistry<Store<?>> METRICS_REGISTRY = new MetricsRegistry<Store<?>>()
      .register("ArchetypeChunkCount", Store::getArchetypeChunkCount, Codec.INTEGER)
      .register("EntityCount", Store::getEntityCount, Codec.INTEGER)
      .register(
         "Systems",
         var0 -> {
            ComponentRegistry.Data var1 = var0.getRegistry().getData();
            HistoricMetric[] var2 = var0.getSystemMetrics();
            SystemMetricData[] var3 = new SystemMetricData[var1.getSystemSize()];

            for (int var4 = 0; var4 < var1.getSystemSize(); var4++) {
               ISystem var5 = var1.getSystem(var4);
               MetricResults var6 = null;
               if (var5 class="kw">instanceof MetricSystem var7) {
                  var6 = var7.toMetricResults(var0);
               }

               var3[var4] = new SystemMetricData(
                  var5.getClass().getName(),
                  var0.getArchetypeChunkCountFor(var4),
                  var0.getEntityCountFor(var4),
                  var5 class="kw">instanceof TickingSystem ? var2[var4] : null,
                  var6
               );
            }

            class="kw">return var3;
         },
         new ArrayCodec<>(SystemMetricData.CODEC, SystemMetricData[]::new)
      )
      .register("ArchetypeChunks", Store::collectArchetypeChunkData, new ArrayCodec<>(ArchetypeChunkData.CODEC, ArchetypeChunkData[]::new));
   @Nonnull
   class="kw">private class="kw">final ComponentRegistry<ECS_TYPE> registry;
   @Nonnull
   class="kw">private class="kw">final ECS_TYPE externalData;
   @Nonnull
   class="kw">private class="kw">final IResourceStorage resourceStorage;
   class="kw">private class="kw">final Deque<CommandBuffer<ECS_TYPE>> commandBuffers = new ArrayDeque<>();
   class="kw">private class="kw">final Thread thread = Thread.currentThread();
   @Nonnull
   class="kw">private class="kw">final ParallelTask<EntityTickingSystem.SystemTaskData<ECS_TYPE>> parallelTask = new ParallelTask<>(EntityTickingSystem.SystemTaskData::new);
   @Nonnull
   class="kw">private class="kw">final ParallelTask<ForEachTaskData<ECS_TYPE>> forEachTask = new ParallelTask<>(ForEachTaskData::new);
   @Nonnull
   class="kw">private class="kw">final ParallelTask<EntityDataSystem.SystemTaskData<ECS_TYPE, ?, ?>> fetchTask = new ParallelTask<>(EntityDataSystem.SystemTaskData::new);
   @Nonnull
   class="kw">private class="kw">final Store.ProcessingCounter processing = new Store.ProcessingCounter();
   class="kw">private class="kw">volatile boolean shutdown;
   int storeIndex;
   class="kw">private int entitiesSize;
   @Nonnull
   class="kw">private Ref<ECS_TYPE>[] refs = new Ref[16];
   @Nonnull
   class="kw">private BitSet[] systemIndexToArchetypeChunkIndexes = ArrayUtil.EMPTY_BITSET_ARRAY;
   @Nonnull
   class="kw">private class="kw">final Object2IntMap<Archetype<ECS_TYPE>> archetypeToIndexMap = new Object2IntOpenHashMap();
   class="kw">private int archetypeSize;
   @Nonnull
   class="kw">private class="kw">final BitSet archetypeChunkReuse = new BitSet();
   @Nonnull
   class="kw">private ArchetypeChunk<ECS_TYPE>[] archetypeChunks = ArchetypeChunk.emptyArray();
   @Nonnull
   class="kw">private Resource<ECS_TYPE>[] resources = Resource.EMPTY_ARRAY;
   @Nonnull
   class="kw">private HistoricMetric[] systemMetrics = HistoricMetric.EMPTY_ARRAY;
   @Deprecated(forRemoval = true)
   class="kw">private boolean disableProcessingAssert = false;
   @Nonnull
   class="kw">final AtomicLong seqlockRetries = new AtomicLong();

   Store(@Nonnull ComponentRegistry<ECS_TYPE> var1, int var2, @Nonnull ECS_TYPE var3, @Nonnull IResourceStorage var4) {
      this.registry = var1;
      this.storeIndex = var2;
      this.externalData = var3;
      this.resourceStorage = var4;
      this.archetypeToIndexMap.defaultReturnValue(Integer.MIN_VALUE);
   }

   @Nonnull
   CommandBuffer<ECS_TYPE> takeCommandBuffer() {
      this.assertThread();
      if (this.commandBuffers.isEmpty()) {
         class="kw">return new CommandBuffer<>(this);
      }

      CommandBuffer var1 = this.commandBuffers.pop();
      assert var1.setThread();
      class="kw">return var1;
   }

   void storeCommandBuffer(@Nonnull CommandBuffer<ECS_TYPE> var1) {
      this.assertThread();
      var1.validateEmpty();
      this.commandBuffers.add(var1);
   }

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

   @Nonnull
   class="kw">public ComponentRegistry<ECS_TYPE> getRegistry() {
      class="kw">return this.registry;
   }

   @Nonnull
   @Override
   class="kw">public ECS_TYPE getExternalData() {
      class="kw">return this.externalData;
   }

   @Nonnull
   class="kw">public IResourceStorage getResourceStorage() {
      class="kw">return this.resourceStorage;
   }

   @Nonnull
   class="kw">public ParallelTask<EntityTickingSystem.SystemTaskData<ECS_TYPE>> getParallelTask() {
      class="kw">return this.parallelTask;
   }

   @Nonnull
   class="kw">public ParallelTask<EntityDataSystem.SystemTaskData<ECS_TYPE, ?, ?>> getFetchTask() {
      class="kw">return this.fetchTask;
   }

   @Nonnull
   class="kw">public HistoricMetric[] getSystemMetrics() {
      this.assertThread();
      class="kw">return this.systemMetrics;
   }

   class="kw">public boolean isShutdown() {
      class="kw">return this.shutdown;
   }

   void onAdd(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1) {
      this.updateArchetypeIndexes(var1);
      int var2 = var1.getResourceSize();
      this.resources = Arrays.copyOf(this.resources, var2);

      for (int var3 = 0; var3 < var2; var3++) {
         ResourceType var4 = (ResourceType<ECS_TYPE, ? class="kw">extends Resource<ECS_TYPE>>)var1.getResourceType(var3);
         if (var4 != null) {
            this.resources[var3] = (Resource<ECS_TYPE>)this.resourceStorage.load(this, var1, var4).join();
         }
      }

      for (int var6 = 0; var6 < var1.getSystemSize(); var6++) {
         this.updateData(var1, var1, new SystemChange<>(ChangeType.REGISTERED, var1.getSystem(var6)));
      }

      this.systemMetrics = Arrays.copyOf(this.systemMetrics, var1.getSystemSize());
      SystemType var7 = this.registry.getTickableSystemType();
      BitSet var8 = var1.getSystemIndexesForType(var7);
      int var5 = -1;

      while ((var5 = var8.nextSetBit(var5 + 1)) >= 0) {
         this.systemMetrics[var5] = HistoricMetric.builder(33333333L, TimeUnit.NANOSECONDS)
            .addPeriod(1L, TimeUnit.SECONDS)
            .addPeriod(1L, TimeUnit.MINUTES)
            .addPeriod(5L, TimeUnit.MINUTES)
            .build();
      }
   }

   class="kw">public void shutdown() {
      if (this.shutdown) {
         throw new IllegalStateException("Store is already shutdown!");
      }

      this.registry.removeStore(this);
   }

   void shutdown0(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1) {
      if (this.thread.isAlive() && this.thread != Thread.currentThread()) {
         throw new IllegalArgumentException("Unable to shutdown store while thread is still running!");
      }

      for (int var2 = var1.getSystemSize() - 1; var2 >= 0; var2--) {
         this.updateData(var1, var1, new SystemChange<>(ChangeType.UNREGISTERED, var1.getSystem(var2)));
      }

      this.saveAllResources0(var1).join();
      this.processing.lock();

      try {
         for (int var6 = 0; var6 < this.entitiesSize; var6++) {
            this.refs[var6].invalidate();
            this.refs[var6] = null;
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      this.shutdown = true;
   }

   @Nonnull
   class="kw">public CompletableFuture<Void> saveAllResources() {
      class="kw">return this.saveAllResources0(this.registry.getData());
   }

   @Nonnull
   class="kw">private CompletableFuture<Void> saveAllResources0(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1) {
      int var2 = var1.getResourceSize();
      CompletableFuture[] var3 = new CompletableFuture[var2];
      int var4 = 0;

      for (int var5 = 0; var5 < var2; var5++) {
         ResourceType var6 = (ResourceType<ECS_TYPE, ? class="kw">extends Resource<ECS_TYPE>>)var1.getResourceType(var5);
         if (var6 != null) {
            var3[var4++] = this.resourceStorage.save(this, var1, var6, this.resources[var5]);
         }
      }

      class="kw">return CompletableFuture.allOf(Arrays.copyOf(var3, var4));
   }

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

   class="kw">public int getEntityCountFor(@Nonnull Query<ECS_TYPE> var1) {
      this.assertThread();
      if (var1 class="kw">instanceof ExactArchetypeQuery var2) {
         int var6 = this.archetypeToIndexMap.getInt(var2.getArchetype());
         class="kw">return var6 != Integer.MIN_VALUE ? this.archetypeChunks[var6].size() : 0;
      } else {
         int var3 = 0;

         for (int var4 = 0; var4 < this.archetypeSize; var4++) {
            ArchetypeChunk var5 = this.archetypeChunks[var4];
            if (var5 != null && var1.test(var5.getArchetype())) {
               var3 += var5.size();
            }
         }

         class="kw">return var3;
      }
   }

   class="kw">public int getEntityCountFor(int var1) {
      this.assertThread();
      int var2 = 0;
      BitSet var3 = this.systemIndexToArchetypeChunkIndexes[var1];
      int var4 = -1;

      while ((var4 = var3.nextSetBit(var4 + 1)) >= 0) {
         var2 += this.archetypeChunks[var4].size();
      }

      class="kw">return var2;
   }

   class="kw">public int getArchetypeChunkCount() {
      this.assertThread();
      class="kw">return this.archetypeSize;
   }

   @Nonnull
   class="kw">public ArchetypeChunkData[] collectArchetypeChunkData() {
      this.assertThread();
      ObjectArrayList var1 = new ObjectArrayList(this.archetypeSize);

      for (int var2 = 0; var2 < this.archetypeSize; var2++) {
         ArchetypeChunk var3 = this.archetypeChunks[var2];
         if (var3 != null) {
            Archetype var4 = var3.getArchetype();
            String[] var5 = new String[var4.count()];
            int var6 = 0;

            for (int var7 = var4.getMinIndex(); var7 < var4.length(); var7++) {
               ComponentType var8 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)var4.get(var7);
               if (var8 != null) {
                  var5[var6++] = var8.getTypeClass().getName();
               }
            }

            var1.add(new ArchetypeChunkData(var5, var3.size()));
         }
      }

      class="kw">return (ArchetypeChunkData[])var1.toArray(ArchetypeChunkData[]::new);
   }

   class="kw">public int getArchetypeChunkCountFor(int var1) {
      this.assertThread();
      class="kw">return this.systemIndexToArchetypeChunkIndexes[var1].cardinality();
   }

   @Nullable
   class="kw">public Ref<ECS_TYPE> addEntity(@Nonnull Archetype<ECS_TYPE> var1, @Nonnull AddReason var2) {
      this.assertThread();
      this.assertWriteProcessing();
      Component[] var3;
      if (var1.isEmpty()) {
         var3 = Component.EMPTY_ARRAY;
      } else {
         ComponentRegistry.Data var4 = this.registry._internal_getData();
         var3 = new Component[var1.length()];

         for (int var5 = var1.getMinIndex(); var5 < var1.length(); var5++) {
            ComponentType var6 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)var1.get(var5);
            if (var6 != null) {
               var3[var6.getIndex()] = var4.createComponent((ComponentType<ECS_TYPE, Component<ECS_TYPE>>)var6);
            }
         }
      }

      class="kw">return this.addEntity(this.registry.newHolder(var1, var3), new Ref<>(this), var2);
   }

   @Nullable
   @Override
   class="kw">public Ref<ECS_TYPE> addEntity(@Nonnull Holder<ECS_TYPE> var1, @Nonnull AddReason var2) {
      class="kw">return this.addEntity(var1, new Ref<>(this), var2);
   }

   @Nullable
   class="kw">public Ref<ECS_TYPE> addEntity(@Nonnull Holder<ECS_TYPE> var1, @Nonnull Ref<ECS_TYPE> var2, @Nonnull AddReason var3) {
      if (var2.isValid()) {
         throw new IllegalArgumentException("EntityReference is already in use!");
      }

      if (var2.getStore() != this) {
         throw new IllegalArgumentException("EntityReference is not for this store!");
      }

      this.assertThread();
      this.assertWriteProcessing();
      CommandBuffer var4 = this.takeCommandBuffer();
      ComponentRegistry.Data var5 = this.registry._internal_getData();
      this.processing.lock();

      try {
         SystemType var6 = this.registry.getHolderSystemType();
         BitSet var7 = var5.getSystemIndexesForType(var6);
         int var8 = -1;

         while ((var8 = var7.nextSetBit(var8 + 1)) >= 0) {
            HolderSystem var9 = var5.getSystem(var8, var6);
            if (var9.test(this.registry, var1.getArchetype())) {
               var9.onEntityAdd(var1, var3, this);
            }
         }

         int var20 = this.entitiesSize++;
         int var21 = this.refs.length;
         if (var21 <= var20) {
            var8 = ArrayUtil.grow(var20);
            this.refs = Arrays.copyOf(this.refs, var8);
         }

         this.refs[var20] = var2;
         var2.setIndex(var20);
         var8 = this.findOrCreateArchetypeChunk(var1.getArchetype());
         ArchetypeChunk var24 = this.archetypeChunks[var8];
         int var10 = var24.addEntity(var2, var1);
         var2.beginMutation();
         var2.setPosition(var24, var10);
         var2.endMutation();
         SystemType systemTypex = this.registry.getRefSystemType();
         BitSet systemIndexesx = var5.getSystemIndexesForType(systemTypex);
         BitSet var13 = var24.getSystemIndexes();
         var4.track(var2);
         int systemIndexx = -1;

         while ((systemIndexx = systemIndexesx.nextSetBit(systemIndexx + 1)) >= 0) {
            if (var13.get(systemIndexx)) {
               RefSystem var15 = var5.getSystem(systemIndexx, systemTypex);
               boolean var16 = this.disableProcessingAssert;
               this.disableProcessingAssert = var15 class="kw">instanceof DisableProcessingAssert;
               var15.onEntityAdded(var2, var3, this, var4);
               this.disableProcessingAssert = var16;
               if (var4.consumeWasTrackedRefRemoved()) {
                  break;
               }
            }
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var4.consume();
      class="kw">return var2.isValid() ? var2 : null;
   }

   @Nonnull
   @Override
   class="kw">public Ref<ECS_TYPE>[] addEntities(@Nonnull Holder<ECS_TYPE>[] var1, @Nonnull AddReason var2) {
      class="kw">return this.addEntities(var1, 0, var1.length, var2);
   }

   @Nonnull
   class="kw">public Ref<ECS_TYPE>[] addEntities(@Nonnull Holder<ECS_TYPE>[] var1, int var2, int var3, @Nonnull AddReason var4) {
      Ref[] var5 = new Ref[var3];

      for (int var6 = 0; var6 < var3; var6++) {
         var5[var6] = new Ref<>(this);
      }

      this.addEntities(var1, var2, var5, 0, var3, var4);
      class="kw">return var5;
   }

   class="kw">public void addEntities(@Nonnull Holder<ECS_TYPE>[] var1, @Nonnull Ref<ECS_TYPE>[] var2, @Nonnull AddReason var3) {
      if (var1.length != var2.length) {
         throw new IllegalArgumentException("EntityHolder and EntityReference array length doesn't match!");
      }

      this.addEntities(var1, 0, var2, 0, var1.length, var3);
   }

   class="kw">public void addEntities(@Nonnull Holder<ECS_TYPE>[] var1, int var2, @Nonnull Ref<ECS_TYPE>[] var3, int var4, int var5, @Nonnull AddReason var6) {
      int var7 = var2 + var5;
      int var8 = var4 + var5;
      if (var1.length < var7) {
         throw new IllegalArgumentException("EntityHolder start and length exceed array length!");
      }

      if (var3.length < var8) {
         throw new IllegalArgumentException("EntityReference start and length exceed array length!");
      }

      for (int var9 = var4; var9 < var8; var9++) {
         Ref var10 = var3[var9];
         if (var10.isValid()) {
            throw new IllegalArgumentException("EntityReference is already in use!");
         }

         if (var10.getStore() != this) {
            throw new IllegalArgumentException("EntityReference is not for this store!");
         }
      }

      this.assertThread();
      this.assertWriteProcessing();
      CommandBuffer var25 = this.takeCommandBuffer();
      ComponentRegistry.Data var26 = this.registry._internal_getData();
      this.processing.lock();

      try {
         SystemType var11 = this.registry.getHolderSystemType();
         BitSet var12 = var26.getSystemIndexesForType(var11);
         int var13 = -1;

         while ((var13 = var12.nextSetBit(var13 + 1)) >= 0) {
            HolderSystem var14 = var26.getSystem(var13, var11);

            for (int var15 = var2; var15 < var7; var15++) {
               if (var14.test(this.registry, var1[var15].getArchetype())) {
                  var14.onEntityAdd(var1[var15], var6, this);
               }
            }
         }

         int var27 = this.entitiesSize;
         this.entitiesSize += var5;
         int var28 = this.refs.length;
         if (var28 <= this.entitiesSize) {
            var13 = ArrayUtil.grow(this.entitiesSize);
            this.refs = Arrays.copyOf(this.refs, var13);
         }

         System.arraycopy(var3, var4, this.refs, var27, var5);
         var13 = var4;

         for (int var33 = var27; var13 < var8; var33++) {
            var3[var13].setIndex(var33);
            var13++;
         }

         var13 = 0;

         for (int var34 = var27; var13 < var5; var34++) {
            Ref var36 = var3[var4 + var13];
            Holder var16 = var1[var2 + var13];
            int var17 = this.findOrCreateArchetypeChunk(var16.getArchetype());
            ArchetypeChunk var18 = this.archetypeChunks[var17];
            int var19 = var18.addEntity(var36, var16);
            var36.beginMutation();
            var36.setPosition(var18, var19);
            var36.endMutation();
            var13++;
         }

         SystemType systemTypex = this.registry.getRefSystemType();
         BitSet systemIndexesx = var26.getSystemIndexesForType(systemTypex);
         int systemIndexx = -1;

         while ((systemIndexx = systemIndexesx.nextSetBit(systemIndexx + 1)) >= 0) {
            for (int var38 = var4; var38 < var8; var38++) {
               Ref var39 = var3[var38];
               BitSet var40 = var39.getArchetypeChunk().getSystemIndexes();
               if (var40.get(systemIndexx)) {
                  RefSystem var41 = var26.getSystem(systemIndexx, systemTypex);
                  boolean var20 = this.disableProcessingAssert;
                  this.disableProcessingAssert = var41 class="kw">instanceof DisableProcessingAssert;
                  var25.track(var39);
                  var41.onEntityAdded(var39, var6, this, var25);
                  if (var25.consumeWasTrackedRefRemoved()) {
                     int var21 = var8 - var38;
                     if (var21 > 1) {
                        System.arraycopy(var3, var38 + 1, var3, var38, var21 - 1);
                        var3[var8 - 1] = var39;
                        var38--;
                     }

                     var8--;
                     var5--;
                  }

                  this.disableProcessingAssert = var20;
               }
            }
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var25.consume();
   }

   @Nonnull
   class="kw">public Holder<ECS_TYPE> copyEntity(@Nonnull Ref<ECS_TYPE> var1) {
      class="kw">return this.copyEntity(var1, this.registry.newHolder());
   }

   @Nonnull
   class="kw">public Holder<ECS_TYPE> copyEntity(@Nonnull Ref<ECS_TYPE> var1, @Nonnull Holder<ECS_TYPE> var2) {
      this.assertThread();
      var1.validate(this);
      class="kw">return var1.getArchetypeChunk().copyEntity(var1.getChunkEntityIndex(), var2);
   }

   @Nonnull
   class="kw">public Holder<ECS_TYPE> copySerializableEntity(@Nonnull Ref<ECS_TYPE> var1) {
      class="kw">return this.copySerializableEntity(var1, this.registry.newHolder(), null);
   }

   @Nonnull
   class="kw">public Holder<ECS_TYPE> copySerializableEntity(
      @Nonnull Ref<ECS_TYPE> var1, @Nonnull Holder<ECS_TYPE> var2, @Nullable Predicate<ComponentType<ECS_TYPE, ?>> var3
   ) {
      this.assertThread();
      var1.validate(this);
      class="kw">return var1.getArchetypeChunk().copySerializableEntity(this.registry.getData(), var1.getChunkEntityIndex(), var2, var3);
   }

   @Nonnull
   @Override
   class="kw">public Archetype<ECS_TYPE> getArchetype(@Nonnull Ref<ECS_TYPE> var1) {
      this.assertThread();
      var1.validate(this);
      class="kw">return var1.getArchetypeChunk().getArchetype();
   }

   @Nonnull
   class="kw">protected Archetype<ECS_TYPE> __internal_getArchetype(@Nonnull Ref<ECS_TYPE> var1) {
      var1.validate(this);
      class="kw">return var1.getArchetypeChunk().getArchetype();
   }

   @Nonnull
   class="kw">public Holder<ECS_TYPE> removeEntity(@Nonnull Ref<ECS_TYPE> var1, @Nonnull RemoveReason var2) {
      class="kw">return this.removeEntity(var1, this.registry.newHolder(), var2);
   }

   @Nonnull
   @Override
   class="kw">public Holder<ECS_TYPE> removeEntity(@Nonnull Ref<ECS_TYPE> var1, @Nonnull Holder<ECS_TYPE> var2, @Nonnull RemoveReason var3) {
      class="kw">return this.removeEntity(var1, var2, var3, null);
   }

   @Nonnull
   Holder<ECS_TYPE> removeEntity(@Nonnull Ref<ECS_TYPE> var1, @Nonnull Holder<ECS_TYPE> var2, @Nonnull RemoveReason var3, @Nullable Throwable var4) {
      this.assertThread();
      this.assertWriteProcessing();
      int var5 = var1.validate(this);
      CommandBuffer var6 = this.takeCommandBuffer();
      ArchetypeChunk var7 = var1.getArchetypeChunk();
      int var8 = var1.getChunkEntityIndex();
      ComponentRegistry.Data var9 = this.registry._internal_getData();
      this.processing.lock();

      try {
         SystemType var10 = this.registry.getRefSystemType();
         BitSet var11 = var9.getSystemIndexesForType(var10);
         BitSet var12 = var7.getSystemIndexes();
         int var13 = -1;

         while ((var13 = var11.nextSetBit(var13 + 1)) >= 0) {
            if (var12.get(var13)) {
               var9.getSystem(var13, var10).onEntityRemove(var1, var3, this, var6);
            }
         }

         int var22 = this.entitiesSize - 1;
         if (var5 != var22) {
            Ref var24 = this.refs[var22];
            var24.setIndex(var5);
            this.refs[var5] = var24;
         }

         this.refs[var22] = null;
         this.entitiesSize = var22;
         var1.beginMutation();
         var7.removeEntity(var8, var2);
         if (var7.size() == 0) {
            this.removeArchetypeChunk(var7);
         }

         var1.invalidate(var4);
      } class="kw">finally {
         this.processing.unlock();
      }

      var6.consume();
      this.processing.lock();

      try {
         SystemType var23 = this.registry.getHolderSystemType();
         BitSet var25 = var9.getSystemIndexesForType(var23);
         int var26 = -1;

         while ((var26 = var25.nextSetBit(var26 + 1)) >= 0) {
            HolderSystem var27 = var9.getSystem(var26, var23);
            if (var27.test(this.registry, var2.getArchetype())) {
               var27.onEntityRemoved(var2, var3, this);
            }
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      class="kw">return var2;
   }

   @Nonnull
   class="kw">public Holder<ECS_TYPE>[] removeEntities(@Nonnull Ref<ECS_TYPE>[] var1, @Nonnull RemoveReason var2) {
      class="kw">return this.removeEntities(var1, 0, var1.length, var2);
   }

   @Nonnull
   class="kw">public Holder<ECS_TYPE>[] removeEntities(@Nonnull Ref<ECS_TYPE>[] var1, int var2, int var3, @Nonnull RemoveReason var4) {
      Holder[] var5 = new Holder[var3];

      for (int var6 = 0; var6 < var3; var6++) {
         var5[var6] = this.registry.newHolder();
      }

      class="kw">return this.removeEntities(var1, var2, var5, 0, var3, var4);
   }

   @Nonnull
   class="kw">public Holder<ECS_TYPE>[] removeEntities(@Nonnull Ref<ECS_TYPE>[] var1, @Nonnull Holder<ECS_TYPE>[] var2, @Nonnull RemoveReason var3) {
      if (var1.length != var2.length) {
         throw new IllegalArgumentException("EntityHolder and EntityReference array length doesn't match!");
      } else {
         class="kw">return this.removeEntities(var1, 0, var2, 0, var1.length, var3);
      }
   }

   @Nonnull
   class="kw">public Holder<ECS_TYPE>[] removeEntities(
      @Nonnull Ref<ECS_TYPE>[] var1, int var2, @Nonnull Holder<ECS_TYPE>[] var3, int var4, int var5, @Nonnull RemoveReason var6
   ) {
      int var7 = var2 + var5;
      int var8 = var4 + var5;
      if (var1.length < var7) {
         throw new IllegalArgumentException("EntityReference start and length exceed array length!");
      }

      if (var3.length < var8) {
         throw new IllegalArgumentException("EntityHolder start and length exceed array length!");
      }

      for (int var9 = var2; var9 < var7; var9++) {
         var1[var9].validate(this);
      }

      this.assertThread();
      this.assertWriteProcessing();
      CommandBuffer var26 = this.takeCommandBuffer();
      ComponentRegistry.Data var10 = this.registry._internal_getData();
      this.processing.lock();

      try {
         SystemType var11 = this.registry.getRefSystemType();
         BitSet var12 = var10.getSystemIndexesForType(var11);
         int var13 = -1;

         while ((var13 = var12.nextSetBit(var13 + 1)) >= 0) {
            for (int var14 = var2; var14 < var7; var14++) {
               Ref var15 = var1[var14];
               BitSet var16 = var15.getArchetypeChunk().getSystemIndexes();
               if (var16.get(var13)) {
                  var10.getSystem(var13, var11).onEntityRemove(var1[var14], var6, this, var26);
               }
            }
         }

         for (int var27 = 0; var27 < var5; var27++) {
            Ref var30 = var1[var2 + var27];
            var13 = var30.getIndex();
            ArchetypeChunk var34 = var30.getArchetypeChunk();
            int var36 = var30.getChunkEntityIndex();
            int var38 = this.entitiesSize - 1;
            if (var13 != var38) {
               Ref var17 = this.refs[var38];
               var17.setIndex(var13);
               this.refs[var13] = var17;
            }

            this.refs[var38] = null;
            this.entitiesSize = var38;
            Holder var39 = var3[var4 + var27];
            var30.beginMutation();
            var34.removeEntity(var36, var39);
            if (var34.size() == 0) {
               this.removeArchetypeChunk(var34);
            }
         }

         for (int var28 = var2; var28 < var7; var28++) {
            var1[var28].invalidate();
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var26.consume();
      this.processing.lock();

      try {
         SystemType var29 = this.registry.getHolderSystemType();
         BitSet var31 = var10.getSystemIndexesForType(var29);
         int var33 = -1;

         while ((var33 = var31.nextSetBit(var33 + 1)) >= 0) {
            HolderSystem var35 = var10.getSystem(var33, var29);

            for (int var37 = var4; var37 < var8; var37++) {
               if (var35.test(this.registry, var3[var37].getArchetype())) {
                  var35.onEntityRemoved(var3[var37], var6, this);
               }
            }
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      class="kw">return var3;
   }

   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void ensureComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      this.assertThread();
      this.assertWriteProcessing();
      var2.validateRegistry(this.registry);
      var2.validate();
      CommandBuffer var3 = this.takeCommandBuffer();
      this.processing.lock();

      try {
         ArchetypeChunk var4 = var1.getArchetypeChunk();
         if (!var4.getArchetype().contains(var2)) {
            Component var5 = this.registry._internal_getData().createComponent(var2);
            this.datachunk_addComponent(var1, var4, var2, var5, var3);
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var3.consume();
   }

   @Nonnull
   @Override
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> T ensureAndGetComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      this.assertThread();
      this.assertWriteProcessing();
      var2.validateRegistry(this.registry);
      var2.validate();
      CommandBuffer var3 = this.takeCommandBuffer();
      this.processing.lock();

      Component var4;
      try {
         ArchetypeChunk var5 = var1.getArchetypeChunk();
         var4 = var5.__internal_getComponent(var1.getChunkEntityIndex(), var2);
         if (var4 == null) {
            var4 = this.registry._internal_getData().createComponent(var2);
            this.datachunk_addComponent(var1, var5, var2, var4, var3);
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var3.consume();
      class="kw">return var4;
   }

   @Nonnull
   @Override
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> T addComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      this.assertThread();
      this.assertWriteProcessing();
      Component var3 = this.registry._internal_getData().createComponent(var2);
      this.addComponent(var1, var2, var3);
      class="kw">return var3;
   }

   @Override
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void addComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2, @Nonnull T var3) {
      this.assertThread();
      this.assertWriteProcessing();
      var1.validate(this);
      var2.validateRegistry(this.registry);
      var2.validate();
      Objects.requireNonNull(var3);
      CommandBuffer var4 = this.takeCommandBuffer();
      this.processing.lock();

      try {
         this.datachunk_addComponent(var1, var1.getArchetypeChunk(), var2, var3, var4);
      } class="kw">finally {
         this.processing.unlock();
      }

      var4.consume();
   }

   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void replaceComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2, @Nonnull T var3) {
      this.assertThread();
      this.assertWriteProcessing();
      var1.validate(this);
      var2.validateRegistry(this.registry);
      var2.validate();
      Objects.requireNonNull(var3);
      CommandBuffer var4 = this.takeCommandBuffer();
      this.processing.lock();

      try {
         ArchetypeChunk var5 = var1.getArchetypeChunk();
         int var6 = var1.getChunkEntityIndex();
         Component var7 = var5.__internal_getComponent(var6, var2);
         var5.setComponent(var6, var2, var3);
         BitSet var8 = var5.getSystemIndexes();
         ComponentRegistry.Data var9 = this.registry._internal_getData();
         BitSet var10 = var9.getSystemIndexesForType(this.registry.getRefChangeSystemType());
         int var11 = -1;

         while ((var11 = var10.nextSetBit(var11 + 1)) >= 0) {
            if (var8.get(var11)) {
               RefChangeSystem var12 = (RefChangeSystem<ECS_TYPE, T>)var9.getSystem(var11);
               if (var12.componentType().getIndex() == var2.getIndex()) {
                  var12.onComponentSet(var1, var7, var3, this, var4);
               }
            }
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var4.consume();
   }

   @Override
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void putComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2, @Nonnull T var3) {
      this.assertThread();
      this.assertWriteProcessing();
      var1.validate(this);
      var2.validateRegistry(this.registry);
      var2.validate();
      Objects.requireNonNull(var3);
      CommandBuffer var4 = this.takeCommandBuffer();
      this.processing.lock();

      try {
         ArchetypeChunk var5 = var1.getArchetypeChunk();
         if (var5.getArchetype().contains(var2)) {
            int var6 = var1.getChunkEntityIndex();
            Component var7 = var5.__internal_getComponent(var6, var2);
            var5.setComponent(var6, var2, var3);
            BitSet var8 = var5.getSystemIndexes();
            ComponentRegistry.Data var9 = this.registry._internal_getData();
            BitSet var10 = var9.getSystemIndexesForType(this.registry.getRefChangeSystemType());
            int var11 = -1;

            while ((var11 = var10.nextSetBit(var11 + 1)) >= 0) {
               if (var8.get(var11)) {
                  RefChangeSystem var12 = (RefChangeSystem<ECS_TYPE, T>)var9.getSystem(var11);
                  if (var12.componentType().getIndex() == var2.getIndex()) {
                     var12.onComponentSet(var1, var7, var3, this, var4);
                  }
               }
            }
         } else {
            this.datachunk_addComponent(var1, var5, var2, var3, var4);
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var4.consume();
   }

   @Override
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> T getComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      this.assertThread();
      class="kw">return this.__internal_getComponent(var1, var2);
   }

   @Nullable
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> T getComponentConcurrent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      var2.validateRegistry(this.registry);
      var2.validate();

      while (true) {
         int var3 = var1.getSeq();
         if ((var3 & 1) != 0) {
            Thread.onSpinWait();
         } else {
            if (!var1.isValid(this)) {
               class="kw">return null;
            }

            ArchetypeChunk var4 = var1.getArchetypeChunk();
            if (var4 == null) {
               Thread.onSpinWait();
            } else {
               Component var5 = var4.__internal_getComponentConcurrent(var1.getChunkEntityIndex(), var2);
               VarHandle.loadLoadFence();
               if (var3 == var1.getSeq()) {
                  class="kw">return var5;
               }

               if (COUNT_SEQLOCK_RETRIES) {
                  this.seqlockRetries.incrementAndGet();
               }

               Thread.onSpinWait();
            }
         }
      }
   }

   @Nullable
   class="kw">protected <T class="kw">extends Component<ECS_TYPE>> T __internal_getComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      var1.validate(this);
      var2.validateRegistry(this.registry);
      var2.validate();
      class="kw">return var1.getArchetypeChunk().__internal_getComponent(var1.getChunkEntityIndex(), var2);
   }

   @Override
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void removeComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      this.assertThread();
      this.assertWriteProcessing();
      var1.validate(this);
      var2.validateRegistry(this.registry);
      var2.validate();
      CommandBuffer var3 = this.takeCommandBuffer();
      this.processing.lock();

      try {
         ArchetypeChunk var4 = var1.getArchetypeChunk();
         int var5 = var1.getChunkEntityIndex();
         Component var6 = var4.__internal_getComponent(var5, var2);
         assert var6 != null;
         Archetype var7 = Archetype.remove(var4.getArchetype(), var2);
         int var8 = this.findOrCreateArchetypeChunk(var7);
         ArchetypeChunk var9 = this.archetypeChunks[var8];
         var9.addEntityFrom(var1, var4, var5);
         BitSet var10 = var4.getSystemIndexes();
         ComponentRegistry.Data var11 = this.registry._internal_getData();
         BitSet var12 = var11.getSystemIndexesForType(this.registry.getRefChangeSystemType());
         int var13 = -1;

         while ((var13 = var12.nextSetBit(var13 + 1)) >= 0) {
            if (var10.get(var13)) {
               RefChangeSystem var14 = (RefChangeSystem<ECS_TYPE, T>)var11.getSystem(var13);
               if (var14.componentType().getIndex() == var2.getIndex()) {
                  var14.onComponentRemoved(var1, var6, this, var3);
               }
            }
         }

         if (var4.size() == 0) {
            this.removeArchetypeChunk(var4);
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var3.consume();
   }

   @Override
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void tryRemoveComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      this.removeComponentIfExists(var1, var2);
   }

   class="kw">public <T class="kw">extends Component<ECS_TYPE>> boolean removeComponentIfExists(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      this.assertThread();
      this.assertWriteProcessing();
      var1.validate(this);
      var2.validateRegistry(this.registry);
      var2.validate();
      CommandBuffer var3 = this.takeCommandBuffer();
      this.processing.lock();

      boolean var4;
      try {
         ArchetypeChunk var5 = var1.getArchetypeChunk();
         if (!var5.getArchetype().contains(var2)) {
            var4 = false;
         } else {
            int var6 = var1.getChunkEntityIndex();
            Component var7 = var5.__internal_getComponent(var6, var2);
            assert var7 != null;
            Archetype var8 = Archetype.remove(var5.getArchetype(), var2);
            int var9 = this.findOrCreateArchetypeChunk(var8);
            ArchetypeChunk var10 = this.archetypeChunks[var9];
            var10.addEntityFrom(var1, var5, var6);
            BitSet var11 = var5.getSystemIndexes();
            ComponentRegistry.Data var12 = this.registry._internal_getData();
            BitSet var13 = var12.getSystemIndexesForType(this.registry.getRefChangeSystemType());
            int var14 = -1;

            while ((var14 = var13.nextSetBit(var14 + 1)) >= 0) {
               if (var11.get(var14)) {
                  RefChangeSystem var15 = (RefChangeSystem<ECS_TYPE, T>)var12.getSystem(var14);
                  if (var15.componentType().getIndex() == var2.getIndex()) {
                     var15.onComponentRemoved(var1, var7, this, var3);
                  }
               }
            }

            if (var5.size() == 0) {
               this.removeArchetypeChunk(var5);
            }

            var4 = true;
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var3.consume();
      class="kw">return var4;
   }

   class="kw">public <T class="kw">extends Resource<ECS_TYPE>> void replaceResource(@Nonnull ResourceType<ECS_TYPE, T> var1, @Nonnull T var2) {
      this.assertThread();
      var1.validateRegistry(this.registry);
      Objects.requireNonNull(var2);
      this.resources[var1.getIndex()] = var2;
   }

   @Nonnull
   @Override
   class="kw">public <T class="kw">extends Resource<ECS_TYPE>> T getResource(@Nonnull ResourceType<ECS_TYPE, T> var1) {
      var1.validateRegistry(this.registry);
      class="kw">return (T)this.resources[var1.getIndex()];
   }

   @Nonnull
   class="kw">protected <T class="kw">extends Resource<ECS_TYPE>> T __internal_getResource(@Nonnull ResourceType<ECS_TYPE, T> var1) {
      var1.validateRegistry(this.registry);
      class="kw">return (T)this.resources[var1.getIndex()];
   }

   class="kw">public void forEachChunk(@Nonnull BiConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var1) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      CommandBuffer var2 = this.takeCommandBuffer();
      this.processing.lock();

      try {
         for (int var3 = 0; var3 < this.archetypeSize; var3++) {
            ArchetypeChunk var4 = this.archetypeChunks[var3];
            if (var4 != null) {
               var1.accept(var4, var2);
            }
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var2.consume();
   }

   class="kw">public boolean forEachChunk(@Nonnull BiPredicate<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var1) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      CommandBuffer var2 = this.takeCommandBuffer();
      boolean var3 = false;
      this.processing.lock();

      try {
         for (int var4 = 0; var4 < this.archetypeSize; var4++) {
            ArchetypeChunk var5 = this.archetypeChunks[var4];
            if (var5 != null && var1.test(var5, var2)) {
               var3 = true;
               break;
            }
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var2.consume();
      class="kw">return var3;
   }

   class="kw">public void forEachChunk(Query<ECS_TYPE> var1, @Nonnull BiConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var2) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      CommandBuffer var3 = this.takeCommandBuffer();
      this.processing.lock();

      try {
         if (var1 class="kw">instanceof ExactArchetypeQuery var4) {
            int var5 = this.archetypeToIndexMap.getInt(var4.getArchetype());
            if (var5 != Integer.MIN_VALUE) {
               var2.accept(this.archetypeChunks[var5], var3);
            }
         } else {
            for (int var10 = 0; var10 < this.archetypeSize; var10++) {
               ArchetypeChunk var6 = this.archetypeChunks[var10];
               if (var6 != null && var1.test(var6.getArchetype())) {
                  var2.accept(this.archetypeChunks[var10], var3);
               }
            }
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var3.consume();
   }

   class="kw">public boolean forEachChunk(Query<ECS_TYPE> var1, @Nonnull BiPredicate<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var2) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      CommandBuffer var3 = this.takeCommandBuffer();
      boolean var4 = false;
      this.processing.lock();

      try {
         if (var1 class="kw">instanceof ExactArchetypeQuery var5) {
            int var6 = this.archetypeToIndexMap.getInt(var5.getArchetype());
            if (var6 != Integer.MIN_VALUE) {
               var4 = var2.test(this.archetypeChunks[var6], var3);
            }
         } else {
            for (int var11 = 0; var11 < this.archetypeSize; var11++) {
               ArchetypeChunk var7 = this.archetypeChunks[var11];
               if (var7 != null && var1.test(var7.getArchetype()) && var2.test(this.archetypeChunks[var11], var3)) {
                  var4 = true;
                  break;
               }
            }
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var3.consume();
      class="kw">return var4;
   }

   class="kw">public void forEachChunk(int var1, @Nonnull BiConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var2) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      CommandBuffer var3 = this.takeCommandBuffer();
      this.processing.lock();

      try {
         BitSet var4 = this.systemIndexToArchetypeChunkIndexes[var1];
         int var5 = -1;

         while ((var5 = var4.nextSetBit(var5 + 1)) >= 0) {
            var2.accept(this.archetypeChunks[var5], var3);
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var3.consume();
   }

   class="kw">public boolean forEachChunk(int var1, @Nonnull BiPredicate<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var2) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      CommandBuffer var3 = this.takeCommandBuffer();
      boolean var4 = false;
      this.processing.lock();

      try {
         BitSet var5 = this.systemIndexToArchetypeChunkIndexes[var1];
         int var6 = -1;

         while ((var6 = var5.nextSetBit(var6 + 1)) >= 0) {
            if (var2.test(this.archetypeChunks[var6], var3)) {
               var4 = true;
               break;
            }
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var3.consume();
      class="kw">return var4;
   }

   class="kw">public void forEachEntityParallel(IntBiObjectConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var1) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      CommandBuffer var2 = this.takeCommandBuffer();
      this.forEachTask.init();
      this.processing.lock();

      try {
         for (int var3 = 0; var3 < this.archetypeSize; var3++) {
            ArchetypeChunk var4 = this.archetypeChunks[var3];
            if (var4 != null) {
               int var5 = var4.size();
               if (var5 != 0) {
                  ParallelRangeTask var6 = this.forEachTask.appendTask();
                  var6.init(0, var5);
                  int var7 = 0;

                  for (int var8 = var6.size(); var7 < var8; var7++) {
                     var6.get(var7).init(var1, var4, var2.fork());
                  }
               }
            }
         }

         ForEachTaskData.invokeParallelTask(this.forEachTask, var2);
      } class="kw">finally {
         this.processing.unlock();
      }

      var2.consume();
   }

   class="kw">public void forEachEntityParallel(Query<ECS_TYPE> var1, IntBiObjectConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> var2) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      CommandBuffer var3 = this.takeCommandBuffer();
      this.forEachTask.init();
      this.processing.lock();

      try {
         if (var1 class="kw">instanceof ExactArchetypeQuery var4) {
            int var14 = this.archetypeToIndexMap.getInt(var4.getArchetype());
            if (var14 != Integer.MIN_VALUE) {
               ArchetypeChunk var15 = this.archetypeChunks[var14];
               int var16 = var15.size();
               if (var16 != 0) {
                  ParallelRangeTask var17 = this.forEachTask.appendTask();
                  var17.init(0, var16);
                  int var18 = 0;

                  for (int var19 = var17.size(); var18 < var19; var18++) {
                     var17.get(var18).init(var2, var15, var3.fork());
                  }
               }
            }
         } else {
            for (int var5 = 0; var5 < this.archetypeSize; var5++) {
               ArchetypeChunk var6 = this.archetypeChunks[var5];
               if (var6 != null && var1.test(var6.getArchetype())) {
                  int var7 = var6.size();
                  if (var7 != 0) {
                     ParallelRangeTask var8 = this.forEachTask.appendTask();
                     var8.init(0, var7);
                     int var9 = 0;

                     for (int var10 = var8.size(); var9 < var10; var9++) {
                        var8.get(var9).init(var2, var6, var3.fork());
                     }
                  }
               }
            }
         }

         ForEachTaskData.invokeParallelTask(this.forEachTask, var3);
      } class="kw">finally {
         this.processing.unlock();
      }

      var3.consume();
   }

   class="kw">public <T class="kw">extends ArchetypeDataSystem<ECS_TYPE, Q, R>, Q, R> void fetch(@Nonnull SystemType<ECS_TYPE, T> var1, Q var2, @Nonnull List<R> var3) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      ComponentRegistry.Data var4 = this.registry._internal_getData();
      CommandBuffer var5 = this.takeCommandBuffer();
      this.fetchTask.init();
      BitSet var6 = var4.getSystemIndexesForType(var1);
      this.processing.lock();

      try {
         int var7 = -1;

         while ((var7 = var6.nextSetBit(var7 + 1)) >= 0) {
            ArchetypeDataSystem var8 = (T)var4.getSystem(var7, var1);
            BitSet var9 = this.systemIndexToArchetypeChunkIndexes[var7];
            int var10 = -1;

            while ((var10 = var9.nextSetBit(var10 + 1)) >= 0) {
               var8.fetch(this.archetypeChunks[var10], this, var5, var2, var3);
            }
         }

         EntityDataSystem.SystemTaskData.invokeParallelTask(this.fetchTask, var5, var3);
      } class="kw">finally {
         this.processing.unlock();
      }

      var5.consume();
   }

   class="kw">public <T class="kw">extends EntityDataSystem<ECS_TYPE, Q, R>, Q, R> void fetch(
      @Nonnull Collection<Ref<ECS_TYPE>> var1, @Nonnull SystemType<ECS_TYPE, T> var2, @Nonnull Q var3, @Nonnull List<R> var4
   ) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      ComponentRegistry.Data var5 = this.registry._internal_getData();
      CommandBuffer var6 = this.takeCommandBuffer();
      this.fetchTask.init();
      BitSet var7 = var5.getSystemIndexesForType(var2);
      this.processing.lock();

      try {
         int var8 = -1;

         while ((var8 = var7.nextSetBit(var8 + 1)) >= 0) {
            EntityDataSystem var9 = (T)var5.getSystem(var8, var2);

            for (Ref var11 : var1) {
               ArchetypeChunk var12 = var11.getArchetypeChunk();
               BitSet var13 = var12.getSystemIndexes();
               if (var13.get(var8)) {
                  var9.fetch(var11.getChunkEntityIndex(), var12, this, var6, var3, var4);
               }
            }
         }

         EntityDataSystem.SystemTaskData.invokeParallelTask(this.fetchTask, var6, var4);
      } class="kw">finally {
         this.processing.unlock();
      }

      var6.consume();
   }

   @Override
   class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull Ref<ECS_TYPE> var1, @Nonnull Event var2) {
      EntityEventType var3 = this.registry.getEntityEventTypeForClass(var2.getClass());
      if (var3 != null) {
         ((Store<ECS_TYPE>)this).invoke(var3, var1, var2);
      }
   }

   @Override
   class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull EntityEventType<ECS_TYPE, Event> var1, @Nonnull Ref<ECS_TYPE> var2, @Nonnull Event var3) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      ComponentRegistry.Data var4 = this.registry._internal_getData();
      CommandBuffer var5 = this.takeCommandBuffer();
      var5.track(var2);
      BitSet var6 = var4.getSystemIndexesForType(var1);
      this.processing.lock();

      try {
         ArchetypeChunk var7 = var2.getArchetypeChunk();
         BitSet var8 = var7.getSystemIndexes();
         int var9 = -1;

         while ((var9 = var6.nextSetBit(var9 + 1)) >= 0) {
            var9 = var8.nextSetBit(var9);
            if (var9 < 0) {
               break;
            }

            if (var6.get(var9)) {
               EntityEventSystem var10 = var4.getSystem(var9, var1);
               var10.handleInternal(var2.getChunkEntityIndex(), var7, this, var5, var3);
               if (var5.consumeWasTrackedRefRemoved()) {
                  break;
               }
            }
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var5.consume();
   }

   @Override
   class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull Holder<ECS_TYPE> var1, @Nonnull Event var2) {
      EntityHolderEventType var3 = this.registry.getEntityHolderEventTypeForClass(var2.getClass());
      if (var3 != null) {
         ((Store<ECS_TYPE>)this).invoke(var3, var1, var2);
      }
   }

   @Override
   class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull EntityHolderEventType<ECS_TYPE, Event> var1, @Nonnull Holder<ECS_TYPE> var2, @Nonnull Event var3) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      ComponentRegistry.Data var4 = this.registry._internal_getData();
      CommandBuffer var5 = this.takeCommandBuffer();
      BitSet var6 = var4.getSystemIndexesForType(var1);
      this.processing.lock();

      try {
         Archetype var7 = var2.getArchetype();
         int var8 = -1;

         while ((var8 = var6.nextSetBit(var8 + 1)) >= 0) {
            EntityHolderEventSystem var9 = var4.getSystem(var8, var1);
            if (var9.getQuery() != null && var9.getQuery().test(var7)) {
               var9.handleInternal(var2, this, var5, var3);
            }
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var5.consume();
   }

   @Override
   class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull Event var1) {
      WorldEventType var2 = this.registry.getWorldEventTypeForClass(var1.getClass());
      if (var2 != null) {
         ((Store<ECS_TYPE>)this).invoke(var2, var1);
      }
   }

   @Override
   class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull WorldEventType<ECS_TYPE, Event> var1, @Nonnull Event var2) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      ComponentRegistry.Data var3 = this.registry._internal_getData();
      CommandBuffer var4 = this.takeCommandBuffer();
      BitSet var5 = var3.getSystemIndexesForType(var1);
      this.processing.lock();

      try {
         int var6 = -1;

         while ((var6 = var5.nextSetBit(var6 + 1)) >= 0) {
            WorldEventSystem var7 = var3.getSystem(var6, var1);
            var7.handleInternal(this, var4, var2);
         }
      } class="kw">finally {
         this.processing.unlock();
      }

      var4.consume();
   }

   class="kw">protected <Event class="kw">extends EcsEvent> void internal_invoke(CommandBuffer<ECS_TYPE> var1, Ref<ECS_TYPE> var2, Event var3) {
      EntityEventType var4 = this.registry.getEntityEventTypeForClass(var3.getClass());
      if (var4 != null) {
         ((Store<ECS_TYPE>)this).internal_invoke(var1, var4, var2, var3);
      }
   }

   class="kw">protected <Event class="kw">extends EcsEvent> void internal_invoke(
      CommandBuffer<ECS_TYPE> var1, @Nonnull EntityEventType<ECS_TYPE, Event> var2, Ref<ECS_TYPE> var3, Event var4
   ) {
      ComponentRegistry.Data var5 = this.registry._internal_getData();
      CommandBuffer var6 = var1.fork();
      var6.track(var3);
      BitSet var7 = var5.getSystemIndexesForType(var2);
      ArchetypeChunk var8 = var3.getArchetypeChunk();
      BitSet var9 = var8.getSystemIndexes();
      int var10 = -1;

      while ((var10 = var7.nextSetBit(var10 + 1)) >= 0) {
         var10 = var9.nextSetBit(var10);
         if (var10 < 0) {
            break;
         }

         if (var7.get(var10)) {
            EntityEventSystem var11 = var5.getSystem(var10, var2);
            var11.handleInternal(var3.getChunkEntityIndex(), var8, this, var6, var4);
            if (var6.consumeWasTrackedRefRemoved()) {
               break;
            }
         }
      }

      var6.mergeParallel(var1);
   }

   class="kw">protected <Event class="kw">extends EcsEvent> void internal_invoke(CommandBuffer<ECS_TYPE> var1, Holder<ECS_TYPE> var2, Event var3) {
      EntityHolderEventType var4 = this.registry.getEntityHolderEventTypeForClass(var3.getClass());
      if (var4 != null) {
         ((Store<ECS_TYPE>)this).internal_invoke(var1, var4, var2, var3);
      }
   }

   class="kw">protected <Event class="kw">extends EcsEvent> void internal_invoke(
      CommandBuffer<ECS_TYPE> var1, @Nonnull EntityHolderEventType<ECS_TYPE, Event> var2, Holder<ECS_TYPE> var3, Event var4
   ) {
      ComponentRegistry.Data var5 = this.registry._internal_getData();
      BitSet var6 = var5.getSystemIndexesForType(var2);
      Archetype var7 = var3.getArchetype();
      int var8 = -1;

      while ((var8 = var6.nextSetBit(var8 + 1)) >= 0) {
         EntityHolderEventSystem var9 = var5.getSystem(var8, var2);
         if (var9.getQuery() != null && var9.getQuery().test(var7)) {
            var9.handleInternal(var3, this, var1, var4);
         }
      }
   }

   class="kw">protected <Event class="kw">extends EcsEvent> void internal_invoke(CommandBuffer<ECS_TYPE> var1, Event var2) {
      WorldEventType var3 = this.registry.getWorldEventTypeForClass(var2.getClass());
      if (var3 != null) {
         ((Store<ECS_TYPE>)this).internal_invoke(var1, var3, var2);
      }
   }

   class="kw">protected <Event class="kw">extends EcsEvent> void internal_invoke(CommandBuffer<ECS_TYPE> var1, @Nonnull WorldEventType<ECS_TYPE, Event> var2, Event var3) {
      ComponentRegistry.Data var4 = this.registry._internal_getData();
      BitSet var5 = var4.getSystemIndexesForType(var2);
      int var6 = -1;

      while ((var6 = var5.nextSetBit(var6 + 1)) >= 0) {
         WorldEventSystem var7 = var4.getSystem(var6, var2);
         var7.handleInternal(this, var1, var3);
      }
   }

   class="kw">public void tick(float var1) {
      this.tickInternal(var1, this.registry.getTickingSystemType());
   }

   class="kw">public void pausedTick(float var1) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      this.tickInternal(var1, this.registry.getRunWhenPausedSystemType());
   }

   class="kw">private <Tickable class="kw">extends TickableSystem<ECS_TYPE>> void tickInternal(float var1, SystemType<ECS_TYPE, Tickable> var2) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      this.registry.getDataUpdateLock().readLock().lock();

      try {
         ComponentRegistry.Data var3 = this.registry.doDataUpdate();
         BitSet var4 = var3.getSystemIndexesForType(var2);
         int var5 = -1;

         while ((var5 = var4.nextSetBit(var5 + 1)) >= 0) {
            TickableSystem var6 = (Tickable)var3.getSystem(var5, var2);
            long var7 = System.nanoTime();
            var6.tick(var1, var5, this);
            long var9 = System.nanoTime();
            this.systemMetrics[var5].add(var9, var9 - var7);
         }
      } class="kw">finally {
         this.registry.getDataUpdateLock().readLock().unlock();
      }
   }

   class="kw">public void tick(ArchetypeTickingSystem<ECS_TYPE> var1, float var2, int var3) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      this.assertThread();
      CommandBuffer var4 = this.takeCommandBuffer();
      this.parallelTask.init();
      boolean var5 = this.disableProcessingAssert;
      this.disableProcessingAssert = var1 class="kw">instanceof DisableProcessingAssert;
      this.processing.lock();

      try {
         BitSet var6 = this.systemIndexToArchetypeChunkIndexes[var3];
         int var7 = -1;

         while ((var7 = var6.nextSetBit(var7 + 1)) >= 0) {
            var1.tick(var2, this.archetypeChunks[var7], this, var4);
         }

         EntityTickingSystem.SystemTaskData.invokeParallelTask(this.parallelTask, var4);
      } class="kw">finally {
         this.processing.unlock();
         this.disableProcessingAssert = var5;
      }

      var4.consume();
   }

   void updateData(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1, @Nonnull ComponentRegistry.Data<ECS_TYPE> var2) {
      if (this.shutdown) {
         throw new IllegalStateException("Store is shutdown!");
      }

      int var3 = var2.getResourceSize();
      this.resources = Arrays.copyOf(this.resources, var3);

      for (int var4 = 0; var4 < this.resources.length; var4++) {
         ResourceType var5 = (ResourceType<ECS_TYPE, ? class="kw">extends Resource<ECS_TYPE>>)var2.getResourceType(var4);
         if (this.resources[var4] == null && var5 != null) {
            this.resources[var4] = (Resource<ECS_TYPE>)this.resourceStorage.load(this, var2, var5).join();
         } else if (this.resources[var4] != null && var5 == null) {
            this.resources[var4] = null;
         }
      }

      boolean var11 = false;

      for (int var12 = 0; var12 < var2.getDataChangeCount(); var12++) {
         DataChange var6 = var2.getDataChange(var12);
         var11 |= var6 class="kw">instanceof SystemChange;
         this.updateData(var1, var2, var6);
      }

      HistoricMetric[] var13 = this.systemMetrics;
      this.systemMetrics = new HistoricMetric[var2.getSystemSize()];
      SystemType var14 = this.registry.getTickableSystemType();
      BitSet var7 = var2.getSystemIndexesForType(var14);
      int var8 = -1;

      while ((var8 = var7.nextSetBit(var8 + 1)) >= 0) {
         ISystem var9 = var2.getSystem(var8);
         int var10 = var1.indexOf(var9);
         if (var10 >= 0) {
            this.systemMetrics[var8] = var13[var10];
         } else {
            this.systemMetrics[var8] = HistoricMetric.builder(33333333L, TimeUnit.NANOSECONDS)
               .addPeriod(1L, TimeUnit.SECONDS)
               .addPeriod(1L, TimeUnit.MINUTES)
               .addPeriod(5L, TimeUnit.MINUTES)
               .build();
         }
      }

      if (var11) {
         this.updateArchetypeIndexes(var2);
      }
   }

   class="kw">private void updateData(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1, @Nonnull ComponentRegistry.Data<ECS_TYPE> var2, DataChange var3) {
      this.processing.lock();

      try {
         this.updateData0(var1, var2, var3);
      } class="kw">finally {
         this.processing.unlock();
      }

      if (var3 class="kw">instanceof SystemChange var4) {
         ISystem var5 = var4.getSystem();
         class="kw">switch (var4.getType()) {
            case REGISTERED:
               if (var5 class="kw">instanceof StoreSystem) {
                  ((StoreSystem)var5).onSystemAddedToStore(this);
               }
               break;
            case UNREGISTERED:
               if (var5 class="kw">instanceof StoreSystem) {
                  ((StoreSystem)var5).onSystemRemovedFromStore(this);
               }
         }
      }
   }

   class="kw">private void updateData0(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1, @Nonnull ComponentRegistry.Data<ECS_TYPE> var2, DataChange var3) {
      if (var3 class="kw">instanceof ComponentChange var4) {
         ComponentType var5 = var4.getComponentType();
         ComponentType var6 = this.registry.getUnknownComponentType();
         class="kw">switch (var4.getType()) {
            case REGISTERED:
               String var22 = var2.getComponentId(var5);
               Codec var25 = var2.getComponentCodec((ComponentType<ECS_TYPE, Component<ECS_TYPE>>)var5);
               if (var25 != null) {
                  Holder var28 = this.registry._internal_newEntityHolder();
                  int var29 = this.archetypeSize;

                  for (int var31 = 0; var31 < var29; var31++) {
                     ArchetypeChunk var32 = this.archetypeChunks[var31];
                     if (var32 != null) {
                        Archetype var33 = var32.getArchetype();
                        if (!var33.contains(var5) && var33.contains(var6)) {
                           Archetype var35 = Archetype.add(var33, var5);
                           int var36 = this.findOrCreateArchetypeChunk(var35);
                           ArchetypeChunk var37 = this.archetypeChunks[var36];
                           var32.transferSomeTo(var28, var37, var3x -> {
                              UnknownComponents var4 = var32.getComponent(var3x, var6);
                              assert var4 != null;
                              class="kw">return var4.contains(var22);
                           }, var4x -> {
                              UnknownComponents var5 = var4x.getComponent(var6);
                              assert var5 != null;
                              Component var6 = var5.removeComponent(var22, var25);
                              var4x.addComponent(var5, var6);
                           }, (var1x, var2x) -> var2x.setPosition(var37, var1x));
                           if (var32.size() == 0) {
                              this.archetypeToIndexMap.removeInt(var32.getArchetype());
                              this.archetypeChunks[var31] = null;

                              for (int var17 = 0; var17 < var1.getSystemSize(); var17++) {
                                 this.systemIndexToArchetypeChunkIndexes[var17].clear(var31);
                              }

                              var32.getSystemIndexes().clear();
                              this.archetypeChunkReuse.set(var31);
                           }

                           if (var37.size() == 0) {
                              this.archetypeToIndexMap.removeInt(var37.getArchetype());
                              this.archetypeChunks[var36] = null;

                              for (int var38 = 0; var38 < var1.getSystemSize(); var38++) {
                                 this.systemIndexToArchetypeChunkIndexes[var38].clear(var36);
                              }

                              var37.getSystemIndexes().clear();
                              this.archetypeChunkReuse.set(var36);
                           }
                        }
                     }
                  }
               }
               break;
            case UNREGISTERED:
               Holder var9 = this.registry._internal_newEntityHolder();
               String var7 = var1.getComponentId(var5);
               Codec var8 = var1.getComponentCodec((ComponentType<ECS_TYPE, Component<ECS_TYPE>>)var5);
               int var10 = this.archetypeSize;

               for (int var11 = 0; var11 < var10; var11++) {
                  ArchetypeChunk var12 = this.archetypeChunks[var11];
                  if (var12 != null) {
                     Archetype var13 = var12.getArchetype();
                     if (var13.contains(var5)) {
                        this.archetypeToIndexMap.removeInt(var12.getArchetype());
                        this.archetypeChunks[var11] = null;

                        for (int var14 = 0; var14 < var1.getSystemSize(); var14++) {
                           this.systemIndexToArchetypeChunkIndexes[var14].clear(var11);
                        }

                        var12.getSystemIndexes().clear();
                        this.archetypeChunkReuse.set(var11);
                        Archetype var34 = Archetype.remove(var13, var5);
                        if (var8 != null && !var34.contains(var6)) {
                           var34 = Archetype.add(var34, var6);
                        }

                        int var15 = this.findOrCreateArchetypeChunk(var34);
                        ArchetypeChunk var16 = this.archetypeChunks[var15];
                        var12.transferTo(var9, var16, var4x -> {
                           if (var8 != null) {
                              UnknownComponents var5;
                              if (var4x.getArchetype().contains(var6)) {
                                 var5 = var4x.getComponent(var6);
                                 assert var5 != null;
                              } else {
                                 var5 = new UnknownComponents<>();
                                 var4x.addComponent(var6, var5);
                              }

                              Component var6 = var4x.getComponent((ComponentType<ECS_TYPE, Component<ECS_TYPE>>)var5);
                              var5.addComponent(var7, var6, var8);
                           }

                           var4x.removeComponent(var5);
                        }, (var1x, var2x) -> var2x.setPosition(var16, var1x));
                     }
                  }
               }

               int var30 = this.archetypeChunkReuse.previousClearBit(var10 - 1);
               this.archetypeSize = var30 + 1;
               this.archetypeChunkReuse.clear(this.archetypeSize, var10);
         }
      } else if (var3 class="kw">instanceof SystemChange var18) {
         ISystem var19 = var18.getSystem();
         class="kw">switch (var18.getType()) {
            case REGISTERED:
               if (var19 class="kw">instanceof ArchetypeChunkSystem var21) {
                  for (int var24 = 0; var24 < this.archetypeSize; var24++) {
                     ArchetypeChunk var27 = this.archetypeChunks[var24];
                     if (var27 != null && var21.test(this.registry, var27.getArchetype())) {
                        var21.onSystemAddedToArchetypeChunk(var27);
                     }
                  }
               }
               break;
            case UNREGISTERED:
               if (var19 class="kw">instanceof ArchetypeChunkSystem var20) {
                  for (int var23 = 0; var23 < this.archetypeSize; var23++) {
                     ArchetypeChunk var26 = this.archetypeChunks[var23];
                     if (var26 != null && var20.test(this.registry, var26.getArchetype())) {
                        var20.onSystemRemovedFromArchetypeChunk(var26);
                     }
                  }
               }
         }
      }
   }

   class="kw">private void updateArchetypeIndexes(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1) {
      int var2 = var1.getSystemSize();
      int var3 = this.systemIndexToArchetypeChunkIndexes.length;
      if (var3 < var2) {
         this.systemIndexToArchetypeChunkIndexes = Arrays.copyOf(this.systemIndexToArchetypeChunkIndexes, var2);

         for (int var4 = var3; var4 < var2; var4++) {
            this.systemIndexToArchetypeChunkIndexes[var4] = new BitSet(this.archetypeSize);
         }
      }

      for (int var11 = 0; var11 < var3; var11++) {
         this.systemIndexToArchetypeChunkIndexes[var11].clear();
      }

      for (int var12 = 0; var12 < this.archetypeSize; var12++) {
         ArchetypeChunk var5 = this.archetypeChunks[var12];
         if (var5 != null) {
            var5.getSystemIndexes().clear();
         }
      }

      SystemType var13 = this.registry.getQuerySystemType();
      BitSet var14 = var1.getSystemIndexesForType(var13);
      int var6 = -1;

      while ((var6 = var14.nextSetBit(var6 + 1)) >= 0) {
         QuerySystem var7 = var1.getSystem(var6, var13);
         BitSet var8 = this.systemIndexToArchetypeChunkIndexes[var6];

         for (int var9 = 0; var9 < this.archetypeSize; var9++) {
            ArchetypeChunk var10 = this.archetypeChunks[var9];
            if (var10 != null && var7.test(this.registry, var10.getArchetype())) {
               var8.set(var9);
               var10.getSystemIndexes().set(var6);
            }
         }
      }
   }

   class="kw">public void assertWriteProcessing() {
      if (this.processing.isHeld() && !this.disableProcessingAssert) {
         throw new IllegalStateException("Store is currently processing! Ensure you aren't calling a store method from a system.");
      }
   }

   @Deprecated
   class="kw">public boolean isProcessing() {
      class="kw">return this.processing.isHeld();
   }

   class="kw">public void assertThread() {
      Thread var1 = Thread.currentThread();
      if (var1 != this.thread && this.thread.isAlive()) {
         throw new IllegalStateException("Assert not in thread! " + this.thread + " but was in " + var1);
      }
   }

   class="kw">public boolean isInThread() {
      class="kw">return Thread.currentThread() == this.thread;
   }

   class="kw">public boolean isAliveInDifferentThread() {
      class="kw">return this.thread.isAlive() && Thread.currentThread() != this.thread;
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "Store{super()="
         + this.getClass()
         + "@"
         + this.hashCode()
         + ", registry="
         + this.registry.getClass()
         + "@"
         + this.registry.hashCode()
         + ", shutdown="
         + this.shutdown
         + ", storeIndex="
         + this.storeIndex
         + ", systemIndexToArchetypeChunkIndexes="
         + Arrays.toString(this.systemIndexToArchetypeChunkIndexes)
         + ", archetypeSize="
         + this.archetypeSize
         + ", archetypeChunks="
         + Arrays.toString(this.archetypeChunks)
         + "}";
   }

   class="kw">private <T class="kw">extends Component<ECS_TYPE>> void datachunk_addComponent(
      @Nonnull Ref<ECS_TYPE> var1,
      @Nonnull ArchetypeChunk<ECS_TYPE> var2,
      @Nonnull ComponentType<ECS_TYPE, T> var3,
      @Nonnull T var4,
      @Nonnull CommandBuffer<ECS_TYPE> var5
   ) {
      if (var2.getArchetype().contains(var3)) {
         throw new IllegalArgumentException("Entity already contains component type: " + var3);
      }

      Archetype var6 = Archetype.add(var2.getArchetype(), var3);
      int var7 = this.findOrCreateArchetypeChunk(var6);
      ArchetypeChunk var8 = this.archetypeChunks[var7];
      int var9 = var1.getChunkEntityIndex();
      var8.addEntityFrom(var1, var2, var9, var3, var4);
      BitSet var10 = var8.getSystemIndexes();
      ComponentRegistry.Data var11 = this.registry._internal_getData();
      BitSet var12 = var11.getSystemIndexesForType(this.registry.getRefChangeSystemType());
      int var13 = -1;

      while ((var13 = var12.nextSetBit(var13 + 1)) >= 0) {
         if (var10.get(var13)) {
            RefChangeSystem var14 = (RefChangeSystem<ECS_TYPE, T>)var11.getSystem(var13);
            if (var14.componentType().getIndex() == var3.getIndex()) {
               var14.onComponentAdded(var1, var4, this, var5);
            }
         }
      }

      if (var2.size() == 0) {
         this.removeArchetypeChunk(var2);
      }
   }

   class="kw">private int findOrCreateArchetypeChunk(@Nonnull Archetype<ECS_TYPE> var1) {
      int var2 = this.archetypeToIndexMap.getInt(var1);
      if (var2 != Integer.MIN_VALUE) {
         class="kw">return var2;
      }

      ComponentRegistry.Data var3 = this.registry._internal_getData();
      if (this.archetypeChunkReuse.isEmpty()) {
         var2 = this.archetypeSize++;
      } else {
         var2 = this.archetypeChunkReuse.nextSetBit(0);
         this.archetypeChunkReuse.clear(var2);
      }

      int var4 = this.archetypeChunks.length;
      if (var4 <= var2) {
         int var5 = ArrayUtil.grow(var2);
         this.archetypeChunks = Arrays.copyOf(this.archetypeChunks, var5);
      }

      ArchetypeChunk var12 = new ArchetypeChunk<>(this, var1);
      var12.setArchetypeIndex(var2);
      this.archetypeChunks[var2] = var12;
      this.archetypeToIndexMap.put(var1, var2);
      BitSet var6 = var12.getSystemIndexes();
      SystemType var7 = this.registry.getQuerySystemType();
      BitSet var8 = var3.getSystemIndexesForType(var7);
      int var9 = -1;

      while ((var9 = var8.nextSetBit(var9 + 1)) >= 0) {
         QuerySystem var10 = var3.getSystem(var9, var7);
         if (var10.test(this.registry, var1)) {
            this.systemIndexToArchetypeChunkIndexes[var9].set(var2);
            var6.set(var9);
            if (var10 class="kw">instanceof ArchetypeChunkSystem) {
               ((ArchetypeChunkSystem)var10).onSystemAddedToArchetypeChunk(var12);
            }
         }
      }

      class="kw">return var2;
   }

   class="kw">private void removeArchetypeChunk(@Nonnull ArchetypeChunk<ECS_TYPE> var1) {
      int var2 = var1.getArchetypeIndex();
      Archetype var3 = var1.getArchetype();
      this.archetypeToIndexMap.removeInt(var3);
      this.archetypeChunks[var2] = null;
      var1.getSystemIndexes().clear();
      ComponentRegistry.Data var4 = this.registry._internal_getData();
      BitSet var5 = var4.getSystemIndexesForType(this.registry.getQuerySystemType());
      int var6 = -1;

      while ((var6 = var5.nextSetBit(var6 + 1)) >= 0) {
         this.systemIndexToArchetypeChunkIndexes[var6].clear(var2);
         if (var4.getSystem(var6) class="kw">instanceof ArchetypeChunkSystem var8 && var8.test(this.registry, var3)) {
            var8.onSystemRemovedFromArchetypeChunk(var1);
         }
      }

      if (var2 == this.archetypeSize - 1) {
         int var9 = this.archetypeChunkReuse.previousClearBit(var2 - 1);
         this.archetypeSize = var9 + 1;
         this.archetypeChunkReuse.clear(this.archetypeSize, var2);
      } else {
         this.archetypeChunkReuse.set(var2);
      }
   }

   class="kw">private class="kw">static class ProcessingCounter class="kw">implements Lock {
      class="kw">private int count = 0;

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

      class="kw">public boolean isHeld() {
         class="kw">return this.count > 0;
      }

      @Override
      class="kw">public void lock() {
         this.count++;
      }

      @Override
      class="kw">public void lockInterruptibly() {
         throw new UnsupportedOperationException("lockInterruptibly() is not supported");
      }

      @Override
      class="kw">public boolean tryLock() {
         throw new UnsupportedOperationException("tryLock() is not supported");
      }

      @Override
      class="kw">public boolean tryLock(long var1, @Nonnull TimeUnit var3) {
         throw new UnsupportedOperationException("tryLock() is not supported");
      }

      @Override
      class="kw">public void unlock() {
         this.count--;
      }

      @Nonnull
      @Override
      class="kw">public Condition newCondition() {
         throw new UnsupportedOperationException("Conditions are not supported");
      }
   }
}