class="kw">package com.hypixel.hytale.builtin.buildertools.objimport;

class="kw">import com.hypixel.hytale.builtin.buildertools.BlockColorIndex;
class="kw">import java.awt.image.BufferedImage;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class="kw">final class MeshVoxelizer {
   class="kw">private MeshVoxelizer() {
   }

   @Nonnull
   class="kw">public class="kw">static MeshVoxelizer.VoxelResult voxelize(@Nonnull ObjParser.ObjMesh var0, int var1, boolean var2) {
      class="kw">return voxelize(var0, var1, var2, null, null, null, 0, false);
   }

   @Nonnull
   class="kw">public class="kw">static MeshVoxelizer.VoxelResult voxelize(@Nonnull ObjParser.ObjMesh var0, int var1, boolean var2, @Nullable Map<String, Integer> var3) {
      class="kw">return voxelize(var0, var1, var2, null, var3, null, 0, false);
   }

   @Nonnull
   class="kw">public class="kw">static MeshVoxelizer.VoxelResult voxelize(@Nonnull ObjParser.ObjMesh var0, int var1, boolean var2, @Nullable Map<String, Integer> var3, int var4) {
      class="kw">return voxelize(var0, var1, var2, null, var3, null, var4, false);
   }

   @Nonnull
   class="kw">public class="kw">static MeshVoxelizer.VoxelResult voxelize(
      @Nonnull ObjParser.ObjMesh var0,
      int var1,
      boolean var2,
      @Nullable Map<String, BufferedImage> var3,
      @Nullable Map<String, Integer> var4,
      @Nullable BlockColorIndex var5,
      int var6
   ) {
      class="kw">return voxelize(var0, var1, var2, var3, var4, var5, var6, false);
   }

   @Nonnull
   class="kw">public class="kw">static MeshVoxelizer.VoxelResult voxelize(
      @Nonnull ObjParser.ObjMesh var0,
      int var1,
      boolean var2,
      @Nullable Map<String, BufferedImage> var3,
      @Nullable Map<String, Integer> var4,
      @Nullable BlockColorIndex var5,
      int var6,
      boolean var7
   ) {
      float[] var8 = var0.getBounds();
      float var9 = var8[4] - var8[1];
      float var10 = var8[3] - var8[0];
      float var11 = var8[5] - var8[2];
      if (var9 <= 0.0F) {
         class="kw">return new MeshVoxelizer.VoxelResult(new boolean[1][1][1], null, 1, 1, 1);
      }

      float var12 = var1 / var9;
      float[][] var13 = new float[var0.vertices().size()][3];
      int var14;
      int var15;
      int var16;
      if (var7) {
         float var17 = var8[0] * var12;
         float var18 = var8[3] * var12;
         float var19 = var8[1] * var12;
         float var20 = var8[4] * var12;
         float var21 = var8[2] * var12;
         float var22 = var8[5] * var12;
         float var23 = var17 < 0.0F ? -var17 + 1.0F : 1.0F;
         float var24 = var19 < 0.0F ? -var19 + 1.0F : 1.0F;
         float var25 = var21 < 0.0F ? -var21 + 1.0F : 1.0F;

         for (int var26 = 0; var26 < var0.vertices().size(); var26++) {
            float[] var27 = var0.vertices().get(var26);
            var13[var26][0] = var27[0] * var12 + var23;
            var13[var26][1] = var27[1] * var12 + var24;
            var13[var26][2] = var27[2] * var12 + var25;
         }

         var14 = Math.max(1, (int)Math.ceil(var18 + var23)) + 2;
         var15 = Math.max(1, (int)Math.ceil(var20 + var24)) + 2;
         var16 = Math.max(1, (int)Math.ceil(var22 + var25)) + 2;
      } else {
         var14 = Math.max(1, (int)Math.ceil(var10 * var12)) + 2;
         var15 = Math.max(1, var1) + 2;
         var16 = Math.max(1, (int)Math.ceil(var11 * var12)) + 2;

         for (int var28 = 0; var28 < var0.vertices().size(); var28++) {
            float[] var30 = var0.vertices().get(var28);
            var13[var28][0] = (var30[0] - var8[0]) * var12 + 1.0F;
            var13[var28][1] = (var30[1] - var8[1]) * var12 + 1.0F;
            var13[var28][2] = (var30[2] - var8[2]) * var12 + 1.0F;
         }
      }

      boolean[][][] var29 = new boolean[var14][var15][var16];
      boolean var31 = var3 != null && !var3.isEmpty() && var5 != null;
      int[][][] var32 = !var31 && var4 == null && var6 == 0 ? null : new int[var14][var15][var16];
      rasterizeSurface(var29, var32, var13, var0, var3, var4, var5, var6, var14, var15, var16);
      if (var2) {
         boolean[][][] var33 = floodFillSolid(var29, var14, var15, var16);
         if (var32 != null) {
            fillInteriorBlockIds(var33, var29, var32, var6, var14, var15, var16);
         }

         class="kw">return cropToSolidBounds(var33, var32, var14, var15, var16);
      } else {
         class="kw">return cropToSolidBounds(var29, var32, var14, var15, var16);
      }
   }

