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

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

class="kw">public class Weather {
   class="kw">public class="kw">static class="kw">final int NULLABLE_BIT_FIELD_SIZE = 4;
   class="kw">public class="kw">static class="kw">final int FIXED_BLOCK_SIZE = 30;
   class="kw">public class="kw">static class="kw">final int VARIABLE_FIELD_COUNT = 24;
   class="kw">public class="kw">static class="kw">final int VARIABLE_BLOCK_START = 126;
   class="kw">public class="kw">static class="kw">final int MAX_SIZE = 1677721600;
   @Nullable
   class="kw">public String id;
   @Nullable
   class="kw">public int[] tagIndexes;
   @Nullable
   class="kw">public String stars;
   @Nullable
   class="kw">public Map<Integer, String> moons;
   @Nullable
   class="kw">public Cloud[] clouds;
   @Nullable
   class="kw">public Map<Float, Float> sunlightDampingMultiplier;
   @Nullable
   class="kw">public Map<Float, Color> sunlightColors;
   @Nullable
   class="kw">public Map<Float, ColorAlpha> skyTopColors;
   @Nullable
   class="kw">public Map<Float, ColorAlpha> skyBottomColors;
   @Nullable
   class="kw">public Map<Float, ColorAlpha> skySunsetColors;
   @Nullable
   class="kw">public Map<Float, Color> sunColors;
   @Nullable
   class="kw">public Map<Float, Float> sunScales;
   @Nullable
   class="kw">public Map<Float, ColorAlpha> sunGlowColors;
   @Nullable
   class="kw">public Map<Float, ColorAlpha> moonColors;
   @Nullable
   class="kw">public Map<Float, Float> moonScales;
   @Nullable
   class="kw">public Map<Float, ColorAlpha> moonGlowColors;
   @Nullable
   class="kw">public Map<Float, Color> fogColors;
   @Nullable
   class="kw">public Map<Float, Float> fogHeightFalloffs;
   @Nullable
   class="kw">public Map<Float, Float> fogDensities;
   @Nullable
   class="kw">public String screenEffect;
   @Nullable
   class="kw">public Map<Float, ColorAlpha> screenEffectColors;
   @Nullable
   class="kw">public Map<Float, Color> colorFilters;
   @Nullable
   class="kw">public Map<Float, Color> waterTints;
   @Nullable
   class="kw">public WeatherParticle particle;
   @Nullable
   class="kw">public NearFar fog;
   @Nullable
   class="kw">public FogOptions fogOptions;

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

   class="kw">public Weather(
      @Nullable String var1,
      @Nullable int[] var2,
      @Nullable String var3,
      @Nullable Map<Integer, String> var4,
      @Nullable Cloud[] var5,
      @Nullable Map<Float, Float> var6,
      @Nullable Map<Float, Color> var7,
      @Nullable Map<Float, ColorAlpha> var8,
      @Nullable Map<Float, ColorAlpha> var9,
      @Nullable Map<Float, ColorAlpha> var10,
      @Nullable Map<Float, Color> var11,
      @Nullable Map<Float, Float> var12,
      @Nullable Map<Float, ColorAlpha> var13,
      @Nullable Map<Float, ColorAlpha> var14,
      @Nullable Map<Float, Float> var15,
      @Nullable Map<Float, ColorAlpha> var16,
      @Nullable Map<Float, Color> var17,
      @Nullable Map<Float, Float> var18,
      @Nullable Map<Float, Float> var19,
      @Nullable String var20,
      @Nullable Map<Float, ColorAlpha> var21,
      @Nullable Map<Float, Color> var22,
      @Nullable Map<Float, Color> var23,
      @Nullable WeatherParticle var24,
      @Nullable NearFar var25,
      @Nullable FogOptions var26
   ) {
      this.id = var1;
      this.tagIndexes = var2;
      this.stars = var3;
      this.moons = var4;
      this.clouds = var5;
      this.sunlightDampingMultiplier = var6;
      this.sunlightColors = var7;
      this.skyTopColors = var8;
      this.skyBottomColors = var9;
      this.skySunsetColors = var10;
      this.sunColors = var11;
      this.sunScales = var12;
      this.sunGlowColors = var13;
      this.moonColors = var14;
      this.moonScales = var15;
      this.moonGlowColors = var16;
      this.fogColors = var17;
      this.fogHeightFalloffs = var18;
      this.fogDensities = var19;
      this.screenEffect = var20;
      this.screenEffectColors = var21;
      this.colorFilters = var22;
      this.waterTints = var23;
      this.particle = var24;
      this.fog = var25;
      this.fogOptions = var26;
   }

   class="kw">public Weather(@Nonnull Weather var1) {
      this.id = var1.id;
      this.tagIndexes = var1.tagIndexes;
      this.stars = var1.stars;
      this.moons = var1.moons;
      this.clouds = var1.clouds;
      this.sunlightDampingMultiplier = var1.sunlightDampingMultiplier;
      this.sunlightColors = var1.sunlightColors;
      this.skyTopColors = var1.skyTopColors;
      this.skyBottomColors = var1.skyBottomColors;
      this.skySunsetColors = var1.skySunsetColors;
      this.sunColors = var1.sunColors;
      this.sunScales = var1.sunScales;
      this.sunGlowColors = var1.sunGlowColors;
      this.moonColors = var1.moonColors;
      this.moonScales = var1.moonScales;
      this.moonGlowColors = var1.moonGlowColors;
      this.fogColors = var1.fogColors;
      this.fogHeightFalloffs = var1.fogHeightFalloffs;
      this.fogDensities = var1.fogDensities;
      this.screenEffect = var1.screenEffect;
      this.screenEffectColors = var1.screenEffectColors;
      this.colorFilters = var1.colorFilters;
      this.waterTints = var1.waterTints;
      this.particle = var1.particle;
      this.fog = var1.fog;
      this.fogOptions = var1.fogOptions;
   }

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

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

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

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

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

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

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

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

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

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

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

