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

class="kw">import com.hypixel.hytale.common.plugin.PluginManifest;
class="kw">import com.hypixel.hytale.common.util.FormatUtil;
class="kw">import com.hypixel.hytale.common.util.StringUtil;
class="kw">import com.hypixel.hytale.component.ComponentRegistry;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.component.metric.ArchetypeChunkData;
class="kw">import com.hypixel.hytale.component.system.ISystem;
class="kw">import com.hypixel.hytale.logger.backend.HytaleFileHandler;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.metrics.InitStackThread;
class="kw">import com.hypixel.hytale.metrics.MetricsRegistry;
class="kw">import com.hypixel.hytale.metrics.metric.HistoricMetric;
class="kw">import com.hypixel.hytale.plugin.early.ClassTransformer;
class="kw">import com.hypixel.hytale.plugin.early.EarlyPluginLoader;
class="kw">import com.hypixel.hytale.protocol.io.PacketStatsRecorder;
class="kw">import com.hypixel.hytale.protocol.packets.connection.PongType;
class="kw">import com.hypixel.hytale.server.core.HytaleServer;
class="kw">import com.hypixel.hytale.server.core.HytaleServerConfig;
class="kw">import com.hypixel.hytale.server.core.ShutdownReason;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.CameraManager;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.movement.MovementManager;
class="kw">import com.hypixel.hytale.server.core.entity.movement.MovementStatesComponent;
class="kw">import com.hypixel.hytale.server.core.io.PacketHandler;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPlugin;
class="kw">import com.hypixel.hytale.server.core.plugin.PluginBase;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.Universe;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.WorldGenTimingsCollector;
class="kw">import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
class="kw">import java.io.BufferedWriter;
class="kw">import java.io.FileOutputStream;
class="kw">import java.io.IOException;
class="kw">import java.io.OutputStreamWriter;
class="kw">import java.io.PrintWriter;
class="kw">import java.lang.management.ClassLoadingMXBean;
class="kw">import java.lang.management.GarbageCollectorMXBean;
class="kw">import java.lang.management.ManagementFactory;
class="kw">import java.lang.management.MemoryMXBean;
class="kw">import java.lang.management.MemoryPoolMXBean;
class="kw">import java.lang.management.MemoryUsage;
class="kw">import java.lang.management.OperatingSystemMXBean;
class="kw">import java.lang.management.RuntimeMXBean;
class="kw">import java.lang.management.ThreadInfo;
class="kw">import java.lang.management.ThreadMXBean;
class="kw">import java.nio.charset.StandardCharsets;
class="kw">import java.nio.file.Files;
class="kw">import java.nio.file.Path;
class="kw">import java.nio.file.Paths;
class="kw">import java.time.Instant;
class="kw">import java.time.LocalDateTime;
class="kw">import java.time.ZoneId;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collection;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.concurrent.CompletionException;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import java.util.concurrent.TimeoutException;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.bouncycastle.util.io.TeeOutputStream;
class="kw">import org.bson.BsonArray;
class="kw">import org.bson.BsonDocument;
class="kw">import org.bson.BsonString;
class="kw">import org.bson.BsonValue;

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

   @Nonnull
   class="kw">public class="kw">static Path dumpToJson() class="kw">throws IOException {
      Map var0 = collectPlayerComponentMetrics();
      BsonDocument var1 = HytaleServer.METRICS_REGISTRY.dumpToBson(HytaleServer.get()).asDocument();
      BsonDocument var2 = Universe.METRICS_REGISTRY.dumpToBson(Universe.get()).asDocument();
      BsonArray var3 = new BsonArray();

      for (PlayerRef var5 : Universe.get().getPlayers()) {
         BsonDocument var6 = PlayerRef.METRICS_REGISTRY.dumpToBson(var5).asDocument();
         BsonDocument var7 = var0.get(var5.getUuid());
         if (var7 != null) {
            var6.putAll(var7);
         }

         var3.add(var6);
      }

      var2.put("Players", var3);
      var1.put("Universe", var2);
      BsonArray var8 = new BsonArray();

      for (ClassTransformer var11 : EarlyPluginLoader.getTransformers()) {
         var8.add(new BsonString(var11.getClass().getName()));
      }

      var1.put("EarlyPlugins", var8);
      Path var10 = MetricsRegistry.createDumpPath(".dump.json");
      Files.writeString(var10, BsonUtil.toJson(var1));
      class="kw">return var10;
   }

   @Nonnull
   class="kw">private class="kw">static Map<UUID, BsonDocument> collectPlayerComponentMetrics() {
      ConcurrentHashMap var0 = new ConcurrentHashMap<>();
      Collection var1 = Universe.get().getWorlds().values();
      CompletableFuture[] var2 = var1.stream().map(var1x -> CompletableFuture.runAsync(() -> {
         for (PlayerRef var3 : var1x.getPlayerRefs()) {
            BsonValue var4 = PlayerRef.COMPONENT_METRICS_REGISTRY.dumpToBson(var3);
            var0.put(var3.getUuid(), var4.asDocument());
         }
      }, var1x).orTimeout(30L, TimeUnit.SECONDS)).toArray(CompletableFuture[]::new);
      CompletableFuture.allOf(var2).join();
      class="kw">return var0;
   }

   @Nonnull
   class="kw">public class="kw">static Map<UUID, DumpUtil.PlayerTextData> collectPlayerTextData() {
      ConcurrentHashMap var0 = new ConcurrentHashMap<>();
      Collection var1 = Universe.get().getWorlds().values();
      CompletableFuture[] var2 = var1.stream()
         .map(
            var1x -> CompletableFuture.runAsync(
                  () -> {
                     for (PlayerRef var3 : var1x.getPlayerRefs()) {
                        Ref var4 = var3.getReference();
                        if (var4 != null) {
                           Store var5 = var4.getStore();
                           MovementStatesComponent var6 = var5.getComponent(var4, MovementStatesComponent.getComponentType());
                           MovementManager var7 = var5.getComponent(var4, MovementManager.getComponentType());
                           CameraManager var8 = var5.getComponent(var4, CameraManager.getComponentType());
                           var0.put(
                              var3.getUuid(),
                              new DumpUtil.PlayerTextData(
                                 var3.getUuid(),
                                 var6 != null ? var6.getMovementStates().toString() : null,
                                 var7 != null ? var7.toString() : null,
                                 var8 != null ? var8.toString() : null
                              )
                           );
                        }
                     }
                  },
                  var1x
               )
               .orTimeout(30L, TimeUnit.SECONDS)
         )
         .toArray(CompletableFuture[]::new);
      CompletableFuture.allOf(var2).join();
      class="kw">return var0;
   }

   @Nonnull
   class="kw">public class="kw">static Path dump(boolean var0, boolean var1) {
      Path var2 = createDumpPath(var0, "dump.txt");
      FileOutputStream var3 = null;

      Object var4;
      try {
         var3 = new FileOutputStream(var2.toFile());
         if (var1) {
            var4 = new TeeOutputStream(var3, System.err);
         } else {
            var4 = var3;
         }
      } catch (IOException var13) {
         var13.printStackTrace();
         System.err.println();
         System.err.println("FAILED TO GET OUTPUT STREAM FOR " + var2);
         System.err.println("FAILED TO GET OUTPUT STREAM FOR " + var2);
         System.err.println();
         var4 = System.err;
      }

      try {
         write(new PrintWriter(new BufferedWriter(new OutputStreamWriter(var4, StandardCharsets.UTF_8)), true));
      } class="kw">finally {
         if (var3 != null) {
            try {
               var3.close();
            } catch (IOException var12) {
            }
         }
      }

      class="kw">return var2;
   }

   @Nonnull
   class="kw">public class="kw">static Path createDumpPath(boolean var0, String var1) {
      Path var2 = Paths.get("dumps");

      try {
         if (!Files.exists(var2)) {
            Files.createDirectories(var2);
         }
      } catch (IOException var6) {
         var6.printStackTrace();
      }

      String var3 = (var0 ? "crash-" : "") + HytaleFileHandler.LOG_FILE_DATE_FORMAT.format(LocalDateTime.now(ZoneId.systemDefault()));
      Path var4 = var2.resolve(var3 + "." + var1);
      int var5 = 0;

      while (Files.exists(var4)) {
         var4 = var2.resolve(var3 + "_" + var5++ + "." + var1);
      }

      class="kw">return var4;
   }

   class="kw">private class="kw">static void write(@Nonnull PrintWriter var0) {
      int var1 = 200;
      int var2 = 20;
      long var3 = System.nanoTime();
      section(
         "Summary",
         () -> {
            Universe var1 = Universe.get();
            var0.println("World Count: " + var1.getWorlds().size());

            for (World var3 : var1.getWorlds().values()) {
               var0.println("- " + var3.getName());
               HistoricMetric var4 = var3.getBufferedTickLengthMetricSet();
               long[] var5 = var4.getPeriodsNanos();
               int var6 = var5.length - 1;
               long var7 = var5[var6];
               double var9 = var4.getAverage(var6);
               long var11 = var4.calculateMax(var6);
               long var13 = var4.calculateMin(var6);
               String var15 = FormatUtil.timeUnitToString(var7, TimeUnit.NANOSECONDS, true);
               String var16 = FormatUtil.simpleTimeUnitFormat(var13, var9, var11, TimeUnit.NANOSECONDS, TimeUnit.MILLISECONDS, 3);
               String var17 = FormatUtil.simpleTimeUnitFormat(var3.getTickStepNanos(), TimeUnit.NANOSECONDS, 3);
               var0.printf("\tTick (%s): %s (Limit: %s)\n", var15, var16, var17);
               var0.printf("\tPlayer count: %d\n", var3.getPlayerCount());
            }

            var0.println("Player count: " + var1.getPlayerCount());

            for (PlayerRef var19 : var1.getPlayers()) {
               var0.printf("- %s (%s)\n", var19.getUsername(), var19.getUuid());
               PacketHandler.PingInfo var20 = var19.getPacketHandler().getPingInfo(PongType.Raw);
               HistoricMetric var21 = var20.getPingMetricSet();
               long var22 = var21.calculateMin(1);
               long var8 = (long)var21.getAverage(1);
               long var10 = var21.calculateMax(1);
               var0.println(
                  "\tPing(raw) Min: "
                     + FormatUtil.timeUnitToString(var22, PacketHandler.PingInfo.TIME_UNIT)
                     + ", Avg: "
                     + FormatUtil.timeUnitToString(var8, PacketHandler.PingInfo.TIME_UNIT)
                     + ", Max: "
                     + FormatUtil.timeUnitToString(var10, PacketHandler.PingInfo.TIME_UNIT)
               );
            }
         },
         var0
      );
      section("Server Lifecycle", () -> {
         HytaleServer var1 = HytaleServer.get();
         var0.println("Boot Timestamp: " + var1.getBoot());
         var0.println("Boot Start (nanos): " + var1.getBootStart());
         var0.println("Booting: " + var1.isBooting());
         var0.println("Booted: " + var1.isBooted());
         var0.println("Shutting Down: " + var1.isShuttingDown());
         ShutdownReason var2 = var1.getShutdownReason();
         if (var2 != null) {
            var0.println("Shutdown Reason: " + var2);
         }
      }, var0);
      section("Early Plugins", () -> {
         List var1 = EarlyPluginLoader.getTransformers();
         var0.println("Class Transformer Count: " + var1.size());

         for (ClassTransformer var3 : var1) {
            var0.println("- " + var3.getClass().getName() + " (priority=" + var3.priority() + ")");
         }
      }, var0);
      section("Plugins", () -> {
         List var1 = HytaleServer.get().getPluginManager().getPlugins();
         var0.println("Plugin Count: " + var1.size());

         for (PluginBase var3 : var1) {
            boolean var4 = var3 class="kw">instanceof JavaPlugin var5 && var5.getClassLoader().isInServerClassPath();
            var0.println("- " + var3.getIdentifier() + (var4 ? " [Builtin]" : " [External]"));
            var0.println("\tType: " + var3.getType().getDisplayName());
            var0.println("\tState: " + var3.getState());
            var0.println("\tManifest:");
            BsonDocument var6 = PluginManifest.CODEC.encode(var3.getManifest()).asDocument();
            printIndented(var0, BsonUtil.toJson(var6), "\t\t");
         }
      }, var0);
      section("Server Config", () -> {
         HytaleServerConfig var1 = HytaleServer.get().getConfig();
         BsonDocument var2 = HytaleServerConfig.CODEC.encode(var1).asDocument();
         printIndented(var0, BsonUtil.toJson(var2), "\t");
      }, var0);
      Map var5 = collectPlayerTextData();
      section(
         "Server Info",
         () -> {
            var0.println("HytaleServer:");
            var0.println("\t- " + HytaleServer.get());
            var0.println("\tBooted: " + HytaleServer.get().isBooting());
            var0.println("\tShutting Down: " + HytaleServer.get().isShuttingDown());
            var0.println();
            var0.println("Worlds: ");
            Map var6 = Universe.get().getWorlds();
            var6.forEach(
               (var6x, var7x) -> {
                  var0.println("- " + var6x + ":");
                  var0.println("\t" + var7x);
                  HistoricMetric var8 = var7x.getBufferedTickLengthMetricSet();
                  long[] var9 = var8.getPeriodsNanos();

                  for (int var10 = 0; var10 < var9.length; var10++) {
                     long var11 = var9[var10];
                     String var13 = FormatUtil.timeUnitToString(var11, TimeUnit.NANOSECONDS, true);
                     double var14 = var8.getAverage(var10);
                     long var16 = var8.calculateMin(var10);
                     long var18 = var8.calculateMax(var10);
                     var0.println(
                        "\tTick ("
                           + var13
                           + "): Min: "
                           + FormatUtil.simpleTimeUnitFormat(var16, TimeUnit.NANOSECONDS, 3)
                           + ", Avg: "
                           + FormatUtil.simpleTimeUnitFormat(Math.round(var14), TimeUnit.NANOSECONDS, 3)
                           + "ns, Max: "
                           + FormatUtil.simpleTimeUnitFormat(var18, TimeUnit.NANOSECONDS, 3)
                     );
                     long[] var20 = var8.getTimestamps(var10);
                     long[] var21 = var8.getValues(var10);
                     StringBuilder var22 = new StringBuilder();
                     var22.append("\tTick Graph ").append(var13).append(":\n");
                     StringUtil.generateGraph(
                        var22,
                        var1,
                        var2,
                        var3 - var11,
                        var3,
                        0.0,
                        Math.max(var18, var7x.getTickStepNanos()),
                        var0x -> FormatUtil.simpleTimeUnitFormat(MathUtil.fastCeil(var0x), TimeUnit.NANOSECONDS, 3),
                        var20.length,
                        var1x -> var20[var1x],
                        var1x -> var21[var1x]
                     );
                     var0.println(var22);
                  }

                  var0.println("\tPlayers: ");

                  for (Player var43 : var7x.getPlayers()) {
                     var0.println("\t- " + var43);
                     DumpUtil.PlayerTextData var12 = var5.get(var43.getUuid());
                     var0.println("\t\tMovement States: " + (var12 != null ? var12.movementStates() : "N/A"));
                     var0.println("\t\tMovement Manager: " + (var12 != null ? var12.movementManager() : "N/A"));
                     var0.println("\t\tPage Manager: " + var43.getPageManager());
                     var0.println("\t\tHud Manager: " + var43.getHudManager());
                     var0.println("\t\tCamera Manager: " + (var12 != null ? var12.cameraManager() : "N/A"));
                     var0.println("\t\tChunk Tracker:");

                     for (String var52 : var43.getPlayerRef().getChunkTracker().getLoadedChunksDebug().split("\n", 0)) {
                        var0.println("\t\t\t" + var52);
                     }

                     var0.println("\t\tQueued Packets Count: " + var43.getPlayerConnection().getQueuedPacketsCount());
                     var0.println("\t\tPing:");

                     for (PongType var53 : PongType.values()) {
                        PacketHandler.PingInfo var17 = var43.getPlayerConnection().getPingInfo(var53);
                        var0.println("\t\t- " + var53.name() + ":");
                        HistoricMetric var55 = var17.getPingMetricSet();
                        long var19 = (long)var55.getAverage(1);
                        long var59 = var55.calculateMin(1);
                        long var23 = var55.calculateMax(1);
                        var0.println("\t\t\tPing: Min: " + var59 + ", Avg: " + var19 + ", Max: " + var23);
                        var0.println(
                           "\t\t\t      Min: "
                              + FormatUtil.timeUnitToString(var59, PacketHandler.PingInfo.TIME_UNIT)
                              + ", Avg: "
                              + FormatUtil.timeUnitToString(var19, PacketHandler.PingInfo.TIME_UNIT)
                              + ", Max: "
                              + FormatUtil.timeUnitToString(var23, PacketHandler.PingInfo.TIME_UNIT)
                        );
                        long[] var56 = var55.getPeriodsNanos();

                        for (int var58 = 0; var58 < var56.length; var58++) {
                           var59 = var56[var58];
                           var23 = var55.calculateMin(1);
                           long maxx = var55.calculateMax(1);
                           long[] var27 = var55.getTimestamps(var58);
                           long[] var28 = var55.getValues(var58);
                           String var29 = FormatUtil.timeUnitToString(var59, TimeUnit.NANOSECONDS, true);
                           StringBuilder var30 = new StringBuilder();
                           var30.append("\t\t\tPing Graph ").append(var29).append(":\n");
                           StringUtil.generateGraph(
                              var30,
                              var1,
                              var2,
                              var3 - var59,
                              var3,
                              var23,
                              maxx,
                              var0x -> FormatUtil.timeUnitToString(MathUtil.fastCeil(var0x), PacketHandler.PingInfo.TIME_UNIT),
                              var27.length,
                              var1x -> var27[var1x],
                              var1x -> var28[var1x]
                           );
                           var0.println(var30);
                        }

                        var0.println(
                           "\t\t\tPacket Queue: Min: "
                              + var17.getPacketQueueMetric().getMin()
                              + ", Avg: "
                              + (long)var17.getPacketQueueMetric().getAverage()
                              + ", Max: "
                              + var17.getPacketQueueMetric().getMax()
                        );
                     }

                     var0.println();
                     PacketStatsRecorder var46 = var43.getPlayerConnection().getPacketStatsRecorder();
                     if (var46 != null) {
                        int var49 = 30;
                        long var51 = 0L;
                        long var54 = 0L;
                        long var57 = 0L;
                        int var61 = 0;
                        long var62 = 0L;
                        long var24 = 0L;
                        var0.println("\t\tPackets Sent:");

                        for (int var26 = 0; var26 < 512; var26++) {
                           PacketStatsRecorder.PacketStatsEntry var65 = var46.getEntry(var26);
                           if (var65.getSentCount() > 0) {
                              var51 += var65.getSentCount();
                              var54 += var65.getSentUncompressedTotal();
                              var57 += var65.getSentCompressedTotal() > 0L ? var65.getSentCompressedTotal() : var65.getSentUncompressedTotal();
                              var0.println("\t\t\t" + var65.getName() + " (" + var26 + "):");
                              printPacketStats(
                                 var0,
                                 "\t\t\t\t",
                                 "Total",
                                 var65.getSentCount(),
                                 var65.getSentUncompressedTotal(),
                                 var65.getSentCompressedTotal(),
                                 var65.getSentUncompressedMin(),
                                 var65.getSentUncompressedMax(),
                                 var65.getSentCompressedMin(),
                                 var65.getSentCompressedMax(),
                                 var65.getSentUncompressedAvg(),
                                 var65.getSentCompressedAvg(),
                                 0
                              );
                              PacketStatsRecorder.RecentStats var66 = var65.getSentRecently();
                              if (var66.count() > 0) {
                                 var61 += var66.count();
                                 var62 += var66.uncompressedTotal();
                                 var24 += var66.compressedTotal() > 0L ? var66.compressedTotal() : var66.uncompressedTotal();
                                 printPacketStats(
                                    var0,
                                    "\t\t\t\t",
                                    "Recent",
                                    var66.count(),
                                    var66.uncompressedTotal(),
                                    var66.compressedTotal(),
                                    var66.uncompressedMin(),
                                    var66.uncompressedMax(),
                                    var66.compressedMin(),
                                    var66.compressedMax(),
                                    (double)var66.uncompressedTotal() / var66.count(),
                                    var66.compressedTotal() > 0L ? (double)var66.compressedTotal() / var66.count() : 0.0,
                                    var49
                                 );
                              }
                           }
                        }

                        var0.println("\t\t\t--- Summary ---");
                        var0.println(
                           "\t\t\t\tTotal: "
                              + var51
                              + " packets, "
                              + FormatUtil.bytesToString(var54)
                              + " serialized, "
                              + FormatUtil.bytesToString(var57)
                              + " wire"
                        );
                        if (var61 > 0) {
                           var0.println(
                              String.format(
                                 "\t\t\t\tRecent: %d packets (%.1f/sec), %s serialized, %s wire",
                                 var61,
                                 (double)var61 / var49,
                                 FormatUtil.bytesToString(var62),
                                 FormatUtil.bytesToString(var24)
                              )
                           );
                        }

                        var0.println();
                        long var64 = 0L;
                        long var67 = 0L;
                        long var68 = 0L;
                        int var32 = 0;
                        long var33 = 0L;
                        long var35 = 0L;
                        var0.println("\t\tPackets Received:");

                        for (int var37 = 0; var37 < 512; var37++) {
                           PacketStatsRecorder.PacketStatsEntry var38 = var46.getEntry(var37);
                           if (var38.getReceivedCount() > 0) {
                              var64 += var38.getReceivedCount();
                              var67 += var38.getReceivedUncompressedTotal();
                              var68 += var38.getReceivedCompressedTotal() > 0L ? var38.getReceivedCompressedTotal() : var38.getReceivedUncompressedTotal();
                              var0.println("\t\t\t" + var38.getName() + " (" + var37 + "):");
                              printPacketStats(
                                 var0,
                                 "\t\t\t\t",
                                 "Total",
                                 var38.getReceivedCount(),
                                 var38.getReceivedUncompressedTotal(),
                                 var38.getReceivedCompressedTotal(),
                                 var38.getReceivedUncompressedMin(),
                                 var38.getReceivedUncompressedMax(),
                                 var38.getReceivedCompressedMin(),
                                 var38.getReceivedCompressedMax(),
                                 var38.getReceivedUncompressedAvg(),
                                 var38.getReceivedCompressedAvg(),
                                 0
                              );
                              PacketStatsRecorder.RecentStats var39 = var38.getReceivedRecently();
                              if (var39.count() > 0) {
                                 var32 += var39.count();
                                 var33 += var39.uncompressedTotal();
                                 var35 += var39.compressedTotal() > 0L ? var39.compressedTotal() : var39.uncompressedTotal();
                                 printPacketStats(
                                    var0,
                                    "\t\t\t\t",
                                    "Recent",
                                    var39.count(),
                                    var39.uncompressedTotal(),
                                    var39.compressedTotal(),
                                    var39.uncompressedMin(),
                                    var39.uncompressedMax(),
                                    var39.compressedMin(),
                                    var39.compressedMax(),
                                    (double)var39.uncompressedTotal() / var39.count(),
                                    var39.compressedTotal() > 0L ? (double)var39.compressedTotal() / var39.count() : 0.0,
                                    var49
                                 );
                              }
                           }
                        }

                        var0.println("\t\t\t--- Summary ---");
                        var0.println(
                           "\t\t\t\tTotal: "
                              + var64
                              + " packets, "
                              + FormatUtil.bytesToString(var67)
                              + " serialized, "
                              + FormatUtil.bytesToString(var68)
                              + " wire"
                        );
                        if (var32 > 0) {
                           var0.println(
                              String.format(
                                 "\t\t\t\tRecent: %d packets (%.1f/sec), %s serialized, %s wire",
                                 var32,
                                 (double)var32 / var49,
                                 FormatUtil.bytesToString(var33),
                                 FormatUtil.bytesToString(var35)
                              )
                           );
                        }

                        var0.println();
                     }
                  }

                  var0.println("\tComponent Stores:");

                  try {
                     CompletableFuture.runAsync(() -> {
                        printComponentStore(var0, var1, var2, "Chunks", var3, var7x.getChunkStore().getStore());
                        printComponentStore(var0, var1, var2, "Entities", var3, var7x.getEntityStore().getStore());
                     }, var7x).orTimeout(30L, TimeUnit.SECONDS).join();
                  } catch (CompletionException var40) {
                     if (!(var40.getCause() class="kw">instanceof TimeoutException)) {
                        var40.printStackTrace();
                        var0.println("\t\tFAILED TO DUMP COMPONENT STORES! EXCEPTION!");
                     } else {
                        var0.println("\t\tFAILED TO DUMP COMPONENT STORES! TIMEOUT!");
                     }
                  }

                  var0.println();
                  var0.println();
                  WorldGenTimingsCollector var42 = var7x.getChunkStore().getGenerator().getTimings();
                  var0.println("\tWorld Gen Timings: ");
                  if (var42 != null) {
                     var0.println("\t\tChunk Count: " + var42.getChunkCounter());
                     var0.println("\t\tChunk Time: " + var42.getChunkTime());
                     var0.println("\t\tZone Biome Result Time: " + var42.zoneBiomeResult());
                     var0.println("\t\tPrepare Time: " + var42.prepare());
                     var0.println("\t\tBlock Generation Time: " + var42.blocksGeneration());
                     var0.println("\t\tCave Generation Time: " + var42.caveGeneration());
                     var0.println("\t\tPrefab Generation: " + var42.prefabGeneration());
                     var0.println("\t\tQueue Length: " + var42.getQueueLength());
                     var0.println("\t\tGenerating Count: " + var42.getGeneratingCount());
                  } else {
                     var0.println("\t\tNo Timings Data Collected!");
                  }
               }
            );
            List var7 = Universe.get().getPlayers().stream().filter(var0x -> var0x.getReference() == null).toList();
            if (!var7.isEmpty()) {
               var0.println();
               var0.println("Players not in world (" + var7.size() + "):");

               for (PlayerRef var9 : var7) {
                  var0.println("- " + var9.getUsername() + " (" + var9.getUuid() + ")");
                  var0.println("\tQueued Packets: " + var9.getPacketHandler().getQueuedPacketsCount());
                  PacketHandler.PingInfo var10 = var9.getPacketHandler().getPingInfo(PongType.Raw);
                  HistoricMetric var11 = var10.getPingMetricSet();
                  long var12 = var11.calculateMin(1);
                  long var14 = (long)var11.getAverage(1);
                  long var16 = var11.calculateMax(1);
                  var0.println(
                     "\tPing(raw): Min: "
                        + FormatUtil.timeUnitToString(var12, PacketHandler.PingInfo.TIME_UNIT)
                        + ", Avg: "
                        + FormatUtil.timeUnitToString(var14, PacketHandler.PingInfo.TIME_UNIT)
                        + ", Max: "
                        + FormatUtil.timeUnitToString(var16, PacketHandler.PingInfo.TIME_UNIT)
                  );
               }
            }
         },
         var0
      );
      section(
         "System info",
         () -> {
            RuntimeMXBean var1 = ManagementFactory.getRuntimeMXBean();
            OperatingSystemMXBean var2 = ManagementFactory.getOperatingSystemMXBean();
            long var3 = System.currentTimeMillis();
            var0.println("Start Time: " + Instant.ofEpochMilli(var1.getStartTime()) + " (" + var1.getStartTime() + "ms)");
            var0.println("Current Time: " + Instant.ofEpochMilli(var3) + " (" + var3 + "ms)");
            var0.println("Process Uptime: " + FormatUtil.timeUnitToString(var1.getUptime(), TimeUnit.MILLISECONDS) + " (" + var1.getUptime() + "ms)");
            var0.println("Available processors (cores): " + Runtime.getRuntime().availableProcessors() + " - " + var2.getAvailableProcessors());
            var0.println("System Load Average: " + var2.getSystemLoadAverage());
            var0.println();
            if (var2 class="kw">instanceof com.sun.management.OperatingSystemMXBean var5) {
               var0.println(
                  "Total Physical Memory: "
                     + FormatUtil.bytesToString(var5.getTotalPhysicalMemorySize())
                     + " ("
                     + var5.getTotalPhysicalMemorySize()
                     + " Bytes)"
               );
               var0.println(
                  "Free Physical Memory: " + FormatUtil.bytesToString(var5.getFreePhysicalMemorySize()) + " (" + var5.getFreePhysicalMemorySize() + " Bytes)"
               );
               var0.println("Total Swap Memory: " + FormatUtil.bytesToString(var5.getTotalSwapSpaceSize()) + " (" + var5.getTotalSwapSpaceSize() + " Bytes)");
               var0.println("Free Swap Memory: " + FormatUtil.bytesToString(var5.getFreeSwapSpaceSize()) + " (" + var5.getFreeSwapSpaceSize() + " Bytes)");
               var0.println("System CPU Load: " + var5.getSystemCpuLoad());
               var0.println("Process CPU Load: " + var5.getProcessCpuLoad());
               var0.println();
            }

            var0.println("Processor Identifier: " + System.getenv("PROCESSOR_IDENTIFIER"));
            var0.println("Processor Architecture: " + System.getenv("PROCESSOR_ARCHITECTURE"));
            var0.println("Processor Architecture W64/32: " + System.getenv("PROCESSOR_ARCHITEW6432"));
            var0.println("Number of Processors: " + System.getenv("NUMBER_OF_PROCESSORS"));
            var0.println();
            var0.println("Runtime Name: " + var1.getName());
            var0.println();
            var0.println("OS Name: " + var2.getName());
            var0.println("OS Arch: " + var2.getArch());
            var0.println("OS Version: " + var2.getVersion());
            var0.println();
            var0.println("Spec Name: " + var1.getSpecName());
            var0.println("Spec Vendor: " + var1.getSpecVendor());
            var0.println("Spec Version: " + var1.getSpecVersion());
            var0.println();
            var0.println("VM Name: " + var1.getVmName());
            var0.println("VM Vendor: " + var1.getVmVendor());
            var0.println("VM Version: " + var1.getVmVersion());
            var0.println();
            var0.println("Management Spec Version: " + var1.getManagementSpecVersion());
            var0.println();
            var0.println("Library Path: " + var1.getLibraryPath());

            try {
               var0.println("Boot ClassPath: " + var1.getBootClassPath());
            } catch (UnsupportedOperationException var6x) {
            }

            var0.println("ClassPath: " + var1.getClassPath());
            var0.println();
            var0.println("Input Arguments: " + var1.getInputArguments());
            var0.println("System Properties: " + var1.getSystemProperties());
         },
         var0
      );
      section("Current process info", () -> {
         MemoryMXBean var1 = ManagementFactory.getMemoryMXBean();
         writeMemoryUsage(var0, "Heap Memory Usage: ", var1.getHeapMemoryUsage());
         writeMemoryUsage(var0, "Non-Heap Memory Usage: ", var1.getNonHeapMemoryUsage());
         var0.println("Objects Pending Finalization Count: " + var1.getObjectPendingFinalizationCount());
      }, var0);
      section("Garbage collector", () -> {
         for (GarbageCollectorMXBean var2 : ManagementFactory.getGarbageCollectorMXBeans()) {
            var0.println("Name: " + var2.getName());
            var0.println("\tMemory Pool Names: " + Arrays.toString(var2.getMemoryPoolNames()));
            var0.println("\tCollection Count: " + var2.getCollectionCount());
            var0.println("\tCollection Time: " + var2.getCollectionTime());
            var0.println();
         }
      }, var0);
      section("Memory pools", () -> {
         for (MemoryPoolMXBean var2 : ManagementFactory.getMemoryPoolMXBeans()) {
            var0.println("Name: " + var2.getName());
            var0.println("\tType: " + var2.getType());
            var0.println("\tPeak Usage: " + var2.getPeakUsage());
            var0.println("\tUsage: " + var2.getUsage());
            var0.println("\tUsage Threshold Supported: " + var2.isUsageThresholdSupported());
            if (var2.isUsageThresholdSupported()) {
               var0.println("\tUsage Threshold: " + var2.getUsageThreshold());
               var0.println("\tUsage Threshold Count: " + var2.getUsageThresholdCount());
               var0.println("\tUsage Threshold Exceeded: " + var2.isUsageThresholdExceeded());
            }

            var0.println("\tCollection Usage: " + var2.getCollectionUsage());
            var0.println("\tCollection Usage Threshold Supported: " + var2.isCollectionUsageThresholdSupported());
            if (var2.isCollectionUsageThresholdSupported()) {
               var0.println("\tCollection Usage Threshold: " + var2.getCollectionUsageThreshold());
               var0.println("\tCollection Usage Threshold Count: " + var2.getCollectionUsageThresholdCount());
               var0.println("\tCollection Usage Threshold Exceeded: " + var2.isCollectionUsageThresholdExceeded());
            }

            var0.println();
         }
      }, var0);
      ThreadMXBean var6 = ManagementFactory.getThreadMXBean();
      ThreadInfo[] var7 = var6.dumpAllThreads(true, true);
      section("Threads (Count: " + var7.length + ")", () -> {
         Map var3 = Thread.getAllStackTraces();
         Long2ObjectMap var4 = new Long2ObjectOpenHashMap();

         for (Thread var6 : var3.keySet()) {
            var4.put(var6.getId(), var6);
         }

         for (ThreadInfo var8 : var7) {
            Thread var9 = (Thread)var4.get(var8.getThreadId());
            if (var9 == null) {
               var0.println("Failed to find thread!!!");
            } else {
               var0.println("Name: " + var9.getName());
               var0.println("State: " + var8.getThreadState());
               var0.println("Thread Class: " + var9.getClass());
               var0.println("Thread Group: " + var9.getThreadGroup());
               var0.println("Priority: " + var9.getPriority());
               var0.println("CPU Time: " + var6.getThreadCpuTime(var8.getThreadId()));
               var0.println("Waited Time: " + var8.getWaitedTime());
               var0.println("Waited Count: " + var8.getWaitedCount());
               var0.println("Blocked Time: " + var8.getBlockedTime());
               var0.println("Blocked Count: " + var8.getBlockedCount());
               var0.println("Lock Name: " + var8.getLockName());
               var0.println("Lock Owner Id: " + var8.getLockOwnerId());
               var0.println("Lock Owner Name: " + var8.getLockOwnerName());
               var0.println("Daemon: " + var9.isDaemon());
               var0.println("Interrupted: " + var9.isInterrupted());
               var0.println("Uncaught Exception Handler: " + var9.getUncaughtExceptionHandler().getClass());
               if (var9 class="kw">instanceof InitStackThread) {
                  var0.println("Init Stack: ");
                  StackTraceElement[] var10 = ((InitStackThread)var9).getInitStack();

                  for (StackTraceElement var14 : var10) {
                     var0.println("\tat " + var14);
                  }
               }

               var0.println("Current Stack: ");
               StackTraceElement[] var17 = var3.get(var9);

               for (StackTraceElement var21 : var17) {
                  var0.println("\tat " + var21);
               }
            }

            var0.println(var8);
         }
      }, var0);
      section("Security Manager", () -> {
         SecurityManager var1 = System.getSecurityManager();
         if (var1 != null) {
            var0.println("Class: " + var1.getClass().getName());
         } else {
            var0.println("No Security Manager found!");
         }
      }, var0);
      section("Classes", () -> {
         ClassLoadingMXBean var1 = ManagementFactory.getClassLoadingMXBean();
         var0.println("Loaded Class Count: " + var1.getLoadedClassCount());
         var0.println("Unloaded Class Count: " + var1.getUnloadedClassCount());
         var0.println("Total Loaded Class Count: " + var1.getTotalLoadedClassCount());
      }, var0);
      section("System Classloader", () -> {
         ClassLoader var1 = ClassLoader.getSystemClassLoader();
         writeClassLoader(var0, var1);
      }, var0);
      section("DumpUtil Classloader", () -> {
         ClassLoader var1 = DumpUtil.class.getClassLoader();
         writeClassLoader(var0, var1);
      }, var0);
   }

   class="kw">private class="kw">static void printPacketStats(
      @Nonnull PrintWriter var0,
      @Nonnull String var1,
      @Nonnull String var2,
      int var3,
      long var4,
      long var6,
      long var8,
      long var10,
      long var12,
      long var14,
      double var16,
      double var18,
      int var20
   ) {
      StringBuilder var21 = new StringBuilder();
      var21.append(var2).append(": ").append(var3).append(" packet").append(var3 != 1 ? "s" : "");
      if (var20 > 0) {
         var21.append(String.format(" (%.1f/sec)", (double)var3 / var20));
      }

      var21.append("\n").append(var1).append("  Size: ").append(FormatUtil.bytesToString(var4));
      if (var6 > 0L) {
         var21.append(" -> ").append(FormatUtil.bytesToString(var6)).append(" wire");
         double var22 = 100.0 * var6 / var4;
         var21.append(String.format(" (%.1f%%)", var22));
      }

      var21.append("\n").append(var1).append("  Avg: ").append(FormatUtil.bytesToString((long)var16));
      if (var18 > 0.0) {
         var21.append(" -> ").append(FormatUtil.bytesToString((long)var18)).append(" wire");
      }

      var21.append("\n").append(var1).append("  Range: ").append(FormatUtil.bytesToString(var8)).append(" - ").append(FormatUtil.bytesToString(var10));
      if (var14 > 0L) {
         var21.append(" (wire: ").append(FormatUtil.bytesToString(var12)).append(" - ").append(FormatUtil.bytesToString(var14)).append(")");
      }

      var0.println(var1 + var21);
   }

   class="kw">private class="kw">static void printComponentStore(@Nonnull PrintWriter var0, int var1, int var2, String var3, long var4, @Nonnull Store<?> var6) {
      var0.println("\t- " + var3 + ":");
      var0.println("\t Archetype Chunk Count: " + var6.getArchetypeChunkCount());
      var0.println("\t Entity Count: " + var6.getEntityCount());
      ComponentRegistry.Data var7 = var6.getRegistry().getData();
      HistoricMetric[] var8 = var6.getSystemMetrics();

      for (int var9 = 0; var9 < var7.getSystemSize(); var9++) {
         ISystem var10 = var7.getSystem(var9);
         HistoricMetric var11 = var8[var9];
         var0.println("\t\t " + var10.getClass().getName());
         var0.println("\t\t " + var10);
         var0.println("\t\t Archetype Chunk Count: " + var6.getArchetypeChunkCountFor(var9));
         var0.println("\t\t Entity Count: " + var6.getEntityCountFor(var9));
         if (var11 != null) {
            long[] var12 = var11.getPeriodsNanos();

            for (int var13 = 0; var13 < var12.length; var13++) {
               long var14 = var12[var13];
               String var16 = FormatUtil.timeUnitToString(var14, TimeUnit.NANOSECONDS, true);
               double var17 = var11.getAverage(var13);
               long var19 = var11.calculateMin(var13);
               long var21 = var11.calculateMax(var13);
               var0.println(
                  "\t\t\t("
                     + var16
                     + "): Min: "
                     + FormatUtil.timeUnitToString(var19, TimeUnit.NANOSECONDS)
                     + ", Avg: "
                     + FormatUtil.timeUnitToString((long)var17, TimeUnit.NANOSECONDS)
                     + ", Max: "
                     + FormatUtil.timeUnitToString(var21, TimeUnit.NANOSECONDS)
               );
               long[] var23 = var11.getTimestamps(var13);
               long[] var24 = var11.getValues(var13);
               StringBuilder var25 = new StringBuilder();
               StringUtil.generateGraph(
                  var25,
                  var1,
                  var2,
                  var4 - var14,
                  var4,
                  var19,
                  var21,
                  var0x -> FormatUtil.timeUnitToString(MathUtil.fastCeil(var0x), TimeUnit.NANOSECONDS),
                  var23.length,
                  var1x -> var23[var1x],
                  var1x -> var24[var1x]
               );
               var0.println(var25);
            }
         }
      }

      var0.println("\t\t Archetype Chunks:");

      for (ArchetypeChunkData var29 : var6.collectArchetypeChunkData()) {
         var0.println("\t\t\t- Entities: " + var29.getEntityCount() + ", Components: " + Arrays.toString(var29.getComponentTypes()));
      }
   }

   class="kw">private class="kw">static void section(String var0, @Nonnull Runnable var1, @Nonnull PrintWriter var2) {
      var2.println("**** " + var0 + " ****");

      try {
         var1.run();
      } catch (Throwable var4) {
         new RuntimeException("Failed to get data for section: " + var0, var4).printStackTrace(var2);
      }

      var2.println();
      var2.println();
   }

   class="kw">private class="kw">static void printIndented(@Nonnull PrintWriter var0, @Nonnull String var1, @Nonnull String var2) {
      for (String var6 : var1.split("\n", 0)) {
         var0.println(var2 + var6);
      }
   }

   class="kw">private class="kw">static void writeMemoryUsage(@Nonnull PrintWriter var0, String var1, @Nonnull MemoryUsage var2) {
      var0.println(var1);
      var0.println("\tInit: " + FormatUtil.bytesToString(var2.getInit()) + " (" + var2.getInit() + " Bytes)");
      var0.println("\tUsed: " + FormatUtil.bytesToString(var2.getUsed()) + " (" + var2.getUsed() + " Bytes)");
      var0.println("\tCommitted: " + FormatUtil.bytesToString(var2.getCommitted()) + " (" + var2.getCommitted() + " Bytes)");
      long var3 = var2.getMax();
      if (var3 > 0L) {
         var0.println("\tMax: " + FormatUtil.bytesToString(var3) + " (" + var3 + " Bytes)");
         long var5 = var3 - var2.getCommitted();
         var0.println("\tFree: " + FormatUtil.bytesToString(var5) + " (" + var5 + " Bytes)");
      }
   }

   class="kw">private class="kw">static void writeClassLoader(@Nonnull PrintWriter var0, @Nullable ClassLoader var1) {
      if (var1 != null) {
         var0.println("Class: " + var1.getClass().getName());

         while (var1.getParent() != null) {
            var1 = var1.getParent();
            var0.println(" - Parent: " + var1.getClass().getName());
         }
      } else {
         var0.println("No class loader found!");
      }
   }

   class="kw">public record PlayerTextData(@Nonnull UUID uuid, @Nullable String movementStates, @Nullable String movementManager, @Nullable String cameraManager) {
      class="kw">public PlayerTextData {
      }
   }
}