   class="kw">private class="kw">static int resolveIndex(int var0, int var1) {
      class="kw">return var0 < 0 ? var1 + var0 : var0;
   }

   class="kw">private class="kw">static void rasterizeSurface(
      boolean[][][] var0,
      @Nullable int[][][] var1,
      float[][] var2,
      ObjParser.ObjMesh var3,
      @Nullable Map<String, BufferedImage> var4,
      @Nullable Map<String, Integer> var5,
      @Nullable BlockColorIndex var6,
      int var7,
      int var8,
      int var9,
      int var10
   ) {
      List var11 = var3.faces();
      List var12 = var3.faceUvIndices();
      List var13 = var3.uvCoordinates();
      List var14 = var3.faceMaterials();
      boolean var15 = var4 != null && !var4.isEmpty() && var6 != null;

      for (int var16 = 0; var16 < var11.size(); var16++) {
         int[] var17 = var11.get(var16);
         int var18 = resolveIndex(var17[0], var2.length);
         int var19 = resolveIndex(var17[1], var2.length);
         int var20 = resolveIndex(var17[2], var2.length);
         float[] var21 = var2[var18];
         float[] var22 = var2[var19];
         float[] var23 = var2[var20];
         String var24 = var16 < var14.size() ? var14.get(var16) : null;
         BufferedImage var25 = null;
         int var26 = var7;
         if (var24 != null) {
            if (var15) {
               var25 = var4.get(var24);
            }

            if (var25 == null && var5 != null) {
               var26 = var5.getOrDefault(var24, var7);
            }
         }

         float[] var27 = null;
         float[] var28 = null;
         float[] var29 = null;
         if (var25 != null && var16 < var12.size()) {
            int[] var30 = var12.get(var16);
            if (var30 != null && var30.length >= 3) {
               int var31 = var13.size();
               int var32 = resolveIndex(var30[0], var31);
               int var33 = resolveIndex(var30[1], var31);
               int var34 = resolveIndex(var30[2], var31);
               if (var32 >= 0 && var32 < var31) {
                  var27 = var13.get(var32);
               }

               if (var33 >= 0 && var33 < var31) {
                  var28 = var13.get(var33);
               }

               if (var34 >= 0 && var34 < var31) {
                  var29 = var13.get(var34);
               }
            }
         }

         rasterizeLine(var0, var1, var21, var22, var27, var28, var25, var6, var26, var8, var9, var10);
         rasterizeLine(var0, var1, var22, var23, var28, var29, var25, var6, var26, var8, var9, var10);
         rasterizeLine(var0, var1, var23, var21, var29, var27, var25, var6, var26, var8, var9, var10);
         rasterizeTriangle(var0, var1, var21, var22, var23, var27, var28, var29, var25, var6, var26, var8, var9, var10);
      }
   }

   class="kw">private class="kw">static void rasterizeLine(
      boolean[][][] var0,
      @Nullable int[][][] var1,
      float[] var2,
      float[] var3,
      @Nullable float[] var4,
      @Nullable float[] var5,
      @Nullable BufferedImage var6,
      @Nullable BlockColorIndex var7,
      int var8,
      int var9,
      int var10,
      int var11
   ) {
      float var12 = var3[0] - var2[0];
      float var13 = var3[1] - var2[1];
      float var14 = var3[2] - var2[2];
      float var15 = (float)Math.sqrt(var12 * var12 + var13 * var13 + var14 * var14);
      if (var15 < 0.001F) {
         int var24 = sampleBlockId(var4, var6, var7, var8);
         setVoxel(var0, var1, (int)var2[0], (int)var2[1], (int)var2[2], var24, var9, var10, var11);
      } else {
         int var16 = (int)Math.ceil(var15 * 2.0F) + 1;

         for (int var17 = 0; var17 <= var16; var17++) {
            float var18 = (float)var17 / var16;
            float var19 = var2[0] + var12 * var18;
            float var20 = var2[1] + var13 * var18;
            float var21 = var2[2] + var14 * var18;
            float[] var22 = interpolateUv(var4, var5, var18);
            int var23 = sampleBlockId(var22, var6, var7, var8);
            setVoxel(var0, var1, (int)var19, (int)var20, (int)var21, var23, var9, var10, var11);
         }
      }
   }

