com/hypixel/hytale/assetstore

com/hypixel/hytale/assetstore/AssetConstants.java

package com.hypixel.hytale.assetstore;

public class AssetConstants {
   public static final int EXPECTED_CHILDREN_PER_ASSET = 3;
   public static final int EXPECTED_ASSETS_PER_PATH = 1;
   public static final int EXPECTED_VALUES_PER_TAG = 3;
   public static final int EXPECTED_ASSETS_PER_TAG = 3;

   public AssetConstants() {
   }
}

com/hypixel/hytale/assetstore/AssetExtraInfo.java

package com.hypixel.hytale.assetstore;

import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.common.util.ArrayUtil;
import it.unimi.dsi.fastutil.ints.Int2ObjectFunction;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectMaps;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.ints.IntSets;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class AssetExtraInfo<K> extends ExtraInfo {
   @Nullable
   private final Path assetPath;
   private final Data data;

   public AssetExtraInfo(Data data) {
      super(2147483647, AssetValidationResults::new);
      this.assetPath = null;
      this.data = data;
   }

   public AssetExtraInfo(Path assetPath, Data data) {
      super(2147483647, AssetValidationResults::new);
      this.assetPath = assetPath;
      this.data = data;
   }

   @Nonnull
   public String generateKey() {
      String var10000 = String.valueOf(this.getKey());
      return "*" + var10000 + "_" + this.peekKey('_');
   }

   public K getKey() {
      return (K)this.getData().getKey();
   }

   @Nullable
   public Path getAssetPath() {
      return this.assetPath;
   }

   public Data getData() {
      return this.data;
   }

   public void appendDetailsTo(@Nonnull StringBuilder sb) {
      sb.append("Id: ").append(this.getKey()).append("\n");
      if (this.assetPath != null) {
         sb.append("Path: ").append(this.assetPath).append("\n");
      }

   }

   public AssetValidationResults getValidationResults() {
      return (AssetValidationResults)super.getValidationResults();
   }

   @Nonnull
   public String toString() {
      String var10000 = String.valueOf(this.assetPath);
      return "AssetExtraInfo{assetPath=" + var10000 + ", data=" + String.valueOf(this.data) + "} " + super.toString();
   }

   public static class Data {
      public static final char TAG_VALUE_SEPARATOR = '=';
      private Map<Class<? extends JsonAssetWithMap>, List<Object>> containedAssets;
      private Map<Class<? extends JsonAssetWithMap>, List<RawAsset<Object>>> containedRawAssets;
      @Nullable
      private Data containerData;
      private Class<? extends JsonAsset<?>> assetClass;
      private Object key;
      private Object parentKey;
      private final Map<String, String[]> rawTags;
      private final Int2ObjectMap<IntSet> tagStorage;
      private final Int2ObjectMap<IntSet> unmodifiableTagStorage;
      private final IntSet expandedTagStorage;
      private final IntSet unmodifiableExpandedTagStorage;

      public <K> Data(Class<? extends JsonAsset<K>> assetClass, K key, K parentKey) {
         this.rawTags = new HashMap(0);
         this.tagStorage = new Int2ObjectOpenHashMap<IntSet>(0);
         this.unmodifiableTagStorage = new Int2ObjectOpenHashMap<IntSet>(0);
         this.expandedTagStorage = new IntOpenHashSet(0);
         this.unmodifiableExpandedTagStorage = IntSets.unmodifiable(this.expandedTagStorage);
         this.assetClass = assetClass;
         this.key = key;
         this.parentKey = parentKey;
      }

      public <K> Data(@Nullable Data containerData, Class<? extends JsonAsset<K>> aClass, K key, K parentKey, boolean inheritContainerTags) {
         this(aClass, key, parentKey);
         this.containerData = containerData;
         if (containerData != null && inheritContainerTags) {
            this.putTags(containerData.rawTags);
         }

      }

      public Class<? extends JsonAsset<?>> getAssetClass() {
         return this.assetClass;
      }

      public Object getKey() {
         return this.key;
      }

      public Object getParentKey() {
         return this.parentKey;
      }

      @Nonnull
      public Data getRootContainerData() {
         Data temp;
         for(temp = this; temp.containerData != null; temp = temp.containerData) {
         }

         return temp;
      }

      @Nullable
      public Data getContainerData() {
         return this.containerData;
      }

      @Nullable
      public <K> K getContainerKey(Class<? extends JsonAsset<K>> aClass) {
         if (this.containerData == null) {
            return null;
         } else {
            return (K)(this.containerData.assetClass.equals(aClass) ? this.containerData.key : this.containerData.getContainerKey(aClass));
         }
      }

      public void putTags(@Nonnull Map<String, String[]> tags) {
         for(Map.Entry<String, String[]> entry : tags.entrySet()) {
            String tag = ((String)entry.getKey()).intern();
            this.rawTags.merge(tag, (String[])entry.getValue(), ArrayUtil::combine);
            IntSet tagIndexes = this.ensureTag(tag);

            for(String value : (String[])entry.getValue()) {
               tagIndexes.add(AssetRegistry.getOrCreateTagIndex(value));
               this.ensureTag(value);
               this.rawTags.putIfAbsent(value, ArrayUtil.EMPTY_STRING_ARRAY);
               String valueTag = (tag + "=" + value).intern();
               this.rawTags.putIfAbsent(valueTag, ArrayUtil.EMPTY_STRING_ARRAY);
               this.ensureTag(valueTag);
            }
         }

      }

      @Nonnull
      public Map<String, String[]> getRawTags() {
         return Collections.unmodifiableMap(this.rawTags);
      }

      @Nonnull
      public Int2ObjectMap<IntSet> getTags() {
         return Int2ObjectMaps.<IntSet>unmodifiable(this.unmodifiableTagStorage);
      }

      @Nonnull
      public IntSet getExpandedTagIndexes() {
         return this.unmodifiableExpandedTagStorage;
      }

      public IntSet getTag(int tagIndex) {
         return this.unmodifiableTagStorage.getOrDefault(tagIndex, IntSets.EMPTY_SET);
      }

      public <K, T extends JsonAssetWithMap<K, M>, M extends AssetMap<K, T>> void addContainedAsset(Class<T> assetClass, T asset) {
         if (this.containedAssets == null) {
            this.containedAssets = new HashMap();
         }

         ((List)this.containedAssets.computeIfAbsent(assetClass, (k) -> new ArrayList())).add(asset);
      }

      public <K, T extends JsonAssetWithMap<K, M>, M extends AssetMap<K, T>> void addContainedAsset(Class<T> assetClass, RawAsset<K> rawAsset) {
         if (this.containedRawAssets == null) {
            this.containedRawAssets = new HashMap();
         }

         ((List)this.containedRawAssets.computeIfAbsent(assetClass, (k) -> new ArrayList())).add(rawAsset);
      }

      public <K> void fetchContainedAssets(K key, @Nonnull Map<Class<? extends JsonAssetWithMap>, Map<K, List<Object>>> containedAssets) {
         if (this.containedAssets != null) {
            for(Map.Entry<Class<? extends JsonAssetWithMap>, List<Object>> entry : this.containedAssets.entrySet()) {
               ((List)((Map)containedAssets.computeIfAbsent((Class)entry.getKey(), (k) -> new HashMap())).computeIfAbsent(key, (k) -> new ArrayList(3))).addAll((Collection)entry.getValue());
            }

         }
      }

      public <K> void fetchContainedRawAssets(K key, @Nonnull Map<Class<? extends JsonAssetWithMap>, Map<K, List<RawAsset<Object>>>> containedAssets) {
         if (this.containedRawAssets != null) {
            for(Map.Entry<Class<? extends JsonAssetWithMap>, List<RawAsset<Object>>> entry : this.containedRawAssets.entrySet()) {
               ((List)((Map)containedAssets.computeIfAbsent((Class)entry.getKey(), (k) -> new HashMap())).computeIfAbsent(key, (k) -> new ArrayList(3))).addAll((Collection)entry.getValue());
            }

         }
      }

      public <K, T extends JsonAssetWithMap<K, M>, M extends AssetMap<K, T>> boolean containsAsset(Class<T> tClass, K key) {
         if (this.containedAssets != null) {
            List<T> assets = (List)this.containedAssets.get(tClass);
            if (assets != null) {
               Function<T, K> keyFunction = AssetRegistry.getAssetStore(tClass).getKeyFunction();

               for(T asset : assets) {
                  if (key.equals(keyFunction.apply(asset))) {
                     return true;
                  }
               }
            }
         }

         if (this.containedRawAssets != null) {
            List<RawAsset<T>> rawAssets = (List)this.containedRawAssets.get(tClass);
            if (rawAssets != null) {
               for(RawAsset<T> rawAsset : rawAssets) {
                  if (key.equals(rawAsset.getKey())) {
                     return true;
                  }
               }
            }
         }

         return false;
      }

      public void loadContainedAssets(boolean reloading) {
         if (this.containedAssets != null) {
            for(Map.Entry<Class<? extends JsonAssetWithMap>, List<Object>> entry : this.containedAssets.entrySet()) {
               AssetRegistry.getAssetStore((Class)entry.getKey()).loadAssets("Hytale:Hytale", (List)entry.getValue(), AssetUpdateQuery.DEFAULT, reloading);
            }
         }

         if (this.containedRawAssets != null) {
            for(Map.Entry<Class<? extends JsonAssetWithMap>, List<RawAsset<Object>>> entry : this.containedRawAssets.entrySet()) {
               AssetRegistry.getAssetStore((Class)entry.getKey()).loadBuffersWithKeys("Hytale:Hytale", (List)entry.getValue(), AssetUpdateQuery.DEFAULT, reloading);
            }
         }

      }

      @Nonnull
      private IntSet ensureTag(@Nonnull String tag) {
         int idx = AssetRegistry.getOrCreateTagIndex(tag);
         this.expandedTagStorage.add(idx);
         return (IntSet)this.tagStorage.computeIfAbsent(idx, (Int2ObjectFunction)((k) -> {
            IntSet set = new IntOpenHashSet(3);
            this.unmodifiableTagStorage.put(k, IntSets.unmodifiable(set));
            return set;
         }));
      }

      @Nonnull
      public String toString() {
         String var10000 = String.valueOf(this.containedRawAssets);
         return "Data{containedAssets=" + var10000 + ", rawTags=" + String.valueOf(this.rawTags) + ", parent=" + String.valueOf(this.containerData) + ", assetClass=" + String.valueOf(this.assetClass) + ", key=" + String.valueOf(this.key) + "}";
      }
   }
}

com/hypixel/hytale/assetstore/AssetHolder.java

package com.hypixel.hytale.assetstore;

public interface AssetHolder<K> {
}

com/hypixel/hytale/assetstore/AssetKeyValidator.java

package com.hypixel.hytale.assetstore;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import java.util.function.Supplier;
import javax.annotation.Nonnull;

public class AssetKeyValidator<K> implements Validator<K> {
   private final Supplier<AssetStore<K, ?, ?>> store;

   public AssetKeyValidator(Supplier<AssetStore<K, ?, ?>> store) {
      this.store = store;
   }

   public AssetStore<K, ?, ?> getStore() {
      return (AssetStore)this.store.get();
   }

   public void accept(K k, @Nonnull ValidationResults results) {
      ((AssetStore)this.store.get()).validate(k, results, results.getExtraInfo());
   }

   public void updateSchema(SchemaContext context, @Nonnull Schema target) {
      target.setHytaleAssetRef(((AssetStore)this.store.get()).getAssetClass().getSimpleName());
   }
}

com/hypixel/hytale/assetstore/AssetLoadResult.java

package com.hypixel.hytale.assetstore;

import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import java.nio.file.Path;
import java.util.Map;
import java.util.Set;

public class AssetLoadResult<K, T> {
   private final Map<K, T> loadedAssets;
   private final Map<K, Path> loadedKeyToPathMap;
   private final Set<K> failedToLoadKeys;
   private final Set<Path> failedToLoadPaths;
   private final Map<Class<? extends JsonAssetWithMap>, AssetLoadResult> childAssetResults;

   public AssetLoadResult(Map<K, T> loadedAssets, Map<K, Path> loadedKeyToPathMap, Set<K> failedToLoadKeys, Set<Path> failedToLoadPaths, Map<Class<? extends JsonAssetWithMap>, AssetLoadResult> childAssetResults) {
      this.loadedAssets = loadedAssets;
      this.loadedKeyToPathMap = loadedKeyToPathMap;
      this.failedToLoadKeys = failedToLoadKeys;
      this.failedToLoadPaths = failedToLoadPaths;
      this.childAssetResults = childAssetResults;
   }

   public Map<K, T> getLoadedAssets() {
      return this.loadedAssets;
   }

   public Map<K, Path> getLoadedKeyToPathMap() {
      return this.loadedKeyToPathMap;
   }

   public Set<K>  {
       .failedToLoadKeys;
   }

    Set<Path>  {
       .failedToLoadPaths;
   }

      {
       (.failedToLoadKeys.isEmpty() && .failedToLoadPaths.isEmpty()) {
         (AssetLoadResult result : .childAssetResults.values()) {
             (result.hasFailed()) {
                ;
            }
         }

          ;
      }  {
          ;
      }
   }
}

com/hypixel/hytale/assetstore/AssetMap.java

package com.hypixel.hytale.assetstore;

import com.hypixel.hytale.assetstore.codec.AssetCodec;
import it.unimi.dsi.fastutil.ints.IntSet;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public abstract class AssetMap<K, T extends JsonAsset<K>> {
   public AssetMap() {
   }

   @Nullable
   public abstract T getAsset(K var1);

   @Nullable
   public abstract T getAsset(@Nonnull String var1, K var2);

   @Nullable
   public abstract Path getPath(K var1);

   @Nullable
   public abstract String getAssetPack(K var1);

   public abstract Set<K> getKeys(Path var1);

   public abstract Set<K> getChildren(K var1);

      ;

     Map<K, T> ;

     Map<K, Path> ;

     Set<K> ;

     IntSet ;

      ;

      ;

      ;

     Set<K> ;

     Set<K> ;

      {
       ;
   }

     Set<K> ;
}

com/hypixel/hytale/assetstore/AssetPack.java

package com.hypixel.hytale.assetstore;

import com.hypixel.hytale.common.plugin.PluginManifest;
import java.nio.file.FileSystem;
import java.nio.file.Path;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class AssetPack {
   @Nonnull
   private final String name;
   @Nonnull
   private final Path root;
   @Nullable
   private final FileSystem fileSystem;
   private final boolean isImmutable;
   private final PluginManifest manifest;
   private final Path packLocation;

   public AssetPack(Path packLocation, @Nonnull String name, @Nonnull Path root, @Nullable FileSystem fileSystem, boolean isImmutable, PluginManifest manifest) {
      this.name = name;
      this.root = root;
      this.fileSystem = fileSystem;
      this.isImmutable = isImmutable;
      this.manifest = manifest;
      this.packLocation = packLocation;
   }

   @Nonnull
   public String getName() {
      return this.name;
   }

   
    Path  {
       .root;
   }

   
    FileSystem  {
       .fileSystem;
   }

    PluginManifest  {
       .manifest;
   }

      {
       .isImmutable;
   }

    Path  {
       .packLocation;
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
            (AssetPack)o;
          !.name.equals(assetPack.name) ?  : .root.equals(assetPack.root);
      }  {
          ;
      }
   }

      {
         .name.hashCode();
      result =  * result + .root.hashCode();
       result;
   }

   
    String  {
         .name;
        + var10000 +  + String.valueOf(.root) +  + String.valueOf(.fileSystem) + ;
   }
}

com/hypixel/hytale/assetstore/AssetReferences.java

package com.hypixel.hytale.assetstore;

import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import java.util.Collections;
import java.util.Set;
import javax.annotation.Nonnull;

public class AssetReferences<CK, C extends JsonAssetWithMap<CK, ?>> {
   private final Class<C> parentAssetClass;
   private final Set<CK> parentKeys;

   public AssetReferences(Class<C> parentAssetClass, Set<CK> parentKeys) {
      this.parentAssetClass = parentAssetClass;
      this.parentKeys = parentKeys;
   }

   public Class<C> getParentAssetClass() {
      return this.parentAssetClass;
   }

   public Set<CK> getParentKeys() {
      return this.parentKeys;
   }

   public <T extends JsonAssetWithMap<K, ?>, K> void addChildAssetReferences(Class<T> tClass, K childKey) {
      Class parentAssetClass = this.parentAssetClass;
      AssetStore<CK, C, ?> assetStore = AssetRegistry.getAssetStore(parentAssetClass);

      for(CK parentKey : this.parentKeys) {
         assetStore.addChildAssetReferences(parentKey, tClass, Collections.singleton(childKey));
      }

   }

   
    String  {
         String.valueOf(.parentAssetClass);
        + var10000 +  + String.valueOf(.parentKeys) + ;
   }
}

com/hypixel/hytale/assetstore/AssetRegistry.java

package com.hypixel.hytale.assetstore;

import com.hypixel.hytale.assetstore.event.RegisterAssetStoreEvent;
import com.hypixel.hytale.assetstore.event.RemoveAssetStoreEvent;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.event.IEventDispatcher;
import it.unimi.dsi.fastutil.objects.Object2IntFunction;
import it.unimi.dsi.fastutil.objects.Object2IntMap;
import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.StampedLock;
import javax.annotation.Nonnull;

public class AssetRegistry {
   public static final ReadWriteLock ASSET_LOCK = new ReentrantReadWriteLock();
   public static boolean HAS_INIT = false;
   public static final int TAG_NOT_FOUND = -2147483648;
   private static  Map<Class<?  >, AssetStore<?, ?, ?>> storeMap =  ();
      Map<Class<?  >, AssetStore<?, ?, ?>> storeMapUnmodifiable;
      AtomicInteger NEXT_TAG_INDEX;
      StampedLock TAG_LOCK;
      Object2IntMap<String> TAG_MAP;
      Object2IntMap<String> CLIENT_TAG_MAP;

     {
   }

   
     Map<Class<?  >, AssetStore<?, ?, ?>> getStoreMap() {
       storeMapUnmodifiable;
   }

     <K, T  <K, M>, M  <K, T>> AssetStore<K, T, M>  {
       (AssetStore)storeMap.get(tClass);
   }

   
     <K, T  <K, M>, M  <K, T>, S  <K, T, M>> S  {
      ASSET_LOCK.writeLock().lock();

       {
          (storeMap.putIfAbsent(((AssetStore)assetStore).getAssetClass(), assetStore) != ) {
              ( + String.valueOf(((AssetStore)assetStore).getAssetClass()));
         }
      }  {
         ASSET_LOCK.writeLock().unlock();
      }

      IEventDispatcher<RegisterAssetStoreEvent, RegisterAssetStoreEvent> dispatch = assetStore.getEventBus().dispatchFor(RegisterAssetStoreEvent.class);
       (dispatch.hasListener()) {
         dispatch.dispatch( (assetStore));
      }

       assetStore;
   }

     <K, T  <K, M>, M  <K, T>, S  <K, T, M>>   {
      ASSET_LOCK.writeLock().lock();

       {
         storeMap.remove(((AssetStore)assetStore).getAssetClass());
      }  {
         ASSET_LOCK.writeLock().unlock();
      }

      IEventDispatcher<RemoveAssetStoreEvent, RemoveAssetStoreEvent> dispatch = assetStore.getEventBus().dispatchFor(RemoveAssetStoreEvent.class);
       (dispatch.hasListener()) {
         dispatch.dispatch( (assetStore));
      }

   }

       {
       (tag == ) {
           ();
      }  {
            TAG_LOCK.readLock();

          var3;
          {
            var3 = TAG_MAP.getInt(tag);
         }  {
            TAG_LOCK.unlockRead(stamp);
         }

          var3;
      }
   }

       {
       (tag == ) {
           ();
      }  {
            TAG_LOCK.writeLock();

          var3;
          {
            var3 = TAG_MAP.computeIfAbsent(tag.intern(), (Object2IntFunction)((k) -> NEXT_TAG_INDEX.getAndIncrement()));
         }  {
            TAG_LOCK.unlockWrite(stamp);
         }

          var3;
      }
   }