   @Nullable
   class="kw">public class="kw">static String getStars(MemorySegment var0, int var1) {
      class="kw">return hasStars(var0, var1) ? PacketIO.readVarString("Stars", var0, var1 + getValidatedOffset(var0, var1, 38, 126, "Stars"), 4096000) : null;
   }

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

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

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         int var8 = var0.get(PacketIO.PROTO_INT, var2);
         var2 += 4;
         long var9 = VarInt.getWithLength(var0, var2);
         String var11 = PacketIO.readVarString("value", var0, var2, 0, 4096000, var9);
         var2 += (int)var9 + (int)(var9 >>> 32);
         if (var6.put(var8, var11) != null) {
            throw ProtocolException.duplicateKey("Moons", var8);
         }
      }

      class="kw">return var6;
   }

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

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

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

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

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

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

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

      class="kw">return var8;
   }

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

   @Nullable
   class="kw">public class="kw">static Map<Float, Float> getSunlightDampingMultiplier(MemorySegment var0, int var1) {
      if (!hasSunlightDampingMultiplier(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         float var9 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("SunlightDampingMultiplier", var8);
         }
      }

      class="kw">return var6;
   }

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

   @Nullable
   class="kw">public class="kw">static Map<Float, Color> getSunlightColors(MemorySegment var0, int var1) {
      if (!hasSunlightColors(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         Color var9 = Color.toObject(var0, var2);
         var2 += 3;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("SunlightColors", var8);
         }
      }

      class="kw">return var6;
   }

   @Nullable
   class="kw">public class="kw">static Map<Float, ColorAlpha> getSkyTopColors(MemorySegment var0) {
      class="kw">return getSkyTopColors(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static Map<Float, ColorAlpha> getSkyTopColors(MemorySegment var0, int var1) {
      if (!hasSkyTopColors(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         ColorAlpha var9 = ColorAlpha.toObject(var0, var2);
         var2 += 4;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("SkyTopColors", var8);
         }
      }

      class="kw">return var6;
   }

   @Nullable
   class="kw">public class="kw">static Map<Float, ColorAlpha> getSkyBottomColors(MemorySegment var0) {
      class="kw">return getSkyBottomColors(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static Map<Float, ColorAlpha> getSkyBottomColors(MemorySegment var0, int var1) {
      if (!hasSkyBottomColors(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         ColorAlpha var9 = ColorAlpha.toObject(var0, var2);
         var2 += 4;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("SkyBottomColors", var8);
         }
      }

      class="kw">return var6;
   }

   @Nullable
   class="kw">public class="kw">static Map<Float, ColorAlpha> getSkySunsetColors(MemorySegment var0) {
      class="kw">return getSkySunsetColors(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static Map<Float, ColorAlpha> getSkySunsetColors(MemorySegment var0, int var1) {
      if (!hasSkySunsetColors(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         ColorAlpha var9 = ColorAlpha.toObject(var0, var2);
         var2 += 4;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("SkySunsetColors", var8);
         }
      }

      class="kw">return var6;
   }

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

   @Nullable
   class="kw">public class="kw">static Map<Float, Color> getSunColors(MemorySegment var0, int var1) {
      if (!hasSunColors(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         Color var9 = Color.toObject(var0, var2);
         var2 += 3;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("SunColors", var8);
         }
      }

      class="kw">return var6;
   }

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

   @Nullable
   class="kw">public class="kw">static Map<Float, Float> getSunScales(MemorySegment var0, int var1) {
      if (!hasSunScales(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         float var9 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("SunScales", var8);
         }
      }

      class="kw">return var6;
   }

   @Nullable
   class="kw">public class="kw">static Map<Float, ColorAlpha> getSunGlowColors(MemorySegment var0) {
      class="kw">return getSunGlowColors(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static Map<Float, ColorAlpha> getSunGlowColors(MemorySegment var0, int var1) {
      if (!hasSunGlowColors(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         ColorAlpha var9 = ColorAlpha.toObject(var0, var2);
         var2 += 4;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("SunGlowColors", var8);
         }
      }

      class="kw">return var6;
   }

   @Nullable
   class="kw">public class="kw">static Map<Float, ColorAlpha> getMoonColors(MemorySegment var0) {
      class="kw">return getMoonColors(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static Map<Float, ColorAlpha> getMoonColors(MemorySegment var0, int var1) {
      if (!hasMoonColors(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         ColorAlpha var9 = ColorAlpha.toObject(var0, var2);
         var2 += 4;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("MoonColors", var8);
         }
      }

      class="kw">return var6;
   }

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

   @Nullable
   class="kw">public class="kw">static Map<Float, Float> getMoonScales(MemorySegment var0, int var1) {
      if (!hasMoonScales(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         float var9 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("MoonScales", var8);
         }
      }

      class="kw">return var6;
   }

   @Nullable
   class="kw">public class="kw">static Map<Float, ColorAlpha> getMoonGlowColors(MemorySegment var0) {
      class="kw">return getMoonGlowColors(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static Map<Float, ColorAlpha> getMoonGlowColors(MemorySegment var0, int var1) {
      if (!hasMoonGlowColors(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         ColorAlpha var9 = ColorAlpha.toObject(var0, var2);
         var2 += 4;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("MoonGlowColors", var8);
         }
      }

      class="kw">return var6;
   }

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

   @Nullable
   class="kw">public class="kw">static Map<Float, Color> getFogColors(MemorySegment var0, int var1) {
      if (!hasFogColors(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         Color var9 = Color.toObject(var0, var2);
         var2 += 3;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("FogColors", var8);
         }
      }

      class="kw">return var6;
   }

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

   @Nullable
   class="kw">public class="kw">static Map<Float, Float> getFogHeightFalloffs(MemorySegment var0, int var1) {
      if (!hasFogHeightFalloffs(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         float var9 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("FogHeightFalloffs", var8);
         }
      }

      class="kw">return var6;
   }

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

   @Nullable
   class="kw">public class="kw">static Map<Float, Float> getFogDensities(MemorySegment var0, int var1) {
      if (!hasFogDensities(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         float var9 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("FogDensities", var8);
         }
      }

      class="kw">return var6;
   }

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

   @Nullable
   class="kw">public class="kw">static String getScreenEffect(MemorySegment var0, int var1) {
      class="kw">return hasScreenEffect(var0, var1)
         ? PacketIO.readVarString("ScreenEffect", var0, var1 + getValidatedOffset(var0, var1, 106, 126, "ScreenEffect"), 4096000)
         : null;
   }

   @Nullable
   class="kw">public class="kw">static Map<Float, ColorAlpha> getScreenEffectColors(MemorySegment var0) {
      class="kw">return getScreenEffectColors(var0, 0);
   }

   @Nullable
   class="kw">public class="kw">static Map<Float, ColorAlpha> getScreenEffectColors(MemorySegment var0, int var1) {
      if (!hasScreenEffectColors(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         ColorAlpha var9 = ColorAlpha.toObject(var0, var2);
         var2 += 4;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("ScreenEffectColors", var8);
         }
      }

      class="kw">return var6;
   }

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

   @Nullable
   class="kw">public class="kw">static Map<Float, Color> getColorFilters(MemorySegment var0, int var1) {
      if (!hasColorFilters(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         Color var9 = Color.toObject(var0, var2);
         var2 += 3;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("ColorFilters", var8);
         }
      }

      class="kw">return var6;
   }

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

   @Nullable
   class="kw">public class="kw">static Map<Float, Color> getWaterTints(MemorySegment var0, int var1) {
      if (!hasWaterTints(var0, var1)) {
         class="kw">return null;
      }

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

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

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

      Map var6 = new HashMap<>(var5);

      for (int var7 = 0; var7 < var5; var7++) {
         float var8 = var0.get(PacketIO.PROTO_FLOAT, var2);
         var2 += 4;
         Color var9 = Color.toObject(var0, var2);
         var2 += 3;
         if (var6.put(var8, var9) != null) {
            throw ProtocolException.duplicateKey("WaterTints", var8);
         }
      }

      class="kw">return var6;
   }

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

   @Nullable
   class="kw">public class="kw">static WeatherParticle getParticle(MemorySegment var0, int var1) {
      class="kw">return hasParticle(var0, var1) ? WeatherParticle.toObject(var0, var1 + getValidatedOffset(var0, var1, 122, 126, "Particle")) : null;
   }

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

   @Nullable
   class="kw">public class="kw">static NearFar getFog(MemorySegment var0, int var1) {
      class="kw">return hasFog(var0, var1) ? NearFar.toObject(var0, var1 + 4) : null;
   }

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

   @Nullable
   class="kw">public class="kw">static FogOptions getFogOptions(MemorySegment var0, int var1) {
      class="kw">return hasFogOptions(var0, var1) ? FogOptions.toObject(var0, var1 + 12) : null;
   }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

         var37 += var12;
         var36 = new int[var11];
         MemorySegment.copy(var0, PacketIO.PROTO_INT, var37, var36, 0, var11);
         var4 = var37 + var11 * 4 - var3;
      } else {
         requireSlot(var0, var1 + 34, -1, "TagIndexes");
      }

      String var39 = null;
      if (hasStars(var0, var1)) {
         requireSlot(var0, var1 + 38, var4, "Stars");
         int var40 = var3 + var4;
         long var10 = VarInt.getWithLength(var0, var40);
         var39 = PacketIO.readVarString("Stars", var0, var40, 0, 4096000, var10);
         var4 += (int)var10 + (int)(var10 >>> 32);
      } else {
         requireSlot(var0, var1 + 38, -1, "Stars");
      }

      Map var41 = null;
      if (hasMoons(var0, var1)) {
         requireSlot(var0, var1 + 42, var4, "Moons");
         int var42 = var3 + var4;
         long var46 = VarInt.getWithLength(var0, var42);
         if (var46 == -1L) {
            throw ProtocolException.invalidVarInt("Moons");
         }

         int var13 = (int)var46;
         if (var13 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("Moons", var13, 4096000);
         }

         var42 += (int)(var46 >>> 32);
         if (var42 + var13 * 5L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("Moons", (int)Math.min(var42 + var13 * 5L, 2147483647L), (int)var0.byteSize());
         }

         var41 = new HashMap<>(var13);

         for (int var14 = 0; var14 < var13; var14++) {
            int var15 = var0.get(PacketIO.PROTO_INT, var42);
            var42 += 4;
            long var16 = VarInt.getWithLength(var0, var42);
            String var18 = PacketIO.readVarString("value", var0, var42, 0, 4096000, var16);
            var42 += (int)var16 + (int)(var16 >>> 32);
            if (var41.put(var15, var18) != null) {
               throw ProtocolException.duplicateKey("Moons", var15);
            }
         }

         var4 = var42 - var3;
      } else {
         requireSlot(var0, var1 + 42, -1, "Moons");
      }

      Cloud[] var45 = null;
      if (hasClouds(var0, var1)) {
         requireSlot(var0, var1 + 46, var4, "Clouds");
         int var47 = var3 + var4;
         long var50 = VarInt.getWithLength(var0, var47);
         if (var50 == -1L) {
            throw ProtocolException.invalidVarInt("Clouds");
         }

         int var60 = (int)var50;
         if (var60 > 4096000) {
            throw ProtocolException.arrayTooLong("Clouds", var60, 4096000);
         }

         int var66 = (int)(var50 >>> 32);
         if (var47 + var66 + var60 * 13L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("Clouds", (int)Math.min(var47 + var66 + var60 * 13L, 2147483647L), (int)var0.byteSize());
         }

         var47 += var66;
         var45 = new Cloud[var60];

         for (int var73 = 0; var73 < var60; var73++) {
            var45[var73] = Cloud.toObject(var0, var47, var5);
            var47 = var5.position;
         }

         var4 = var47 - var3;
      } else {
         requireSlot(var0, var1 + 46, -1, "Clouds");
      }

      Map var49 = null;
      if (hasSunlightDampingMultiplier(var0, var1)) {
         requireSlot(var0, var1 + 50, var4, "SunlightDampingMultiplier");
         int var51 = var3 + var4;
         long var55 = VarInt.getWithLength(var0, var51);
         if (var55 == -1L) {
            throw ProtocolException.invalidVarInt("SunlightDampingMultiplier");
         }

         int var67 = (int)var55;
         if (var67 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SunlightDampingMultiplier", var67, 4096000);
         }

         var51 += (int)(var55 >>> 32);
         if (var51 + var67 * 8L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("SunlightDampingMultiplier", (int)Math.min(var51 + var67 * 8L, 2147483647L), (int)var0.byteSize());
         }

         var49 = new HashMap<>(var67);

         for (int var74 = 0; var74 < var67; var74++) {
            float var17 = var0.get(PacketIO.PROTO_FLOAT, var51);
            var51 += 4;
            float var88 = var0.get(PacketIO.PROTO_FLOAT, var51);
            var51 += 4;
            if (var49.put(var17, var88) != null) {
               throw ProtocolException.duplicateKey("SunlightDampingMultiplier", var17);
            }
         }

         var4 = var51 - var3;
      } else {
         requireSlot(var0, var1 + 50, -1, "SunlightDampingMultiplier");
      }

      Map var54 = null;
      if (hasSunlightColors(var0, var1)) {
         requireSlot(var0, var1 + 54, var4, "SunlightColors");
         int var56 = var3 + var4;
         long var61 = VarInt.getWithLength(var0, var56);
         if (var61 == -1L) {
            throw ProtocolException.invalidVarInt("SunlightColors");
         }

         int var75 = (int)var61;
         if (var75 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SunlightColors", var75, 4096000);
         }

         var56 += (int)(var61 >>> 32);
         if (var56 + var75 * 7L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("SunlightColors", (int)Math.min(var56 + var75 * 7L, 2147483647L), (int)var0.byteSize());
         }

         var54 = new HashMap<>(var75);

         for (int var81 = 0; var81 < var75; var81++) {
            float var89 = var0.get(PacketIO.PROTO_FLOAT, var56);
            var56 += 4;
            Color var19 = Color.toObject(var0, var56);
            var56 += 3;
            if (var54.put(var89, var19) != null) {
               throw ProtocolException.duplicateKey("SunlightColors", var89);
            }
         }

         var4 = var56 - var3;
      } else {
         requireSlot(var0, var1 + 54, -1, "SunlightColors");
      }

      Map var59 = null;
      if (hasSkyTopColors(var0, var1)) {
         requireSlot(var0, var1 + 58, var4, "SkyTopColors");
         int var62 = var3 + var4;
         long var68 = VarInt.getWithLength(var0, var62);
         if (var68 == -1L) {
            throw ProtocolException.invalidVarInt("SkyTopColors");
         }

         int var82 = (int)var68;
         if (var82 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SkyTopColors", var82, 4096000);
         }

         var62 += (int)(var68 >>> 32);
         if (var62 + var82 * 8L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("SkyTopColors", (int)Math.min(var62 + var82 * 8L, 2147483647L), (int)var0.byteSize());
         }

         var59 = new HashMap<>(var82);

         for (int var90 = 0; var90 < var82; var90++) {
            float var97 = var0.get(PacketIO.PROTO_FLOAT, var62);
            var62 += 4;
            ColorAlpha var20 = ColorAlpha.toObject(var0, var62);
            var62 += 4;
            if (var59.put(var97, var20) != null) {
               throw ProtocolException.duplicateKey("SkyTopColors", var97);
            }
         }

         var4 = var62 - var3;
      } else {
         requireSlot(var0, var1 + 58, -1, "SkyTopColors");
      }

      Map var65 = null;
      if (hasSkyBottomColors(var0, var1)) {
         requireSlot(var0, var1 + 62, var4, "SkyBottomColors");
         int var69 = var3 + var4;
         long var76 = VarInt.getWithLength(var0, var69);
         if (var76 == -1L) {
            throw ProtocolException.invalidVarInt("SkyBottomColors");
         }

         int var91 = (int)var76;
         if (var91 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SkyBottomColors", var91, 4096000);
         }

         var69 += (int)(var76 >>> 32);
         if (var69 + var91 * 8L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("SkyBottomColors", (int)Math.min(var69 + var91 * 8L, 2147483647L), (int)var0.byteSize());
         }

         var65 = new HashMap<>(var91);

         for (int var98 = 0; var98 < var91; var98++) {
            float var105 = var0.get(PacketIO.PROTO_FLOAT, var69);
            var69 += 4;
            ColorAlpha var21 = ColorAlpha.toObject(var0, var69);
            var69 += 4;
            if (var65.put(var105, var21) != null) {
               throw ProtocolException.duplicateKey("SkyBottomColors", var105);
            }
         }

         var4 = var69 - var3;
      } else {
         requireSlot(var0, var1 + 62, -1, "SkyBottomColors");
      }

      Map var72 = null;
      if (hasSkySunsetColors(var0, var1)) {
         requireSlot(var0, var1 + 66, var4, "SkySunsetColors");
         int var77 = var3 + var4;
         long var83 = VarInt.getWithLength(var0, var77);
         if (var83 == -1L) {
            throw ProtocolException.invalidVarInt("SkySunsetColors");
         }

         int var99 = (int)var83;
         if (var99 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SkySunsetColors", var99, 4096000);
         }

         var77 += (int)(var83 >>> 32);
         if (var77 + var99 * 8L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("SkySunsetColors", (int)Math.min(var77 + var99 * 8L, 2147483647L), (int)var0.byteSize());
         }

         var72 = new HashMap<>(var99);

         for (int var106 = 0; var106 < var99; var106++) {
            float var113 = var0.get(PacketIO.PROTO_FLOAT, var77);
            var77 += 4;
            ColorAlpha var22 = ColorAlpha.toObject(var0, var77);
            var77 += 4;
            if (var72.put(var113, var22) != null) {
               throw ProtocolException.duplicateKey("SkySunsetColors", var113);
            }
         }

         var4 = var77 - var3;
      } else {
         requireSlot(var0, var1 + 66, -1, "SkySunsetColors");
      }

      Map var80 = null;
      if (hasSunColors(var0, var1)) {
         requireSlot(var0, var1 + 70, var4, "SunColors");
         int var84 = var3 + var4;
         long var92 = VarInt.getWithLength(var0, var84);
         if (var92 == -1L) {
            throw ProtocolException.invalidVarInt("SunColors");
         }

         int var107 = (int)var92;
         if (var107 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SunColors", var107, 4096000);
         }

         var84 += (int)(var92 >>> 32);
         if (var84 + var107 * 7L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("SunColors", (int)Math.min(var84 + var107 * 7L, 2147483647L), (int)var0.byteSize());
         }

         var80 = new HashMap<>(var107);

         for (int var114 = 0; var114 < var107; var114++) {
            float var121 = var0.get(PacketIO.PROTO_FLOAT, var84);
            var84 += 4;
            Color var23 = Color.toObject(var0, var84);
            var84 += 3;
            if (var80.put(var121, var23) != null) {
               throw ProtocolException.duplicateKey("SunColors", var121);
            }
         }

         var4 = var84 - var3;
      } else {
         requireSlot(var0, var1 + 70, -1, "SunColors");
      }

      Map var87 = null;
      if (hasSunScales(var0, var1)) {
         requireSlot(var0, var1 + 74, var4, "SunScales");
         int var93 = var3 + var4;
         long var100 = VarInt.getWithLength(var0, var93);
         if (var100 == -1L) {
            throw ProtocolException.invalidVarInt("SunScales");
         }

         int var115 = (int)var100;
         if (var115 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SunScales", var115, 4096000);
         }

         var93 += (int)(var100 >>> 32);
         if (var93 + var115 * 8L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("SunScales", (int)Math.min(var93 + var115 * 8L, 2147483647L), (int)var0.byteSize());
         }

         var87 = new HashMap<>(var115);

         for (int var122 = 0; var122 < var115; var122++) {
            float var129 = var0.get(PacketIO.PROTO_FLOAT, var93);
            var93 += 4;
            float var24 = var0.get(PacketIO.PROTO_FLOAT, var93);
            var93 += 4;
            if (var87.put(var129, var24) != null) {
               throw ProtocolException.duplicateKey("SunScales", var129);
            }
         }

         var4 = var93 - var3;
      } else {
         requireSlot(var0, var1 + 74, -1, "SunScales");
      }

      Map var96 = null;
      if (hasSunGlowColors(var0, var1)) {
         requireSlot(var0, var1 + 78, var4, "SunGlowColors");
         int var101 = var3 + var4;
         long var108 = VarInt.getWithLength(var0, var101);
         if (var108 == -1L) {
            throw ProtocolException.invalidVarInt("SunGlowColors");
         }

         int var123 = (int)var108;
         if (var123 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SunGlowColors", var123, 4096000);
         }

         var101 += (int)(var108 >>> 32);
         if (var101 + var123 * 8L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("SunGlowColors", (int)Math.min(var101 + var123 * 8L, 2147483647L), (int)var0.byteSize());
         }

         var96 = new HashMap<>(var123);

         for (int var130 = 0; var130 < var123; var130++) {
            float var137 = var0.get(PacketIO.PROTO_FLOAT, var101);
            var101 += 4;
            ColorAlpha var25 = ColorAlpha.toObject(var0, var101);
            var101 += 4;
            if (var96.put(var137, var25) != null) {
               throw ProtocolException.duplicateKey("SunGlowColors", var137);
            }
         }

         var4 = var101 - var3;
      } else {
         requireSlot(var0, var1 + 78, -1, "SunGlowColors");
      }

      Map var104 = null;
      if (hasMoonColors(var0, var1)) {
         requireSlot(var0, var1 + 82, var4, "MoonColors");
         int var109 = var3 + var4;
         long var116 = VarInt.getWithLength(var0, var109);
         if (var116 == -1L) {
            throw ProtocolException.invalidVarInt("MoonColors");
         }

         int var131 = (int)var116;
         if (var131 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("MoonColors", var131, 4096000);
         }

         var109 += (int)(var116 >>> 32);
         if (var109 + var131 * 8L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("MoonColors", (int)Math.min(var109 + var131 * 8L, 2147483647L), (int)var0.byteSize());
         }

         var104 = new HashMap<>(var131);

         for (int var138 = 0; var138 < var131; var138++) {
            float var145 = var0.get(PacketIO.PROTO_FLOAT, var109);
            var109 += 4;
            ColorAlpha var26 = ColorAlpha.toObject(var0, var109);
            var109 += 4;
            if (var104.put(var145, var26) != null) {
               throw ProtocolException.duplicateKey("MoonColors", var145);
            }
         }

         var4 = var109 - var3;
      } else {
         requireSlot(var0, var1 + 82, -1, "MoonColors");
      }

      Map var112 = null;
      if (hasMoonScales(var0, var1)) {
         requireSlot(var0, var1 + 86, var4, "MoonScales");
         int var117 = var3 + var4;
         long var124 = VarInt.getWithLength(var0, var117);
         if (var124 == -1L) {
            throw ProtocolException.invalidVarInt("MoonScales");
         }

         int var139 = (int)var124;
         if (var139 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("MoonScales", var139, 4096000);
         }

         var117 += (int)(var124 >>> 32);
         if (var117 + var139 * 8L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("MoonScales", (int)Math.min(var117 + var139 * 8L, 2147483647L), (int)var0.byteSize());
         }

         var112 = new HashMap<>(var139);

         for (int var146 = 0; var146 < var139; var146++) {
            float var153 = var0.get(PacketIO.PROTO_FLOAT, var117);
            var117 += 4;
            float var27 = var0.get(PacketIO.PROTO_FLOAT, var117);
            var117 += 4;
            if (var112.put(var153, var27) != null) {
               throw ProtocolException.duplicateKey("MoonScales", var153);
            }
         }

         var4 = var117 - var3;
      } else {
         requireSlot(var0, var1 + 86, -1, "MoonScales");
      }

      Map var120 = null;
      if (hasMoonGlowColors(var0, var1)) {
         requireSlot(var0, var1 + 90, var4, "MoonGlowColors");
         int var125 = var3 + var4;
         long var132 = VarInt.getWithLength(var0, var125);
         if (var132 == -1L) {
            throw ProtocolException.invalidVarInt("MoonGlowColors");
         }

         int var147 = (int)var132;
         if (var147 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("MoonGlowColors", var147, 4096000);
         }

         var125 += (int)(var132 >>> 32);
         if (var125 + var147 * 8L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("MoonGlowColors", (int)Math.min(var125 + var147 * 8L, 2147483647L), (int)var0.byteSize());
         }

         var120 = new HashMap<>(var147);

         for (int var154 = 0; var154 < var147; var154++) {
            float var159 = var0.get(PacketIO.PROTO_FLOAT, var125);
            var125 += 4;
            ColorAlpha var28 = ColorAlpha.toObject(var0, var125);
            var125 += 4;
            if (var120.put(var159, var28) != null) {
               throw ProtocolException.duplicateKey("MoonGlowColors", var159);
            }
         }

         var4 = var125 - var3;
      } else {
         requireSlot(var0, var1 + 90, -1, "MoonGlowColors");
      }

      Map var128 = null;
      if (hasFogColors(var0, var1)) {
         requireSlot(var0, var1 + 94, var4, "FogColors");
         int var133 = var3 + var4;
         long var140 = VarInt.getWithLength(var0, var133);
         if (var140 == -1L) {
            throw ProtocolException.invalidVarInt("FogColors");
         }

         int var155 = (int)var140;
         if (var155 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("FogColors", var155, 4096000);
         }

         var133 += (int)(var140 >>> 32);
         if (var133 + var155 * 7L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("FogColors", (int)Math.min(var133 + var155 * 7L, 2147483647L), (int)var0.byteSize());
         }

         var128 = new HashMap<>(var155);

         for (int var160 = 0; var160 < var155; var160++) {
            float var167 = var0.get(PacketIO.PROTO_FLOAT, var133);
            var133 += 4;
            Color var29 = Color.toObject(var0, var133);
            var133 += 3;
            if (var128.put(var167, var29) != null) {
               throw ProtocolException.duplicateKey("FogColors", var167);
            }
         }

         var4 = var133 - var3;
      } else {
         requireSlot(var0, var1 + 94, -1, "FogColors");
      }

      Map var136 = null;
      if (hasFogHeightFalloffs(var0, var1)) {
         requireSlot(var0, var1 + 98, var4, "FogHeightFalloffs");
         int var141 = var3 + var4;
         long var148 = VarInt.getWithLength(var0, var141);
         if (var148 == -1L) {
            throw ProtocolException.invalidVarInt("FogHeightFalloffs");
         }

         int var161 = (int)var148;
         if (var161 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("FogHeightFalloffs", var161, 4096000);
         }

         var141 += (int)(var148 >>> 32);
         if (var141 + var161 * 8L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("FogHeightFalloffs", (int)Math.min(var141 + var161 * 8L, 2147483647L), (int)var0.byteSize());
         }

         var136 = new HashMap<>(var161);

         for (int var168 = 0; var168 < var161; var168++) {
            float var175 = var0.get(PacketIO.PROTO_FLOAT, var141);
            var141 += 4;
            float var30 = var0.get(PacketIO.PROTO_FLOAT, var141);
            var141 += 4;
            if (var136.put(var175, var30) != null) {
               throw ProtocolException.duplicateKey("FogHeightFalloffs", var175);
            }
         }

         var4 = var141 - var3;
      } else {
         requireSlot(var0, var1 + 98, -1, "FogHeightFalloffs");
      }

      Map var144 = null;
      if (hasFogDensities(var0, var1)) {
         requireSlot(var0, var1 + 102, var4, "FogDensities");
         int var149 = var3 + var4;
         long var156 = VarInt.getWithLength(var0, var149);
         if (var156 == -1L) {
            throw ProtocolException.invalidVarInt("FogDensities");
         }

         int var169 = (int)var156;
         if (var169 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("FogDensities", var169, 4096000);
         }

         var149 += (int)(var156 >>> 32);
         if (var149 + var169 * 8L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("FogDensities", (int)Math.min(var149 + var169 * 8L, 2147483647L), (int)var0.byteSize());
         }

         var144 = new HashMap<>(var169);

         for (int var176 = 0; var176 < var169; var176++) {
            float var182 = var0.get(PacketIO.PROTO_FLOAT, var149);
            var149 += 4;
            float var31 = var0.get(PacketIO.PROTO_FLOAT, var149);
            var149 += 4;
            if (var144.put(var182, var31) != null) {
               throw ProtocolException.duplicateKey("FogDensities", var182);
            }
         }

         var4 = var149 - var3;
      } else {
         requireSlot(var0, var1 + 102, -1, "FogDensities");
      }

      String var152 = null;
      if (hasScreenEffect(var0, var1)) {
         requireSlot(var0, var1 + 106, var4, "ScreenEffect");
         int var157 = var3 + var4;
         long var162 = VarInt.getWithLength(var0, var157);
         var152 = PacketIO.readVarString("ScreenEffect", var0, var157, 0, 4096000, var162);
         var4 += (int)var162 + (int)(var162 >>> 32);
      } else {
         requireSlot(var0, var1 + 106, -1, "ScreenEffect");
      }

      Map var158 = null;
      if (hasScreenEffectColors(var0, var1)) {
         requireSlot(var0, var1 + 110, var4, "ScreenEffectColors");
         int var163 = var3 + var4;
         long var170 = VarInt.getWithLength(var0, var163);
         if (var170 == -1L) {
            throw ProtocolException.invalidVarInt("ScreenEffectColors");
         }

         int var183 = (int)var170;
         if (var183 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("ScreenEffectColors", var183, 4096000);
         }

         var163 += (int)(var170 >>> 32);
         if (var163 + var183 * 8L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("ScreenEffectColors", (int)Math.min(var163 + var183 * 8L, 2147483647L), (int)var0.byteSize());
         }

         var158 = new HashMap<>(var183);

         for (int var186 = 0; var186 < var183; var186++) {
            float var32 = var0.get(PacketIO.PROTO_FLOAT, var163);
            var163 += 4;
            ColorAlpha var33 = ColorAlpha.toObject(var0, var163);
            var163 += 4;
            if (var158.put(var32, var33) != null) {
               throw ProtocolException.duplicateKey("ScreenEffectColors", var32);
            }
         }

         var4 = var163 - var3;
      } else {
         requireSlot(var0, var1 + 110, -1, "ScreenEffectColors");
      }

      Map var166 = null;
      if (hasColorFilters(var0, var1)) {
         requireSlot(var0, var1 + 114, var4, "ColorFilters");
         int var171 = var3 + var4;
         long var177 = VarInt.getWithLength(var0, var171);
         if (var177 == -1L) {
            throw ProtocolException.invalidVarInt("ColorFilters");
         }

         int var187 = (int)var177;
         if (var187 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("ColorFilters", var187, 4096000);
         }

         var171 += (int)(var177 >>> 32);
         if (var171 + var187 * 7L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("ColorFilters", (int)Math.min(var171 + var187 * 7L, 2147483647L), (int)var0.byteSize());
         }

         var166 = new HashMap<>(var187);

         for (int var188 = 0; var188 < var187; var188++) {
            float var190 = var0.get(PacketIO.PROTO_FLOAT, var171);
            var171 += 4;
            Color var34 = Color.toObject(var0, var171);
            var171 += 3;
            if (var166.put(var190, var34) != null) {
               throw ProtocolException.duplicateKey("ColorFilters", var190);
            }
         }

         var4 = var171 - var3;
      } else {
         requireSlot(var0, var1 + 114, -1, "ColorFilters");
      }

      Map var174 = null;
      if (hasWaterTints(var0, var1)) {
         requireSlot(var0, var1 + 118, var4, "WaterTints");
         int var178 = var3 + var4;
         long var184 = VarInt.getWithLength(var0, var178);
         if (var184 == -1L) {
            throw ProtocolException.invalidVarInt("WaterTints");
         }

         int var189 = (int)var184;
         if (var189 > 4096000) {
            throw ProtocolException.dictionaryTooLarge("WaterTints", var189, 4096000);
         }

         var178 += (int)(var184 >>> 32);
         if (var178 + var189 * 7L > var0.byteSize()) {
            throw ProtocolException.bufferTooSmall("WaterTints", (int)Math.min(var178 + var189 * 7L, 2147483647L), (int)var0.byteSize());
         }

         var174 = new HashMap<>(var189);

         for (int var191 = 0; var191 < var189; var191++) {
            float var192 = var0.get(PacketIO.PROTO_FLOAT, var178);
            var178 += 4;
            Color var35 = Color.toObject(var0, var178);
            var178 += 3;
            if (var174.put(var192, var35) != null) {
               throw ProtocolException.duplicateKey("WaterTints", var192);
            }
         }

         var4 = var178 - var3;
      } else {
         requireSlot(var0, var1 + 118, -1, "WaterTints");
      }

      WeatherParticle var181 = null;
      if (hasParticle(var0, var1)) {
         requireSlot(var0, var1 + 122, var4, "Particle");
         var181 = WeatherParticle.toObject(var0, var3 + var4, var5);
         var4 = var5.position - var3;
      } else {
         requireSlot(var0, var1 + 122, -1, "Particle");
      }

      Weather var185 = new Weather(
         var6,
         var36,
         var39,
         var41,
         var45,
         var49,
         var54,
         var59,
         var65,
         var72,
         var80,
         var87,
         var96,
         var104,
         var112,
         var120,
         var128,
         var136,
         var144,
         var152,
         var158,
         var166,
         var174,
         var181,
         hasFog(var0, var1) ? NearFar.toObject(var0, var1 + 4) : null,
         hasFogOptions(var0, var1) ? FogOptions.toObject(var0, var1 + 12) : null
      );
      if (var2 != null) {
         var2.position = var3 + var4;
      }

      class="kw">return var185;
   }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      var1.set(PacketIO.PROTO_BYTE, var2 + 3, var3);
      if (this.fog != null) {
         this.fog.serialize(var1, var2 + 4);
      } else {
         var1.asSlice(var2 + 4, 8L).fill((byte)0);
      }

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

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

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

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

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

      if (this.moons != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 42, var4 - var2 - 126);
         if (this.moons.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("Moons", this.moons.size(), 4096000);
         }

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

         for (Entry var6 : this.moons.entrySet()) {
            var1.set(PacketIO.PROTO_INT, var4, var6.getKey());
            var4 += 4;
            var4 += PacketIO.writeVarString(var1, var4, var6.getValue(), 4096000);
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 42, -1);
      }

      if (this.clouds != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 46, var4 - var2 - 126);
         if (this.clouds.length > 4096000) {
            throw ProtocolException.arrayTooLong("Clouds", this.clouds.length, 4096000);
         }

         var4 += VarInt.set(var1, var4, this.clouds.length);
         int var30 = 0;

         for (int var48 = 0; var48 < this.clouds.length; var48++) {
            var30 += this.clouds[var48].serialize(var1, var4 + var30);
         }

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

      if (this.sunlightDampingMultiplier != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 50, var4 - var2 - 126);
         if (this.sunlightDampingMultiplier.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SunlightDampingMultiplier", this.sunlightDampingMultiplier.size(), 4096000);
         }

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

         for (Entry var49 : this.sunlightDampingMultiplier.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var49.getKey());
            var4 += 4;
            var1.set(PacketIO.PROTO_FLOAT, var4, var49.getValue());
            var4 += 4;
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 50, -1);
      }

      if (this.sunlightColors != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 54, var4 - var2 - 126);
         if (this.sunlightColors.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SunlightColors", this.sunlightColors.size(), 4096000);
         }

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

         for (Entry var50 : this.sunlightColors.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var50.getKey());
            var4 += 4;
            var4 += var50.getValue().serialize(var1, var4);
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 54, -1);
      }

      if (this.skyTopColors != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 58, var4 - var2 - 126);
         if (this.skyTopColors.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SkyTopColors", this.skyTopColors.size(), 4096000);
         }

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

         for (Entry var51 : this.skyTopColors.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var51.getKey());
            var4 += 4;
            var4 += var51.getValue().serialize(var1, var4);
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 58, -1);
      }

      if (this.skyBottomColors != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 62, var4 - var2 - 126);
         if (this.skyBottomColors.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SkyBottomColors", this.skyBottomColors.size(), 4096000);
         }

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

         for (Entry var52 : this.skyBottomColors.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var52.getKey());
            var4 += 4;
            var4 += var52.getValue().serialize(var1, var4);
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 62, -1);
      }

      if (this.skySunsetColors != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 66, var4 - var2 - 126);
         if (this.skySunsetColors.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SkySunsetColors", this.skySunsetColors.size(), 4096000);
         }

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

         for (Entry var53 : this.skySunsetColors.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var53.getKey());
            var4 += 4;
            var4 += var53.getValue().serialize(var1, var4);
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 66, -1);
      }

      if (this.sunColors != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 70, var4 - var2 - 126);
         if (this.sunColors.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SunColors", this.sunColors.size(), 4096000);
         }

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

         for (Entry var54 : this.sunColors.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var54.getKey());
            var4 += 4;
            var4 += var54.getValue().serialize(var1, var4);
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 70, -1);
      }

      if (this.sunScales != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 74, var4 - var2 - 126);
         if (this.sunScales.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SunScales", this.sunScales.size(), 4096000);
         }

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

         for (Entry var55 : this.sunScales.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var55.getKey());
            var4 += 4;
            var1.set(PacketIO.PROTO_FLOAT, var4, var55.getValue());
            var4 += 4;
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 74, -1);
      }

      if (this.sunGlowColors != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 78, var4 - var2 - 126);
         if (this.sunGlowColors.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("SunGlowColors", this.sunGlowColors.size(), 4096000);
         }

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

         for (Entry var56 : this.sunGlowColors.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var56.getKey());
            var4 += 4;
            var4 += var56.getValue().serialize(var1, var4);
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 78, -1);
      }

      if (this.moonColors != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 82, var4 - var2 - 126);
         if (this.moonColors.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("MoonColors", this.moonColors.size(), 4096000);
         }

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

         for (Entry var57 : this.moonColors.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var57.getKey());
            var4 += 4;
            var4 += var57.getValue().serialize(var1, var4);
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 82, -1);
      }

      if (this.moonScales != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 86, var4 - var2 - 126);
         if (this.moonScales.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("MoonScales", this.moonScales.size(), 4096000);
         }

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

         for (Entry var58 : this.moonScales.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var58.getKey());
            var4 += 4;
            var1.set(PacketIO.PROTO_FLOAT, var4, var58.getValue());
            var4 += 4;
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 86, -1);
      }

      if (this.moonGlowColors != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 90, var4 - var2 - 126);
         if (this.moonGlowColors.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("MoonGlowColors", this.moonGlowColors.size(), 4096000);
         }

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

         for (Entry var59 : this.moonGlowColors.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var59.getKey());
            var4 += 4;
            var4 += var59.getValue().serialize(var1, var4);
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 90, -1);
      }

      if (this.fogColors != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 94, var4 - var2 - 126);
         if (this.fogColors.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("FogColors", this.fogColors.size(), 4096000);
         }

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

         for (Entry var60 : this.fogColors.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var60.getKey());
            var4 += 4;
            var4 += var60.getValue().serialize(var1, var4);
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 94, -1);
      }

      if (this.fogHeightFalloffs != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 98, var4 - var2 - 126);
         if (this.fogHeightFalloffs.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("FogHeightFalloffs", this.fogHeightFalloffs.size(), 4096000);
         }

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

         for (Entry var61 : this.fogHeightFalloffs.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var61.getKey());
            var4 += 4;
            var1.set(PacketIO.PROTO_FLOAT, var4, var61.getValue());
            var4 += 4;
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 98, -1);
      }

      if (this.fogDensities != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 102, var4 - var2 - 126);
         if (this.fogDensities.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("FogDensities", this.fogDensities.size(), 4096000);
         }

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

         for (Entry var62 : this.fogDensities.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var62.getKey());
            var4 += 4;
            var1.set(PacketIO.PROTO_FLOAT, var4, var62.getValue());
            var4 += 4;
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 102, -1);
      }

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

      if (this.screenEffectColors != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 110, var4 - var2 - 126);
         if (this.screenEffectColors.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("ScreenEffectColors", this.screenEffectColors.size(), 4096000);
         }

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

         for (Entry var63 : this.screenEffectColors.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var63.getKey());
            var4 += 4;
            var4 += var63.getValue().serialize(var1, var4);
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 110, -1);
      }

      if (this.colorFilters != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 114, var4 - var2 - 126);
         if (this.colorFilters.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("ColorFilters", this.colorFilters.size(), 4096000);
         }

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

         for (Entry var64 : this.colorFilters.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var64.getKey());
            var4 += 4;
            var4 += var64.getValue().serialize(var1, var4);
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 114, -1);
      }

      if (this.waterTints != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 118, var4 - var2 - 126);
         if (this.waterTints.size() > 4096000) {
            throw ProtocolException.dictionaryTooLarge("WaterTints", this.waterTints.size(), 4096000);
         }

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

         for (Entry var65 : this.waterTints.entrySet()) {
            var1.set(PacketIO.PROTO_FLOAT, var4, var65.getKey());
            var4 += 4;
            var4 += var65.getValue().serialize(var1, var4);
         }
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 118, -1);
      }

      if (this.particle != null) {
         var1.set(PacketIO.PROTO_INT, var2 + 122, var4 - var2 - 126);
         var4 += this.particle.serialize(var1, var4);
      } else {
         var1.set(PacketIO.PROTO_INT, var2 + 122, -1);
      }

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

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

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

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

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

         for (Entry var4 : this.moons.entrySet()) {
            var2 += 4 + PacketIO.stringSize(var4.getValue());
         }

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

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

         for (Cloud var6 : this.clouds) {
            var7 += var6.computeSize();
         }

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

      if (this.sunlightDampingMultiplier != null) {
         var1 += VarInt.size(this.sunlightDampingMultiplier.size()) + this.sunlightDampingMultiplier.size() * 8;
      }

      if (this.sunlightColors != null) {
         var1 += VarInt.size(this.sunlightColors.size()) + this.sunlightColors.size() * 7;
      }

      if (this.skyTopColors != null) {
         var1 += VarInt.size(this.skyTopColors.size()) + this.skyTopColors.size() * 8;
      }

      if (this.skyBottomColors != null) {
         var1 += VarInt.size(this.skyBottomColors.size()) + this.skyBottomColors.size() * 8;
      }

      if (this.skySunsetColors != null) {
         var1 += VarInt.size(this.skySunsetColors.size()) + this.skySunsetColors.size() * 8;
      }

      if (this.sunColors != null) {
         var1 += VarInt.size(this.sunColors.size()) + this.sunColors.size() * 7;
      }

      if (this.sunScales != null) {
         var1 += VarInt.size(this.sunScales.size()) + this.sunScales.size() * 8;
      }

      if (this.sunGlowColors != null) {
         var1 += VarInt.size(this.sunGlowColors.size()) + this.sunGlowColors.size() * 8;
      }

      if (this.moonColors != null) {
         var1 += VarInt.size(this.moonColors.size()) + this.moonColors.size() * 8;
      }

      if (this.moonScales != null) {
         var1 += VarInt.size(this.moonScales.size()) + this.moonScales.size() * 8;
      }

      if (this.moonGlowColors != null) {
         var1 += VarInt.size(this.moonGlowColors.size()) + this.moonGlowColors.size() * 8;
      }

      if (this.fogColors != null) {
         var1 += VarInt.size(this.fogColors.size()) + this.fogColors.size() * 7;
      }

      if (this.fogHeightFalloffs != null) {
         var1 += VarInt.size(this.fogHeightFalloffs.size()) + this.fogHeightFalloffs.size() * 8;
      }

      if (this.fogDensities != null) {
         var1 += VarInt.size(this.fogDensities.size()) + this.fogDensities.size() * 8;
      }

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

      if (this.screenEffectColors != null) {
         var1 += VarInt.size(this.screenEffectColors.size()) + this.screenEffectColors.size() * 8;
      }

      if (this.colorFilters != null) {
         var1 += VarInt.size(this.colorFilters.size()) + this.colorFilters.size() * 7;
      }

      if (this.waterTints != null) {
         var1 += VarInt.size(this.waterTints.size()) + this.waterTints.size() * 7;
      }

      if (this.particle != null) {
         var1 += this.particle.computeSize();
      }

      class="kw">return var1;
   }

   class="kw">public Weather clone() {
      Weather var1 = new Weather();
      var1.id = this.id;
      var1.tagIndexes = this.tagIndexes != null ? Arrays.copyOf(this.tagIndexes, this.tagIndexes.length) : null;
      var1.stars = this.stars;
      var1.moons = this.moons != null ? new HashMap<>(this.moons) : null;
      var1.clouds = this.clouds != null ? Arrays.stream(this.clouds).map(var0 -> var0.clone()).toArray(Cloud[]::new) : null;
      var1.sunlightDampingMultiplier = this.sunlightDampingMultiplier != null ? new HashMap<>(this.sunlightDampingMultiplier) : null;
      if (this.sunlightColors != null) {
         Map var2 = new HashMap<>();

         for (Entry var4 : this.sunlightColors.entrySet()) {
            var2.put(var4.getKey(), var4.getValue().clone());
         }

         var1.sunlightColors = var2;
      }

      if (this.skyTopColors != null) {
         Map var5 = new HashMap<>();

         for (Entry var27 : this.skyTopColors.entrySet()) {
            var5.put(var27.getKey(), var27.getValue().clone());
         }

         var1.skyTopColors = var5;
      }

      if (this.skyBottomColors != null) {
         Map var6 = new HashMap<>();

         for (Entry var28 : this.skyBottomColors.entrySet()) {
            var6.put(var28.getKey(), var28.getValue().clone());
         }

         var1.skyBottomColors = var6;
      }

      if (this.skySunsetColors != null) {
         Map var7 = new HashMap<>();

         for (Entry var29 : this.skySunsetColors.entrySet()) {
            var7.put(var29.getKey(), var29.getValue().clone());
         }

         var1.skySunsetColors = var7;
      }

      if (this.sunColors != null) {
         Map var8 = new HashMap<>();

         for (Entry var30 : this.sunColors.entrySet()) {
            var8.put(var30.getKey(), var30.getValue().clone());
         }

         var1.sunColors = var8;
      }

      var1.sunScales = this.sunScales != null ? new HashMap<>(this.sunScales) : null;
      if (this.sunGlowColors != null) {
         Map var9 = new HashMap<>();

         for (Entry var31 : this.sunGlowColors.entrySet()) {
            var9.put(var31.getKey(), var31.getValue().clone());
         }

         var1.sunGlowColors = var9;
      }

      if (this.moonColors != null) {
         Map var10 = new HashMap<>();

         for (Entry var32 : this.moonColors.entrySet()) {
            var10.put(var32.getKey(), var32.getValue().clone());
         }

         var1.moonColors = var10;
      }

      var1.moonScales = this.moonScales != null ? new HashMap<>(this.moonScales) : null;
      if (this.moonGlowColors != null) {
         Map var11 = new HashMap<>();

         for (Entry var33 : this.moonGlowColors.entrySet()) {
            var11.put(var33.getKey(), var33.getValue().clone());
         }

         var1.moonGlowColors = var11;
      }

      if (this.fogColors != null) {
         Map var12 = new HashMap<>();

         for (Entry var34 : this.fogColors.entrySet()) {
            var12.put(var34.getKey(), var34.getValue().clone());
         }

         var1.fogColors = var12;
      }

      var1.fogHeightFalloffs = this.fogHeightFalloffs != null ? new HashMap<>(this.fogHeightFalloffs) : null;
      var1.fogDensities = this.fogDensities != null ? new HashMap<>(this.fogDensities) : null;
      var1.screenEffect = this.screenEffect;
      if (this.screenEffectColors != null) {
         Map var13 = new HashMap<>();

         for (Entry var35 : this.screenEffectColors.entrySet()) {
            var13.put(var35.getKey(), var35.getValue().clone());
         }

         var1.screenEffectColors = var13;
      }

      if (this.colorFilters != null) {
         Map var14 = new HashMap<>();

         for (Entry var36 : this.colorFilters.entrySet()) {
            var14.put(var36.getKey(), var36.getValue().clone());
         }

         var1.colorFilters = var14;
      }

      if (this.waterTints != null) {
         Map var15 = new HashMap<>();

         for (Entry var37 : this.waterTints.entrySet()) {
            var15.put(var37.getKey(), var37.getValue().clone());
         }

         var1.waterTints = var15;
      }

      var1.particle = this.particle != null ? this.particle.clone() : null;
      var1.fog = this.fog != null ? this.fog.clone() : null;
      var1.fogOptions = this.fogOptions != null ? this.fogOptions.clone() : null;
      class="kw">return var1;
   }

   @Override
   class="kw">public boolean equals(Object var1) {
      if (this == var1) {
         class="kw">return true;
      } else {
         class="kw">return !(var1 class="kw">instanceof Weather var2)
            ? false
            : Objects.equals(this.id, var2.id)
               && Arrays.equals(this.tagIndexes, var2.tagIndexes)
               && Objects.equals(this.stars, var2.stars)
               && Objects.equals(this.moons, var2.moons)
               && Arrays.equals(this.clouds, var2.clouds)
               && Objects.equals(this.sunlightDampingMultiplier, var2.sunlightDampingMultiplier)
               && Objects.equals(this.sunlightColors, var2.sunlightColors)
               && Objects.equals(this.skyTopColors, var2.skyTopColors)
               && Objects.equals(this.skyBottomColors, var2.skyBottomColors)
               && Objects.equals(this.skySunsetColors, var2.skySunsetColors)
               && Objects.equals(this.sunColors, var2.sunColors)
               && Objects.equals(this.sunScales, var2.sunScales)
               && Objects.equals(this.sunGlowColors, var2.sunGlowColors)
               && Objects.equals(this.moonColors, var2.moonColors)
               && Objects.equals(this.moonScales, var2.moonScales)
               && Objects.equals(this.moonGlowColors, var2.moonGlowColors)
               && Objects.equals(this.fogColors, var2.fogColors)
               && Objects.equals(this.fogHeightFalloffs, var2.fogHeightFalloffs)
               && Objects.equals(this.fogDensities, var2.fogDensities)
               && Objects.equals(this.screenEffect, var2.screenEffect)
               && Objects.equals(this.screenEffectColors, var2.screenEffectColors)
               && Objects.equals(this.colorFilters, var2.colorFilters)
               && Objects.equals(this.waterTints, var2.waterTints)
               && Objects.equals(this.particle, var2.particle)
               && Objects.equals(this.fog, var2.fog)
               && Objects.equals(this.fogOptions, var2.fogOptions);
      }
   }

   @Override
   class="kw">public int hashCode() {
      int var1 = 1;
      var1 = 31 * var1 + Objects.hashCode(this.id);
      var1 = 31 * var1 + Arrays.hashCode(this.tagIndexes);
      var1 = 31 * var1 + Objects.hashCode(this.stars);
      var1 = 31 * var1 + Objects.hashCode(this.moons);
      var1 = 31 * var1 + Arrays.hashCode(this.clouds);
      var1 = 31 * var1 + Objects.hashCode(this.sunlightDampingMultiplier);
      var1 = 31 * var1 + Objects.hashCode(this.sunlightColors);
      var1 = 31 * var1 + Objects.hashCode(this.skyTopColors);
      var1 = 31 * var1 + Objects.hashCode(this.skyBottomColors);
      var1 = 31 * var1 + Objects.hashCode(this.skySunsetColors);
      var1 = 31 * var1 + Objects.hashCode(this.sunColors);
      var1 = 31 * var1 + Objects.hashCode(this.sunScales);
      var1 = 31 * var1 + Objects.hashCode(this.sunGlowColors);
      var1 = 31 * var1 + Objects.hashCode(this.moonColors);
      var1 = 31 * var1 + Objects.hashCode(this.moonScales);
      var1 = 31 * var1 + Objects.hashCode(this.moonGlowColors);
      var1 = 31 * var1 + Objects.hashCode(this.fogColors);
      var1 = 31 * var1 + Objects.hashCode(this.fogHeightFalloffs);
      var1 = 31 * var1 + Objects.hashCode(this.fogDensities);
      var1 = 31 * var1 + Objects.hashCode(this.screenEffect);
      var1 = 31 * var1 + Objects.hashCode(this.screenEffectColors);
      var1 = 31 * var1 + Objects.hashCode(this.colorFilters);
      var1 = 31 * var1 + Objects.hashCode(this.waterTints);
      var1 = 31 * var1 + Objects.hashCode(this.particle);
      var1 = 31 * var1 + Objects.hashCode(this.fog);
      class="kw">return 31 * var1 + Objects.hashCode(this.fogOptions);
   }
}