   @Nullable
   class="kw">private class="kw">static float[] interpolateUv(@Nullable float[] var0, @Nullable float[] var1, float var2) {
      class="kw">return var0 != null && var1 != null ? new float[]{var0[0] + (var1[0] - var0[0]) * var2, var0[1] + (var1[1] - var0[1]) * var2} : var0;
   }

   class="kw">private class="kw">static int sampleBlockId(@Nullable float[] var0, @Nullable BufferedImage var1, @Nullable BlockColorIndex var2, int var3) {
      if (var0 != null && var1 != null && var2 != null) {
         int var4 = TextureSampler.sampleAlphaAt(var1, var0[0], var0[1]);
         if (var4 < 128) {
            class="kw">return 0;
         }

         int[] var5 = TextureSampler.sampleAt(var1, var0[0], var0[1]);
         int var6 = var2.findClosestBlock(var5[0], var5[1], var5[2]);
         class="kw">return var6 > 0 ? var6 : var3;
      } else {
         class="kw">return var3;
      }
   }

   class="kw">private class="kw">static void setVoxel(boolean[][][] var0, @Nullable int[][][] var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8) {
      if (var2 >= 0 && var2 < var6 && var3 >= 0 && var3 < var7 && var4 >= 0 && var4 < var8) {
         var0[var2][var3][var4] = true;
         if (var1 != null && var5 != 0 && var1[var2][var3][var4] == 0) {
            var1[var2][var3][var4] = var5;
         }
      }
   }

   class="kw">private class="kw">static void rasterizeTriangle(
      boolean[][][] var0,
      @Nullable int[][][] var1,
      float[] var2,
      float[] var3,
      float[] var4,
      @Nullable float[] var5,
      @Nullable float[] var6,
      @Nullable float[] var7,
      @Nullable BufferedImage var8,
      @Nullable BlockColorIndex var9,
      int var10,
      int var11,
      int var12,
      int var13
   ) {
      float var14 = Math.min(var2[0], Math.min(var3[0], var4[0]));
      float var15 = Math.max(var2[0], Math.max(var3[0], var4[0]));
      float var16 = Math.min(var2[1], Math.min(var3[1], var4[1]));
      float var17 = Math.max(var2[1], Math.max(var3[1], var4[1]));
      float var18 = Math.min(var2[2], Math.min(var3[2], var4[2]));
      float var19 = Math.max(var2[2], Math.max(var3[2], var4[2]));
      int var20 = Math.max(0, (int)Math.floor(var14) - 1);
      int var21 = Math.min(var11 - 1, (int)Math.ceil(var15) + 1);
      int var22 = Math.max(0, (int)Math.floor(var16) - 1);
      int var23 = Math.min(var12 - 1, (int)Math.ceil(var17) + 1);
      int var24 = Math.max(0, (int)Math.floor(var18) - 1);
      int var25 = Math.min(var13 - 1, (int)Math.ceil(var19) + 1);
      boolean var26 = var5 != null && var6 != null && var7 != null && var8 != null && var9 != null;

      for (int var27 = var20; var27 <= var21; var27++) {
         for (int var28 = var22; var28 <= var23; var28++) {
            for (int var29 = var24; var29 <= var25; var29++) {
               float var30 = var27 + 0.5F;
               float var31 = var28 + 0.5F;
               float var32 = var29 + 0.5F;
               if (pointNearTriangle(var30, var31, var32, var2, var3, var4, 0.87F)) {
                  int var33 = var10;
                  if (var26) {
                     float[] var34 = barycentric(var30, var31, var32, var2, var3, var4);
                     if (var34 != null) {
                        float var35 = var34[0] * var5[0] + var34[1] * var6[0] + var34[2] * var7[0];
                        float var36 = var34[0] * var5[1] + var34[1] * var6[1] + var34[2] * var7[1];
                        int var37 = TextureSampler.sampleAlphaAt(var8, var35, var36);
                        if (var37 < 128) {
                           class="kw">continue;
                        }

                        int[] var38 = TextureSampler.sampleAt(var8, var35, var36);
                        int var39 = var9.findClosestBlock(var38[0], var38[1], var38[2]);
                        if (var39 > 0) {
                           var33 = var39;
                        }
                     }
                  }

                  var0[var27][var28][var29] = true;
                  if (var1 != null && var33 != 0 && var1[var27][var28][var29] == 0) {
                     var1[var27][var28][var29] = var33;
                  }
               }
            }
         }
      }
   }