       {
       (tag == ) {
           ();
      }  {
            TAG_LOCK.writeLock();

          var3;
          {
            var3 = CLIENT_TAG_MAP.put(tag, TAG_MAP.computeIfAbsent(tag, (Object2IntFunction)((k) -> NEXT_TAG_INDEX.getAndIncrement()))) == -;
         }  {
            TAG_LOCK.unlockWrite(stamp);
         }

          var3;
      }
   }

   
     Object2IntMap<String>  {
         TAG_LOCK.readLock();

      Object2IntOpenHashMap var2;
       {
         var2 =  (CLIENT_TAG_MAP);
      }  {
         TAG_LOCK.unlockRead(stamp);
      }

       var2;
   }

    {
      storeMapUnmodifiable = Collections.unmodifiableMap(storeMap);
      NEXT_TAG_INDEX =  ();
      TAG_LOCK =  ();
      TAG_MAP =  <String>();
      CLIENT_TAG_MAP =  <String>();
      TAG_MAP.defaultReturnValue(-);
      CLIENT_TAG_MAP.defaultReturnValue(-);
   }
}

com/hypixel/hytale/assetstore/AssetStore.java

package com.hypixel.hytale.assetstore;

import com.hypixel.hytale.assetstore.codec.AssetCodec;
import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.assetstore.event.GenerateAssetsEvent;
import com.hypixel.hytale.assetstore.event.LoadedAssetsEvent;
import com.hypixel.hytale.assetstore.event.RemovedAssetsEvent;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.builder.BuilderField;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.exception.CodecValidationException;
import com.hypixel.hytale.codec.util.RawJsonReader;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import com.hypixel.hytale.codec.validation.validator.ArrayValidator;
import com.hypixel.hytale.codec.validation.validator.MapKeyValidator;
import com.hypixel.hytale.codec.validation.validator.MapValueValidator;
import com.hypixel.hytale.common.util.FormatUtil;
import com.hypixel.hytale.common.util.StringUtil;
import com.hypixel.hytale.event.IEventBus;
import com.hypixel.hytale.event.IEventDispatcher;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.logger.backend.HytaleLoggerBackend;
import com.hypixel.hytale.logger.sentry.SkipSentryException;
import com.hypixel.hytale.logger.util.GithubMessageUtil;
import com.hypixel.hytale.sneakythrow.SneakyThrow;
 it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
 java.io.IOException;
 java.nio.file.FileVisitOption;
 java.nio.file.FileVisitResult;
 java.nio.file.Files;
 java.nio.file.Path;
 java.nio.file.SimpleFileVisitor;
 java.nio.file.StandardOpenOption;
 java.nio.file.attribute.BasicFileAttributes;
 java.util.ArrayList;
 java.util.Collection;
 java.util.Collections;
 java.util.HashMap;
 java.util.HashSet;
 java.util.List;
 java.util.Map;
 java.util.Objects;
 java.util.Set;
 java.util.concurrent.CompletableFuture;
 java.util.concurrent.ConcurrentHashMap;
 java.util.function.Function;
 java.util.function.Predicate;
 java.util.logging.Level;
 java.util.stream.Collectors;
 java.util.stream.Stream;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;
 org.bson.BsonDocument;
 org.bson.BsonString;
 org.bson.BsonValue;

   <K, T  <K, M>, M  <K, T>> {
        ;
   
     HytaleLogger logger;
   
     Class<K> kClass;
   
     Class<T> tClass;
     String path;
   
     String extension;
     AssetCodec<K, T> codec;
     Function<T, K> keyFunction;
   
     Set<Class<?  <?>>> loadsAfter;
   
     Set<Class<?  <?>>> unmodifiableLoadsAfter;
   
     Set<Class<?  <?>>> loadsBefore;
     M assetMap;
     Function<K, T> replaceOnRemove;
   
     Predicate<T> isUnknown;
      unmodifiable;
     List<T> preAddedAssets;
     Class<?  <?>> idProvider;
     Map<Class<?  <?, ?>>, Map<K, Set<Object>>> childAssetsMap =  ();
   
    Set<Class<?  >> loadedContainedAssetsFor =  ();
        ;

     {
      .kClass = builder.kClass;
      .tClass = builder.tClass;
      .logger = HytaleLogger.get( + .tClass.getSimpleName());
      .path = builder.path;
      .extension = builder.extension;
      .codec = builder.codec;
      .keyFunction = builder.keyFunction;
      .isUnknown = builder.isUnknown ==  ? (v) ->  : builder.isUnknown;
      .loadsAfter = builder.loadsAfter;
      .unmodifiableLoadsAfter = Collections.unmodifiableSet(builder.loadsAfter);
      .loadsBefore = Collections.unmodifiableSet(builder.loadsBefore);
      .assetMap = builder.assetMap;
      .replaceOnRemove = builder.replaceOnRemove;
      .unmodifiable = builder.unmodifiable;
      .preAddedAssets = builder.preAddedAssets;
      .idProvider = builder.idProvider;
       (builder.replaceOnRemove ==  && .assetMap.requireReplaceOnRemove()) {
            .tClass.getSimpleName();
           ( + var10002 +  + .assetMap.getClass().getSimpleName() + );
      }
   }

     IEventBus ;

      ;

      ;

      ;

   
    Class<K>  {
       .kClass;
   }

   
    Class<T>  {
       .tClass;
   }

    String  {
       .path;
   }

   
    String  {
       .extension;
   }

    AssetCodec<K, T>  {
       .codec;
   }

    Function<T, K>  {
       .keyFunction;
   }

   
    Set<Class<?  <?>>> getLoadsAfter() {
       .unmodifiableLoadsAfter;
   }

    M  {
       .assetMap;
   }

    Function<K, T>  {
       .replaceOnRemove;
   }

      {
       .unmodifiable;
   }

    List<T>  {
       .preAddedAssets;
   }

    <X  >   {
       .loadedContainedAssetsFor.contains(x);
   }

    Class<?  <?>> getIdProvider() {
       .idProvider;
   }

   
    HytaleLogger  {
       .logger;
   }

      {
      (Class<?  <?>> aClass : .loadsBefore) {
         AssetRegistry.getAssetStore(aClass).loadsAfter.add(.tClass);
      }

   }

   
   
    <D  <?>>   {
       (DISABLE_DYNAMIC_DEPENDENCIES) {
           ();
      }  {
         .loadsAfter.add(aClass);
      }
   }

   
    K  {
         path.getFileName().toString();
       (K).decodeStringKey(fileName.substring(, fileName.length() - .extension.length()));
   }

   
    K  {
       (K)(.codec.getKeyCodec().getChildCodec() == Codec.STRING ? key : .codec.getKeyCodec().getChildCodec().decode( (key)));
   }

   
    K  {
       (o == ) {
          ;
      }  {
          (K)(o.getClass().equals(.kClass) ? o : .decodeStringKey(o.toString()));
      }
   }

      {
       (key != ) {
          (.assetMap.getAsset(key) == ) {
             (extraInfo  AssetExtraInfo) {
               (AssetExtraInfo.   ((AssetExtraInfo)extraInfo).getData(); data != ; data = data.getContainerData()) {
                   (data.containsAsset(.tClass, key)) {
                     ;
                  }
               }
            }

               String.valueOf(key);
            results.fail( + var10001 +  + .tClass.getName() + );
         }
      }
   }

      {
          (, AssetValidationResults::);
      .codec.validateDefaults(extraInfo,  ());
      extraInfo.getValidationResults().logOrThrowValidatorExceptions(.logger, );
   }

      {
          (, AssetValidationResults::);
      HashSet<Codec<?>> tested =  ();
      .codec.validateDefaults(extraInfo, tested);
      Set<Class<?  <?>>> assetClasses =  ();
      Set<Class<?  <?>>> maybeLateAssetClasses =  ();

      (Codec<?> other : tested) {
          (other  BuilderCodec) {
            (BuilderCodec<?> builderCodec = (BuilderCodec)other; builderCodec != ; builderCodec = builderCodec.getParent()) {
               (List<?  <?, ?>> value : builderCodec.getEntries().values()) {
                  (BuilderField<?, ?> field : value) {
                      (field.supportsVersion(extraInfo.getVersion())) {
                        List<Validator<?>> validators = field.getValidators();
                         (validators != ) {
                           (Validator<?> validator : validators) {
                               (validator  ArrayValidator) {
                                 ArrayValidator<?> arrayValidator = (ArrayValidator)validator;
                                 validator = arrayValidator.getValidator();
                              }   (validator  MapKeyValidator) {
                                 MapKeyValidator<?> arrayValidator = (MapKeyValidator)validator;
                                 validator = arrayValidator.getKeyValidator();
                              }   (validator  MapValueValidator) {
                                 MapValueValidator<?> arrayValidator = (MapValueValidator)validator;
                                 validator = arrayValidator.getValueValidator();
                              }

                               (validator  AssetKeyValidator) {
                                    (AssetKeyValidator)validator;
                                 assetClasses.add(assetKeyValidator.getStore().getAssetClass());
                              }
                           }
                        }
                     }
                  }
               }
            }
         }   (other  ContainedAssetCodec) {
            ContainedAssetCodec<?, ?, ?> containedAssetCodec = (ContainedAssetCodec)other;
            maybeLateAssetClasses.add(containedAssetCodec.getAssetClass());
         }
      }

      HashSet<Object> missing =  ();
      HashSet<Object> unused =  ();

      (Class<?  <?>> assetClass : assetClasses) {
          (!.loadsAfter.contains(assetClass)) {
            missing.add(assetClass);
         }
      }

      (Class<?  <?>> aClass : .loadsAfter) {
          (!assetClasses.contains(aClass) && !maybeLateAssetClasses.contains(aClass)) {
            unused.add(aClass);
         }
      }

       (!missing.isEmpty()) {
         HytaleLogger.   .logger.at(Level.WARNING);
            missing.stream().map(Object::toString);
         var10000.log( + (String)var10001.collect(Collectors.joining(, , )));
      }

       (!unused.isEmpty()) {
         HytaleLogger.   .logger.at(Level.WARNING);
            unused.stream().map(Object::toString);
         var27.log( + (String)var28.collect(Collectors.joining(, , )));
      }

   }

   
    AssetLoadResult<K, T>   IOException {
       (.unmodifiable) {
           ();
      }  {
         Objects.requireNonNull(assetsPath, );
          ArrayList<Path> files =  ();
         Set<FileVisitOption> optionsSet = Set.of();
         Files.walkFileTree(assetsPath, optionsSet, ,  <Path>() {
            
             FileVisitResult   IOException {
                (attrs.isRegularFile() && file.toString().endsWith(AssetStore..extension)) {
                  files.add(file);
               }

                FileVisitResult.CONTINUE;
            }
         });
          .loadAssetsFromPaths(packKey, files);
      }
   }

   
    AssetLoadResult<K, T>  {
       .loadAssetsFromPaths(packKey, paths, AssetUpdateQuery.DEFAULT);
   }

   
    AssetLoadResult<K, T>  {
       .loadAssetsFromPaths(packKey, paths, query, );
   }

   
    AssetLoadResult<K, T>  {
       (.unmodifiable) {
           ();
      }  {
         Objects.requireNonNull(paths, );
            System.nanoTime();
         Set<Path> documents =  ();

         (Path path : paths) {
               path.toAbsolutePath().normalize();
            Set<K> keys = .assetMap.getKeys(normalize);
             (keys != ) {
               (K key : keys) {
                  .loadAllChildren(documents, key);
               }
            }

            documents.add(normalize);
            .loadAllChildren(documents, .decodeFilePathKey(path));
         }

         List<RawAsset<K>> rawAssets =  (documents.size());

         (Path p : documents) {
            rawAssets.add( (.decodeFilePathKey(p), p));
         }

         Map<K, T> loadedAssets = Collections.synchronizedMap( ());
         Map<K, Path> loadedKeyToPathMap =  ();
         Set<K> failedToLoadKeys = ConcurrentHashMap.newKeySet();
         Set<Path> failedToLoadPaths = ConcurrentHashMap.newKeySet();
         Map<Class<?  >, AssetLoadResult> childAssetResults =  ();
         .loadAssets0(packKey, loadedAssets, rawAssets, loadedKeyToPathMap, failedToLoadKeys, failedToLoadPaths, query, forceLoadAll, childAssetResults);
            System.nanoTime();
            end - start;
         .logger.at(Level.FINE).log(, loadedAssets.size(), failedToLoadKeys.size(), .assetMap.getAssetCount(), .tClass.getSimpleName(), paths.size(), FormatUtil.nanosToString(diff));
           <K, T>(loadedAssets, loadedKeyToPathMap, failedToLoadKeys, failedToLoadPaths, childAssetResults);
      }
   }

   
    AssetLoadResult<K, T>  {
         System.nanoTime();
      Set<Path> documents =  ();

      (RawAsset<K> document : preLoaded) {
         .loadAllChildren(documents, document.getKey());
      }

      List<RawAsset<K>> rawAssets =  (preLoaded.size() + documents.size());
      rawAssets.addAll(preLoaded);

      (Path p : documents) {
         rawAssets.add( (.decodeFilePathKey(p), p));
      }

      Map<K, T> loadedAssets = Collections.synchronizedMap( ());
      Map<K, Path> loadedKeyToPathMap =  ();
      Set<K> failedToLoadKeys = ConcurrentHashMap.newKeySet();
      Set<Path> failedToLoadPaths = ConcurrentHashMap.newKeySet();
      Map<Class<?  >, AssetLoadResult> childAssetResults =  ();
      .loadAssets0(packKey, loadedAssets, rawAssets, loadedKeyToPathMap, failedToLoadKeys, failedToLoadPaths, query, forceLoadAll, childAssetResults);
         System.nanoTime();
         end - start;
      .logger.at(Level.FINE).log(, loadedAssets.size(), failedToLoadKeys.size(), .assetMap.getAssetCount(), .tClass.getSimpleName(), FormatUtil.nanosToString(diff));
        <K, T>(loadedAssets, loadedKeyToPathMap, failedToLoadKeys, failedToLoadPaths, childAssetResults);
   }

   
    AssetLoadResult<K, T>  {
       .loadAssets(packKey, assets, AssetUpdateQuery.DEFAULT);
   }

   
    AssetLoadResult<K, T>  {
       .loadAssets(packKey, assets, query, );
   }

   
    AssetLoadResult<K, T>  {
       (.unmodifiable) {
           ();
      }  {
         Objects.requireNonNull(assets, );
            System.nanoTime();
         Map<K, T> loadedAssets = Collections.synchronizedMap( ());
         Set<Path> documents =  ();
         .loadAllChildren(loadedAssets, assets, documents);
         List<RawAsset<K>> rawAssets =  (documents.size());

         (Path p : documents) {
            rawAssets.add( (.decodeFilePathKey(p), p));
         }

         Map<K, Path> loadedKeyToPathMap =  ();
         Set<K> failedToLoadKeys = ConcurrentHashMap.newKeySet();
         Set<Path> failedToLoadPaths = ConcurrentHashMap.newKeySet();
         Map<Class<?  >, AssetLoadResult> childAssetResults =  ();
         .loadAssets0(packKey, loadedAssets, rawAssets, loadedKeyToPathMap, failedToLoadKeys, failedToLoadPaths, query, forceLoadAll, childAssetResults);
            System.nanoTime();
            end - start;
         .logger.at(Level.FINE).log(, loadedAssets.size(), failedToLoadKeys.size(), .assetMap.getAssetCount(), .tClass.getSimpleName(), FormatUtil.nanosToString(diff));
           <K, T>(loadedAssets, loadedKeyToPathMap, failedToLoadKeys, failedToLoadPaths, childAssetResults);
      }
   }

   
    AssetLoadResult<K, T>  {
       .loadAssetsWithReferences(packKey, assets, AssetUpdateQuery.DEFAULT);
   }

   
    AssetLoadResult<K, T>  {
       .loadAssetsWithReferences(packKey, assets, query, );
   }

   
    AssetLoadResult<K, T>  {
       (.unmodifiable) {
           ();
      }  {
         Objects.requireNonNull(assets, );
            System.nanoTime();
         Map<K, T> loadedAssets = Collections.synchronizedMap( ());
         Set<T> assetKeys = assets.keySet();
         Set<Path> documents =  ();
         .loadAllChildren(loadedAssets, assetKeys, documents);
         List<RawAsset<K>> rawAssets =  (documents.size());

         (Path p : documents) {
            rawAssets.add( (.decodeFilePathKey(p), p));
         }

         Map<K, Path> loadedKeyToPathMap =  ();
         Set<K> failedToLoadKeys = ConcurrentHashMap.newKeySet();
         Set<Path> failedToLoadPaths = ConcurrentHashMap.newKeySet();
         Map<Class<?  >, AssetLoadResult> childAssetResults =  ();
         .loadAssets0(packKey, loadedAssets, rawAssets, loadedKeyToPathMap, failedToLoadKeys, failedToLoadPaths, query, forceLoadAll, childAssetResults);

         (Map.Entry<T, List<AssetReferences<?, ?>>> entry : assets.entrySet()) {
               (T)(entry.getKey());
            Objects.requireNonNull(asset, );
               (K).keyFunction.apply(asset);
             (key == ) {
                 (String.format(, asset));
            }

            (AssetReferences<?, ?> references : (List)entry.getValue()) {
               references.addChildAssetReferences(.tClass, key);
            }
         }

            System.nanoTime();
            end - start;
         .logger.at(Level.FINE).log(, loadedAssets.size(), failedToLoadKeys.size(), .assetMap.getAssetCount(), .tClass.getSimpleName(), FormatUtil.nanosToString(diff));
           <K, T>(loadedAssets, loadedKeyToPathMap, failedToLoadKeys, failedToLoadPaths, childAssetResults);
      }
   }

   
    Set<K>  {
       .removeAssetWithPaths(packKey, paths, AssetUpdateQuery.DEFAULT);
   }

   
    Set<K>  {
       (.unmodifiable) {
           ();
      }  {
         Set<K> allKeys =  ();

         (Path path : paths) {
               path.toAbsolutePath().normalize();
            Set<K> keys = .assetMap.getKeys(normalize);
             (keys != ) {
               allKeys.addAll(keys);
            }
         }

          .removeAssets(packKey, , allKeys, assetUpdateQuery);
      }
   }

   
    Set<K>  {
       .removeAssetWithPath(path, AssetUpdateQuery.DEFAULT);
   }

   
    Set<K>  {
       (.unmodifiable) {
           ();
      }  {
            path.toAbsolutePath().normalize();
         Set<K> keys = .assetMap.getKeys(normalize);
          keys !=  ? .removeAssets(, , keys, assetUpdateQuery) : Collections.emptySet();
      }
   }

   
    Set<K>  {
       .removeAssets(, , keys, AssetUpdateQuery.DEFAULT);
   }

   
    Set<K>  {
       (.unmodifiable) {
           ();
      }  {
            System.nanoTime();
         AssetRegistry.ASSET_LOCK.writeLock().lock();

         List<Map.Entry<String, Object>> pathsToReload;
          {
            Set<K> toBeRemoved =  ();
            Set<K> temp =  ();

            (K key : keys) {
               toBeRemoved.add(key);
                  .assetMap.getPath(key);
                (path != ) {
                  .logRemoveAsset(key, path);
               }  {
                  .logRemoveAsset(key, (Path));
               }

               temp.clear();
               .collectAllChildren(key, temp);
               .logRemoveChildren(key, temp);
               toBeRemoved.addAll(temp);
            }

             (!toBeRemoved.isEmpty()) {
               .removeChildrenAssets(packKey, toBeRemoved);
               pathsToReload = ;
                (all) {
                  .assetMap.remove(toBeRemoved);
               }  {
                  pathsToReload =  ();
                  .assetMap.remove(packKey, toBeRemoved, pathsToReload);
               }

                (.replaceOnRemove != ) {
                  Map<K, T> replacements = (Map)toBeRemoved.stream().collect(Collectors.toMap(Function.identity(), (keyx) -> {
                        (T)(.replaceOnRemove.apply(keyx));
                     Objects.requireNonNull(replacement, );
                        (K).keyFunction.apply(replacement);
                      (replacementKey == ) {
                          (keyx.toString());
                     }  {
                         (!keyx.equals(replacementKey)) {
                           .logger.at(Level.WARNING).log(, replacementKey, keyx);
                        }

                         replacement;
                     }
                  }));
                  .assetMap.putAll(, .codec, replacements, Collections.emptyMap(), Collections.emptyMap());
                  .handleRemoveOrUpdate((Set), replacements, AssetUpdateQuery.DEFAULT);
                  .loadContainedAssets(, replacements.values(),  (), AssetUpdateQuery.DEFAULT, );
               }  {
                  .handleRemoveOrUpdate(toBeRemoved, (Map), assetUpdateQuery);
               }

                (pathsToReload != ) {
                  (Map.Entry<String, Object> e : pathsToReload) {
                      (e.getValue()  Path) {
                        .loadAssetsFromPaths((String)e.getKey(), List.of((Path)e.getValue()));
                     }  {
                        .loadAssets((String)e.getKey(), List.of((JsonAssetWithMap)e.getValue()));
                     }
                  }
               }

                  System.nanoTime();
                  end - start;
               .logger.at(Level.INFO).log(, toBeRemoved.size(), .assetMap.getAssetCount(), .tClass.getSimpleName(), FormatUtil.nanosToString(diff));
                (!toBeRemoved.isEmpty()) {
                     .getEventBus().dispatchFor(RemovedAssetsEvent.class, .tClass);
                   (dispatcher.hasListener()) {
                     dispatcher.dispatch( (.tClass, .assetMap, toBeRemoved, .replaceOnRemove != ));
                  }
               }

                  toBeRemoved;
                (Set<K>)var24;
            }

            pathsToReload = toBeRemoved;
         }  {
            AssetRegistry.ASSET_LOCK.writeLock().unlock();
         }

          pathsToReload;
      }
   }

      {
      AssetRegistry.ASSET_LOCK.writeLock().lock();

       {
         Set<K> assets = .assetMap.getKeysForPack(name);
          (assets != ) {
            .removeAssets(name, , assets, AssetUpdateQuery.DEFAULT);
            ;
         }
      }  {
         AssetRegistry.ASSET_LOCK.writeLock().unlock();
      }

   }

    AssetLoadResult<K, T>   IOException {
       .writeAssetToDisk(pack, assetsByPath, AssetUpdateQuery.DEFAULT);
   }

    AssetLoadResult<K, T>   IOException {
       (pack.isImmutable()) {
           ();
      }  {
         (Map.Entry<Path, T> entry : assetsByPath.entrySet()) {
               (T)(entry.getValue());
               (K)asset.getId();
               pack.getRoot().resolve().resolve(.path).resolve((Path)entry.getKey());
            AssetExtraInfo.   .codec.getData(asset);
               data ==  ?  : data.getParentKey();
               .codec.encode(asset,  (assetPath,  .Data(.tClass, id, .transformKey(parentId))));
            Files.writeString(assetPath, bsonValue.toString(), StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING);
         }

          .loadAssets(pack.getName(),  (assetsByPath.values()), query);
      }
   }

   
    T  {
      KeyedCodec<K> parentCodec = .codec.getParentCodec();
         (K)(parentCodec !=  ? parentCodec.getOrNull(document) : );
         RawJsonReader.fromBuffer(document.toString().toCharArray());

       {
         AssetExtraInfo<K> extraInfo =  <K>( .Data(.getAssetClass(), key, parentKey));
          (parentKey == ) {
            reader.consumeWhiteSpace();
               .codec.decodeJsonAsset(reader, extraInfo);
             (asset == ) {
                 (document.toString());
            }  {
               extraInfo.getValidationResults().logOrThrowValidatorExceptions(.logger);
               .logUnusedKeys(key, (Path), extraInfo);
                asset;
            }
         }  {
               parentKey.equals() ? (JsonAssetWithMap).assetMap.getAsset(packKey, key) : (JsonAssetWithMap).assetMap.getAsset(parentKey);
             (parent == ) {
                 (parentKey.toString());
            }  {
               reader.consumeWhiteSpace();
                  .codec.decodeAndInheritJsonAsset(reader, parent, extraInfo);
                (asset == ) {
                    (document.toString());
               }  {
                  extraInfo.getValidationResults().logOrThrowValidatorExceptions(.logger);
                  .logUnusedKeys(key, (Path), extraInfo);
                   asset;
               }
            }
         }
      }  (IOException e) {
          SneakyThrow.sneakyThrow(e);
      }
   }

    <CK>   {
      ((Set)((Map).childAssetsMap.computeIfAbsent(childAssetClass, (k) ->  ())).computeIfAbsent(parentKey, (k) -> ConcurrentHashMap.newKeySet())).addAll(childKeys);
   }

      {
      Map<K, Set<K>> loadedAssetChildren =  ();
      .decodeAssets(packKey, preLoaded, loadedAssets, loadedKeyToPathMap, loadedAssetChildren, failedToLoadKeys, failedToLoadPaths, .assetMap, query, forceLoadAll);
      AssetRegistry.ASSET_LOCK.writeLock().lock();

       {
            .getEventBus().dispatchFor(GenerateAssetsEvent.class, .tClass);
          (generateDispatcher.hasListener()) {
            generateDispatcher.dispatch( (.tClass, .assetMap, loadedAssets, loadedAssetChildren));
         }

         Map<K, K> toBeRemovedMap =  ();
         Set<K> temp =  ();

         (K key : failedToLoadKeys) {
             (toBeRemovedMap.putIfAbsent(key, key) == ) {
               .logRemoveAsset(key, (Path));
               temp.clear();
               .collectAllChildren(key, temp);

               (K k : temp) {
                  toBeRemovedMap.putIfAbsent(k, key);
               }
            }
         }

         (Path path : failedToLoadPaths) {
            Set<K> keys = .assetMap.getKeys(path);
             (keys != ) {
               (K key : keys) {
                   (toBeRemovedMap.putIfAbsent(key, key) == ) {
                     .logRemoveAsset(key, path);
                     temp.clear();
                     .collectAllChildren(key, temp);

                     (K k : temp) {
                        toBeRemovedMap.putIfAbsent(k, key);
                     }
                  }
               }
            }
         }

         .assetMap.putAll(packKey, .codec, loadedAssets, loadedKeyToPathMap, loadedAssetChildren);
         Set<K> toBeRemoved = toBeRemovedMap.keySet();
          (!toBeRemoved.isEmpty()) {
            .logRemoveChildren(toBeRemovedMap);
            .removeChildrenAssets(packKey, toBeRemoved);
         }

          (.replaceOnRemove !=  && !toBeRemoved.isEmpty()) {
            Map<K, T> replacements = (Map)toBeRemoved.stream().filter((kx) -> .assetMap.getAsset(kx) != ).collect(Collectors.toMap(Function.identity(), (keyx) -> {
                  (T)(.replaceOnRemove.apply(keyx));
               Objects.requireNonNull(replacement, );
                  (K).keyFunction.apply(replacement);
                (replacementKey == ) {
                    (keyx.toString());
               }  {
                   (!keyx.equals(replacementKey)) {
                     .logger.at(Level.WARNING).log(, replacementKey, keyx);
                  }

                   replacement;
               }
            }));
            .assetMap.putAll(, .codec, replacements, Collections.emptyMap(), Collections.emptyMap());
            replacements.putAll(loadedAssets);
            .handleRemoveOrUpdate((Set), replacements, query);
         }  {
            .assetMap.remove(toBeRemoved);
            .handleRemoveOrUpdate(toBeRemoved, loadedAssets, query);
         }

         .loadContainedAssets(packKey, loadedAssets.values(), childAssetResults, query, forceLoadAll);
         .reloadChildrenContainerAssets(packKey, loadedAssets);
          (!loadedAssets.isEmpty()) {
               .getEventBus().dispatchFor(LoadedAssetsEvent.class, .tClass);
             (dispatcher.hasListener()) {
               dispatcher.dispatch( (.tClass, .assetMap, loadedAssets, , query));
            }
         }

          (!toBeRemoved.isEmpty()) {
               .getEventBus().dispatchFor(RemovedAssetsEvent.class, .tClass);
             (dispatcher.hasListener()) {
               dispatcher.dispatch( (.tClass, .assetMap, toBeRemoved, .replaceOnRemove != ));
            }
         }
      }  {
         AssetRegistry.ASSET_LOCK.writeLock().unlock();
      }

   }

      {
      HashSet<Path> toReload =  ();
      HashMap<Class<?  <?, ?>>, Set<Path>> toReloadTypes =  ();

      (Map.Entry<K, T> entry : loadedAssets.entrySet()) {
            (K)entry.getKey();
            .assetMap.getPath(key);
          (path != ) {
            .collectChildrenInDifferentFile(key, path, toReload, toReloadTypes, loadedAssets.keySet());
         }
      }

         ;
       (!toReload.isEmpty()) {
         query =  (, AssetUpdateQuery.RebuildCache.DEFAULT);
         .loadAssetsFromPaths(packKey, toReload, query, );
      }

       (!toReloadTypes.isEmpty()) {
          (query == ) {
            query =  (, AssetUpdateQuery.RebuildCache.DEFAULT);
         }

         (Map.Entry<Class<?  <?, ?>>, Set<Path>> entry : toReloadTypes.entrySet()) {
               AssetRegistry.getAssetStore((Class)entry.getKey());
            assetStore.loadAssetsFromPaths(packKey, (Collection)entry.getValue(), query, );
         }
      }

   }

      {
      (K child : .assetMap.getChildren(key)) {
          (!ignore.contains(child)) {
               .assetMap.getPath(child);
             (childPath !=  && !path.equals(childPath)) {
               paths.add(childPath);
            }  {
               AssetExtraInfo.   .codec.getData((JsonAssetWithMap).assetMap.getAsset(child));
               AssetExtraInfo.   data !=  ? data.getRootContainerData() : ;
                (root != ) {
                   (root.getAssetClass() == .tClass) {
                        (K)root.getKey();
                      (ignore.contains(rootKey)) {
                        ;
                     }

                        .assetMap.getPath(rootKey);
                      (!path.equals(rootPath)) {
                        paths.add(rootPath);
                        ;
                     }
                  }  {
                        root.getAssetClass();
                      (assetClass == ) {
                        ;
                     }

                        AssetRegistry.getAssetStore(assetClass);
                        assetStore.getAssetMap().getPath(root.getKey());
                      (rootPath != ) {
                        ((Set)typedPaths.computeIfAbsent(assetClass, (k) ->  ())).add(rootPath);
                        ;
                     }
                  }
               }

               .collectChildrenInDifferentFile(child, path, paths, typedPaths, ignore);
            }
         }
      }

   }

      {
      (Map.Entry<Class<?  <?, ?>>, Map<K, Set<Object>>> entry : .childAssetsMap.entrySet()) {
            (Class)entry.getKey();
         Map<K, Set<Object>> value = (Map)entry.getValue();
         Set<Object> allChildKeys = ;

         (K key : toBeRemoved) {
            Set<Object> childKeys = (Set)value.remove(key);
             (childKeys != ) {
                (allChildKeys == ) {
                  allChildKeys =  ();
               }

               allChildKeys.addAll(childKeys);
            }
         }

          (allChildKeys !=  && !allChildKeys.isEmpty()) {
            AssetRegistry.getAssetStore(k).removeAssets(packKey, , allChildKeys, AssetUpdateQuery.DEFAULT);
         }
      }

   }

      {
      Map<Class<?  >, Map<K, List<Object>>> containedAssetsByClass =  ();

      (T t : assets) {
         AssetExtraInfo.   .codec.getData(t);
          (data != ) {
            data.fetchContainedAssets(.keyFunction.apply(t), containedAssetsByClass);
         }
      }

      (Map.Entry<Class<?  >, Map<K, List<Object>>> entry : containedAssetsByClass.entrySet()) {
         Class<?  > assetClass = (Class)entry.getKey();
         Map<K, List<Object>> containedAssets = (Map)entry.getValue();
            AssetRegistry.getAssetStore(assetClass);
         .loadedContainedAssetsFor.add(assetClass);
         List<Object> childList =  ();

         (Map.Entry<K, List<Object>> containedEntry : containedAssets.entrySet()) {
               (K)containedEntry.getKey();

            (Object contained : (List)containedEntry.getValue()) {
                  assetStore.getKeyFunction().apply(contained);
               ((Set)((Map).childAssetsMap.computeIfAbsent(assetStore.getAssetClass(), (k) ->  ())).computeIfAbsent(key, (k) -> ConcurrentHashMap.newKeySet())).add(containedKey);
               childList.add(contained);
            }
         }

            assetStore.loadAssets(packKey, childList, query, forceLoadAll);
         childAssetsResults.put(assetClass, result);
      }

      Map<Class<?  >, Map<K, List<RawAsset<Object>>>> containedRawAssetsByClass =  ();

      (T t : assets) {
         AssetExtraInfo.   .codec.getData(t);
          (data != ) {
            data.fetchContainedRawAssets(.keyFunction.apply(t), containedRawAssetsByClass);
         }
      }

      (Map.Entry<Class<?  >, Map<K, List<RawAsset<Object>>>> entry : containedRawAssetsByClass.entrySet()) {
         Class<?  > assetClass = (Class)entry.getKey();
         Map<K, List<RawAsset<Object>>> containedAssets = (Map)entry.getValue();
            AssetRegistry.getAssetStore(assetClass);
         .loadedContainedAssetsFor.add(assetClass);
         List<RawAsset<?>> childList =  ();

         (Map.Entry<K, List<RawAsset<Object>>> containedEntry : containedAssets.entrySet()) {
               (K)containedEntry.getKey();

            (RawAsset<Object> contained : (List)containedEntry.getValue()) {
                  contained.getKey();
               ((Set)((Map).childAssetsMap.computeIfAbsent(assetStore.getAssetClass(), (k) ->  ())).computeIfAbsent(key, (k) -> ConcurrentHashMap.newKeySet())).add(containedKey);
               RawAsset var10000;
                (contained.getContainedAssetMode()) {
                   NONE:
                   GENERATE_ID:
                   INJECT_PARENT:
                   INHERIT_ID:
                     var10000 = contained;
                     ;
                   INHERIT_ID_AND_PARENT:
                        contained.getParentKey();
                      (parentKey == ) {
                        var10000 = contained;
                     }   (assetStore.getAssetMap().getAsset(parentKey) ==  && !containedAssets.containsKey(parentKey)) {
                        .logger.at(Level.WARNING).log(, parentKey, assetStore.getAssetClass().getSimpleName(), containedKey);
                        var10000 = contained.withResolveKeys(containedKey, (Object));
                     }  {
                        var10000 = contained;
                     }
                     ;
                  :
                       ((String), (Throwable));
               }

               RawAsset<Object> resolvedContained = var10000;
               childList.add(resolvedContained);
            }
         }

            assetStore.loadBuffersWithKeys(packKey, childList, query, forceLoadAll);
         childAssetsResults.put(assetClass, result);
      }

   }

      {
       (!rawAssets.isEmpty()) {
         Map<K, RawAsset<K>> waitingForParent =  ();
         CompletableFuture<DecodedAsset<K, T>>[] futuresArr =  [rawAssets.size()];

         (   ; i < rawAssets.size(); ++i) {
            futuresArr[i] = .executeAssetDecode(loadedAssets, loadedKeyToPathMap, failedToLoadKeys, failedToLoadPaths, assetMap, query, forceLoadAll, waitingForParent, (RawAsset)rawAssets.get(i));
         }

         CompletableFuture.allOf(futuresArr).join();

         (CompletableFuture<DecodedAsset<K, T>> future : futuresArr) {
            DecodedAsset<K, T> decodedAsset = (DecodedAsset)future.getNow((Object));
             (decodedAsset != ) {
               loadedAssets.put(decodedAsset.getKey(), decodedAsset.getAsset());
            }
         }

         List<CompletableFuture<DecodedAsset<K, T>>> futures =  ();

         (!waitingForParent.isEmpty()) {
               ;

            (Map.Entry<K, RawAsset<K>> entry : waitingForParent.entrySet()) {
                  (K)entry.getKey();
               RawAsset<K> rawAsset = (RawAsset)entry.getValue();
                  rawAsset.getPath();
                  rawAsset.getParentKey();
                  (T)(loadedAssets.get(parentKey));
                (parent == ) {
                   (waitingForParent.containsKey(parentKey)) {
                     ;
                  }

                   (assetMap == ) {
                     .recordFailedToLoad(failedToLoadKeys, failedToLoadPaths, key, path);
                     .logger.at(Level.SEVERE).log(, parentKey, key, path);
                     ;
                  }

                  parent = parentKey.equals() ? (JsonAssetWithMap)assetMap.getAsset(packKey, key) : (JsonAssetWithMap)assetMap.getAsset(parentKey);
                   (parent == ) {
                     .recordFailedToLoad(failedToLoadKeys, failedToLoadPaths, key, path);
                     .logger.at(Level.SEVERE).log(, parentKey, key, path);
                     ;
                  }
               }

                (.isUnknown.test(parent)) {
                  .recordFailedToLoad(failedToLoadKeys, failedToLoadPaths, key, path);
                  .logger.at(Level.SEVERE).log(, parentKey, key, path);
               }  {
                  ++processedAssets;
                  futures.add(CompletableFuture.supplyAsync(() -> {
                     [] buffer = ([])RawJsonReader.READ_BUFFER.get();
                     RawJsonReader reader;
                      (rawAsset.getBuffer() != ) {
                        reader = RawJsonReader.fromBuffer(rawAsset.getBuffer());
                     }  {
                         {
                           reader = RawJsonReader.fromPath(path, buffer);
                        }  (IOException e) {
                           ((HytaleLogger.Api).logger.at(Level.SEVERE).withCause(e)).log(, path);
                            ;
                        }
                     }

                     DecodedAsset<K, T> decodedAsset = ;

                      {
                        decodedAsset = .decodeAssetWithParent0(loadedAssets, loadedKeyToPathMap, loadedAssetChildren, failedToLoadKeys, failedToLoadPaths, assetMap, query, forceLoadAll, rawAsset, reader, parent);
                     }  {
                         {
                            (rawAsset.getBuffer() != ) {
                              reader.close();
                           }  {
                              [] value = reader.closeAndTakeBuffer();
                               (value.length > buffer.length) {
                                 RawJsonReader.READ_BUFFER.set(value);
                              }
                           }
                        }  (IOException e) {
                           ((HytaleLogger.Api).logger.at(Level.SEVERE).withCause(e)).log(, path);
                        }

                         (decodedAsset == ) {
                           waitingForParent.remove(key);
                        }

                     }

                      decodedAsset;
                  }));
               }
            }

            CompletableFuture<DecodedAsset<K, T>>[] futuresArray = (CompletableFuture[])futures.toArray((x$) ->  [x$]);
            CompletableFuture.allOf(futuresArray).join();
            futures.clear();

            (CompletableFuture<DecodedAsset<K, T>> future : futuresArray) {
               DecodedAsset<K, T> decodedAsset = (DecodedAsset)future.getNow((Object));
                (decodedAsset != ) {
                  loadedAssets.put(decodedAsset.getKey(), decodedAsset.getAsset());
                  waitingForParent.remove(decodedAsset.getKey());
               }
            }

             (processedAssets == ) {
               (Map.Entry<K, RawAsset<K>> entry : waitingForParent.entrySet()) {
                     (K)entry.getKey();
                     ((RawAsset)entry.getValue()).getPath();
                     (K)((RawAsset)entry.getValue()).getParentKey();
                  .recordFailedToLoad(failedToLoadKeys, failedToLoadPaths, key, assetPath);
                  .logger.at(Level.SEVERE).log(, parentKey, key, assetPath);
               }
               ;
            }
         }

      }
   }

   
    CompletableFuture<DecodedAsset<K, T>>  {
       CompletableFuture.supplyAsync(() -> {
         RawJsonReader reader;
          {
               RawJsonReader.READ_BUFFER;
            Objects.requireNonNull(var10001);
            reader = rawAsset.toRawJsonReader(var10001::get);
         }  (IOException e) {
            ((HytaleLogger.Api).logger.at(Level.SEVERE).withCause(e)).log(, rawAsset);
             ;
         }

         AssetHolder<K> holder;
          {
            holder = .decodeAsset0(loadedAssets, loadedKeyToPathMap, failedToLoadKeys, failedToLoadPaths, assetMap, query, forceLoadAll, rawAsset, reader);
             (holder  RawAsset<K> waiting) {
               waitingForParent.put(waiting.getKey(), waiting);
            }
         }  {
             {
                (rawAsset.getBuffer() != ) {
                  reader.close();
               }  {
                  [] value = reader.closeAndTakeBuffer();
                   (value.length > (([])RawJsonReader.READ_BUFFER.get()).length) {
                     RawJsonReader.READ_BUFFER.set(value);
                  }
               }
            }  (IOException e) {
               ((HytaleLogger.Api).logger.at(Level.SEVERE).withCause(e)).log(, .path);
            }

         }

          holder  DecodedAsset ? (DecodedAsset)holder : ;
      });
   }

   
    AssetHolder<K>  {
         rawAsset.getPath();
         System.nanoTime();
         rawAsset.getKey();
         rawAsset.getParentKey();

       {
         KeyedCodec<K> keyCodec = .codec.getKeyCodec();
         KeyedCodec<K> parentCodec = .codec.getParentCodec();
          (key == ) {
             (rawAsset.getPath() != ) {
                 ();
            }

            reader.mark();
             (parentCodec !=  && !rawAsset.isParentKeyResolved()) {
                  RawJsonReader.seekToKeyFromObjectStart(reader, keyCodec.getKey(), parentCodec.getKey());
                (s != ) {
                   (keyCodec.getKey().equals(s)) {
                     key = (K)keyCodec.getChildCodec().decodeJson(reader);
                  }   (parentCodec.getKey().equals(s)) {
                     parentKey = (K)parentCodec.getChildCodec().decodeJson(reader);
                  }

                  s = RawJsonReader.seekToKeyFromObjectContinued(reader, keyCodec.getKey(), parentCodec.getKey());
                   (s != ) {
                      (keyCodec.getKey().equals(s)) {
                        key = (K)keyCodec.getChildCodec().decodeJson(reader);
                     }   (parentCodec.getKey().equals(s)) {
                        parentKey = (K)parentCodec.getChildCodec().decodeJson(reader);
                     }
                  }
               }
            }   (RawJsonReader.seekToKey(reader, keyCodec.getKey())) {
               key = (K)keyCodec.getChildCodec().decodeJson(reader);
            }

             (key == ) {
                 ();
            }

            reader.reset();
         }   (parentCodec !=  && !rawAsset.isParentKeyResolved()) {
            reader.mark();
             (RawJsonReader.seekToKey(reader, parentCodec.getKey())) {
               parentKey = (K)parentCodec.getChildCodec().decodeJson(reader);
            }

            reader.reset();
         }

          (assetPath == ) {
            assetPath = (Path)loadedKeyToPathMap.get(key);
         }

          (parentKey != ) {
             rawAsset.withResolveKeys(key, parentKey);
         }

         AssetExtraInfo<K> extraInfo =  <K>(assetPath, rawAsset.makeData(.getAssetClass(), key, (Object)));
         reader.consumeWhiteSpace();
            .codec.decodeJsonAsset(reader, extraInfo);
          (asset == ) {
              (rawAsset.toString());
         }

         extraInfo.getValidationResults().logOrThrowValidatorExceptions(.logger, , assetPath ==  ? rawAsset.getParentPath() : assetPath, rawAsset.getLineOffset());
          (!DISABLE_ASSET_COMPARE && (query ==  || !query.isDisableAssetCompare()) && assetMap !=  && asset.equals(((AssetMap)assetMap).getAsset(key))) {
            .logger.at(Level.INFO).log(, key);
             ;
         }

         .testKeyFormat(key, assetPath);
          (!forceLoadAll) {
         }

          (assetPath != ) {
            loadedKeyToPathMap.put(key, assetPath);
         }

         .logUnusedKeys(key, assetPath, extraInfo);
         .logLoadedAsset(key, (Object), assetPath);
           (key, asset);
      }  (CodecValidationException e) {
         .recordFailedToLoad(failedToLoadKeys, failedToLoadPaths, key, assetPath);
         .logger.at(Level.SEVERE).log(, key, assetPath, e.getMessage());
      }  (CodecException | IOException var20) {
         .recordFailedToLoad(failedToLoadKeys, failedToLoadPaths, key, assetPath);
          (GithubMessageUtil.isGithub()) {
               assetPath ==  ? (key ==  ?  : key.toString()) : assetPath.toString();
            String message;
             (var20  CodecException) {
                  (CodecException)var20;
               message = codecException.getMessage();
                (codecException.getCause() != ) {
                  message = message +  + codecException.getCause().getMessage();
               }
            }  {
               message = ((Exception)var20).getMessage();
            }

             (reader.getLine() == -) {
               HytaleLoggerBackend.rawLog(GithubMessageUtil.messageError(pathStr, message));
            }  {
               HytaleLoggerBackend.rawLog(GithubMessageUtil.messageError(pathStr, reader.getLine(), reader.getColumn(), message));
            }
         }

         ((HytaleLogger.Api).logger.at(Level.SEVERE).withCause( (var20))).log(, key, assetPath, reader);
      }  (Throwable var21) {
         .recordFailedToLoad(failedToLoadKeys, failedToLoadPaths, key, assetPath);
          (GithubMessageUtil.isGithub()) {
               assetPath ==  ? (key ==  ?  : key.toString()) : assetPath.toString();
               var21.getMessage();
            HytaleLoggerBackend.rawLog(GithubMessageUtil.messageError(pathStr, message));
         }

         ((HytaleLogger.Api).logger.at(Level.SEVERE).withCause(var21)).log(, key, assetPath);
      }

       ;
   }

   
    DecodedAsset<K, T>  {
         rawAsset.getKey();
       (!rawAsset.isParentKeyResolved()) {
           ();
      }  {
            rawAsset.getParentKey();
            rawAsset.getPath();

          {
             (assetPath == ) {
               assetPath = (Path)loadedKeyToPathMap.get(key);
            }

            AssetExtraInfo<K> extraInfo =  <K>(assetPath, rawAsset.makeData(.getAssetClass(), key, parentKey));
            reader.consumeWhiteSpace();
               .codec.decodeAndInheritJsonAsset(reader, parent, extraInfo);
             (asset == ) {
                 (assetPath.toString());
            }

            extraInfo.getValidationResults().logOrThrowValidatorExceptions(.logger);
             (key.equals(parentKey)) {
               .recordFailedToLoad(failedToLoadKeys, failedToLoadPaths, key, assetPath);
               .logger.at(Level.SEVERE).log(, key);
                ;
            }

             (!DISABLE_ASSET_COMPARE && (query ==  || !query.isDisableAssetCompare()) && assetMap !=  && asset.equals(((AssetMap)assetMap).getAsset(key))) {
               .logger.at(Level.INFO).log(, key);
                ;
            }

            .testKeyFormat(key, assetPath);
             (!forceLoadAll) {
            }

            ((Set)loadedAssetChildren.computeIfAbsent(parentKey, (k) -> ConcurrentHashMap.newKeySet())).add(key);
             (assetPath != ) {
               loadedKeyToPathMap.put(key, assetPath);
            }

            .logUnusedKeys(key, assetPath, extraInfo);
            .logLoadedAsset(key, parentKey, assetPath);
              <K, T>(key, asset);
         }  (CodecValidationException e) {
            .recordFailedToLoad(failedToLoadKeys, failedToLoadPaths, key, assetPath);
            .logger.at(Level.SEVERE).log(, key, assetPath, e.getMessage());
         }  (CodecException | IOException e) {
            .recordFailedToLoad(failedToLoadKeys, failedToLoadPaths, key, assetPath);
            ((HytaleLogger.Api).logger.at(Level.SEVERE).withCause( (e))).log(, key, assetPath, reader);
         }  (Exception e) {
            .recordFailedToLoad(failedToLoadKeys, failedToLoadPaths, key, assetPath);
            ((HytaleLogger.Api).logger.at(Level.SEVERE).withCause(e)).log(, key, assetPath);
         }

          ;
      }
   }

      {
      (T asset : assetKeys) {
         Objects.requireNonNull(asset, );
            (K).keyFunction.apply(asset);
          (key == ) {
              (String.format(, asset));
         }

         loadedAssets.put(key, asset);
          (.loadAllChildren(documents, key)) {
                ();
            sb.append(key).append();
            .logChildTree(sb, , key,  ());
            .logger.at(Level.SEVERE).log(, sb);
         }
      }

   }

      {
      Set<K> set = .assetMap.getChildren(key);
       (set == ) {
          ;
      }  {
            ;

         (K child : set) {
               .assetMap.getPath(child);
             (childPath != ) {
                (documents.add(childPath)) {
                  circular |= .loadAllChildren(documents, child);
               }  {
                  circular = ;
               }
            }
         }

          circular;
      }
   }

      {
       (.collectAllChildren0(key, children)) {
             ();
         sb.append(key).append();
         .logChildTree(sb, , key,  ());
         .logger.at(Level.SEVERE).log(, sb);
      }

   }

      {
      Set<K> set = .assetMap.getChildren(key);
       (set == ) {
          ;
      }  {
            ;

         (K child : set) {
             (children.add(child)) {
               circular |= .collectAllChildren0(child, children);
            }  {
               circular = ;
            }
         }

          circular;
      }
   }

      {
      Set<K> set = .assetMap.getChildren(key);
       (set != ) {
         (K child : set) {
             (children.add(child)) {
               sb.append(indent).append().append(child).append();
               .logChildTree(sb, indent + , child, children);
            }  {
               sb.append(indent).append().append(child).append().append(indent).append().append();
            }
         }

      }
   }

      {
         .assetMap.getPath(parentKey);

      (K child : toBeRemoved) {
            .assetMap.getPath(child);
          (childPath != ) {
             (path != ) {
               .logger.at(Level.WARNING).log(, childPath, path);
            }  {
               .logger.at(Level.WARNING).log(, childPath, parentKey);
            }
         }  {
            .logger.at(Level.WARNING).log(, child, parentKey);
         }
      }

   }

      {
      (Map.Entry<K, K> entry : toBeRemoved.entrySet()) {
            (K)entry.getKey();
            (K)entry.getValue();
            .assetMap.getPath(child);
          (childPath != ) {
               .assetMap.getPath(parentKey);
             (path != ) {
               .logger.at(Level.WARNING).log(, childPath, path);
            }  {
               .logger.at(Level.WARNING).log(, childPath, parentKey);
            }
         }  {
            .logger.at(Level.WARNING).log(, child, parentKey);
         }
      }

   }

      {
         key.toString();
       (!StringUtil.isCapitalized(keyStr, )) {
            StringUtil.capitalize(keyStr, );
          (assetPath == ) {
            .logger.at(Level.WARNING).log(, key, expected);
         }  {
            .logger.at(Level.WARNING).log(, key, assetPath, expected);
         }

      }
   }

      {
      List<String> unknownKeys = extraInfo.getUnknownKeys();
       (!unknownKeys.isEmpty()) {
          (GithubMessageUtil.isGithub()) {
               assetPath ==  ? key.toString() : assetPath.toString();

            (   ; i < unknownKeys.size(); ++i) {
                  (String)unknownKeys.get(i);
               HytaleLoggerBackend.rawLog(GithubMessageUtil.messageWarning(pathStr,  + unknownKey));
            }
         }   (assetPath != ) {
            .logger.at(Level.WARNING).log(, key, assetPath, String.join(, unknownKeys));
         }  {
            .logger.at(Level.WARNING).log(, key, String.join(, unknownKeys));
         }
      }

   }

      {
       (path ==  && parentKey == ) {
         .logger.at(Level.FINE).log(, key);
      }   (path == ) {
         .logger.at(Level.FINE).log(, key, parentKey);
      }   (parentKey == ) {
         .logger.at(Level.FINE).log(, key, path);
      }  {
         .logger.at(Level.FINE).log(, key, path, parentKey);
      }

   }

      {
       (path == ) {
         .logger.at(Level.FINE).log(, key);
      }  {
         .logger.at(Level.FINE).log(, key, path);
      }

   }

      {
       (key != ) {
         failedToLoadKeys.add(key);
      }

       (path != ) {
         failedToLoadPaths.add(path);
      }

   }

   
    String  {
        + String.valueOf(.tClass) + ;
   }

       <K, T  <K, M>, M  <K, T>, B  <K, T, M, B>> {
      
        Class<K> kClass;
      
        Class<T> tClass;
        M assetMap;
        Set<Class<?  <?>>> loadsAfter =  ();
        Set<Class<?  <?>>> loadsBefore =  ();
       String path;
      
          ;
       AssetCodec<K, T> codec;
       Function<T, K> keyFunction;
       Function<K, T> replaceOnRemove;
       Predicate<T> isUnknown;
        unmodifiable;
       List<T> preAddedAssets;
       Class<?  <?>> idProvider;

        {
         .kClass = (Class)Objects.requireNonNull(kClass, );
         .tClass = (Class)Objects.requireNonNull(tClass, );
         .assetMap = assetMap;
      }

      
       B  {
         .path = (String)Objects.requireNonNull(path, );
          (B);
      }

      
       B  {
         Objects.requireNonNull(extension, );
          (extension.length() >=  && extension.charAt() == ) {
            .extension = extension;
             (B);
         }  {
              ();
         }
      }

      
       B  {
         .codec = (AssetCodec)Objects.requireNonNull(codec, );
          (B);
      }

      
       B  {
         .keyFunction = (Function)Objects.requireNonNull(keyFunction, );
          (B);
      }

      
       B  {
         .isUnknown = (Predicate)Objects.requireNonNull(isUnknown, );
          (B);
      }

      
      
        B  {
         Collections.addAll(.loadsAfter, clazz);
          (B);
      }

      
      
        B  {
         Collections.addAll(.loadsBefore, clazz);
          (B);
      }

      
       B  {
         .replaceOnRemove = (Function)Objects.requireNonNull(replaceOnRemove, );
          (B);
      }

      
       B  {
         .unmodifiable = ;
          (B);
      }

      
       B  {
          (.preAddedAssets == ) {
            .preAddedAssets =  ();
         }

         .preAddedAssets.addAll(list);
          (B);
      }

      
       B  {
         .idProvider = provider;
          (B);
      }

        AssetStore<K, T, M> ;
   }
}

com/hypixel/hytale/assetstore/AssetUpdateQuery.java

package com.hypixel.hytale.assetstore;

import javax.annotation.Nonnull;

public class AssetUpdateQuery {
   public static final AssetUpdateQuery DEFAULT;
   public static final AssetUpdateQuery DEFAULT_NO_REBUILD;
   private final boolean disableAssetCompare;
   private final RebuildCache rebuildCache;

   public AssetUpdateQuery(boolean disableAssetCompare, RebuildCache rebuildCache) {
      this.disableAssetCompare = disableAssetCompare;
      this.rebuildCache = rebuildCache;
   }

   public AssetUpdateQuery(RebuildCache rebuildCache) {
      this(AssetStore.DISABLE_ASSET_COMPARE, rebuildCache);
   }

   public boolean isDisableAssetCompare() {
      return this.disableAssetCompare;
   }

   @Nonnull
   public RebuildCache getRebuildCache() {
      return this.rebuildCache;
   }

   @Nonnull
   public String toString() {
      return "AssetUpdateQuery{rebuildCache=" + String.valueOf(.rebuildCache) + ;
   }

    {
      DEFAULT =  (AssetUpdateQuery.RebuildCache.DEFAULT);
      DEFAULT_NO_REBUILD =  (AssetUpdateQuery.RebuildCache.NO_REBUILD);
   }