   @Nullable
   class="kw">private class="kw">static float[] barycentric(float var0, float var1, float var2, float[] var3, float[] var4, float[] var5) {
      float[] var6 = new float[]{var4[0] - var3[0], var4[1] - var3[1], var4[2] - var3[2]};
      float[] var7 = new float[]{var5[0] - var3[0], var5[1] - var3[1], var5[2] - var3[2]};
      float var8 = var6[1] * var7[2] - var6[2] * var7[1];
      float var9 = var6[2] * var7[0] - var6[0] * var7[2];
      float var10 = var6[0] * var7[1] - var6[1] * var7[0];
      float var11 = Math.abs(var8);
      float var12 = Math.abs(var9);
      float var13 = Math.abs(var10);
      float var14;
      float var15;
      float var16;
      float var17;
      float var18;
      float var19;
      float var20;
      float var21;
      if (var11 >= var12 && var11 >= var13) {
         var14 = var3[1];
         var17 = var3[2];
         var15 = var4[1];
         var18 = var4[2];
         var16 = var5[1];
         var19 = var5[2];
         var20 = var1;
         var21 = var2;
      } else if (var12 >= var11 && var12 >= var13) {
         var14 = var3[0];
         var17 = var3[2];
         var15 = var4[0];
         var18 = var4[2];
         var16 = var5[0];
         var19 = var5[2];
         var20 = var0;
         var21 = var2;
      } else {
         var14 = var3[0];
         var17 = var3[1];
         var15 = var4[0];
         var18 = var4[1];
         var16 = var5[0];
         var19 = var5[1];
         var20 = var0;
         var21 = var1;
      }

      float var22 = (var18 - var19) * (var14 - var16) + (var16 - var15) * (var17 - var19);
      if (Math.abs(var22) < 1.0E-10F) {
         class="kw">return null;
      }

      float var23 = ((var18 - var19) * (var20 - var16) + (var16 - var15) * (var21 - var19)) / var22;
      float var24 = ((var19 - var17) * (var20 - var16) + (var14 - var16) * (var21 - var19)) / var22;
      float var25 = 1.0F - var23 - var24;
      class="kw">return new float[]{var23, var24, var25};
   }

   class="kw">private class="kw">static boolean pointNearTriangle(float var0, float var1, float var2, float[] var3, float[] var4, float[] var5, float var6) {
      float var7 = var4[0] - var3[0];
      float var8 = var4[1] - var3[1];
      float var9 = var4[2] - var3[2];
      float var10 = var5[0] - var3[0];
      float var11 = var5[1] - var3[1];
      float var12 = var5[2] - var3[2];
      float var13 = var8 * var12 - var9 * var11;
      float var14 = var9 * var10 - var7 * var12;
      float var15 = var7 * var11 - var8 * var10;
      float var16 = var13 * var13 + var14 * var14 + var15 * var15;
      if (var16 < 1.0E-12F) {
         class="kw">return false;
      }

      float var17 = (float)Math.sqrt(var16);
      float var18 = var0 - var3[0];
      float var19 = var1 - var3[1];
      float var20 = var2 - var3[2];
      float var21 = var13 * var18 + var14 * var19 + var15 * var20;
      float var22 = Math.abs(var21) / var17;
      if (var22 > var6) {
         class="kw">return false;
      }

      float var23 = var21 / var16;
      float var24 = var0 - var23 * var13;
      float var25 = var1 - var23 * var14;
      float var26 = var2 - var23 * var15;
      class="kw">return pointInTriangleWithTolerance(var24, var25, var26, var3, var4, var5, 0.1F);
   }