       {
             (, , , , , );
             (, , , , , );
         blockTextures;
         models;
         modelTextures;
         mapGeometry;
         itemIcons;
         commonAssetsRebuild;

        {
         .blockTextures = blockTextures;
         .models = models;
         .modelTextures = modelTextures;
         .mapGeometry = mapGeometry;
         .itemIcons = itemIcons;
         .commonAssetsRebuild = commonAssetsRebuild;
      }

         {
          .blockTextures;
      }

         {
          .models;
      }

         {
          .modelTextures;
      }

         {
          .mapGeometry;
      }

         {
          .itemIcons;
      }

         {
          .commonAssetsRebuild;
      }

      
       RebuildCacheBuilder  {
           (.blockTextures, .models, .modelTextures, .mapGeometry, .itemIcons, .commonAssetsRebuild);
      }

      
        RebuildCacheBuilder  {
           ();
      }

      
       String  {
           + .blockTextures +  + .models +  + .modelTextures +  + .mapGeometry +  + .itemIcons +  + .commonAssetsRebuild + ;
      }
   }

       {
        blockTextures;
        models;
        modelTextures;
        mapGeometry;
        itemIcons;
        commonAssetsRebuild;

      RebuildCacheBuilder() {
      }

      RebuildCacheBuilder( blockTextures,  models,  modelTextures,  mapGeometry,  itemIcons,  commonAssetsRebuild) {
         .blockTextures = blockTextures;
         .models = models;
         .modelTextures = modelTextures;
         .mapGeometry = mapGeometry;
         .itemIcons = itemIcons;
         .commonAssetsRebuild = commonAssetsRebuild;
      }

         {
         .blockTextures = blockTextures;
      }

         {
         .models = models;
      }

         {
         .modelTextures = modelTextures;
      }

         {
         .mapGeometry = mapGeometry;
      }

         {
         .itemIcons = itemIcons;
      }

         {
         .commonAssetsRebuild = commonAssetsRebuild;
      }

      
       RebuildCache  {
           (.blockTextures, .models, .modelTextures, .mapGeometry, .itemIcons, .commonAssetsRebuild);
      }

      
       String  {
           + .blockTextures +  + .models +  + .modelTextures +  + .mapGeometry +  + .itemIcons +  + .commonAssetsRebuild + ;
      }
   }
}

com/hypixel/hytale/assetstore/AssetValidationResults.java

package com.hypixel.hytale.assetstore;

import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.logger.backend.HytaleLoggerBackend;
import com.hypixel.hytale.logger.util.GithubMessageUtil;
import java.nio.file.Path;
import java.util.HashSet;
import java.util.Set;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class AssetValidationResults extends ValidationResults {
   private Set<Class<? extends JsonAsset>> disabledMissingAssetClasses;

   public AssetValidationResults(ExtraInfo extraInfo) {
      super(extraInfo);
   }

   public void handleMissingAsset(String field, @Nonnull Class<? extends JsonAsset> assetType, Object assetId) {
      if (this.disabledMissingAssetClasses == null || !this.disabledMissingAssetClasses.contains(assetType)) {
         throw new MissingAssetException(field, assetType, assetId);
      }
   }

   public void handleMissingAsset(String field, @Nonnull Class<? extends JsonAsset> assetType, Object assetId, String extra) {
       (.disabledMissingAssetClasses ==  || !.disabledMissingAssetClasses.contains(assetType)) {
           (field, assetType, assetId, extra);
      }
   }

      {
       (.disabledMissingAssetClasses == ) {
         .disabledMissingAssetClasses =  ();
      }

      .disabledMissingAssetClasses.add(assetType);
   }

      {
      .logOrThrowValidatorExceptions(logger, msg, (Path), );
   }

      {
       (GithubMessageUtil.isGithub() && .validatorExceptions !=  && !.validatorExceptions.isEmpty()) {
         (ValidationResults.ValidatorResultsHolder holder : .validatorExceptions) {
               ;
             (path == ) {
                  .extraInfo;
                (var9  AssetExtraInfo) {
                  AssetExtraInfo<?> assetExtraInfo = (AssetExtraInfo)var9;
                  path = assetExtraInfo.getAssetPath();
               }
            }

             (path != ) {
               file = path.toString();
            }

            (ValidationResults.ValidationResult result : holder.results()) {
               String var10000;
                (result.result()) {
                   SUCCESS -> var10000 = ;
                   WARNING -> var10000 = holder.line() == - ? GithubMessageUtil.messageWarning(file, result.reason()) : GithubMessageUtil.messageWarning(file, holder.line() + lineOffset, holder.column(), result.reason());
                   FAIL -> var10000 = holder.line() == - ? GithubMessageUtil.messageError(file, result.reason()) : GithubMessageUtil.messageError(file, holder.line() + lineOffset, holder.column(), result.reason());
                   ->   ((String), (Throwable));
               }

               HytaleLoggerBackend.rawLog(var10000);
            }
         }
      }

      .logOrThrowValidatorExceptions(logger, msg);
   }
}