   class="kw">private class="kw">static boolean pointInTriangleWithTolerance(float var0, float var1, float var2, float[] var3, float[] var4, float[] var5, float var6) {
      float var7 = var4[0] - var3[0];
      float var8 = var4[1] - var3[1];
      float var9 = var4[2] - var3[2];
      float var10 = var5[0] - var3[0];
      float var11 = var5[1] - var3[1];
      float var12 = var5[2] - var3[2];
      float var13 = var0 - var3[0];
      float var14 = var1 - var3[1];
      float var15 = var2 - var3[2];
      float var16 = var7 * var7 + var8 * var8 + var9 * var9;
      float var17 = var7 * var10 + var8 * var11 + var9 * var12;
      float var18 = var10 * var10 + var11 * var11 + var12 * var12;
      float var19 = var13 * var7 + var14 * var8 + var15 * var9;
      float var20 = var13 * var10 + var14 * var11 + var15 * var12;
      float var21 = var16 * var18 - var17 * var17;
      if (Math.abs(var21) < 1.0E-12F) {
         class="kw">return false;
      }

      float var22 = (var18 * var19 - var17 * var20) / var21;
      float var23 = (var16 * var20 - var17 * var19) / var21;
      class="kw">return var22 >= -var6 && var23 >= -var6 && var22 + var23 <= 1.0F + var6;
   }

   class="kw">private class="kw">static boolean[][][] floodFillSolid(boolean[][][] var0, int var1, int var2, int var3) {
      int var4 = var1 + 2;
      int var5 = var2 + 2;
      int var6 = var3 + 2;
      int var7 = var4 * var5;
      int var8 = var7 * var6;
      boolean[] var9 = new boolean[var8];
      int[] var10 = new int[var8];
      int var11 = 0;
      int var12 = 0;
      var9[0] = true;
      var10[var12++] = 0;

      while (var11 < var12) {
         int var13 = var10[var11++];
         int var14 = var13 % var4;
         int var15 = var13 / var4 % var5;
         int var16 = var13 / var7;
         if (var14 + 1 < var4 && tryEnqueue(var0, var1, var2, var3, var9, var10, var14 + 1, var15, var16, var4, var7, var12)) {
            var12++;
         }

         if (var14 - 1 >= 0 && tryEnqueue(var0, var1, var2, var3, var9, var10, var14 - 1, var15, var16, var4, var7, var12)) {
            var12++;
         }

         if (var15 + 1 < var5 && tryEnqueue(var0, var1, var2, var3, var9, var10, var14, var15 + 1, var16, var4, var7, var12)) {
            var12++;
         }

         if (var15 - 1 >= 0 && tryEnqueue(var0, var1, var2, var3, var9, var10, var14, var15 - 1, var16, var4, var7, var12)) {
            var12++;
         }

         if (var16 + 1 < var6 && tryEnqueue(var0, var1, var2, var3, var9, var10, var14, var15, var16 + 1, var4, var7, var12)) {
            var12++;
         }

         if (var16 - 1 >= 0 && tryEnqueue(var0, var1, var2, var3, var9, var10, var14, var15, var16 - 1, var4, var7, var12)) {
            var12++;
         }
      }

      boolean[][][] var22 = new boolean[var1][var2][var3];

      for (int var23 = 0; var23 < var1; var23++) {
         for (int var24 = 0; var24 < var2; var24++) {
            for (int var25 = 0; var25 < var3; var25++) {
               int var17 = var23 + 1;
               int var18 = var24 + 1;
               int var19 = var25 + 1;
               int var20 = var17 + var18 * var4 + var19 * var7;
               var22[var23][var24][var25] = !var9[var20];
            }
         }
      }

      class="kw">return var22;
   }

   class="kw">private class="kw">static boolean tryEnqueue(
      boolean[][][] var0, int var1, int var2, int var3, boolean[] var4, int[] var5, int var6, int var7, int var8, int var9, int var10, int var11
   ) {
      int var12 = var6 + var7 * var9 + var8 * var10;
      if (var4[var12]) {
         class="kw">return false;
      }

      int var13 = var6 - 1;
      int var14 = var7 - 1;
      int var15 = var8 - 1;
      if (var13 >= 0 && var14 >= 0 && var15 >= 0 && var13 < var1 && var14 < var2 && var15 < var3 && var0[var13][var14][var15]) {
         class="kw">return false;
      }

      var4[var12] = true;
      var5[var11] = var12;
      class="kw">return true;
   }

   class="kw">private class="kw">static MeshVoxelizer.VoxelResult cropToSolidBounds(boolean[][][] var0, @Nullable int[][][] var1, int var2, int var3, int var4) {
      int var5 = var2;
      int var6 = var3;
      int var7 = var4;
      int var8 = -1;
      int var9 = -1;
      int var10 = -1;