com/hypixel/hytale/assetstore/DecodedAsset.java

package com.hypixel.hytale.assetstore;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class DecodedAsset<K, T extends JsonAsset<K>> implements AssetHolder<K> {
   private final K key;
   private final T asset;

   public DecodedAsset(K key, T asset) {
      this.key = key;
      this.asset = asset;
   }

   public K getKey() {
      return this.key;
   }

   public T getAsset() {
      return this.asset;
   }

   public boolean equals(@Nullable Object o) {
      if (this == o) {
         return true;
      } else if (o != null && this.getClass() == o.getClass()) {
         DecodedAsset<?, ?> that = (DecodedAsset)o;
         if (this.key != null) {
            if (!this.key.equals(that.key)) {
                ;
            }
         }   (that.key != ) {
             ;
         }

          .asset !=  ? .asset.equals(that.asset) : that.asset == ;
      }  {
          ;
      }
   }

      {
         .key !=  ? .key.hashCode() : ;
      result =  * result + (.asset !=  ? .asset.hashCode() : );
       result;
   }

   
    String  {
         String.valueOf(.key);
        + var10000 +  + String.valueOf(.asset) + ;
   }
}

com/hypixel/hytale/assetstore/JsonAsset.java

package com.hypixel.hytale.assetstore;

public interface JsonAsset<K> {
   K getId();
}

com/hypixel/hytale/assetstore/MissingAssetException.java

package com.hypixel.hytale.assetstore;

import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.validation.ValidationResults;
import javax.annotation.Nonnull;

public class MissingAssetException extends RuntimeException {
   private String field;
   private Class<? extends JsonAsset> assetType;
   private Object assetId;

   public MissingAssetException(String field, @Nonnull Class<? extends JsonAsset> assetType, Object assetId) {
      String var10001 = String.valueOf(assetId);
      super("Missing asset '" + var10001 + "' of type " + assetType.getSimpleName() + " for field '" + field + "'!");
      this.field = field;
      this.assetType = assetType;
      this.assetId = assetId;
   }

   public MissingAssetException(String field, @Nonnull Class<? extends JsonAsset> assetType, Object assetId, String extra) {
      String var10001 = String.valueOf(assetId);
      super("Missing asset '" + var10001 + "' of type " + assetType.getSimpleName() + " for field '" + field + "'! " + extra);
      .field = field;
      .assetType = assetType;
      .assetId = assetId;
   }

    String  {
       .field;
   }

    Class<?  > getAssetType() {
       .assetType;
   }

    Object  {
       .assetId;
   }

       {
         extraInfo.getValidationResults();
       (validationResults  AssetValidationResults) {
         ((AssetValidationResults)validationResults).handleMissingAsset(field, assetType, assetId);
      }  {
           (field, assetType, assetId);
      }
   }

       {
         extraInfo.getValidationResults();
       (validationResults  AssetValidationResults) {
         ((AssetValidationResults)validationResults).handleMissingAsset(field, assetType, assetId, extra);
      }  {
           (field, assetType, assetId, extra);
      }
   }
}

com/hypixel/hytale/assetstore/RawAsset.java

package com.hypixel.hytale.assetstore;

import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.nio.file.Path;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.ParametersAreNullableByDefault;

@ParametersAreNullableByDefault
public class RawAsset<K> implements AssetHolder<K> {
   private final Path parentPath;
   @Nullable
   private final K key;
   private final int lineOffset;
   private final boolean parentKeyResolved;
   @Nullable
   private final K parentKey;
   @Nullable
   private final Path path;
   @Nullable
   private final char[] buffer;
   @Nullable
   private final AssetExtraInfo.Data containerData;
   @Nonnull
   private final ContainedAssetCodec.Mode containedAssetMode;

     {
      .key = key;
      .lineOffset = ;
      .parentKeyResolved = ;
      .parentKey = ;
      .path = path;
      .parentPath = ;
      .buffer = ;
      .containerData = ;
      .containedAssetMode = ContainedAssetCodec.Mode.NONE;
   }

     {
      .key = key;
      .lineOffset = lineOffset;
      .parentKeyResolved = ;
      .parentKey = parentKey;
      .path = ;
      .parentPath = parentPath;
      .buffer = buffer;
      .containerData = containerData;
      .containedAssetMode = containedAssetMode;
   }

     {
      .key = key;
      .lineOffset = ;
      .parentKeyResolved = parentKeyResolved;
      .parentKey = parentKey;
      .path = path;
      .parentPath = ;
      .buffer = buffer;
      .containerData = containerData;
      .containedAssetMode = containedAssetMode;
   }

   
    K  {
       .key;
   }

      {
       .parentKeyResolved;
   }

   
    K  {
       .parentKey;
   }

   
    Path  {
       .path;
   }

    Path  {
       .parentPath;
   }

      {
       .lineOffset;
   }

    [] getBuffer() {
       .buffer;
   }

   
    ContainedAssetCodec.Mode  {
       .containedAssetMode;
   }

   
    RawJsonReader   IOException {
       .path !=  ? RawJsonReader.fromPath(.path, ([])bufferSupplier.get()) : RawJsonReader.fromBuffer(.buffer);
   }

   
    AssetExtraInfo.Data  {
       var10000;
       (.containedAssetMode) {
          INHERIT_ID:
          INHERIT_ID_AND_PARENT:
          INJECT_PARENT:
            var10000 = ;
            ;
          NONE:
          GENERATE_ID:
            var10000 = ;
            ;
         :
              ((String), (Throwable));
      }

         var10000;
        .Data(.containerData, aClass, key, parentKey, inheritTags);
   }

   
    RawAsset<K>  {
        <K>(key, , parentKey, .path, .buffer, .containerData, .containedAssetMode);
   }

   
    String  {
         String.valueOf(.key);
        + var10000 +  + .parentKeyResolved +  + String.valueOf(.parentKey) +  + String.valueOf(.path) +  + (.buffer !=  ? .buffer.length : -) + ;
   }
}

com/hypixel/hytale/assetstore/codec/AssetBuilderCodec.java

package com.hypixel.hytale.assetstore.codec;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.JsonAsset;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class AssetBuilderCodec<K, T extends JsonAsset<K>> extends BuilderCodec<T> implements AssetCodec<K, T> {
   public static final KeyedCodec<Map<String, String[]>> TAGS_CODEC;
   private static final String TAG_DOCUMENTATION = "Tags are a general way to describe an asset that can be interpreted by other systems in a way they see fit.\n\nFor example you could tag something with a **Material** tag with the values **Solid** and **Stone**, And another single tag **Ore**.\n\nTags will be expanded into a single list of tags automatically. Using the above example with **Material** and **Ore** the end result would be the following list of tags: **Ore**, **Material**, **Solid**, **Stone**, **Material=Solid** and **Material=Stone**.";
   
     KeyedCodec<K> idCodec;
   
     KeyedCodec<K> parentCodec;
     BiConsumer<T, K> idSetter;
     BiConsumer<T, AssetExtraInfo.Data> dataSetter;
   
     Function<T, AssetExtraInfo.Data> dataGetter;

     {
      (builder);
      .idCodec = builder.idCodec;
      .parentCodec =  <K>(, .idCodec.getChildCodec());
      .idSetter = builder.idSetter;
      .dataSetter = builder.dataSetter;
      .dataGetter = builder.dataGetter;
   }

   
    KeyedCodec<K>  {
       .idCodec;
   }

   
    KeyedCodec<K>  {
       .parentCodec;
   }

    AssetExtraInfo.Data  {
       (AssetExtraInfo.Data).dataGetter.apply(t);
   }

    T   IOException {
       (T).decodeAndInheritJsonAsset(reader, (JsonAsset), extraInfo);
   }

    T   IOException {
         (T)(.supplier.get());
      .dataSetter.accept(t, extraInfo.getData());
       (parent != ) {
         .inherit(t, parent, extraInfo);
      }

      .decodeAndInheritJson0(reader, t, parent, extraInfo);
      .idSetter.accept(t, extraInfo.getKey());
      .afterDecodeAndValidate(t, extraInfo);
       t;
   }

   
    ObjectSchema  {
       .toSchema(context, (JsonAsset).supplier.get());
   }

   
    ObjectSchema  {
         .toSchema(context, def);
      KeyedCodec<K> parent = .getParentCodec();
         parent.getChildCodec().toSchema(context);
      parentSchema.setMarkdownDescription( + .tClass.getSimpleName() + );
      Class<?  T> rootClass = .tClass;

      (BuilderCodec<?  T> rootCodec = ; rootCodec.getParent() != ; rootClass = rootCodec.getInnerClass()) {
         rootCodec = rootCodec.getParent();
      }

      parentSchema.setHytaleParent( .InheritSettings(rootClass.getSimpleName()));
      LinkedHashMap<String, Schema> props =  ();
      props.put(parent.getKey(), parentSchema);
      props.putAll(schema.getProperties());
      schema.setProperties(props);
       schema;
   }

   
     <K, T  <K>> Builder<K, T>  {
        <K, T>(tClass, supplier, idCodec, idSetter, idGetter, dataSetter, dataGetter);
   }

   
     <K, T  <K>> Builder<K, T>  {
        <K, T>(tClass, supplier, parentCodec, idCodec, idSetter, idGetter, dataSetter, dataGetter);
   }

   
     <K, T  <K>> AssetBuilderCodec<K, T>  {
       ((Builder)builder(codec.getInnerClass(), codec.getSupplier(), codec, idCodec, idSetter, idGetter, dataSetter, dataGetter).documentation(codec.getDocumentation())).build();
   }

    {
      TAGS_CODEC =  <Map<String, String[]>>(,  (Codec.STRING_ARRAY, HashMap::));
   }

      <K, T  <K>>  .BuilderBase<T, Builder<K, T>> {
      
        KeyedCodec<K> idCodec;
        BiConsumer<T, K> idSetter;
        BiConsumer<T, AssetExtraInfo.Data> dataSetter;
      
        Function<T, AssetExtraInfo.Data> dataGetter;

        {
         (tClass, supplier);
         .idCodec =  <K>(, idCodec);
         .idSetter = idSetter;
         .dataSetter = dataSetter;
         .dataGetter = dataGetter;
         .appendInherited(AssetBuilderCodec.TAGS_CODEC, (t, tags) -> ((AssetExtraInfo.Data)dataGetter.apply(t)).putTags(tags), (t) -> {
            AssetExtraInfo.   (AssetExtraInfo.Data)dataGetter.apply(t);
             data !=  ? data.getRawTags() : ;
         }, (t, parent) -> {
            AssetExtraInfo.   (AssetExtraInfo.Data)dataGetter.apply(t);
            AssetExtraInfo.   (AssetExtraInfo.Data)dataGetter.apply(parent);
             (data !=  && parentData != ) {
               data.putTags(parentData.getRawTags());
            }

         }).documentation().add();
      }

        {
         (tClass, supplier, parentCodec);
         .idCodec =  <K>(, idCodec);
         .idSetter = idSetter;
         .dataSetter = dataSetter;
         .dataGetter = dataGetter;
         .appendInherited(AssetBuilderCodec.TAGS_CODEC, (t, tags) -> ((AssetExtraInfo.Data)dataGetter.apply(t)).putTags(tags), (t) -> {
            AssetExtraInfo.   (AssetExtraInfo.Data)dataGetter.apply(t);
             data !=  ? data.getRawTags() : ;
         }, (t, parent) -> {
            AssetExtraInfo.   (AssetExtraInfo.Data)dataGetter.apply(t);
            AssetExtraInfo.   (AssetExtraInfo.Data)dataGetter.apply(parent);
             (data !=  && parentData != ) {
               data.putTags(parentData.getRawTags());
            }

         }).documentation().add();
      }

      
       AssetBuilderCodec<K, T>  {
           <K, T>();
      }
   }
}

com/hypixel/hytale/assetstore/codec/AssetCodec.java

package com.hypixel.hytale.assetstore.codec;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.JsonAsset;
import com.hypixel.hytale.codec.InheritCodec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.util.RawJsonReader;
import com.hypixel.hytale.codec.validation.ValidatableCodec;
import java.io.IOException;
import javax.annotation.Nullable;

public interface AssetCodec<K, T extends JsonAsset<K>> extends InheritCodec<T>, ValidatableCodec<T> {
   KeyedCodec<K> getKeyCodec();

   KeyedCodec<K> getParentCodec();

   @Nullable
   AssetExtraInfo.Data getData(T var1);

   T decodeJsonAsset(RawJsonReader var1, AssetExtraInfo<K> var2) throws IOException;

   T decodeAndInheritJsonAsset(RawJsonReader var1, T var2, AssetExtraInfo<K> var3) throws IOException;
}

com/hypixel/hytale/assetstore/codec/AssetCodecMapCodec.java

package com.hypixel.hytale.assetstore.codec;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.JsonAsset;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.lookup.ACodecMapCodec;
import com.hypixel.hytale.codec.lookup.Priority;
import com.hypixel.hytale.codec.lookup.StringCodecMapCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;
import org.bson.BsonValue;

public class AssetCodecMapCodec<K, T extends JsonAsset<K>> extends StringCodecMapCodec<T, AssetBuilderCodec<K, T>> implements AssetCodec<K, T> {
   @Nonnull
   protected final KeyedCodec<K> idCodec;
   @Nonnull
     KeyedCodec<K> parentCodec;
     BiConsumer<T, K> idSetter;
     Function<T, K> idGetter;
     BiConsumer<T, AssetExtraInfo.Data> dataSetter;
     Function<T, AssetExtraInfo.Data> dataGetter;

     {
      ();
      .idCodec =  <K>(, idCodec);
      .parentCodec =  <K>(, idCodec);
      .idSetter = idSetter;
      .idGetter = idGetter;
      .dataSetter = dataSetter;
      .dataGetter = dataGetter;
   }

     {
      (key);
      .idCodec =  <K>(, idCodec);
      .parentCodec =  <K>(, idCodec);
      .idSetter = idSetter;
      .idGetter = idGetter;
      .dataSetter = dataSetter;
      .dataGetter = dataGetter;
   }

     {
      (, allowDefault);
      .idCodec =  <K>(, idCodec);
      .parentCodec =  <K>(, idCodec);
      .idSetter = idSetter;
      .idGetter = idGetter;
      .dataSetter = dataSetter;
      .dataGetter = dataGetter;
   }

     {
      (key, allowDefault);
      .idCodec =  <K>(, idCodec);
      .parentCodec =  <K>(, idCodec);
      .idSetter = idSetter;
      .idGetter = idGetter;
      .dataSetter = dataSetter;
      .dataGetter = dataGetter;
   }

   
    KeyedCodec<K>  {
       .idCodec;
   }

   
    KeyedCodec<K>  {
       .parentCodec;
   }

    AssetExtraInfo.Data  {
       (AssetExtraInfo.Data).dataGetter.apply(t);
   }

   
    AssetCodecMapCodec<K, T>  {
       .register(Priority.NORMAL, id, aClass, codec);
   }

   
    AssetCodecMapCodec<K, T>  {
      AssetBuilderCodec<K, T> assetCodec = AssetBuilderCodec.<K, T>wrap(codec, .idCodec.getChildCodec(), .idSetter, .idGetter, .dataSetter, .dataGetter);
      .register(priority, (String)id, aClass, assetCodec);
       ;
   }

    T  {
         document.get(.key);
      AssetBuilderCodec<K, T> codec = (AssetBuilderCodec).idToCodec.get(id ==  ?  : id.asString().getValue());
       (codec == ) {
         AssetBuilderCodec<K, T> defaultCodec = (AssetBuilderCodec).getDefaultCodec();
          (defaultCodec == ) {
               .key;
              .UnknownIdException( + var10002 +  + String.valueOf(id));
         }  {
             (T)(defaultCodec.decodeAndInherit(document, parent, extraInfo));
         }
      }  {
          (T)(codec.decodeAndInherit(document, parent, extraInfo));
      }
   }

      {
         document.get(.key);
      AssetBuilderCodec<K, T> codec = (AssetBuilderCodec).idToCodec.get(id ==  ?  : id.asString().getValue());
       (codec == ) {
         AssetBuilderCodec<K, T> defaultCodec = (AssetBuilderCodec).getDefaultCodec();
          (defaultCodec == ) {
               .key;
              .UnknownIdException( + var10002 +  + String.valueOf(id));
         }  {
            defaultCodec.decodeAndInherit(document, t, parent, extraInfo);
         }
      }  {
         codec.decodeAndInherit(document, t, parent, extraInfo);
      }
   }

    T   IOException {
      reader.mark();
         ;
       (RawJsonReader.seekToKey(reader, .key)) {
         id = reader.readString();
      }   (parent != ) {
         id = (String).getIdFor(parent.getClass());
      }

      reader.reset();
      extraInfo.ignoreUnusedKey(.key);

      JsonAsset var7;
       {
         AssetBuilderCodec<K, T> codec = id ==  ?  : (AssetBuilderCodec).idToCodec.get(id);
          (codec != ) {
               (JsonAsset)codec.decodeAndInheritJson(reader, parent, extraInfo);
             (T)var11;
         }

         AssetBuilderCodec<K, T> defaultCodec = (AssetBuilderCodec).getDefaultCodec();
          (defaultCodec == ) {
              .UnknownIdException( + .key +  + id);
         }

         var7 = (JsonAsset)defaultCodec.decodeAndInheritJson(reader, parent, extraInfo);
      }  {
         extraInfo.popIgnoredUnusedKey();
      }

       (T)var7;
   }

       IOException {
      reader.mark();
         ;
       (RawJsonReader.seekToKey(reader, .key)) {
         id = reader.readString();
      }   (parent != ) {
         id = (String).getIdFor(parent.getClass());
      }

      reader.reset();
      extraInfo.ignoreUnusedKey(.key);

       {
         AssetBuilderCodec<K, T> codec = id ==  ?  : (AssetBuilderCodec).idToCodec.get(id);
          (codec != ) {
            codec.decodeAndInheritJson(reader, t, parent, extraInfo);
            ;
         }

         AssetBuilderCodec<K, T> defaultCodec = (AssetBuilderCodec).getDefaultCodec();
          (defaultCodec == ) {
              .UnknownIdException( + .key +  + id);
         }

         defaultCodec.decodeAndInheritJson(reader, t, parent, extraInfo);
      }  {
         extraInfo.popIgnoredUnusedKey();
      }

   }

    T   IOException {
       (T).decodeAndInheritJsonAsset(reader, (JsonAsset), extraInfo);
   }

    T   IOException {
      reader.mark();
         ;
       (RawJsonReader.seekToKey(reader, .key)) {
         id = reader.readString();
      }   (parent != ) {
         id = (String).getIdFor(parent.getClass());
      }

      reader.reset();
      extraInfo.ignoreUnusedKey(.key);

      JsonAsset var8;
       {
         AssetBuilderCodec<K, T> codec = id ==  ?  : (AssetBuilderCodec).idToCodec.get(id);
          (codec == ) {
            AssetBuilderCodec<K, T> defaultCodec = (AssetBuilderCodec).getDefaultCodec();
             (defaultCodec == ) {
                 .UnknownIdException( + .key +  + id);
            }

            codec = defaultCodec;
         }

         Supplier<T> supplier = codec.getSupplier();
          (supplier == ) {
              ();
         }

            (T)(supplier.get());
         .dataSetter.accept(t, extraInfo.getData());
          (parent != ) {
            codec.inherit(t, parent, extraInfo);
         }

         codec.decodeAndInheritJson0(reader, t, parent, extraInfo);
         .idSetter.accept(t, extraInfo.getKey());
         codec.afterDecodeAndValidate(t, extraInfo);
         var8 = t;
      }  {
         extraInfo.popIgnoredUnusedKey();
      }

       (T)var8;
   }

   
    Schema  {
         .toSchema(context);
      schema.getHytaleSchemaTypeField().setParentPropertyKey(.parentCodec.getKey());
       schema;
   }