      for (int var11 = 0; var11 < var2; var11++) {
         for (int var12 = 0; var12 < var3; var12++) {
            for (int var13 = 0; var13 < var4; var13++) {
               if (var0[var11][var12][var13]) {
                  if (var11 < var5) {
                     var5 = var11;
                  }

                  if (var12 < var6) {
                     var6 = var12;
                  }

                  if (var13 < var7) {
                     var7 = var13;
                  }

                  if (var11 > var8) {
                     var8 = var11;
                  }

                  if (var12 > var9) {
                     var9 = var12;
                  }

                  if (var13 > var10) {
                     var10 = var13;
                  }
               }
            }
         }
      }

      if (var8 >= var5 && var9 >= var6 && var10 >= var7) {
         int var18 = var8 - var5 + 1;
         int var19 = var9 - var6 + 1;
         int var20 = var10 - var7 + 1;
         boolean[][][] var14 = new boolean[var18][var19][var20];
         int[][][] var15 = var1 != null ? new int[var18][var19][var20] : null;

         for (int var16 = 0; var16 < var18; var16++) {
            for (int var17 = 0; var17 < var19; var17++) {
               System.arraycopy(var0[var5 + var16][var6 + var17], var7, var14[var16][var17], 0, var20);
               if (var15 != null && var1 != null) {
                  System.arraycopy(var1[var5 + var16][var6 + var17], var7, var15[var16][var17], 0, var20);
               }
            }
         }

         class="kw">return new MeshVoxelizer.VoxelResult(var14, var15, var18, var19, var20);
      } else {
         class="kw">return new MeshVoxelizer.VoxelResult(new boolean[1][1][1], null, 1, 1, 1);
      }
   }

   class="kw">private class="kw">static void fillInteriorBlockIds(boolean[][][] var0, boolean[][][] var1, int[][][] var2, int var3, int var4, int var5, int var6) {
      for (int var7 = 0; var7 < var4; var7++) {
         for (int var8 = 0; var8 < var5; var8++) {
            for (int var9 = 0; var9 < var6; var9++) {
               if (var0[var7][var8][var9] && !var1[var7][var8][var9] && var2[var7][var8][var9] == 0) {
                  int var10 = findNearestSurfaceBlockId(var2, var1, var7, var8, var9, var4, var5, var6);
                  var2[var7][var8][var9] = var10 != 0 ? var10 : var3;
               }
            }
         }
      }
   }

   class="kw">private class="kw">static int findNearestSurfaceBlockId(int[][][] var0, boolean[][][] var1, int var2, int var3, int var4, int var5, int var6, int var7) {
      for (int var8 = 1; var8 <= 5; var8++) {
         for (int var9 = -var8; var9 <= var8; var9++) {
            for (int var10 = -var8; var10 <= var8; var10++) {
               for (int var11 = -var8; var11 <= var8; var11++) {
                  int var12 = var2 + var9;
                  int var13 = var3 + var10;
                  int var14 = var4 + var11;
                  if (var12 >= 0
                     && var12 < var5
                     && var13 >= 0
                     && var13 < var6
                     && var14 >= 0
                     && var14 < var7
                     && var1[var12][var13][var14]
                     && var0[var12][var13][var14] != 0) {
                     class="kw">return var0[var12][var13][var14];
                  }
               }
            }
         }
      }

      class="kw">return 0;
   }

   class="kw">public record VoxelResult(boolean[][][] voxels, @Nullable int[][][] blockIds, int sizeX, int sizeY, int sizeZ) {
      class="kw">public VoxelResult {
      }

      class="kw">public int countSolid() {
         int var1 = 0;

         for (int var2 = 0; var2 < this.sizeX; var2++) {
            for (int var3 = 0; var3 < this.sizeY; var3++) {
               for (int var4 = 0; var4 < this.sizeZ; var4++) {
                  if (this.voxels[var2][var3][var4]) {
                     var1++;
                  }
               }
            }
         }

         class="kw">return var1;
      }

      class="kw">public int getBlockId(int var1, int var2, int var3) {
         if (this.blockIds == null) {
            class="kw">return 0;
         } else {
            class="kw">return var1 >= 0 && var1 < this.sizeX && var2 >= 0 && var2 < this.sizeY && var3 >= 0 && var3 < this.sizeZ ? this.blockIds[var1][var2][var3] : 0;
         }
      }
   }
}