      {
      .mutateChildSchema(key, context, c, objectSchema);
      AssetBuilderCodec<K, T> def = (AssetBuilderCodec).getDefaultCodec();
       (!.allowDefault || def != c) {
             ();
         idField.setRequired(.key);
             ();
         parentField.setRequired(.parentCodec.getKey());
         AssetBuilderCodec<K, T> bc = (AssetBuilderCodec)c;
            (Schema)objectSchema.getProperties().get(bc.getParentCodec().getKey());
          (parentSchema != ) {
            Schema.   parentSchema.getHytaleParent();
            settings.setMapKey(.key);
            settings.setMapKeyValue(key);
            objectSchema.setOneOf( []{idField, parentField});
         }
      }

   }
}

com/hypixel/hytale/assetstore/codec/ContainedAssetCodec.java

package com.hypixel.hytale.assetstore.codec;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetMap;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.RawAsset;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import com.hypixel.hytale.codec.validation.ValidatableCodec;
import java.io.IOException;
import java.nio.file.Path;
import java.util.Set;
import java.util.function.Function;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonValue;

public class ContainedAssetCodec<K, T extends JsonAssetWithMap<K, M>, M extends AssetMap<K, T>> implements Codec<K>, ValidatableCodec<K> {
   private static final boolean DISABLE_DIRECT_LOADING = true;
   private final Class<T> assetClass;
     AssetCodec<K, T> codec;
   
     Mode mode;
     Function<AssetExtraInfo<K>, K> keyGenerator;

     {
      (assetClass, codec, ContainedAssetCodec.Mode.GENERATE_ID);
   }

     {
      (assetClass, codec, mode, (assetExtraInfo) -> AssetRegistry.getAssetStore(assetClass).transformKey(assetExtraInfo.generateKey()));
   }

     {
       (mode == ContainedAssetCodec.Mode.NONE) {
           ();
      }  {
         .assetClass = assetClass;
         .codec = codec;
         .mode = mode;
         .keyGenerator = keyGenerator;
      }
   }

    Class<T>  {
       .assetClass;
   }

   
    K  {
       (!(extraInfo  AssetExtraInfo<K> assetExtraInfo)) {
           ();
      }   (bsonValue.isString()) {
          .codec.getKeyCodec().getChildCodec().decode(bsonValue, extraInfo);
      }  {
         KeyedCodec<K> parentCodec = .codec.getParentCodec();
            (K)(parentCodec !=  ? parentCodec.getOrNull(bsonValue.asDocument(), extraInfo) : );
         AssetStore<K, T, M> assetStore = AssetRegistry.<K, T, M>getAssetStore(.assetClass);
         K id;
          (.mode.ordinal()) {
             :
               id = (K).keyGenerator.apply(assetExtraInfo);
                  ;
               ;
             :
               id = assetStore.transformKey(assetExtraInfo.getKey());
                  ;
               ;
             :
               id = assetStore.transformKey(assetExtraInfo.getKey());
                (parentId == ) {
                     assetExtraInfo.getData().getParentKey();
                   (thisAssetParentId != ) {
                     parentId = assetStore.transformKey(thisAssetParentId);
                  }
               }

                  ;
               ;
             :
               id = (K).keyGenerator.apply(assetExtraInfo);
                (parentId ==  && !assetExtraInfo.getKey().equals(id)) {
                  parentId = assetExtraInfo.getKey();
               }

                  ;
               ;
            :
                 ();
         }

            parentId !=  ? (JsonAssetWithMap)assetStore.getAssetMap().getAsset(parentId) : ;
          (parentId !=  && parent != ) {
         }

         [] clone = bsonValue.asDocument().toJson().toCharArray();
            assetExtraInfo.getAssetPath();
         assetExtraInfo.getData().addContainedAsset(.assetClass,  (path, id, parentId, , clone, assetExtraInfo.getData(), .mode));
          id;
      }
   }

    BsonValue  {
       (key.toString().startsWith()) {
            (T)(AssetRegistry.getAssetStore(.assetClass).getAssetMap().getAsset(key));
          (asset != ) {
             .codec.encode(asset, extraInfo);
         }
      }

       .codec.getKeyCodec().getChildCodec().encode(key, extraInfo);
   }

   
    K   IOException {
       (!(extraInfo  AssetExtraInfo<K> assetExtraInfo)) {
           ();
      }  {
            reader.getLine() - ;
          (reader.peekFor()) {
             .codec.getKeyCodec().getChildCodec().decodeJson(reader, extraInfo);
         }  {
            reader.mark();
               ;
               ;
            KeyedCodec<K> parentCodec = .codec.getParentCodec();
             (parentCodec !=  && RawJsonReader.seekToKey(reader, parentCodec.getKey())) {
               parentId = parentCodec.getChildCodec().decodeJson(reader, extraInfo);
               needsSkip = ;
            }

            AssetStore<K, T, M> assetStore = AssetRegistry.<K, T, M>getAssetStore(.assetClass);
            K id;
             (.mode.ordinal()) {
                :
                  id = (K).keyGenerator.apply(assetExtraInfo);
                     ;
                  ;
                :
                  id = assetStore.transformKey(assetExtraInfo.getKey());
                     ;
                  ;
                :
                  id = assetStore.transformKey(assetExtraInfo.getKey());
                   (parentId == ) {
                        assetExtraInfo.getData().getParentKey();
                      (thisAssetParentId != ) {
                        parentId = assetStore.transformKey(thisAssetParentId);
                     }
                  }

                     ;
                  ;
                :
                  id = (K).keyGenerator.apply(assetExtraInfo);
                   (parentId ==  && !assetExtraInfo.getKey().equals(id)) {
                     parentId = assetExtraInfo.getKey();
                  }

                     ;
                  ;
               :
                    ();
            }

               parentId !=  ? (JsonAssetWithMap)assetStore.getAssetMap().getAsset(parentId) : ;
             (parentId !=  && parent != ) {
            }

             (needsSkip) {
               reader.skipObjectContinued();
            }

            [] clone = reader.cloneMark();
            reader.unmark();
               assetExtraInfo.getAssetPath();
            assetExtraInfo.getData().addContainedAsset(.assetClass,  (path, id, parentId, lineStart, clone, assetExtraInfo.getData(), .mode));
             id;
         }
      }
   }

   
    Schema  {
         context.refDefinition(.codec.getKeyCodec().getChildCodec());
      keySchema.setTitle( + .assetClass.getSimpleName());
         context.refDefinition(.codec);
         Schema.anyOf(keySchema, nestedSchema);
      s.setHytaleAssetRef(.assetClass.getSimpleName());
       s;
   }

      {
      AssetRegistry.getAssetStore(.assetClass).validate(k, extraInfo.getValidationResults(), extraInfo);
   }

      {
       (tested.add()) {
         ;
      }
   }

       {
      NONE,
      GENERATE_ID,
      INHERIT_ID,
      INHERIT_ID_AND_PARENT,
      INJECT_PARENT;

        {
      }
   }
}

com/hypixel/hytale/assetstore/event/AssetMonitorEvent.java

package com.hypixel.hytale.assetstore.event;

import com.hypixel.hytale.event.IEvent;
import java.nio.file.Path;
import java.util.List;
import javax.annotation.Nonnull;

public abstract class AssetMonitorEvent<T> implements IEvent<T> {
   @Nonnull
   private final List<Path> createdOrModifiedFilesToLoad;
   @Nonnull
   private final List<Path> removedFilesToUnload;
   @Nonnull
   private final List<Path> createdOrModifiedDirectories;
   @Nonnull
   private final List<Path> removedFilesAndDirectories;
   @Nonnull
   private final String assetPack;

   public AssetMonitorEvent(@Nonnull String assetPack, @Nonnull List<Path> createdOrModified, @Nonnull List<Path> removed, @Nonnull List<Path> createdDirectories, @Nonnull List<Path> removedDirectories) {
      this.assetPack = assetPack;
      this.createdOrModifiedFilesToLoad = createdOrModified;
      this.removedFilesToUnload = removed;
      this.createdOrModifiedDirectories = createdDirectories;
      this.removedFilesAndDirectories = removedDirectories;
   }

   @Nonnull
   public String  {
       .assetPack;
   }

   
    List<Path>  {
       .createdOrModifiedFilesToLoad;
   }

   
    List<Path>  {
       .removedFilesToUnload;
   }

   
    List<Path>  {
       .removedFilesAndDirectories;
   }

   
    List<Path>  {
       .createdOrModifiedDirectories;
   }
}

com/hypixel/hytale/assetstore/event/AssetStoreEvent.java

package com.hypixel.hytale.assetstore.event;

import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.event.IEvent;
import javax.annotation.Nonnull;

public abstract class AssetStoreEvent<KeyType> implements IEvent<KeyType> {
   @Nonnull
   private final AssetStore<?, ?, ?> assetStore;

   public AssetStoreEvent(@Nonnull AssetStore<?, ?, ?> assetStore) {
      this.assetStore = assetStore;
   }

   @Nonnull
   public AssetStore<?, ?, ?> getAssetStore() {
      return this.assetStore;
   }

   @Nonnull
   public String toString() {
      return "AssetStoreEvent{assetStore=" + String.valueOf(this.assetStore) + "}";
   }
}

com/hypixel/hytale/assetstore/event/AssetStoreMonitorEvent.java

package com.hypixel.hytale.assetstore.event;

import com.hypixel.hytale.assetstore.AssetStore;
import java.nio.file.Path;
import java.util.List;
import javax.annotation.Nonnull;

public class AssetStoreMonitorEvent extends AssetMonitorEvent<Void> {
   @Nonnull
   private final AssetStore<?, ?, ?> assetStore;

   public AssetStoreMonitorEvent(@Nonnull String assetPack, @Nonnull AssetStore<?, ?, ?> assetStore, @Nonnull List<Path> createdOrModified, @Nonnull List<Path> removed, @Nonnull List<Path> createdOrModifiedDirectories, @Nonnull List<Path> removedDirectories) {
      super(assetPack, createdOrModified, removed, createdOrModifiedDirectories, removedDirectories);
      this.assetStore = assetStore;
   }

   @Nonnull
   public AssetStore<?, ?, ?> getAssetStore() {
      return this.assetStore;
   }

   @Nonnull
   public String toString() {
      return "AssetMonitorEvent{assetStore=" + String.valueOf(this.assetStore) + "}";
   }
}

com/hypixel/hytale/assetstore/event/AssetsEvent.java

package com.hypixel.hytale.assetstore.event;

import com.hypixel.hytale.assetstore.JsonAsset;
import com.hypixel.hytale.event.IEvent;

public abstract class AssetsEvent<K, T extends JsonAsset<K>> implements IEvent<Class<T>> {
   public AssetsEvent() {
   }
}

com/hypixel/hytale/assetstore/event/GenerateAssetsEvent.java

package com.hypixel.hytale.assetstore.event;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetMap;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.common.util.FormatUtil;
import com.hypixel.hytale.event.IProcessedEvent;
import com.hypixel.hytale.logger.HytaleLogger;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import javax.annotation.Nonnull;

public class GenerateAssetsEvent<K, T extends JsonAssetWithMap<K, M>, M extends AssetMap<K, T>> extends AssetsEvent<K, T> implements IProcessedEvent {
   private final Class<T> tClass;
   private final M assetMap;
   @Nonnull
   private final Map<K, T> loadedAssets;
   private final Map<K, Set<K>> assetChildren;
   @Nonnull
   private final Map<K, T> unmodifiableLoadedAssets;
     Map<K, T> addedAssets =  ();
     Map<K, Set<K>> addedAssetChildren =  ();
     Map<Class<?  <?, ?>>, Map<?, Set<K>>> addedChildAssetsMap =  ();
     before;

     {
      .tClass = tClass;
      .assetMap = assetMap;
      .loadedAssets = loadedAssets;
      .assetChildren = assetChildren;
      .unmodifiableLoadedAssets = Collections.unmodifiableMap(loadedAssets);
      .before = System.nanoTime();
   }

    Class<T>  {
       .tClass;
   }

   
    Map<K, T>  {
       .unmodifiableLoadedAssets;
   }

    M  {
       .assetMap;
   }

      {
       (!.loadedAssets.containsKey(parent) && .assetMap.getAsset(parent) == ) {
           ( + String.valueOf(parent) + );
      }   (parent.equals(childKey)) {
           ( + String.valueOf(parent) + );
      }  {
         AssetStore<K, T, M> assetStore = AssetRegistry.<K, T, M>getAssetStore(.tClass);
         AssetExtraInfo<K> extraInfo =  <K>(assetStore.getCodec().getData(asset));
         assetStore.getCodec().validate(asset, extraInfo);
         extraInfo.getValidationResults().logOrThrowValidatorExceptions(assetStore.getLogger());
         .addedAssets.put(childKey, asset);
         ((Set).addedAssetChildren.computeIfAbsent(parent, (k) ->  ())).add(childKey);
      }
   }

   
       {
      (   ; i < parents.length; ++i) {
            (K)parents[i];
          (!.loadedAssets.containsKey(parent) && .assetMap.getAsset(parent) == ) {
              ( + i +  + String.valueOf(parent) + );
         }

          (parent.equals(childKey)) {
              ( + String.valueOf(parent) + );
         }
      }

      AssetStore<K, T, M> assetStore = AssetRegistry.<K, T, M>getAssetStore(.tClass);
      AssetExtraInfo<K> extraInfo =  <K>(assetStore.getCodec().getData(asset));
      assetStore.getCodec().validate(asset, extraInfo);
      extraInfo.getValidationResults().logOrThrowValidatorExceptions(assetStore.getLogger());
      .addedAssets.put(childKey, asset);

      (K parent : parents) {
         ((Set).addedAssetChildren.computeIfAbsent(parent, (k) ->  ())).add(childKey);
      }

   }

    <P  <PK, ?>, PK>   {
       (AssetRegistry.getAssetStore(parentAssetClass).getAssetMap().getAsset(parentKey) == ) {
            String.valueOf(parentKey);
           ( + var10002 +  + String.valueOf(parentAssetClass) + );
      }   (parentKey.equals(childKey)) {
           ( + String.valueOf(parentKey) + );
      }  {
         AssetStore<K, T, M> assetStore = AssetRegistry.<K, T, M>getAssetStore(.tClass);
         AssetExtraInfo<K> extraInfo =  <K>(assetStore.getCodec().getData(asset));
         assetStore.getCodec().validate(asset, extraInfo);
         extraInfo.getValidationResults().logOrThrowValidatorExceptions(assetStore.getLogger());
         .addedAssets.put(childKey, asset);
         ((Set)((Map).addedChildAssetsMap.computeIfAbsent(parentAssetClass, (k) ->  ())).computeIfAbsent(parentKey, (k) ->  ())).add(childKey);
      }
   }

      {
      (   ; i < parents.length; ++i) {
         ParentReference<?, ?> parent = parents[i];
          (AssetRegistry.getAssetStore(parent.getParentAssetClass()).getAssetMap().getAsset(parent.getParentKey()) == ) {
              ( + i +  + String.valueOf(parent) + );
         }

          (parent.parentKey.equals(childKey)) {
              ( + String.valueOf(parent.parentKey) + );
         }
      }

      AssetStore<K, T, M> assetStore = AssetRegistry.<K, T, M>getAssetStore(.tClass);
      AssetExtraInfo<K> extraInfo =  <K>(assetStore.getCodec().getData(asset));
      assetStore.getCodec().validate(asset, extraInfo);
      extraInfo.getValidationResults().logOrThrowValidatorExceptions(assetStore.getLogger());
      .addedAssets.put(childKey, asset);

      (ParentReference<?, ?> parent : parents) {
         ((Set)((Map).addedChildAssetsMap.computeIfAbsent(parent.parentAssetClass, (k) ->  ())).computeIfAbsent(parent.parentKey, (k) ->  ())).add(childKey);
      }

   }

      {
      HytaleLogger.getLogger().at(Level.INFO).log(, .addedAssets.size(), .tClass.getSimpleName(), hookName, FormatUtil.nanosToString(System.nanoTime() - .before));
      .loadedAssets.putAll(.addedAssets);
      .addedAssets.clear();

      (Map.Entry<K, Set<K>> entry : .addedAssetChildren.entrySet()) {
            (K)entry.getKey();
         ((Set).assetChildren.computeIfAbsent(parent, (kx) -> ConcurrentHashMap.newKeySet())).addAll((Collection)entry.getValue());
      }

      .addedAssetChildren.clear();

      (Map.Entry<Class<?  <?, ?>>, Map<?, Set<K>>> entry : .addedChildAssetsMap.entrySet()) {
            (Class)entry.getKey();
            AssetRegistry.getAssetStore(k);

         (Map.Entry<?, Set<K>> childEntry : ((Map)entry.getValue()).entrySet()) {
            assetStore.addChildAssetReferences(childEntry.getKey(), .tClass, (Set)childEntry.getValue());
         }
      }

      .addedChildAssetsMap.clear();
      .before = System.nanoTime();
   }

   
    String  {
         String.valueOf(.tClass);
        + var10000 +  + .loadedAssets.size() +  + .toString() + ;
   }

      <P  <PK, ?>, PK> {
        Class<P> parentAssetClass;
        PK parentKey;

        {
         .parentAssetClass = parentAssetClass;
         .parentKey = parentKey;
      }

       Class<P>  {
          .parentAssetClass;
      }

       PK  {
          .parentKey;
      }

      
       String  {
            String.valueOf(.parentAssetClass);
           + var10000 +  + String.valueOf(.parentKey) + ;
      }
   }
}

com/hypixel/hytale/assetstore/event/LoadedAssetsEvent.java

package com.hypixel.hytale.assetstore.event;

import com.hypixel.hytale.assetstore.AssetMap;
import com.hypixel.hytale.assetstore.AssetUpdateQuery;
import com.hypixel.hytale.assetstore.JsonAsset;
import java.util.Collections;
import java.util.Map;
import javax.annotation.Nonnull;

public class LoadedAssetsEvent<K, T extends JsonAsset<K>, M extends AssetMap<K, T>> extends AssetsEvent<K, T> {
   @Nonnull
   private final Class<T> tClass;
   @Nonnull
   private final M assetMap;
   @Nonnull
   private final Map<K, T> loadedAssets;
   private final boolean initial;
   @Nonnull
   private final AssetUpdateQuery query;

   public LoadedAssetsEvent(@Nonnull Class<T> tClass, @Nonnull M assetMap, @Nonnull Map<K, T> loadedAssets, boolean initial, @Nonnull AssetUpdateQuery query) {
      this.tClass = tClass;
      this.assetMap = assetMap;
      this.loadedAssets = Collections.unmodifiableMap(loadedAssets);
      this.initial = initial;
      .query = query;
   }

    Class<T>  {
       .tClass;
   }

    M  {
       .assetMap;
   }

   
    Map<K, T>  {
       .loadedAssets;
   }

      {
       .initial;
   }

   
    AssetUpdateQuery  {
       .query;
   }

   
    String  {
         String.valueOf(.loadedAssets);
        + var10000 +  + .initial +  + String.valueOf(.query) +  + .toString();
   }
}

com/hypixel/hytale/assetstore/event/RegisterAssetStoreEvent.java

package com.hypixel.hytale.assetstore.event;

import com.hypixel.hytale.assetstore.AssetStore;
import javax.annotation.Nonnull;

public class RegisterAssetStoreEvent extends AssetStoreEvent<Void> {
   public RegisterAssetStoreEvent(@Nonnull AssetStore<?, ?, ?> assetStore) {
      super(assetStore);
   }
}

com/hypixel/hytale/assetstore/event/RemoveAssetStoreEvent.java

package com.hypixel.hytale.assetstore.event;

import com.hypixel.hytale.assetstore.AssetStore;
import javax.annotation.Nonnull;

public class RemoveAssetStoreEvent extends AssetStoreEvent<Void> {
   public RemoveAssetStoreEvent(@Nonnull AssetStore<?, ?, ?> assetStore) {
      super(assetStore);
   }
}

com/hypixel/hytale/assetstore/event/RemovedAssetsEvent.java

package com.hypixel.hytale.assetstore.event;

import com.hypixel.hytale.assetstore.AssetMap;
import com.hypixel.hytale.assetstore.JsonAsset;
import java.util.Collections;
import java.util.Set;
import javax.annotation.Nonnull;

public class RemovedAssetsEvent<K, T extends JsonAsset<K>, M extends AssetMap<K, T>> extends AssetsEvent<K, T> {
   private final Class<T> tClass;
   private final M assetMap;
   @Nonnull
   private final Set<K> removedAssets;
   private final boolean replaced;

   public RemovedAssetsEvent(Class<T> tClass, M assetMap, @Nonnull Set<K> removedAssets, boolean replaced) {
      this.tClass = tClass;
      this.assetMap = assetMap;
      this.removedAssets = Collections.unmodifiableSet(removedAssets);
      this.replaced = replaced;
   }

   public Class<T> getAssetClass() {
      return this.tClass;
   }

   public M getAssetMap() {
      return this.assetMap;
   }

   
    Set<K>  {
       .removedAssets;
   }

      {
       .replaced;
   }

   
    String  {
         String.valueOf(.removedAssets);
        + var10000 +  + .replaced +  + .toString();
   }
}

com/hypixel/hytale/assetstore/iterator/AssetStoreIterator.java

package com.hypixel.hytale.assetstore.iterator;

import com.hypixel.hytale.assetstore.AssetMap;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.JsonAsset;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import java.io.Closeable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class AssetStoreIterator implements Iterator<AssetStore<?, ?, ?>>, Closeable {
   @Nonnull
   private final List<AssetStore<?, ?, ?>> list;

   public AssetStoreIterator(@Nonnull Collection<AssetStore<?, ?, ?>> values) {
      this.list = new ArrayList(values);
   }

   public boolean hasNext() {
      return !this.list.isEmpty();
   }

   @Nullable
   public AssetStore<?, ?, ?> next() {
      Iterator<AssetStore<?, ?, ?>> iterator = this.list.iterator();

      while(iterator.hasNext()) {
         AssetStore<?, ? extends JsonAssetWithMap<?, ?  <?, ?>>, ?  <?, ?  <?, ?>>> assetStore = (AssetStore)iterator.next();
          (!.isWaitingForDependencies(assetStore)) {
            iterator.remove();
             assetStore;
         }
      }

       ;
   }

      {
       .list.size();
   }

      {
      (Class<?  <?>> aClass : assetStore.getLoadsAfter()) {
            AssetRegistry.getAssetStore(aClass);
          (otherStore == ) {
              ( + String.valueOf(aClass));
         }

          (.list.contains(otherStore)) {
             ;
         }
      }

       ;
   }

      {
      Class<?  <?, ?  <?, ?>>> assetClass = assetStore.getAssetClass();

      (AssetStore<?, ?, ?> store : .list) {
          (store.getLoadsAfter().contains(assetClass)) {
             ;
         }
      }

       ;
   }

      {
   }
}

com/hypixel/hytale/assetstore/iterator/CircularDependencyException.java

package com.hypixel.hytale.assetstore.iterator;

import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.JsonAsset;
import java.util.Collection;
import javax.annotation.Nonnull;

public class CircularDependencyException extends RuntimeException {
   public CircularDependencyException(@Nonnull Collection<AssetStore<?, ?, ?>> values, @Nonnull AssetStoreIterator iterator) {
      super(makeMessage(values, iterator));
   }

   @Nonnull
   protected static String makeMessage(@Nonnull Collection<AssetStore<?, ?, ?>> values, @Nonnull AssetStoreIterator iterator) {
      String var10002 = String.valueOf(values);
      StringBuilder sb = new StringBuilder("Failed to process any stores there must be a circular dependency! " + var10002 + ", " + iterator.size() + "\nWaiting for Asset Stores:\n");

      for(AssetStore<?, ?, ?> store : values) {
         if (iterator.isWaitingForDependencies(store)) {
            sb.append(store.getAssetClass()).append("\n");

            for(Class<? extends <?>> aClass : store.getLoadsAfter()) {
                  AssetRegistry.getAssetStore(aClass);
                (otherStore == ) {
                    ( + String.valueOf(aClass));
               }

                (iterator.isWaitingForDependencies(otherStore)) {
                  sb.append().append(otherStore.getAssetClass()).append();
               }
            }
         }
      }

       sb.toString();
   }
}

com/hypixel/hytale/assetstore/map/AssetMapWithIndexes.java

package com.hypixel.hytale.assetstore.map;

import com.hypixel.fastutil.ints.Int2ObjectConcurrentHashMap;
import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.JsonAsset;
import com.hypixel.hytale.assetstore.codec.AssetCodec;
import it.unimi.dsi.fastutil.ints.IntIterator;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.ints.IntSets;
import java.util.Map;
import javax.annotation.Nonnull;

public abstract class AssetMapWithIndexes<K, T extends JsonAsset<K>> extends DefaultAssetMap<K, T> {
   public static final int NOT_FOUND = -2147483648;
   protected final Int2ObjectConcurrentHashMap<IntSet> indexedTagStorage = new Int2ObjectConcurrentHashMap<IntSet>();
   protected final Int2ObjectConcurrentHashMap<IntSet> unmodifiableIndexedTagStorage = new Int2ObjectConcurrentHashMap<IntSet>();

   public AssetMapWithIndexes() {
   }

   protected void clear() {
      super.clear();
      this.indexedTagStorage.clear();
      .unmodifiableIndexedTagStorage.clear();
   }

    IntSet  {
       .unmodifiableIndexedTagStorage.getOrDefault(index, IntSets.EMPTY_SET);
   }

      {
   }

      {
      AssetExtraInfo.   codec.getData(value);
       (data != ) {
            data.getExpandedTagIndexes().iterator();

         (iterator.hasNext()) {
               iterator.nextInt();
            .putAssetTag(key, index, tag);
         }

      }
   }

      {
      .putAssetTag(key, tag);
      ((IntSet).indexedTagStorage.computeIfAbsent(tag, (k) -> {
            Int2ObjectConcurrentHashMap.newKeySet();
         .unmodifiableIndexedTagStorage.put(k, IntSets.unmodifiable(set));
          set;
      })).add(index);
   }

      {
       ;
   }
}

com/hypixel/hytale/assetstore/map/BlockTypeAssetMap.java

package com.hypixel.hytale.assetstore.map;

import com.hypixel.hytale.assetstore.codec.AssetCodec;
import it.unimi.dsi.fastutil.objects.Object2IntMap;
import it.unimi.dsi.fastutil.objects.Object2IntOpenCustomHashMap;
import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenCustomHashMap;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.objects.ObjectSets;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.StampedLock;
import java.util.function.Function;
import java.util.function.IntFunction;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class BlockTypeAssetMap<K, T extends JsonAssetWithMap<K, BlockTypeAssetMap<K, T>>> extends AssetMapWithIndexes<K, T> {
   private final AtomicInteger nextIndex = new AtomicInteger();
   private final StampedLock keyToIndexLock = new StampedLock();
     Object2IntMap<K> keyToIndex =  <K>(CaseInsensitiveHashStrategy.getInstance());
   
     IntFunction<T[]> arrayProvider;
         ();
    T[] array;
     Map<K, ObjectSet<K>> subKeyMap =  <K, ObjectSet<K>>(CaseInsensitiveHashStrategy.getInstance());
   
   
     Function<T, String> groupGetter;
   
   
     Object2IntMap<String> groupMap =  <String>();

     {
      .arrayProvider = arrayProvider;
      .groupGetter = groupGetter;
      .array = (JsonAssetWithMap[])arrayProvider.apply();
      .keyToIndex.defaultReturnValue(-);
   }

      {
         .keyToIndexLock.tryOptimisticRead();
         .keyToIndex.getInt(key);
       (.keyToIndexLock.validate(stamp)) {
          value;
      }  {
         stamp = .keyToIndexLock.readLock();

          var5;
          {
            var5 = .keyToIndex.getInt(key);
         }  {
            .keyToIndexLock.unlockRead(stamp);
         }

          var5;
      }
   }

      {
         .keyToIndexLock.tryOptimisticRead();
         .keyToIndex.getOrDefault(key, def);
       (.keyToIndexLock.validate(stamp)) {
          value;
      }  {
         stamp = .keyToIndexLock.readLock();

          var6;
          {
            var6 = .keyToIndex.getOrDefault(key, def);
         }  {
            .keyToIndexLock.unlockRead(stamp);
         }

          var6;
      }
   }

      {
      .arrayLock.lock();

       var1;
       {
         var1 = .array.length;
      }  {
         .arrayLock.unlock();
      }

       var1;
   }

   
    T  {
       (T)(index >=  && index < .array.length ? .array[index] : );
   }

    T  {
       (T)(index >=  && index < .array.length ? .array[index] : def);
   }

   
    ObjectSet<K>  {
      ObjectSet<K> subKeySet = (ObjectSet).subKeyMap.get(key);
       subKeySet !=  ? ObjectSets.unmodifiable(subKeySet) : ObjectSets.singleton(key);
   }

      {
       .groupMap.getInt(group);
   }

   
    String[] getGroups() {
       (String[]).groupMap.keySet().toArray((x$) ->  [x$]);
   }

      {
      .clear();
         .keyToIndexLock.writeLock();
      .arrayLock.lock();

       {
         .keyToIndex.clear();
         .array = (JsonAssetWithMap[]).arrayProvider.apply();
      }  {
         .arrayLock.unlock();
         .keyToIndexLock.unlockWrite(stamp);
      }

   }

      {
      .putAll(packKey, codec, loadedAssets, loadedKeyToPathMap, loadedAssetChildren);
      .putAll0(codec, loadedAssets);
   }

      {
         .keyToIndexLock.writeLock();
      .arrayLock.lock();

       {
            ;

         (K key : loadedAssets.keySet()) {
               .keyToIndex.getInt(key);
             (index == -) {
               .keyToIndex.put(key, index = .nextIndex.getAndIncrement());
            }

             (index < ) {
                 ();
            }

             (index > highestIndex) {
               highestIndex = index;
            }
         }

            highestIndex + ;
          (length < ) {
              ();
         }

          (length > .array.length) {
            T[] newArray = (JsonAssetWithMap[]).arrayProvider.apply(length);
            System.arraycopy(.array, , newArray, , .array.length);
            .array = newArray;
         }

         (Map.Entry<K, T> entry : loadedAssets.entrySet()) {
               (K)entry.getKey();
               .keyToIndex.getInt(key);
             (index < ) {
                 ();
            }

               (T)(entry.getValue());
            .array[index] = value;
            ObjectSet<K> subKeySet = (ObjectSet).subKeyMap.get(key);
             (subKeySet != ) {
               subKeySet.add(key);
            }

               (String).groupGetter.apply(value);
             (!.groupMap.containsKey(group)) {
                  .groupMap.size();
               .groupMap.put(group, groupIndex);
            }

            .putAssetTag(codec, key, index, value);
         }
      }  {
         .arrayLock.unlock();
         .keyToIndexLock.unlockWrite(stamp);
      }

   }

    Set<K>  {
      Set<K> remove = .remove(keys);
      .remove0(keys);
       remove;
   }

    Set<K>  {
      Set<K> remove = .remove(packKey, keys, pathsToReload);
      .remove0(keys);
       remove;
   }

      {
         .keyToIndexLock.writeLock();
      .arrayLock.lock();

       {
         (K key : keys) {
               .keyToIndex.getInt(key);
             (blockId != -) {
               .array[blockId] = ;
               .indexedTagStorage.forEachWithInt((_k, value, id) -> value.remove(id), blockId);
            }

            ObjectSet<K> subKeySet = (ObjectSet).subKeyMap.get(key);
             (subKeySet != ) {
               subKeySet.remove(key);
            }
         }

          i;
         (i = .array.length - ; i >  && .array[i] == ; --i) {
         }

            i + ;
          (length != .array.length) {
            T[] newArray = (JsonAssetWithMap[]).arrayProvider.apply(length);
            System.arraycopy(.array, , newArray, , newArray.length);
            .array = newArray;
         }
      }  {
         .arrayLock.unlock();
         .keyToIndexLock.unlockWrite(stamp);
      }

   }
}

com/hypixel/hytale/assetstore/map/CaseInsensitiveHashStrategy.java

package com.hypixel.hytale.assetstore.map;

import it.unimi.dsi.fastutil.Hash;

public class CaseInsensitiveHashStrategy<K> implements Hash.Strategy<K> {
   private static final CaseInsensitiveHashStrategy INSTANCE = new CaseInsensitiveHashStrategy();

   public CaseInsensitiveHashStrategy() {
   }

   public static <K> CaseInsensitiveHashStrategy<K> getInstance() {
      return INSTANCE;
   }

   public int hashCode(K key) {
      if (key == null) {
         return 0;
      } else if (!(key instanceof String)) {
         return key.hashCode();
      } else {
         String s = (String)key;
         int hash = 0;

         for(int i = 0; i < s.length(); ++i) {
            hash =  * hash + Character.toLowerCase(s.charAt(i));
         }

          hash;
      }
   }

      {
       (a == b) {
          ;
      }   (a !=  && b != ) {
          (a  String) {
               (String)a;
             (b  String) {
                  (String)b;
                sa.equalsIgnoreCase(sb);
            }
         }

          a.equals(b);
      }  {
          ;
      }
   }
}

com/hypixel/hytale/assetstore/map/DefaultAssetMap.java

package com.hypixel.hytale.assetstore.map;

import com.hypixel.fastutil.ints.Int2ObjectConcurrentHashMap;
import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetMap;
import com.hypixel.hytale.assetstore.JsonAsset;
import com.hypixel.hytale.assetstore.codec.AssetCodec;
import it.unimi.dsi.fastutil.ints.IntIterator;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.ints.IntSets;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenCustomHashMap;
import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.objects.ObjectSets;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.StampedLock;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class DefaultAssetMap<K, T extends JsonAsset<K>> extends AssetMap<K, T> {
   public   AssetRef[] EMPTY_PAIR_ARRAY =  [];
         ;
         ();
   
     Map<K, T> assetMap;
     Map<K, AssetRef<T>[]> assetChainMap;
     Map<String, ObjectSet<K>> packAssetKeys =  ();
     Map<Path, ObjectSet<K>> pathToKeyMap =  ();
     Map<K, ObjectSet<K>> assetChildren;
     Int2ObjectConcurrentHashMap<Set<K>> tagStorage =  <Set<K>>();
     Int2ObjectConcurrentHashMap<Set<K>> unmodifiableTagStorage =  <Set<K>>();
     IntSet unmodifiableTagKeys;

     {
      .unmodifiableTagKeys = IntSets.unmodifiable(.tagStorage.keySet());
      .assetMap =  <K, T>(CaseInsensitiveHashStrategy.getInstance());
      .assetChainMap =  <K, AssetRef<T>[]>(CaseInsensitiveHashStrategy.getInstance());
      .assetChildren =  <K, ObjectSet<K>>(CaseInsensitiveHashStrategy.getInstance());
   }

     {
      .unmodifiableTagKeys = IntSets.unmodifiable(.tagStorage.keySet());
      .assetMap = assetMap;
      .assetChainMap =  <K, AssetRef<T>[]>(CaseInsensitiveHashStrategy.getInstance());
      .assetChildren =  <K, ObjectSet<K>>(CaseInsensitiveHashStrategy.getInstance());
   }

   
    T  {
         .assetMapLock.tryOptimisticRead();
         (T)(.assetMap.get(key));
       (.assetMapLock.validate(stamp)) {
          value;
      }  {
         stamp = .assetMapLock.readLock();

         JsonAsset var5;
          {
            var5 = (JsonAsset).assetMap.get(key);
         }  {
            .assetMapLock.unlockRead(stamp);
         }

          (T)var5;
      }
   }

   
    T  {
         .assetMapLock.tryOptimisticRead();
         .getAssetForPack0(packKey, key);
       (.assetMapLock.validate(stamp)) {
          result;
      }  {
         stamp = .assetMapLock.readLock();

         JsonAsset var6;
          {
            var6 = .getAssetForPack0(packKey, key);
         }  {
            .assetMapLock.unlockRead(stamp);
         }

          (T)var6;
      }
   }

    T  {
      AssetRef<T>[] chain = (AssetRef[]).assetChainMap.get(key);
       (chain == ) {
          ;
      }  {
         (   ; i < chain.length; ++i) {
            AssetRef<T> pair = chain[i];
             (Objects.equals(pair.pack, packKey)) {
                (i == ) {
                   ;
               }

                chain[i - ].value;
            }
         }

          (T)(.assetMap.get(key));
      }
   }

   
    Path  {
         .assetMapLock.tryOptimisticRead();
         .getPath0(key);
       (.assetMapLock.validate(stamp)) {
          result;
      }  {
         stamp = .assetMapLock.readLock();

         Path var5;
          {
            var5 = .getPath0(key);
         }  {
            .assetMapLock.unlockRead(stamp);
         }

          var5;
      }
   }

   
    String  {
         .assetMapLock.tryOptimisticRead();
         .getAssetPack0(key);
       (.assetMapLock.validate(stamp)) {
          result;
      }  {
         stamp = .assetMapLock.readLock();

         String var5;
          {
            var5 = .getAssetPack0(key);
         }  {
            .assetMapLock.unlockRead(stamp);
         }

          var5;
      }
   }

   
    Path  {
      AssetRef<T> result = .getAssetRef(key);
       result !=  ? result.path : ;
   }

   
    String  {
      AssetRef<T> result = .getAssetRef(key);
       result !=  ? result.pack : ;
   }

   
    AssetRef<T>  {
      AssetRef<T>[] chain = (AssetRef[]).assetChainMap.get(key);
       chain ==  ?  : chain[chain.length - ];
   }

    Set<K>  {
      ObjectSet<K> set = (ObjectSet).pathToKeyMap.get(path);
       set ==  ? ObjectSets.emptySet() : ObjectSets.unmodifiable(set);
   }

    Set<K>  {
         .assetMapLock.tryOptimisticRead();
      ObjectSet<K> children = (ObjectSet).assetChildren.get(key);
      Set<K> result = children ==  ? ObjectSets.emptySet() : ObjectSets.unmodifiable(children);
       (.assetMapLock.validate(stamp)) {
          result;
      }  {
         stamp = .assetMapLock.readLock();

         ObjectSet var6;
          {
            children = (ObjectSet).assetChildren.get(key);
            var6 = children ==  ? ObjectSets.emptySet() : ObjectSets.unmodifiable(children);
         }  {
            .assetMapLock.unlockRead(stamp);
         }

          var6;
      }
   }

      {
       .assetMap.size();
   }

   
    Map<K, T>  {
       Collections.unmodifiableMap(.assetMap);
   }

   
    Map<K, Path>  {
         .assetMapLock.readLock();

      Map var4;
       {
         var4 = (Map).assetChainMap.entrySet().stream().map((e) -> Map.entry(e.getKey(), Arrays.stream((AssetRef[])e.getValue()).filter((v) -> Objects.equals(v.pack, packKey)).findFirst())).filter((e) -> ((Optional)e.getValue()).isPresent()).filter((e) -> ((AssetRef)((Optional)e.getValue()).get()).path != ).collect(Collectors.toMap(Map.Entry::getKey, (e) -> ((AssetRef)((Optional)e.getValue()).get()).path));
      }  {
         .assetMapLock.unlockRead(stamp);
      }

       var4;
   }

    Set<K>  {
       .unmodifiableTagStorage.getOrDefault(tagIndex, ObjectSets.emptySet());
   }

   
    IntSet  {
       .unmodifiableTagKeys;
   }

      {
       .tagStorage.size();
   }

      {
         .assetMapLock.writeLock();

       {
         .assetChildren.clear();
         .assetChainMap.clear();
         .pathToKeyMap.clear();
         .assetMap.clear();
         .tagStorage.clear();
         .unmodifiableTagStorage.clear();
      }  {
         .assetMapLock.unlockWrite(stamp);
      }

   }

      {
         .assetMapLock.writeLock();

       {
         (Map.Entry<K, Set<K>> entry : loadedAssetChildren.entrySet()) {
            ((ObjectSet).assetChildren.computeIfAbsent(entry.getKey(), (k) ->  ())).addAll((Collection)entry.getValue());
         }

         (Map.Entry<K, Path> entry : loadedKeyToPathMap.entrySet()) {
            ((ObjectSet).pathToKeyMap.computeIfAbsent((Path)entry.getValue(), (k) ->  ())).add(entry.getKey());
         }

         (Map.Entry<K, T> e : loadedAssets.entrySet()) {
               (K)e.getKey();
            ((ObjectSet).packAssetKeys.computeIfAbsent(packKey, (v) ->  ())).add(key);
            AssetRef<T>[] chain = (AssetRef[]).assetChainMap.get(key);
             (chain == ) {
               chain = EMPTY_PAIR_ARRAY;
            }

               ;

            (AssetRef<T> pair : chain) {
                (Objects.equals(pair.pack, packKey)) {
                  pair.value = (T)e.getValue();
                  found = ;
                  ;
               }
            }

             (!found) {
               chain = (AssetRef[])Arrays.copyOf(chain, chain.length + );
               chain[chain.length - ] =  (packKey, (Path)loadedKeyToPathMap.get(e.getKey()), (JsonAsset)e.getValue());
               .assetChainMap.put(key, chain);
            }

               chain[chain.length - ].value;
            .assetMap.put(key, finalVal);
         }
      }  {
         .assetMapLock.unlockWrite(stamp);
      }

      .putAssetTags(codec, loadedAssets);
   }

      {
      (Map.Entry<K, T> entry : loadedAssets.entrySet()) {
         AssetExtraInfo.   codec.getData((JsonAsset)entry.getValue());
          (data != ) {
               (K)entry.getKey();
               data.getExpandedTagIndexes().iterator();

            (iterator.hasNext()) {
                  iterator.nextInt();
               .putAssetTag(key, tag);
            }
         }
      }

   }

      {
      ((Set).tagStorage.computeIfAbsent(tag, (k) -> {
         ObjectOpenHashSet<K> set =  <K>();
         .unmodifiableTagStorage.put(k, ObjectSets.unmodifiable(set));
          set;
      })).add(key);
   }

    Set<K>  {
       (Set).packAssetKeys.get(name);
   }

    Set<K>  {
         .assetMapLock.writeLock();

      Object var16;
       {
         Set<K> children =  ();

         (K key : keys) {
            AssetRef<T>[] chain = (AssetRef[]).assetChainMap.remove(key);
             (chain != ) {
               AssetRef<T> info = chain[chain.length - ];
                (info.path != ) {
                  .pathToKeyMap.computeIfPresent(info.path, (p, list) -> {
                     list.remove(key);
                      list.isEmpty() ?  : list;
                  });
               }

               .assetMap.remove(key);

               (AssetRef<T> c : chain) {
                  ((ObjectSet).packAssetKeys.get(Objects.requireNonNullElse(c.pack, ))).remove(key);
               }

               (ObjectSet<K> child : .assetChildren.values()) {
                  child.remove(key);
               }

               ObjectSet<K> child = (ObjectSet).assetChildren.remove(key);
                (child != ) {
                  children.addAll(child);
               }
            }
         }

         .tagStorage.forEach((_k, value, removedKeys) -> value.removeAll(removedKeys), keys);
         children.removeAll(keys);
         var16 = children;
      }  {
         .assetMapLock.unlockWrite(stamp);
      }

       (Set<K>)var16;
   }

    Set<K>  {
         .assetMapLock.writeLock();

      Set var8;
       {
         Set<K> children =  ();
         ObjectSet<K> packKeys = (ObjectSet).packAssetKeys.get(Objects.requireNonNullElse(packKey, ));
          (packKeys != ) {
            Iterator<K> iterator = keys.iterator();

            (iterator.hasNext()) {
                  (K)iterator.next();
               packKeys.remove(key);
               AssetRef<T>[] chain = (AssetRef[]).assetChainMap.remove(key);
                (chain.length == ) {
                  AssetRef<T> info = chain[];
                   (!Objects.equals(info.pack, packKey)) {
                     iterator.remove();
                     .assetChainMap.put(key, chain);
                  }  {
                      (info.path != ) {
                        .pathToKeyMap.computeIfPresent(info.path, (p, list) -> {
                           list.remove(key);
                            list.isEmpty() ?  : list;
                        });
                     }

                     .assetMap.remove(key);

                     (ObjectSet<K> child : .assetChildren.values()) {
                        child.remove(key);
                     }

                     ObjectSet<K> child = (ObjectSet).assetChildren.remove(key);
                      (child != ) {
                        children.addAll(child);
                     }
                  }
               }  {
                  iterator.remove();
                  AssetRef<T>[] newChain =  [chain.length - ];
                     ;

                  (   ; i < chain.length; ++i) {
                     AssetRef<T> pair = chain[i];
                      (Objects.equals(pair.pack, packKey)) {
                         (pair.path != ) {
                           .pathToKeyMap.computeIfPresent(pair.path, (p, list) -> {
                              list.remove(key);
                               list.isEmpty() ?  : list;
                           });
                        }
                     }  {
                        newChain[offset++] = pair;
                         (pair.path != ) {
                           pathsToReload.add(Map.entry(pair.pack, pair.path));
                        }  {
                           pathsToReload.add(Map.entry(pair.pack, pair.value));
                        }
                     }
                  }

                  .assetChainMap.put(key, newChain);
                  AssetRef<T> newAsset = newChain[newChain.length - ];
                  .assetMap.put(key, newAsset.value);
                   (newAsset.path != ) {
                     ((ObjectSet).pathToKeyMap.computeIfAbsent(newAsset.path, (k) ->  ())).add(key);
                  }
               }
            }

            .tagStorage.forEach((_k, value, removedKeys) -> value.removeAll(removedKeys), keys);
            children.removeAll(keys);
               children;
             (Set<K>)var19;
         }

         var8 = Collections.emptySet();
      }  {
         .assetMapLock.unlockWrite(stamp);
      }

       var8;
   }

      <T> {
        String pack;
        Path path;
       T value;

        {
         .pack = pack;
         .path = path;
         .value = value;
      }
   }
}

com/hypixel/hytale/assetstore/map/IndexedAssetMap.java

package com.hypixel.hytale.assetstore.map;

import com.hypixel.hytale.assetstore.codec.AssetCodec;
import it.unimi.dsi.fastutil.objects.Object2IntMap;
import it.unimi.dsi.fastutil.objects.Object2IntOpenCustomHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.StampedLock;
import javax.annotation.Nonnull;

public class IndexedAssetMap<K, T extends JsonAssetWithMap<K, IndexedAssetMap<K, T>>> extends AssetMapWithIndexes<K, T> {
   private final AtomicInteger nextIndex = new AtomicInteger();
   private final StampedLock keyToIndexLock = new StampedLock();
   private final Object2IntMap<K> keyToIndex = new Object2IntOpenCustomHashMap<K>(CaseInsensitiveHashStrategy.getInstance());

   public IndexedAssetMap() {
      this.keyToIndex.defaultReturnValue(-2147483648);
   }

   public int  {
         .keyToIndexLock.tryOptimisticRead();
         .keyToIndex.getInt(key);
       (.keyToIndexLock.validate(stamp)) {
          value;
      }  {
         stamp = .keyToIndexLock.readLock();

          var5;
          {
            var5 = .keyToIndex.getInt(key);
         }  {
            .keyToIndexLock.unlockRead(stamp);
         }

          var5;
      }
   }

      {
         .keyToIndexLock.tryOptimisticRead();
         .keyToIndex.getOrDefault(key, def);
       (.keyToIndexLock.validate(stamp)) {
          value;
      }  {
         stamp = .keyToIndexLock.readLock();

          var6;
          {
            var6 = .keyToIndex.getOrDefault(key, def);
         }  {
            .keyToIndexLock.unlockRead(stamp);
         }

          var6;
      }
   }

      {
       .nextIndex.get();
   }

      {
      .clear();
         .keyToIndexLock.writeLock();

       {
         .keyToIndex.clear();
      }  {
         .keyToIndexLock.unlockWrite(stamp);
      }

   }

      {
      .putAll(packKey, codec, loadedAssets, loadedKeyToPathMap, loadedAssetChildren);
         .keyToIndexLock.writeLock();

       {
         (Map.Entry<K, T> entry : loadedAssets.entrySet()) {
               (K)entry.getKey();
             index;
             ((index = .keyToIndex.getInt(key)) == -) {
               .keyToIndex.put(key, index = .nextIndex.getAndIncrement());
            }

               (T)(entry.getValue());
            .putAssetTag(codec, key, index, value);
         }
      }  {
         .keyToIndexLock.unlockWrite(stamp);
      }

   }

    Set<K>  {
      Set<K> remove = .remove(keys);
      .remove0(keys);
       remove;
   }

    Set<K>  {
      Set<K> remove = .remove(packKey, keys, pathsToReload);
      .remove0(keys);
       remove;
   }

      {
         .keyToIndexLock.writeLock();

       {
         (K key : keys) {
               .keyToIndex.removeInt(key);
            .indexedTagStorage.forEachWithInt((_k, value, idx) -> value.remove(idx), index);
         }
      }  {
         .keyToIndexLock.unlockWrite(stamp);
      }

   }
}

com/hypixel/hytale/assetstore/map/IndexedLookupTableAssetMap.java

package com.hypixel.hytale.assetstore.map;

import com.hypixel.hytale.assetstore.codec.AssetCodec;
import it.unimi.dsi.fastutil.objects.Object2IntMap;
import it.unimi.dsi.fastutil.objects.Object2IntOpenCustomHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.StampedLock;
import java.util.function.IntFunction;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class IndexedLookupTableAssetMap<K, T extends JsonAssetWithMap<K, IndexedLookupTableAssetMap<K, T>>> extends AssetMapWithIndexes<K, T> {
   private final AtomicInteger nextIndex = new AtomicInteger();
   private final StampedLock keyToIndexLock = new StampedLock();
   private final Object2IntMap<K> keyToIndex = new Object2IntOpenCustomHashMap<K>(CaseInsensitiveHashStrategy.getInstance());
   @Nonnull
   private final IntFunction<T[]> arrayProvider;
         ();
    T[] array;

     {
      .arrayProvider = arrayProvider;
      .array = (JsonAssetWithMap[])arrayProvider.apply();
      .keyToIndex.defaultReturnValue(-);
   }

      {
         .keyToIndexLock.tryOptimisticRead();
         .keyToIndex.getInt(key);
       (.keyToIndexLock.validate(stamp)) {
          value;
      }  {
         stamp = .keyToIndexLock.readLock();

          var5;
          {
            var5 = .keyToIndex.getInt(key);
         }  {
            .keyToIndexLock.unlockRead(stamp);
         }

          var5;
      }
   }

      {
         .keyToIndexLock.tryOptimisticRead();
         .keyToIndex.getOrDefault(key, def);
       (.keyToIndexLock.validate(stamp)) {
          value;
      }  {
         stamp = .keyToIndexLock.readLock();

          var6;
          {
            var6 = .keyToIndex.getOrDefault(key, def);
         }  {
            .keyToIndexLock.unlockRead(stamp);
         }

          var6;
      }
   }

      {
       .nextIndex.get();
   }

   
    T  {
       (T)(index >=  && index < .array.length ? .array[index] : );
   }

    T  {
       (T)(index >=  && index < .array.length ? .array[index] : def);
   }

      {
      .clear();
         .keyToIndexLock.writeLock();
      .arrayLock.lock();

       {
         .keyToIndex.clear();
         .array = (JsonAssetWithMap[]).arrayProvider.apply();
      }  {
         .arrayLock.unlock();
         .keyToIndexLock.unlockWrite(stamp);
      }

   }

      {
      .putAll(packKey, codec, loadedAssets, loadedKeyToPathMap, loadedAssetChildren);
      .putAll0(codec, loadedAssets);
   }

      {
         .keyToIndexLock.writeLock();
      .arrayLock.lock();

       {
            ;

         (K key : loadedAssets.keySet()) {
               .keyToIndex.getInt(key);
             (index == -) {
               .keyToIndex.put(key, index = .nextIndex.getAndIncrement());
            }

             (index < ) {
                 ();
            }

             (index > highestIndex) {
               highestIndex = index;
            }
         }

            highestIndex + ;
          (length < ) {
              ();
         }

          (length > .array.length) {
            T[] newArray = (JsonAssetWithMap[]).arrayProvider.apply(length);
            System.arraycopy(.array, , newArray, , .array.length);
            .array = newArray;
         }

         (Map.Entry<K, T> entry : loadedAssets.entrySet()) {
               (K)entry.getKey();
               .keyToIndex.getInt(key);
             (index < ) {
                 ();
            }

               (T)(entry.getValue());
            .array[index] = value;
            .putAssetTag(codec, key, index, value);
         }
      }  {
         .arrayLock.unlock();
         .keyToIndexLock.unlockWrite(stamp);
      }

   }

    Set<K>  {
      Set<K> remove = .remove(keys);
      .remove0(keys);
       remove;
   }

    Set<K>  {
      Set<K> remove = .remove(packKey, keys, pathsToReload);
      .remove0(keys);
       remove;
   }

      {
         .keyToIndexLock.writeLock();
      .arrayLock.lock();

       {
         (K key : keys) {
               .keyToIndex.getInt(key);
             (blockId != -) {
               .array[blockId] = ;
               .indexedTagStorage.forEachWithInt((_k, value, id) -> value.remove(id), blockId);
            }
         }

          i;
         (i = .array.length - ; i >  && .array[i] == ; --i) {
         }

            i + ;
          (length != .array.length) {
            T[] newArray = (JsonAssetWithMap[]).arrayProvider.apply(length);
            System.arraycopy(.array, , newArray, , newArray.length);
            .array = newArray;
         }
      }  {
         .arrayLock.unlock();
         .keyToIndexLock.unlockWrite(stamp);
      }

   }
}

com/hypixel/hytale/assetstore/map/JsonAssetWithMap.java

package com.hypixel.hytale.assetstore.map;

import com.hypixel.hytale.assetstore.AssetMap;
import com.hypixel.hytale.assetstore.JsonAsset;

public interface JsonAssetWithMap<K, M extends AssetMap<K, ?>> extends JsonAsset<K> {
}

com/hypixel/hytale/assetstore/map/LookupTableAssetMap.java

package com.hypixel.hytale.assetstore.map;

import com.hypixel.hytale.assetstore.codec.AssetCodec;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.IntFunction;
import java.util.function.IntSupplier;
import java.util.function.ToIntFunction;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class LookupTableAssetMap<K, T extends JsonAssetWithMap<K, LookupTableAssetMap<K, T>>> extends AssetMapWithIndexes<K, T> {
   @Nonnull
   private final IntFunction<T[]> arrayProvider;
   private final ToIntFunction<K> indexGetter;
   private final IntSupplier maxIndexGetter;
   private final ReentrantLock arrayLock = new ReentrantLock();
   private T[] array;

   public LookupTableAssetMap(@Nonnull IntFunction<T[]> arrayProvider, ToIntFunction<K> indexGetter, IntSupplier maxIndexGetter) {
      this.arrayProvider = arrayProvider;
      this.indexGetter = indexGetter;
      this.maxIndexGetter = maxIndexGetter;
      .array = (JsonAssetWithMap[])arrayProvider.apply();
   }

   
    T  {
       (T)(index >=  && index < .array.length ? .array[index] : );
   }

    T  {
       (T)(index >=  && index < .array.length ? .array[index] : def);
   }

      {
      .clear();
      .arrayLock.lock();

       {
         .array = (JsonAssetWithMap[]).arrayProvider.apply();
      }  {
         .arrayLock.unlock();
      }

   }

      {
      .putAll(packKey, codec, loadedAssets, loadedKeyToPathMap, loadedAssetChildren);
      .arrayLock.lock();

       {
         .resize();

         (Map.Entry<K, T> entry : loadedAssets.entrySet()) {
               (K)entry.getKey();
               .indexGetter.applyAsInt(key);
             (index < ) {
                 ();
            }

             (index >= .array.length) {
                 ();
            }

               (T)(entry.getValue());
            .array[index] = value;
            .putAssetTag(codec, key, index, value);
         }
      }  {
         .arrayLock.unlock();
      }

   }

    Set<K>  {
      Set<K> remove = .remove(keys);
      .remove0(keys);
       remove;
   }

    Set<K>  {
      Set<K> remove = .remove(packKey, keys, pathsToReload);
      .remove0(keys);
       remove;
   }

      {
      .arrayLock.lock();

       {
         (K key : keys) {
               .indexGetter.applyAsInt(key);
             (blockId != -) {
               .array[blockId] = ;
               .indexedTagStorage.forEachWithInt((_k, value, id) -> value.remove(id), blockId);
            }
         }

         .resize();
      }  {
         .arrayLock.unlock();
      }

   }

      {
         .maxIndexGetter.getAsInt();
       (length < ) {
           ();
      }  {
          (length > .array.length) {
            T[] newArray = (JsonAssetWithMap[]).arrayProvider.apply(length);
            System.arraycopy(.array, , newArray, , .array.length);
            .array = newArray;
         }   (length < .array.length) {
            (   length; i < .array.length; ++i) {
                (.array[i] != ) {
                    ();
               }
            }

            T[] newArray = (JsonAssetWithMap[]).arrayProvider.apply(length);
            System.arraycopy(.array, , newArray, , newArray.length);
            .array = newArray;
         }

      }
   }

      {
       ;
   }
}

com/hypixel/hytale/assetstore/map/ProvidedIndexAssetMap.java

package com.hypixel.hytale.assetstore.map;

import com.hypixel.hytale.assetstore.codec.AssetCodec;
import it.unimi.dsi.fastutil.objects.Object2IntMap;
import it.unimi.dsi.fastutil.objects.Object2IntOpenCustomHashMap;
import java.nio.file.Path;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.StampedLock;
import java.util.function.ToIntBiFunction;
import javax.annotation.Nonnull;

public class ProvidedIndexAssetMap<K, T extends JsonAssetWithMap<K, ProvidedIndexAssetMap<K, T>>> extends AssetMapWithIndexes<K, T> {
   private final StampedLock keyToIndexLock = new StampedLock();
   private final Object2IntMap<K> keyToIndex = new Object2IntOpenCustomHashMap<K>(CaseInsensitiveHashStrategy.getInstance());
   private final ToIntBiFunction<K, T> indexGetter;

   public ProvidedIndexAssetMap(ToIntBiFunction<K, T> indexGetter) {
      this.indexGetter = indexGetter;
      this.keyToIndex.defaultReturnValue(-2147483648);
   }

   public int getIndex(K key) {
      long   .keyToIndexLock.tryOptimisticRead();
         .keyToIndex.getInt(key);
       (.keyToIndexLock.validate(stamp)) {
          value;
      }  {
         stamp = .keyToIndexLock.readLock();

          var5;
          {
            var5 = .keyToIndex.getInt(key);
         }  {
            .keyToIndexLock.unlockRead(stamp);
         }

          var5;
      }
   }

      {
         .keyToIndexLock.tryOptimisticRead();
         .keyToIndex.getOrDefault(key, def);
       (.keyToIndexLock.validate(stamp)) {
          value;
      }  {
         stamp = .keyToIndexLock.readLock();

          var6;
          {
            var6 = .keyToIndex.getOrDefault(key, def);
         }  {
            .keyToIndexLock.unlockRead(stamp);
         }

          var6;
      }
   }

      {
      .clear();
         .keyToIndexLock.writeLock();

       {
         .keyToIndex.clear();
      }  {
         .keyToIndexLock.unlockWrite(stamp);
      }

   }

      {
      .putAll(packKey, codec, loadedAssets, loadedKeyToPathMap, loadedAssetChildren);
         .keyToIndexLock.writeLock();

       {
         (Map.Entry<K, T> entry : loadedAssets.entrySet()) {
               (K)entry.getKey();
               (T)(entry.getValue());
             index;
             ((index = .keyToIndex.getInt(key)) == -) {
               .keyToIndex.put(key, index = .indexGetter.applyAsInt(key, value));
            }

            .putAssetTag(codec, key, index, value);
         }
      }  {
         .keyToIndexLock.unlockWrite(stamp);
      }

   }

    Set<K>  {
      Set<K> remove = .remove(keys);
         .keyToIndexLock.writeLock();

       {
         (K key : keys) {
               .keyToIndex.removeInt(key);
            .indexedTagStorage.forEachWithInt((_k, value, idx) -> value.remove(idx), index);
         }
      }  {
         .keyToIndexLock.unlockWrite(stamp);
      }

       remove;
   }

      {
       ;
   }
}