Remove timings impl

patches/api/Expose-server-build-information.patch

@@ -320,17 +320,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/UnsafeValues.java
 +++ b/src/main/java/org/bukkit/UnsafeValues.java
 @@ -0,0 +0,0 @@ public interface UnsafeValues {
-      */
-     @Deprecated(forRemoval = true)
-     String getTimingsServerName();
+         return !Bukkit.getUnsafe().isSupportedApiVersion(plugin.getDescription().getAPIVersion());
+     }
+     // Paper end
 +
++    // Paper start
 +    /**
 +     * Called once by the version command on first use, then cached.
 +     */
 +    default com.destroystokyo.paper.util.VersionFetcher getVersionFetcher() {
 +        return new com.destroystokyo.paper.util.VersionFetcher.DummyVersionFetcher();
 +    }
-     // Paper end
++    // Paper end
  }
 diff --git a/src/main/java/org/bukkit/command/defaults/VersionCommand.java b/src/main/java/org/bukkit/command/defaults/VersionCommand.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

patches/api/Timings-v2.patch

@@ -94,7 +94,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            TimingsManager.HISTORY.add(new TimingHistory());
 +            TimingsManager.resetTimings();
 +        }
-+        Bukkit.getUnsafe().reportTimings();
++        //Bukkit.getUnsafe().reportTimings();
 +    }
 +
 +    boolean isViolated() {
@@ -1426,14 +1426,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @param enabled Should timings be reported
 +     */
 +    public static void setTimingsEnabled(boolean enabled) {
-+        timingsEnabled = enabled;
-+        warnAboutDeprecationOnEnable();
-+        reset();
-+    }
-+
-+    private static void warnAboutDeprecationOnEnable() {
-+        if (timingsEnabled && !warnedAboutDeprecationOnEnable) {
-+            Bukkit.getLogger().warning(PlainTextComponentSerializer.plainText().serialize(deprecationMessage()));
++        if (enabled && !warnedAboutDeprecationOnEnable) {
++            Bukkit.getLogger().severe(PlainTextComponentSerializer.plainText().serialize(deprecationMessage()));
 +            warnedAboutDeprecationOnEnable = true;
 +        }
 +    }
@@ -1441,7 +1435,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public static Component deprecationMessage() {
 +        return Component.text()
 +            .color(TextColor.color(0xffc93a))
-+            .append(Component.text("[!] The timings profiler has been enabled but has been scheduled for removal from Paper in the future."))
++            .append(Component.text("[!] The timings profiler is in no-op mode and will be fully removed in a later update."))
 +            .append(Component.newline())
 +            .append(Component.text("    We recommend migrating to the spark profiler."))
 +            .append(Component.newline())
@@ -1674,8 +1668,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        if (!testPermission(sender)) {
 +            return true;
 +        }
-+        if (false) {
++        if (true) {
 +            sender.sendMessage(Timings.deprecationMessage());
++            return true;
 +        }
 +        if (args.length < 1) {
 +            sender.sendMessage(text("Usage: " + this.usageMessage, NamedTextColor.RED));
@@ -2906,35 +2901,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          /**
           * Sends the component to the player
           *
-diff --git a/src/main/java/org/bukkit/UnsafeValues.java b/src/main/java/org/bukkit/UnsafeValues.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/UnsafeValues.java
-+++ b/src/main/java/org/bukkit/UnsafeValues.java
-@@ -0,0 +0,0 @@ public interface UnsafeValues {
-     net.kyori.adventure.text.Component resolveWithContext(net.kyori.adventure.text.Component component, org.bukkit.command.CommandSender context, org.bukkit.entity.Entity scoreboardSubject, boolean bypassPermissions) throws java.io.IOException;
-     // Paper end
- 
-+    /**
-+     * @deprecated Timings will be removed in the future
-+     */
-+    @Deprecated(forRemoval = true)
-+    void reportTimings(); // Paper
-     Material toLegacy(Material material);
- 
-     Material fromLegacy(Material material);
-@@ -0,0 +0,0 @@ public interface UnsafeValues {
-         return !Bukkit.getUnsafe().isSupportedApiVersion(plugin.getDescription().getAPIVersion());
-     }
-     // Paper end
-+
-+    // Paper start
-+    /**
-+     * @deprecated Timings will be removed in the future
-+     */
-+    @Deprecated(forRemoval = true)
-+    String getTimingsServerName();
-+    // Paper end
- }
 diff --git a/src/main/java/org/bukkit/command/BufferedCommandSender.java b/src/main/java/org/bukkit/command/BufferedCommandSender.java
 new file mode 100644
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
@@ -3560,8 +3526,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      /**
 @@ -0,0 +0,0 @@ public final class SimplePluginManager implements PluginManager {
+      *
       * @param use True if per event timing code should be used
       */
++    @Deprecated(forRemoval = true)
      public void useTimings(boolean use) {
 -        useTimings = use;
 +        co.aikar.timings.Timings.setTimingsEnabled(use); // Paper

patches/server/Add-NamespacedKey-biome-methods.patch

@@ -10,10 +10,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
 +++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
 @@ -0,0 +0,0 @@ public final class CraftMagicNumbers implements UnsafeValues {
+         var supplier = net.minecraft.world.entity.ai.attributes.DefaultAttributes.getSupplier((net.minecraft.world.entity.EntityType<? extends net.minecraft.world.entity.LivingEntity>) net.minecraft.core.registries.BuiltInRegistries.ENTITY_TYPE.getValue(CraftNamespacedKey.toMinecraft(bukkitEntityKey)));
+         return new io.papermc.paper.attribute.UnmodifiableAttributeMap(supplier);
      }
-     // Paper end
- 
-+    // Paper start - namespaced key biome methods
++
 +    @Override
 +    public org.bukkit.NamespacedKey getBiomeKey(org.bukkit.RegionAccessor accessor, int x, int y, int z) {
 +        org.bukkit.craftbukkit.CraftRegionAccessor cra = (org.bukkit.craftbukkit.CraftRegionAccessor) accessor;
@@ -26,8 +26,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        net.minecraft.core.Holder<net.minecraft.world.level.biome.Biome> biomeBase = cra.getHandle().registryAccess().lookupOrThrow(net.minecraft.core.registries.Registries.BIOME).getOrThrow(net.minecraft.resources.ResourceKey.create(net.minecraft.core.registries.Registries.BIOME, org.bukkit.craftbukkit.util.CraftNamespacedKey.toMinecraft(biomeKey)));
 +        cra.setBiome(x, y, z, biomeBase);
 +    }
-+    // Paper end - namespaced key biome methods
-+
-     @Override
-     public String get(Class<?> aClass, String s) {
-         if (aClass == Enchantment.class) {
+     // Paper end
+ 
+     /**

patches/server/Add-Raw-Byte-ItemStack-Serialization.patch

@@ -62,4 +62,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
      // Paper end
  
-     @Override
+     /**

patches/server/Add-api-for-spawn-egg-texture-colors.patch

@@ -9,8 +9,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
 +++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
 @@ -0,0 +0,0 @@ public final class CraftMagicNumbers implements UnsafeValues {
-         return CraftRegistry.get(registry, namespacedKey, ApiVersion.CURRENT);
      }
+     // Paper end
  
 +    // Paper start - spawn egg color visibility
 +    @Override

patches/server/Add-debug-for-sync-chunk-loads.patch

@@ -308,11 +308,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
  
              Objects.requireNonNull(completablefuture);
-             if (!completablefuture.isDone()) { // Paper
-+                com.destroystokyo.paper.io.SyncLoadFinder.logSyncLoad(this.level, x, z); // Paper - Add debug for sync chunk loads
-                 this.level.timings.syncChunkLoad.startTiming(); // Paper
              chunkproviderserver_b.managedBlock(completablefuture::isDone);
-                 this.level.timings.syncChunkLoad.stopTiming(); // Paper
++            // com.destroystokyo.paper.io.SyncLoadFinder.logSyncLoad(this.level, x, z); // Paper - Add debug for sync chunk loads
+             ChunkResult<ChunkAccess> chunkresult = (ChunkResult) completablefuture.join();
+             ChunkAccess ichunkaccess1 = (ChunkAccess) chunkresult.orElse(null); // CraftBukkit - decompile error
+ 
 diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java

patches/server/Add-tick-times-API-and-mspt-command.patch

@@ -151,7 +151,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        // Paper end - Add tick times API and /mspt command
          this.logTickMethodTime(i);
          gameprofilerfiller.pop();
-         co.aikar.timings.TimingsManager.FULL_SERVER_TICK.stopTiming(); // Paper
+     }
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
      public static record ServerResourcePackInfo(UUID id, String url, String hash, boolean isRequired, @Nullable Component prompt) {
  

patches/server/Anti-Xray.patch

@@ -1178,9 +1178,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      // Paper end - add paper world config
  
 +    public final com.destroystokyo.paper.antixray.ChunkPacketBlockController chunkPacketBlockController; // Paper - Anti-Xray
-     public final co.aikar.timings.WorldTimingsHandler timings; // Paper
      public static BlockPos lastPhysicsProblem; // Spigot
      private org.spigotmc.TickLimiter entityLimiter;
+     private org.spigotmc.TickLimiter tileLimiter;
 @@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
  
      public abstract ResourceKey<LevelStem> getTypeKey();
@@ -1191,7 +1191,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.paperConfig = paperWorldConfigCreator.apply(this.spigotConfig); // Paper - create paper world config
          this.generator = gen;
 @@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-         this.timings = new co.aikar.timings.WorldTimingsHandler(this); // Paper - code below can generate new world and access timings
+         // CraftBukkit end
          this.entityLimiter = new org.spigotmc.TickLimiter(this.spigotConfig.entityMaxTickTime);
          this.tileLimiter = new org.spigotmc.TickLimiter(this.spigotConfig.tileMaxTickTime);
 +        this.chunkPacketBlockController = this.paperConfig().anticheat.antiXray.enabled ? new com.destroystokyo.paper.antixray.ChunkPacketBlockControllerAntiXray(this, executor) : com.destroystokyo.paper.antixray.ChunkPacketBlockController.NO_OPERATION_INSTANCE; // Paper - Anti-Xray

patches/server/Async-command-map-building.patch

@@ -61,6 +61,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
          MinecraftServer.LOGGER.info("Stopping server");
 +        Commands.COMMAND_SENDING_POOL.shutdownNow(); // Paper - Perf: Async command map building; Shutdown and don't bother finishing
-         MinecraftTimings.stopServer(); // Paper
          // CraftBukkit start
          if (this.server != null) {
+             this.server.disablePlugins();

patches/server/Brigadier-based-command-API.patch

@@ -2345,10 +2345,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
      }
  
-+    @Deprecated // Paper
-     public void handleCommand(String s) { // Paper - private -> public
+-    private void handleCommand(String s) {
 -        org.spigotmc.AsyncCatcher.catchOp("Command Dispatched Async: " + s); // Paper - Add async catcher
--        co.aikar.timings.MinecraftTimings.playerCommandTimer.startTiming(); // Paper
 -        if ( org.spigotmc.SpigotConfig.logCommands ) // Spigot
 -        this.LOGGER.info(this.player.getScoreboardName() + " issued server command: " + s);
 -
@@ -2358,7 +2356,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        this.cserver.getPluginManager().callEvent(event);
 -
 -        if (event.isCancelled()) {
--            co.aikar.timings.MinecraftTimings.playerCommandTimer.stopTiming(); // Paper
 -            return;
 -        }
 -
@@ -2371,7 +2368,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -            java.util.logging.Logger.getLogger(ServerGamePacketListenerImpl.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
 -            return;
 -        } finally {
--            co.aikar.timings.MinecraftTimings.playerCommandTimer.stopTiming(); // Paper
++    @Deprecated // Paper
++    public void handleCommand(String s) { // Paper - private -> public
 +        // Paper start - Remove all this old duplicated logic
 +        if (s.startsWith("/")) {
 +            s = s.substring(1);

patches/server/Bundle-spark.patch

@@ -282,9 +282,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          io.papermc.paper.command.brigadier.PaperCommands.INSTANCE.setValid(); // Paper - reset invalid state for event fire below
          io.papermc.paper.plugin.lifecycle.event.LifecycleEventRunner.INSTANCE.callReloadableRegistrarEvent(io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents.COMMANDS, io.papermc.paper.command.brigadier.PaperCommands.INSTANCE, org.bukkit.plugin.Plugin.class, io.papermc.paper.plugin.lifecycle.event.registrar.ReloadableRegistrarEvent.Cause.INITIAL); // Paper - call commands event for regular plugins
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
          MinecraftServer.LOGGER.info("Stopping server");
          Commands.COMMAND_SENDING_POOL.shutdownNow(); // Paper - Perf: Async command map building; Shutdown and don't bother finishing
-         MinecraftTimings.stopServer(); // Paper
 +        this.server.spark.disable(); // Paper - spark
          // CraftBukkit start
          if (this.server != null) {
@@ -298,13 +298,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              // Paper end - Improved Watchdog Support
              org.spigotmc.WatchdogThread.hasStarted = true; // Paper
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         });
-         isOversleep = false;MinecraftTimings.serverOversleep.stopTiming();
-         // Paper end
+             }
+         }
+ 
 +        this.server.spark.tickStart(); // Paper - spark
          new com.destroystokyo.paper.event.server.ServerTickStartEvent(this.tickCount+1).callEvent(); // Paper - Server Tick Events
- 
          ++this.tickCount;
+         this.tickRateManager.tick();
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
          long remaining = (TICK_TIME - (endTime - lastTick)) - catchupTime;
          new com.destroystokyo.paper.event.server.ServerTickEndEvent(this.tickCount, ((double)(endTime - lastTick) / 1000000D), remaining).callEvent();

patches/server/Configurable-feature-seeds.patch

@@ -5,19 +5,6 @@ Subject: [PATCH] Configurable feature seeds
 
 Co-authored-by: Thonk <30448663+ExcessiveAmountsOfZombies@users.noreply.github.com>
 
-diff --git a/src/main/java/co/aikar/timings/TimingsExport.java b/src/main/java/co/aikar/timings/TimingsExport.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/co/aikar/timings/TimingsExport.java
-+++ b/src/main/java/co/aikar/timings/TimingsExport.java
-@@ -0,0 +0,0 @@ public class TimingsExport extends Thread {
-         JSONObject object = new JSONObject();
-         for (String key : config.getKeys(false)) {
-             String fullKey = (parentKey != null ? parentKey + "." + key : key);
--            if (fullKey.equals("database") || fullKey.equals("settings.bungeecord-addresses") || TimingsManager.hiddenConfigs.contains(fullKey) || key.startsWith("seed-") || key.equals("worldeditregentempworld")) {
-+            if (fullKey.equals("database") || fullKey.equals("settings.bungeecord-addresses") || TimingsManager.hiddenConfigs.contains(fullKey) || key.startsWith("seed-") || key.equals("worldeditregentempworld") || key.equals("feature-seeds")) {
-                 continue;
-             }
-             final Object val = config.get(key);
 diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java b/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java

patches/server/Configurable-max-block-fluid-ticks.patch

@@ -19,4 +19,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            this.fluidTicks.tick(j, paperConfig().environment.maxFluidTicks, this::tickFluid); // Paper - configurable max fluid ticks
              gameprofilerfiller.pop();
          }
-         this.timings.scheduledBlocks.stopTiming(); // Paper
+ 

patches/server/Detail-more-information-in-watchdog-dumps.patch

@@ -61,7 +61,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                try { // Paper - detailed watchdog information
                  if (listener instanceof ServerCommonPacketListenerImpl serverCommonPacketListener && serverCommonPacketListener.processedDisconnect) return; // CraftBukkit - Don't handle sync packets for kicked players
                  if (listener.shouldHandleMessage(packet)) {
-                     co.aikar.timings.Timing timing = co.aikar.timings.MinecraftTimings.getPacketTiming(packet); // Paper - timings
+                     try {
 @@ -0,0 +0,0 @@ public class PacketUtils {
                  } else {
                      PacketUtils.LOGGER.debug("Ignoring packet due to disconnection: {}", packet);
@@ -103,14 +103,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                currentlyTickingEntity.lazySet(entity);
 +            }
 +            // Paper end - log detailed entity tick information
-         ++TimingHistory.entityTicks; // Paper - timings
          // Spigot start
-         co.aikar.timings.Timing timer; // Paper
+         /*if (!org.spigotmc.ActivationRange.checkIfActive(entity)) { // Paper - comment out EAR 2
+             entity.tickCount++;
 @@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
              this.tickPassenger(entity, entity1, isActive); // Paper - EAR 2
          }
-         // } finally { timer.stopTiming(); } // Paper - timings // EAR 2
--
+ 
 +        // Paper start - log detailed entity tick information
 +        } finally {
 +            if (currentlyTickingEntity.get() == entity) {

patches/server/Disable-ice-and-snow.patch

@@ -21,4 +21,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        } // Paper - Option to disable ice and snow
  
          gameprofilerfiller.popPush("tickBlocks");
-         timings.chunkTicksBlocks.startTiming(); // Paper
+         if (randomTickSpeed > 0) {

patches/server/Enforce-Sync-Player-Saves.patch

@@ -15,12 +15,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public void saveAll() {
 +        io.papermc.paper.util.MCUtil.ensureMain("Save Players" , () -> { // Paper - Ensure main
-         MinecraftTimings.savePlayers.startTiming(); // Paper
          for (int i = 0; i < this.players.size(); ++i) {
--            this.save((ServerPlayer) this.players.get(i));
-+            this.save(this.players.get(i));
+             this.save((ServerPlayer) this.players.get(i));
          }
-         MinecraftTimings.savePlayers.stopTiming(); // Paper
+ 
 +        return null; }); // Paper - ensure main
      }
  

patches/server/Entity-Activation-Range-2.0.patch

@@ -20,36 +20,22 @@ diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/mai
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java
 +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ package net.minecraft.server.level;
- 
- import com.google.common.annotations.VisibleForTesting;
- import co.aikar.timings.TimingHistory; // Paper
--import co.aikar.timings.Timings; // Paper
- import com.google.common.collect.Lists;
- import com.mojang.datafixers.DataFixer;
- import com.mojang.datafixers.util.Pair;
 @@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-         ++TimingHistory.entityTicks; // Paper - timings
+ 
+     public void tickNonPassenger(Entity entity) {
          // Spigot start
-         co.aikar.timings.Timing timer; // Paper
 -        if (!org.spigotmc.ActivationRange.checkIfActive(entity)) {
-+        /*if (!org.spigotmc.ActivationRange.checkIfActive(entity)) { // Paper - comment out - EAR 2, reimplement below
++        /*if (!org.spigotmc.ActivationRange.checkIfActive(entity)) { // Paper - comment out EAR 2
              entity.tickCount++;
-             timer = entity.getType().inactiveTickTimer.startTiming(); try { // Paper - timings
              entity.inactiveTick();
-             } finally { timer.stopTiming(); } // Paper
              return;
 -        }
 +        }*/ // Paper - comment out EAR 2
          // Spigot end
-         // Paper start- timings
--        TimingHistory.activatedEntityTicks++;
--        timer = entity.getVehicle() != null ? entity.getType().passengerTickTimer.startTiming() : entity.getType().tickTimer.startTiming();
-+        final boolean isActive = org.spigotmc.ActivationRange.checkIfActive(entity);
-+        timer = isActive ? entity.getType().tickTimer.startTiming() : entity.getType().inactiveTickTimer.startTiming(); // Paper
-         try {
-         // Paper end - timings
++        final boolean isActive = org.spigotmc.ActivationRange.checkIfActive(entity); // Paper - EAR 2
          entity.setOldPosAndRot();
+         ProfilerFiller gameprofilerfiller = Profiler.get();
+ 
 @@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
              return BuiltInRegistries.ENTITY_TYPE.getKey(entity.getType()).toString();
          });
@@ -59,7 +45,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          entity.postTick(); // CraftBukkit
 +        } else { entity.inactiveTick(); } // Paper - EAR 2
          gameprofilerfiller.pop();
-+        } finally { timer.stopTiming(); } // Paper - timings // EAR 2
          Iterator iterator = entity.getPassengers().iterator();
  
          while (iterator.hasNext()) {
@@ -68,8 +53,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -            this.tickPassenger(entity, entity1);
 +            this.tickPassenger(entity, entity1, isActive); // Paper - EAR 2
          }
--        } finally { timer.stopTiming(); } // Paper - timings
-+        // } finally { timer.stopTiming(); } // Paper - timings // EAR 2
  
      }
  
@@ -408,26 +391,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  import net.minecraft.world.entity.projectile.FireworkRocketEntity;
  import net.minecraft.world.entity.projectile.ThrowableProjectile;
  import net.minecraft.world.entity.projectile.ThrownTrident;
- import net.minecraft.world.entity.raid.Raider;
-+import co.aikar.timings.MinecraftTimings;
-+import net.minecraft.world.entity.schedule.Activity;
- import net.minecraft.world.level.Level;
- import net.minecraft.world.phys.AABB;
--import co.aikar.timings.MinecraftTimings;
- 
- public class ActivationRange
- {
 @@ -0,0 +0,0 @@ public class ActivationRange
  
          AABB boundingBox = new AABB( 0, 0, 0, 0, 0, 0 );
      }
 +    // Paper start
 +
-+    static Activity[] VILLAGER_PANIC_IMMUNITIES = {
-+        Activity.HIDE,
-+        Activity.PRE_RAID,
-+        Activity.RAID,
-+        Activity.PANIC
++    static net.minecraft.world.entity.schedule.Activity[] VILLAGER_PANIC_IMMUNITIES = {
++        net.minecraft.world.entity.schedule.Activity.HIDE,
++        net.minecraft.world.entity.schedule.Activity.PRE_RAID,
++        net.minecraft.world.entity.schedule.Activity.RAID,
++        net.minecraft.world.entity.schedule.Activity.PANIC
 +    };
 +
 +    private static int checkInactiveWakeup(Entity entity) {
@@ -556,8 +530,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            }
 +            // Paper end
          }
-         MinecraftTimings.entityActivationCheckTimer.stopTiming();
      }
+ 
 @@ -0,0 +0,0 @@ public class ActivationRange
       * @param entity
       * @return
@@ -620,7 +594,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              {
 -                return true;
 +                return 20; // Paper
-+            }
+             }
+-            if ( entity instanceof Villager && ( (Villager) entity ).canBreed() )
 +            // Paper start
 +            if (entity instanceof Bee) {
 +                Bee bee = (Bee)entity;
@@ -631,13 +606,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                ) {
 +                    return 20;
 +                }
-             }
--            if ( entity instanceof Villager && ( (Villager) entity ).canBreed() )
++            }
 +            if ( entity instanceof Villager ) {
 +                Brain<Villager> behaviorController = ((Villager) entity).getBrain();
 +
 +                if (config.villagersActiveForPanic) {
-+                    for (Activity activity : VILLAGER_PANIC_IMMUNITIES) {
++                    for (net.minecraft.world.entity.schedule.Activity activity : VILLAGER_PANIC_IMMUNITIES) {
 +                        if (behaviorController.isActive(activity)) {
 +                            return 20*5;
 +                        }
@@ -645,7 +619,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                }
 +
 +                if (config.villagersWorkImmunityAfter > 0 && inactiveFor >= config.villagersWorkImmunityAfter) {
-+                    if (behaviorController.isActive(Activity.WORK)) {
++                    if (behaviorController.isActive(net.minecraft.world.entity.schedule.Activity.WORK)) {
 +                        return config.villagersWorkImmunityFor;
 +                    }
 +                }
@@ -677,11 +651,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            // Paper start
 +            if (entity instanceof Mob && ((Mob) entity).targetSelector.hasTasks() ) {
 +                return 0;
-             }
++            }
 +            if (entity instanceof Pillager) {
 +                Pillager pillager = (Pillager) entity;
 +                // TODO:?
-+            }
+             }
 +            // Paper end
          }
          // SPIGOT-6644: Otherwise the target refresh tick will be missed

patches/server/Expand-world-key-API.patch

@@ -81,4 +81,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
      // Paper end
  
-     @Override
+     /**

patches/server/Expose-protocol-version.patch

@@ -19,4 +19,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
      // Paper end
  
-     @Override
+     /**

patches/server/Expose-server-build-information.patch

@@ -696,17 +696,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
 +++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
 @@ -0,0 +0,0 @@ public final class CraftMagicNumbers implements UnsafeValues {
-     public String getTimingsServerName() {
-         return io.papermc.paper.configuration.GlobalConfiguration.get().timings.serverName;
+         return CraftRegistry.get(registry, namespacedKey, ApiVersion.CURRENT);
      }
-+
+ 
++    // Paper start
 +    @Override
 +    public com.destroystokyo.paper.util.VersionFetcher getVersionFetcher() {
 +        return new com.destroystokyo.paper.PaperVersionFetcher();
 +    }
-     // Paper end
- 
-     @Override
++    // Paper end
++
+     /**
+      * This helper class represents the different NBT Tags.
+      * <p>
 diff --git a/src/main/java/org/spigotmc/WatchdogThread.java b/src/main/java/org/spigotmc/WatchdogThread.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/spigotmc/WatchdogThread.java

patches/server/Expose-the-Entity-Counter-to-allow-plugins-to-use-va.patch

@@ -35,4 +35,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
      // Paper end
  
-     @Override
+     /**

patches/server/Fix-MC-117075-Block-entity-unload-lag-spike.patch

@@ -30,5 +30,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
 +        this.blockEntityTickers.removeAll(toRemove); // Paper - Fix MC-117075
  
-         this.timings.tileEntityTick.stopTiming(); // Spigot
          this.tickingBlockEntities = false;
+         gameprofilerfiller.pop();

patches/server/Fix-custom-statistic-criteria-creation.patch

@@ -9,17 +9,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
 +++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
 @@ -0,0 +0,0 @@ public final class CraftMagicNumbers implements UnsafeValues {
+         net.minecraft.core.Holder<net.minecraft.world.level.biome.Biome> biomeBase = cra.getHandle().registryAccess().lookupOrThrow(net.minecraft.core.registries.Registries.BIOME).getOrThrow(net.minecraft.resources.ResourceKey.create(net.minecraft.core.registries.Registries.BIOME, org.bukkit.craftbukkit.util.CraftNamespacedKey.toMinecraft(biomeKey)));
+         cra.setBiome(x, y, z, biomeBase);
      }
-     // Paper end - namespaced key biome methods
- 
-+    // Paper start - fix custom stats criteria creation
++
 +    @Override
 +    public String getStatisticCriteriaKey(org.bukkit.Statistic statistic) {
 +        if (statistic.getType() != org.bukkit.Statistic.Type.UNTYPED) return "minecraft.custom:minecraft." + statistic.getKey().getKey();
 +        return org.bukkit.craftbukkit.CraftStatistic.getNMSStatistic(statistic).getName();
 +    }
-+    // Paper end - fix custom stats criteria creation
-+
-     @Override
-     public String get(Class<?> aClass, String s) {
-         if (aClass == Enchantment.class) {
+     // Paper end
+ 
+     /**

patches/server/Folia-scheduler-and-owned-region-API.patch

@@ -1152,9 +1152,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         MinecraftTimings.bukkitSchedulerTimer.startTiming(); // Spigot // Paper
+             entityplayer.connection.suspendFlushing();
+         });
          this.server.getScheduler().mainThreadHeartbeat(); // CraftBukkit
-         MinecraftTimings.bukkitSchedulerTimer.stopTiming(); // Spigot // Paper
 +        // Paper start - Folia scheduler API
 +        ((io.papermc.paper.threadedregions.scheduler.FoliaGlobalRegionScheduler) Bukkit.getGlobalRegionScheduler()).tick();
 +        getAllLevels().forEach(level -> {
@@ -1171,7 +1171,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        // Paper end - Folia scheduler API
          io.papermc.paper.adventure.providers.ClickCallbackProviderImpl.CALLBACK_MANAGER.handleQueue(this.tickCount); // Paper
          gameprofilerfiller.push("commandFunctions");
-         MinecraftTimings.commandFunctionsTimer.startTiming(); // Spigot // Paper
+         this.getFunctions().tick();
 diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/players/PlayerList.java

patches/server/Get-entity-default-attributes.patch

@@ -102,7 +102,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
      // Paper end
  
-     @Override
+     /**
 diff --git a/src/test/java/io/papermc/paper/attribute/EntityTypeAttributesTest.java b/src/test/java/io/papermc/paper/attribute/EntityTypeAttributesTest.java
 new file mode 100644
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000

patches/server/Improve-Player-chat-API-handling.patch

@@ -30,15 +30,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          } else if (this.player.getChatVisibility() == ChatVisiblity.SYSTEM) {
              // Do nothing, this is coming from a plugin
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-         }
      }
  
--    private void handleCommand(String s) {
-+    public void handleCommand(String s) { // Paper - private -> public
+     private void handleCommand(String s) {
 +        org.spigotmc.AsyncCatcher.catchOp("Command Dispatched Async: " + s); // Paper - Add async catcher
-         co.aikar.timings.MinecraftTimings.playerCommandTimer.startTiming(); // Paper
          if ( org.spigotmc.SpigotConfig.logCommands ) // Spigot
          this.LOGGER.info(this.player.getScoreboardName() + " issued server command: " + s);
+ 
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java

patches/server/Improved-Async-Task-Scheduler.patch

@@ -353,18 +353,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
 -    private void parsePending() {
--        MinecraftTimings.bukkitSchedulerPendingTimer.startTiming();
 +    void parsePending() { // Paper
-+        if (!this.isAsyncScheduler) MinecraftTimings.bukkitSchedulerPendingTimer.startTiming(); // Paper
          CraftTask head = this.head;
          CraftTask task = head.getNext();
          CraftTask lastTask = head;
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-             task.setNext(null);
-         }
-         this.head = lastTask;
--        MinecraftTimings.bukkitSchedulerPendingTimer.stopTiming();
-+        if (!this.isAsyncScheduler) MinecraftTimings.bukkitSchedulerPendingTimer.stopTiming(); // Paper
-     }
- 
-     private boolean isReady(final int currentTick) {

patches/server/Incremental-chunk-and-player-saving.patch

@@ -65,24 +65,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            org.bukkit.Bukkit.getPluginManager().callEvent(new org.bukkit.event.world.WorldSaveEvent(getWorld()));
 +        }
 +
-+        try (co.aikar.timings.Timing ignored = this.timings.worldSave.startTiming()) {
-+            if (doFull) {
-+                this.saveLevelData(true);
-+            }
-+
-+            // chunk autosave is already called by the ChunkSystem during unload processing (ChunkMap#processUnloads)
-+
-+            // Copied from save()
-+            // CraftBukkit start - moved from MinecraftServer.saveChunks
-+            if (doFull) { // Paper
-+                ServerLevel worldserver1 = this;
-+
-+                this.serverLevelData.setWorldBorder(worldserver1.getWorldBorder().createSettings());
-+                this.serverLevelData.setCustomBossEvents(this.server.getCustomBossEvents().save(this.registryAccess()));
-+                this.convertable.saveDataTag(this.server.registryAccess(), this.serverLevelData, this.server.getPlayerList().getSingleplayerData());
-+            }
-+            // CraftBukkit end
++        if (doFull) {
++            this.saveLevelData(true);
 +        }
++        // chunk autosave is already called by the ChunkSystem during unload processing (ChunkMap#processUnloads)
++        // Copied from save()
++        // CraftBukkit start - moved from MinecraftServer.saveChunks
++        if (doFull) { // Paper
++            ServerLevel worldserver1 = this;
++            this.serverLevelData.setWorldBorder(worldserver1.getWorldBorder().createSettings());
++            this.serverLevelData.setCustomBossEvents(this.server.getCustomBossEvents().save(this.registryAccess()));
++            this.convertable.saveDataTag(this.server.registryAccess(), this.serverLevelData, this.server.getPlayerList().getSingleplayerData());
++        }
++        // CraftBukkit end
 +    }
 +    // Paper end - Incremental chunk and player saving
 +
@@ -123,17 +118,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    public void saveAll(int interval) {
          io.papermc.paper.util.MCUtil.ensureMain("Save Players" , () -> { // Paper - Ensure main
-         MinecraftTimings.savePlayers.startTiming(); // Paper
 +        int numSaved = 0;
 +        long now = MinecraftServer.currentTick;
          for (int i = 0; i < this.players.size(); ++i) {
--            this.save(this.players.get(i));
-+            ServerPlayer entityplayer = this.players.get(i);
-+            if (interval == -1 || now - entityplayer.lastSave >= interval) {
-+                this.save(entityplayer);
+-            this.save((ServerPlayer) this.players.get(i));
++            final ServerPlayer player = this.players.get(i);
++            if (interval == -1 || now - player.lastSave >= interval) {
++                this.save(player);
 +                if (interval != -1 && ++numSaved >= io.papermc.paper.configuration.GlobalConfiguration.get().playerAutoSave.maxPerTick()) { break; }
 +            }
 +            // Paper end - Incremental chunk and player saving
          }
-         MinecraftTimings.savePlayers.stopTiming(); // Paper
+ 
          return null; }); // Paper - ensure main

patches/server/ItemStack-Tooltip-API.patch

@@ -9,10 +9,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
 +++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
 @@ -0,0 +0,0 @@ public final class CraftMagicNumbers implements UnsafeValues {
+         if (statistic.getType() != org.bukkit.Statistic.Type.UNTYPED) return "minecraft.custom:minecraft." + statistic.getKey().getKey();
+         return org.bukkit.craftbukkit.CraftStatistic.getNMSStatistic(statistic).getName();
      }
-     // Paper end - fix custom stats criteria creation
- 
-+    // Paper start - expose itemstack tooltip lines
++
 +    @Override
 +    public java.util.List<net.kyori.adventure.text.Component> computeTooltipLines(final ItemStack itemStack, final io.papermc.paper.inventory.tooltip.TooltipContext tooltipContext, final org.bukkit.entity.Player player) {
 +        Preconditions.checkArgument(tooltipContext != null, "tooltipContext cannot be null");
@@ -25,8 +25,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            player == null ? null : ((org.bukkit.craftbukkit.entity.CraftPlayer) player).getHandle(), flag);
 +        return lines.stream().map(io.papermc.paper.adventure.PaperAdventure::asAdventure).toList();
 +    }
-+    // Paper end - expose itemstack tooltip lines
-+
-     @Override
-     public String get(Class<?> aClass, String s) {
-         if (aClass == Enchantment.class) {
+     // Paper end
+ 
+     // Paper start - spawn egg color visibility

patches/server/ItemStack-repair-check-API.patch

@@ -22,7 +22,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
      // Paper end
  
-     @Override
+     /**
 diff --git a/src/test/java/io/papermc/paper/util/ItemStackRepairCheckTest.java b/src/test/java/io/papermc/paper/util/ItemStackRepairCheckTest.java
 new file mode 100644
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000

patches/server/Moonrise-optimisation-patches.patch

@@ -23390,8 +23390,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
 @@ -0,0 +0,0 @@ import org.bukkit.event.server.ServerLoadEvent;
+ // CraftBukkit end
  
- import co.aikar.timings.MinecraftTimings; // Paper
  
 -public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTask> implements ServerInfo, ChunkIOErrorReporter, CommandSource {
 +public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTask> implements ServerInfo, ChunkIOErrorReporter, CommandSource, ca.spottedleaf.moonrise.patches.chunk_system.server.ChunkSystemMinecraftServer { // Paper - rewrite chunk system
@@ -26436,12 +26436,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -            ServerChunkCache.MainThreadExecutor chunkproviderserver_b = this.mainThreadProcessor;
 -
 -            Objects.requireNonNull(completablefuture);
--            if (!completablefuture.isDone()) { // Paper
--                com.destroystokyo.paper.io.SyncLoadFinder.logSyncLoad(this.level, x, z); // Paper - Add debug for sync chunk loads
--                this.level.timings.syncChunkLoad.startTiming(); // Paper
 -            chunkproviderserver_b.managedBlock(completablefuture::isDone);
--                this.level.timings.syncChunkLoad.stopTiming(); // Paper
--            } // Paper
+-            // com.destroystokyo.paper.io.SyncLoadFinder.logSyncLoad(this.level, x, z); // Paper - Add debug for sync chunk loads
 -            ChunkResult<ChunkAccess> chunkresult = (ChunkResult) completablefuture.join();
 -            ChunkAccess ichunkaccess1 = (ChunkAccess) chunkresult.orElse(null); // CraftBukkit - decompile error
 -
@@ -26622,9 +26618,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public void save(boolean flush) {
 -        this.runDistanceManagerUpdates();
 +        // Paper - rewrite chunk system
-         try (co.aikar.timings.Timing timed = level.timings.chunkSaveData.startTiming()) { // Paper - Timings
          this.chunkMap.saveAllChunks(flush);
-         } // Paper - Timings
+     }
+ 
 @@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
      }
  
@@ -26647,13 +26643,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
          gameprofilerfiller.push("purge");
 @@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
+         this.runDistanceManagerUpdates();
          gameprofilerfiller.popPush("chunks");
          if (tickChunks) {
-             this.level.timings.chunks.startTiming(); // Paper - timings
 +            ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)this.level).moonrise$getPlayerChunkLoader().tick(); // Paper - rewrite chunk system
              this.tickChunks();
-             this.level.timings.chunks.stopTiming(); // Paper - timings
              this.chunkMap.tick();
+         }
 @@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
                      gameprofilerfiller.push("filteringTickingChunks");
                      this.collectTickingChunks(list);
@@ -27290,8 +27286,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
          }
 @@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+ 
          gameprofilerfiller.popPush("tickBlocks");
-         timings.chunkTicksBlocks.startTiming(); // Paper
          if (randomTickSpeed > 0) {
 -            LevelChunkSection[] achunksection = chunk.getSections();
 -
@@ -27325,7 +27321,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            this.optimiseRandomTick(chunk, randomTickSpeed); // Paper - optimise random ticking
          }
  
-         timings.chunkTicksBlocks.stopTiming(); // Paper
+         gameprofilerfiller.pop();
 @@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
          if (fluid1.is(fluid)) {
              fluid1.tick(this, pos, iblockdata);
@@ -27363,18 +27359,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
          if (!savingDisabled) {
 @@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+                 progressListener.progressStage(Component.translatable("menu.savingChunks"));
              }
  
-                 timings.worldSaveChunks.startTiming(); // Paper
 -            chunkproviderserver.save(flush);
-+            if (!close) { chunkproviderserver.save(flush); } // Paper - add close param
-                 timings.worldSaveChunks.stopTiming(); // Paper
-             }// Paper
 -            if (flush) {
 -                this.entityManager.saveAll();
 -            } else {
 -                this.entityManager.autoSave();
 -            }
++            if (!close) { chunkproviderserver.save(flush); } // Paper - add close param
 +            // Paper - rewrite chunk system
  
          }
@@ -31791,7 +31785,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            org.bukkit.craftbukkit.event.CraftEventFactory.callEntitiesLoadEvent(this.level, this.chunkPos, ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)this.level).moonrise$getChunkTaskScheduler().chunkHolderManager.getChunkHolder(this.locX, this.locZ).getEntityChunk().getAllEntities()); // Paper - rewrite chunk system
  
              if (this.needsDecoration) {
-                 try (co.aikar.timings.Timing ignored = this.level.timings.chunkLoadPopulate.startTiming()) { // Paper
+                 this.needsDecoration = false;
 @@ -0,0 +0,0 @@ public class LevelChunk extends ChunkAccess {
      }
  

patches/server/Optimize-Hoppers.patch

@@ -88,14 +88,14 @@ diff --git a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.ja
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
 +++ b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
-@@ -0,0 +0,0 @@ import co.aikar.timings.MinecraftTimings; // Paper
- import co.aikar.timings.Timing; // Paper
+@@ -0,0 +0,0 @@ import org.bukkit.inventory.InventoryHolder;
+ // CraftBukkit end
  
  public abstract class BlockEntity {
 +    static boolean ignoreTileUpdates; // Paper - Perf: Optimize Hoppers
  
-     public Timing tickTimer = MinecraftTimings.getTileEntityTimings(this); // Paper
      // CraftBukkit start - data containers
+     private static final CraftPersistentDataTypeRegistry DATA_TYPE_REGISTRY = new CraftPersistentDataTypeRegistry();
 @@ -0,0 +0,0 @@ public abstract class BlockEntity {
  
      public void setChanged() {

patches/server/Optimize-World-Time-Updates.patch

@@ -12,8 +12,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         }
  
-         MinecraftTimings.timeUpdateTimer.startTiming(); // Spigot // Paper
          // Send time updates to everyone, it will get the right time from the world the player is in.
 -        if (this.tickCount % 20 == 0) {
 -            for (int i = 0; i < this.getPlayerList().players.size(); ++i) {
@@ -34,9 +34,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                ClientboundSetTimePacket packet = (playerTime == dayTime) ? worldPacket :
 +                    new ClientboundSetTimePacket(worldTime, playerTime, doDaylight);
 +                entityplayer.connection.send(packet); // Add support for per player time
++                // Paper end - Perf: Optimize time updates
              }
          }
-+        // Paper end - Perf: Optimize time updates
-         MinecraftTimings.timeUpdateTimer.stopTiming(); // Spigot // Paper
  
-         while (iterator.hasNext()) {

patches/server/Optional-per-player-mob-spawns.patch

@@ -50,8 +50,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      this.tickChunks(gameprofilerfiller, j, list);
                      gameprofilerfiller.pop();
 @@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
+     private void tickChunks(ProfilerFiller profiler, long timeDelta, List<LevelChunk> chunks) {
          profiler.popPush("naturalSpawnCount");
-         this.level.timings.countNaturalMobs.startTiming(); // Paper - timings
          int j = this.distanceManager.getNaturalSpawnChunkCount();
 -        NaturalSpawner.SpawnState spawnercreature_d = NaturalSpawner.createState(j, this.level.getAllEntities(), this::getFullChunk, new LocalMobCapCalculator(this.chunkMap));
 +        // Paper start - Optional per player mob spawns
@@ -67,9 +67,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            spawnercreature_d = NaturalSpawner.createState(naturalSpawnChunkCount, this.level.getAllEntities(), this::getFullChunk, !this.level.paperConfig().entities.spawning.perPlayerMobSpawns ? new LocalMobCapCalculator(this.chunkMap) : null, false);
 +        }
 +        // Paper end - Optional per player mob spawns
-         this.level.timings.countNaturalMobs.stopTiming(); // Paper - timings
  
          this.lastSpawnState = spawnercreature_d;
+         profiler.popPush("spawnAndTick");
 diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java

patches/server/Paper-config-files.patch

@@ -493,7 +493,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package io.papermc.paper.configuration;
 +
-+import co.aikar.timings.MinecraftTimings;
 +import com.mojang.logging.LogUtils;
 +import io.papermc.paper.configuration.constraint.Constraints;
 +import io.papermc.paper.configuration.type.number.DoubleOr;
@@ -510,7 +509,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.spongepowered.configurate.objectmapping.meta.Required;
 +import org.spongepowered.configurate.objectmapping.meta.Setting;
 +
-+import java.util.List;
 +import java.util.Map;
 +import java.util.Objects;
 +import java.util.OptionalInt;
@@ -592,29 +590,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        public boolean enableImmediately = false;
 +    }
 +
-+    @Deprecated(forRemoval = true)
-+    public Timings timings;
-+
-+    @Deprecated(forRemoval = true)
-+    public class Timings extends ConfigurationPart {
-+        public boolean enabled = false;
-+        public boolean verbose = true;
-+        public String url = "https://timings.aikar.co/";
-+        public boolean serverNamePrivacy = false;
-+        public List<String> hiddenConfigEntries = List.of(
-+            "database",
-+            "proxies.velocity.secret"
-+        );
-+        public int historyInterval = 300;
-+        public int historyLength = 3600;
-+        public String serverName = "Unknown Server";
-+
-+        @PostProcess
-+        private void postProcess() {
-+            MinecraftTimings.processConfig(this);
-+        }
-+    }
-+
 +    public Proxies proxies;
 +
 +    public class Proxies extends ConfigurationPart {

patches/server/Prevent-block-entity-and-entity-crashes.patch

@@ -62,5 +62,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                        LevelChunk.this.removeBlockEntity(this.getPos());
 +                        // Paper end - Prevent block entity and entity crashes
                          // Spigot start
-                     } finally {
-                         this.blockEntity.tickTimer.stopTiming();
+                     }
+                 }

patches/server/Protect-Bedrock-and-End-Portal-Frames-from-being-des.patch

@@ -44,9 +44,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/block/Block.java
 +++ b/src/main/java/net/minecraft/world/level/block/Block.java
 @@ -0,0 +0,0 @@ public class Block extends BlockBehaviour implements ItemLike {
+     public static final int UPDATE_LIMIT = 512;
      protected final StateDefinition<Block, BlockState> stateDefinition;
      private BlockState defaultBlockState;
-     // Paper start
++    // Paper start - Protect Bedrock and End Portal/Frames from being destroyed
 +    public final boolean isDestroyable() {
 +        return io.papermc.paper.configuration.GlobalConfiguration.get().unsupportedSettings.allowPermanentBlockBreakExploits ||
 +            this != Blocks.BARRIER &&
@@ -60,9 +61,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            this != Blocks.STRUCTURE_BLOCK &&
 +            this != Blocks.JIGSAW;
 +    }
-     public co.aikar.timings.Timing timing;
-     public co.aikar.timings.Timing getTiming() {
-         if (timing == null) {
++    // Paper end - Protect Bedrock and End Portal/Frames from being destroyed
+     @Nullable
+     private Item item;
+     private static final int CACHE_SIZE = 256;
 diff --git a/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java b/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java

patches/server/Rate-options-and-timings-for-sensors-and-behaviors.patch

@@ -8,25 +8,6 @@ This adds config options to specify the tick rate for sensors
  for those in order to be able to have some metrics as to which
  ones might need tweaking.
 
-diff --git a/src/main/java/co/aikar/timings/MinecraftTimings.java b/src/main/java/co/aikar/timings/MinecraftTimings.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/co/aikar/timings/MinecraftTimings.java
-+++ b/src/main/java/co/aikar/timings/MinecraftTimings.java
-@@ -0,0 +0,0 @@ public final class MinecraftTimings {
-         return Timings.ofSafe("Minecraft", "## tickEntity - " + entityType + " - " + type, tickEntityTimer);
-     }
- 
-+    public static Timing getBehaviorTimings(String type) {
-+        return Timings.ofSafe("## Behavior - " + type);
-+    }
-+
-+    public static Timing getSensorTimings(String type, int rate) {
-+        return Timings.ofSafe("## Sensor - " + type + " (Default rate: " + rate + ")");
-+    }
-+
-     /**
-      * Get a named timer for the specified tile entity type to track type specific timings.
-      * @param entity
 diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/Behavior.java b/src/main/java/net/minecraft/world/entity/ai/behavior/Behavior.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/behavior/Behavior.java
@@ -37,7 +18,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      private final int maxDuration;
 +    // Paper start - configurable behavior tick rate and timings
 +    private final String configKey;
-+    private final co.aikar.timings.Timing timing;
 +    // Paper end - configurable behavior tick rate and timings
  
      public Behavior(Map<MemoryModuleType<?>, MemoryStatus> requiredMemoryState) {
@@ -53,7 +33,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            key = key.substring(lastSeparator + 1);
 +        }
 +        this.configKey = key.toLowerCase(java.util.Locale.ROOT);
-+        this.timing = co.aikar.timings.MinecraftTimings.getBehaviorTimings(configKey);
 +        // Paper end - configurable behavior tick rate and timings
      }
  
@@ -71,27 +50,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (this.hasRequiredMemories(entity) && this.checkExtraStartConditions(world, entity)) {
              this.status = Behavior.Status.RUNNING;
              int i = this.minDuration + world.getRandom().nextInt(this.maxDuration + 1 - this.minDuration);
-             this.endTimestamp = time + (long)i;
-+            this.timing.startTiming(); // Paper - behavior timings
-             this.start(world, entity, time);
-+            this.timing.stopTiming(); // Paper - behavior timings
-             return true;
-         } else {
-             return false;
-@@ -0,0 +0,0 @@ public abstract class Behavior<E extends LivingEntity> implements BehaviorContro
- 
-     @Override
-     public final void tickOrStop(ServerLevel world, E entity, long time) {
-+        this.timing.startTiming(); // Paper - behavior timings
-         if (!this.timedOut(time) && this.canStillUse(world, entity, time)) {
-             this.tick(world, entity, time);
-         } else {
-             this.doStop(world, entity, time);
-         }
-+        this.timing.stopTiming(); // Paper - behavior timings
-     }
- 
-     protected void tick(ServerLevel world, E entity, long time) {
 diff --git a/src/main/java/net/minecraft/world/entity/ai/sensing/Sensor.java b/src/main/java/net/minecraft/world/entity/ai/sensing/Sensor.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/sensing/Sensor.java
@@ -102,7 +60,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      private long timeToTick;
 +    // Paper start - configurable sensor tick rate and timings
 +    private final String configKey;
-+    private final co.aikar.timings.Timing timing;
 +    // Paper end
  
      public Sensor(int senseInterval) {
@@ -113,7 +70,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            key = key.substring(lastSeparator + 1);
 +        }
 +        this.configKey = key.toLowerCase(java.util.Locale.ROOT);
-+        this.timing = co.aikar.timings.MinecraftTimings.getSensorTimings(configKey, senseInterval);
 +        // Paper end
          this.scanRate = senseInterval;
          this.timeToTick = (long)RANDOM.nextInt(senseInterval);
@@ -125,11 +81,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -            this.timeToTick = (long)this.scanRate;
 +            // Paper start - configurable sensor tick rate and timings
 +            this.timeToTick = java.util.Objects.requireNonNullElse(world.paperConfig().tickRates.sensor.get(entity.getType(), this.configKey), this.scanRate);
-+            this.timing.startTiming();
              this.updateTargetingConditionRanges(entity);
 +            // Paper end
              this.doTick(world, entity);
-+            this.timing.stopTiming(); // Paper - sensor timings
          }
      }
- 

patches/server/Remove-CraftScheduler-Async-Task-Debugger.patch

@@ -22,9 +22,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  // We don't need to parse pending
                  // (async tasks must live with race-conditions if they attempt to cancel between these few lines of code)
 @@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
+         }
          this.pending.addAll(temp);
          temp.clear();
-         MinecraftTimings.bukkitSchedulerFinishTimer.stopTiming(); // Paper
 -        this.debugHead = this.debugHead.getNextHead(this.currentTick);
 +        //this.debugHead = this.debugHead.getNextHead(this.currentTick); // Paper
      }

patches/server/Remove-Spigot-timings.patch

@@ -0,0 +1,967 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Thu, 3 Mar 2016 04:00:11 -0600
+Subject: [PATCH] Remove Spigot timings
+
+
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -0,0 +0,0 @@ import org.bukkit.craftbukkit.Main;
+ import org.bukkit.event.server.ServerLoadEvent;
+ // CraftBukkit end
+ 
+-import org.bukkit.craftbukkit.SpigotTimings; // Spigot
+ 
+ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTask> implements ServerInfo, ChunkIOErrorReporter, CommandSource {
+ 
+@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             }
+         }
+ 
+-        SpigotTimings.serverTickTimer.startTiming(); // Spigot
+         ++this.tickCount;
+         this.tickRateManager.tick();
+         this.tickChildren(shouldKeepTicking);
+@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+         ProfilerFiller gameprofilerfiller = Profiler.get();
+ 
++        this.runAllTasks(); // Paper - move runAllTasks() into full server tick (previously for timings)
+         gameprofilerfiller.push("tallying");
+         long k = Util.getNanos() - i;
+         int l = this.tickCount % 100;
+@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         this.smoothedTickTimeMillis = this.smoothedTickTimeMillis * 0.8F + (float) k / (float) TimeUtil.NANOSECONDS_PER_MILLISECOND * 0.19999999F;
+         this.logTickMethodTime(i);
+         gameprofilerfiller.pop();
+-        SpigotTimings.serverTickTimer.stopTiming(); // Spigot
+-        org.spigotmc.CustomTimingsHandler.tick(); // Spigot
+     }
+ 
+     private void autoSave() {
+         this.ticksUntilAutosave = this.autosavePeriod; // CraftBukkit
+-        SpigotTimings.worldSaveTimer.startTiming(); // Spigot
+         MinecraftServer.LOGGER.debug("Autosave started");
+         ProfilerFiller gameprofilerfiller = Profiler.get();
+ 
+@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         this.saveEverything(true, false, false);
+         gameprofilerfiller.pop();
+         MinecraftServer.LOGGER.debug("Autosave finished");
+-        SpigotTimings.worldSaveTimer.stopTiming(); // Spigot
+     }
+ 
+     private void logTickMethodTime(long tickStartTime) {
+@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         this.getPlayerList().getPlayers().forEach((entityplayer) -> {
+             entityplayer.connection.suspendFlushing();
+         });
+-        SpigotTimings.schedulerTimer.startTiming(); // Spigot
+         this.server.getScheduler().mainThreadHeartbeat(); // CraftBukkit
+-        SpigotTimings.schedulerTimer.stopTiming(); // Spigot
+         io.papermc.paper.adventure.providers.ClickCallbackProviderImpl.CALLBACK_MANAGER.handleQueue(this.tickCount); // Paper
+         gameprofilerfiller.push("commandFunctions");
+-        SpigotTimings.commandFunctionsTimer.startTiming(); // Spigot
+         this.getFunctions().tick();
+-        SpigotTimings.commandFunctionsTimer.stopTiming(); // Spigot
+         gameprofilerfiller.popPush("levels");
+         Iterator iterator = this.getAllLevels().iterator();
+ 
+         // CraftBukkit start
+         // Run tasks that are waiting on processing
+-        SpigotTimings.processQueueTimer.startTiming(); // Spigot
+         while (!this.processQueue.isEmpty()) {
+             this.processQueue.remove().run();
+         }
+-        SpigotTimings.processQueueTimer.stopTiming(); // Spigot
+ 
+-        SpigotTimings.timeUpdateTimer.startTiming(); // Spigot
+         // Send time updates to everyone, it will get the right time from the world the player is in.
+         if (this.tickCount % 20 == 0) {
+             for (int i = 0; i < this.getPlayerList().players.size(); ++i) {
+@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+                 entityplayer.connection.send(new ClientboundSetTimePacket(entityplayer.level().getGameTime(), entityplayer.getPlayerTime(), entityplayer.serverLevel().getGameRules().getBoolean(GameRules.RULE_DAYLIGHT))); // Add support for per player time
+             }
+         }
+-        SpigotTimings.timeUpdateTimer.stopTiming(); // Spigot
+ 
+         while (iterator.hasNext()) {
+             ServerLevel worldserver = (ServerLevel) iterator.next();
+@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             gameprofilerfiller.push("tick");
+ 
+             try {
+-                worldserver.timings.doTick.startTiming(); // Spigot
+                 worldserver.tick(shouldKeepTicking);
+-                worldserver.timings.doTick.stopTiming(); // Spigot
+             } catch (Throwable throwable) {
+                 CrashReport crashreport = CrashReport.forThrowable(throwable, "Exception ticking world");
+ 
+@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         }
+ 
+         gameprofilerfiller.popPush("connection");
+-        SpigotTimings.connectionTimer.startTiming(); // Spigot
+         this.tickConnection();
+-        SpigotTimings.connectionTimer.stopTiming(); // Spigot
+         gameprofilerfiller.popPush("players");
+-        SpigotTimings.playerListTimer.startTiming(); // Spigot
+         this.playerList.tick();
+-        SpigotTimings.playerListTimer.stopTiming(); // Spigot
+         if (SharedConstants.IS_RUNNING_IN_IDE && this.tickRateManager.runsNormally()) {
+             GameTestTicker.SINGLETON.tick();
+         }
+ 
+         gameprofilerfiller.popPush("server gui refresh");
+ 
+-        SpigotTimings.tickablesTimer.startTiming(); // Spigot
+         for (int i = 0; i < this.tickables.size(); ++i) {
+             ((Runnable) this.tickables.get(i)).run();
+         }
+-        SpigotTimings.tickablesTimer.stopTiming(); // Spigot
+ 
+         gameprofilerfiller.popPush("send chunks");
+         iterator = this.playerList.getPlayers().iterator();
+diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -0,0 +0,0 @@ import org.apache.logging.log4j.Level;
+ import org.apache.logging.log4j.LogManager;
+ import org.apache.logging.log4j.io.IoBuilder;
+ import org.bukkit.command.CommandSender;
+-import org.bukkit.craftbukkit.SpigotTimings; // Spigot
+ import org.bukkit.craftbukkit.util.TerminalCompletionHandler;
+ import org.bukkit.craftbukkit.util.TerminalConsoleWriterThread;
+ import org.bukkit.event.server.ServerCommandEvent;
+@@ -0,0 +0,0 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+     }
+ 
+     public void handleConsoleInputs() {
+-        SpigotTimings.serverCommandTimer.startTiming(); // Spigot
+         while (!this.consoleInput.isEmpty()) {
+             ConsoleInput servercommand = (ConsoleInput) this.consoleInput.remove(0);
+ 
+@@ -0,0 +0,0 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+             // CraftBukkit end
+         }
+ 
+-        SpigotTimings.serverCommandTimer.stopTiming(); // Spigot
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
++++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
+             }
+ 
+             gameprofilerfiller.incrementCounter("getChunkCacheMiss");
+-            this.level.timings.syncChunkLoadTimer.startTiming(); // Spigot
+             CompletableFuture<ChunkResult<ChunkAccess>> completablefuture = this.getChunkFutureMainThread(x, z, leastStatus, create);
+             ServerChunkCache.MainThreadExecutor chunkproviderserver_b = this.mainThreadProcessor;
+ 
+             Objects.requireNonNull(completablefuture);
+             chunkproviderserver_b.managedBlock(completablefuture::isDone);
+-            this.level.timings.syncChunkLoadTimer.stopTiming(); // Spigot
+             ChunkResult<ChunkAccess> chunkresult = (ChunkResult) completablefuture.join();
+             ChunkAccess ichunkaccess1 = (ChunkAccess) chunkresult.orElse(null); // CraftBukkit - decompile error
+ 
+@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
+         ProfilerFiller gameprofilerfiller = Profiler.get();
+ 
+         gameprofilerfiller.push("purge");
+-        this.level.timings.doChunkMap.startTiming(); // Spigot
+         if (this.level.tickRateManager().runsNormally() || !tickChunks || this.level.spigotConfig.unloadFrozenChunks) { // Spigot
+             this.distanceManager.purgeStaleTickets();
+         }
+ 
+         this.runDistanceManagerUpdates();
+-        this.level.timings.doChunkMap.stopTiming(); // Spigot
+         gameprofilerfiller.popPush("chunks");
+         if (tickChunks) {
+             this.tickChunks();
+-            this.level.timings.tracker.startTiming(); // Spigot
+             this.chunkMap.tick();
+-            this.level.timings.tracker.stopTiming(); // Spigot
+         }
+ 
+-        this.level.timings.doChunkUnload.startTiming(); // Spigot
+         gameprofilerfiller.popPush("unload");
+         this.chunkMap.tick(shouldKeepTicking);
+-        this.level.timings.doChunkUnload.stopTiming(); // Spigot
+         gameprofilerfiller.pop();
+         this.clearCache();
+     }
+@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
+             }
+ 
+             if (this.level.shouldTickBlocksAt(chunkcoordintpair.toLong())) {
+-                this.level.timings.doTickTiles.startTiming(); // Spigot
+                 this.level.tickChunk(chunk, k);
+-                this.level.timings.doTickTiles.stopTiming(); // Spigot
+             }
+         }
+ 
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -0,0 +0,0 @@ import net.minecraft.world.ticks.LevelTicks;
+ import org.slf4j.Logger;
+ import org.bukkit.Bukkit;
+ import org.bukkit.WeatherType;
+-import org.bukkit.craftbukkit.SpigotTimings; // Spigot
+ import org.bukkit.craftbukkit.event.CraftEventFactory;
+ import org.bukkit.craftbukkit.generator.CustomWorldChunkManager;
+ import org.bukkit.craftbukkit.util.WorldUUID;
+@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+         }
+ 
+         gameprofilerfiller.push("tickPending");
+-        this.timings.doTickPending.startTiming(); // Spigot
+         if (!this.isDebug() && flag) {
+             j = this.getGameTime();
+             gameprofilerfiller.push("blockTicks");
+@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             this.fluidTicks.tick(j, 65536, this::tickFluid);
+             gameprofilerfiller.pop();
+         }
+-        this.timings.doTickPending.stopTiming(); // Spigot
+ 
+         gameprofilerfiller.popPush("raid");
+         if (flag) {
+@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+         this.getChunkSource().tick(shouldKeepTicking, true);
+         gameprofilerfiller.popPush("blockEvents");
+         if (flag) {
+-            this.timings.doSounds.startTiming(); // Spigot
+             this.runBlockEvents();
+-            this.timings.doSounds.stopTiming(); // Spigot
+         }
+ 
+         this.handlingTick = false;
+@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+ 
+         if (flag1 || this.emptyTime++ < 300) {
+             gameprofilerfiller.push("entities");
+-            this.timings.tickEntities.startTiming(); // Spigot
+             if (this.dragonFight != null && flag) {
+                 gameprofilerfiller.push("dragonFight");
+                 this.dragonFight.tick();
+@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             }
+ 
+             org.spigotmc.ActivationRange.activateEntities(this); // Spigot
+-            this.timings.entityTick.startTiming(); // Spigot
+             this.entityTickList.forEach((entity) -> {
+                 if (!entity.isRemoved()) {
+                     if (!tickratemanager.isEntityFrozen(entity)) {
+@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+                     }
+                 }
+             });
+-            this.timings.entityTick.stopTiming(); // Spigot
+-            this.timings.tickEntities.stopTiming(); // Spigot
+             gameprofilerfiller.pop();
+             this.tickBlockEntities();
+         }
+@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             return;
+         }
+         // Spigot end
+-        entity.tickTimer.startTiming(); // Spigot
+         entity.setOldPosAndRot();
+         ProfilerFiller gameprofilerfiller = Profiler.get();
+ 
+@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+ 
+             this.tickPassenger(entity, entity1);
+         }
+-        entity.tickTimer.stopTiming(); // Spigot
+ 
+     }
+ 
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+ 
+     @Override
+     public void tick() {
+-        org.bukkit.craftbukkit.SpigotTimings.playerConnectionTimer.startTiming(); // Spigot
+         if (this.ackBlockChangesUpTo > -1) {
+             this.send(new ClientboundBlockChangedAckPacket(this.ackBlockChangesUpTo));
+             this.ackBlockChangesUpTo = -1;
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+             this.player.resetLastActionTime(); // CraftBukkit - SPIGOT-854
+             this.disconnect((Component) Component.translatable("multiplayer.disconnect.idling"));
+         }
+-        org.bukkit.craftbukkit.SpigotTimings.playerConnectionTimer.stopTiming(); // Spigot
+ 
+     }
+ 
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+     }
+ 
+     private void handleCommand(String s) {
+-        org.bukkit.craftbukkit.SpigotTimings.playerCommandTimer.startTiming(); // Spigot
+         if ( org.spigotmc.SpigotConfig.logCommands ) // Spigot
+         this.LOGGER.info(this.player.getScoreboardName() + " issued server command: " + s);
+ 
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+         this.cserver.getPluginManager().callEvent(event);
+ 
+         if (event.isCancelled()) {
+-            org.bukkit.craftbukkit.SpigotTimings.playerCommandTimer.stopTiming(); // Spigot
+             return;
+         }
+ 
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+             java.util.logging.Logger.getLogger(ServerGamePacketListenerImpl.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
+             return;
+         } finally {
+-            org.bukkit.craftbukkit.SpigotTimings.playerCommandTimer.stopTiming(); // Spigot
+         }
+     }
+     // CraftBukkit end
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -0,0 +0,0 @@ import org.bukkit.command.CommandSender;
+ import org.bukkit.entity.Hanging;
+ import org.bukkit.entity.LivingEntity;
+ import org.bukkit.entity.Vehicle;
+-import org.spigotmc.CustomTimingsHandler; // Spigot
+ import org.bukkit.event.entity.EntityCombustByEntityEvent;
+ import org.bukkit.event.hanging.HangingBreakByEntityEvent;
+ import org.bukkit.event.vehicle.VehicleBlockCollisionEvent;
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     // Marks an entity, that it was removed by a plugin via Entity#remove
+     // Main use case currently is for SPIGOT-7487, preventing dropping of leash when leash is removed
+     public boolean pluginRemoved = false;
+-    public CustomTimingsHandler tickTimer = org.bukkit.craftbukkit.SpigotTimings.getEntityTimings(this); // Spigot
+     // Spigot start
+     public final org.spigotmc.ActivationRange.ActivationType activationType = org.spigotmc.ActivationRange.initializeEntityActivationType(this);
+     public final boolean defaultActivationState;
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     }
+ 
+     public void move(MoverType type, Vec3 movement) {
+-        org.bukkit.craftbukkit.SpigotTimings.entityMoveTimer.startTiming(); // Spigot
+         if (this.noPhysics) {
+             this.setPos(this.getX() + movement.x, this.getY() + movement.y, this.getZ() + movement.z);
+         } else {
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+                 gameprofilerfiller.pop();
+             }
+         }
+-        org.bukkit.craftbukkit.SpigotTimings.entityMoveTimer.stopTiming(); // Spigot
+     }
+ 
+     private void applyMovementEmissionAndPlaySound(Entity.MovementEmission moveEffect, Vec3 movement, BlockPos landingPos, BlockState landingState) {
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -0,0 +0,0 @@ import org.bukkit.event.entity.EntityTeleportEvent;
+ import org.bukkit.event.player.PlayerItemConsumeEvent;
+ // CraftBukkit end
+ 
+-import org.bukkit.craftbukkit.SpigotTimings; // Spigot
+-
+ public abstract class LivingEntity extends Entity implements Attackable {
+ 
+     private static final Logger LOGGER = LogUtils.getLogger();
+@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
+ 
+     @Override
+     public void tick() {
+-        SpigotTimings.timerEntityBaseTick.startTiming(); // Spigot
+         super.tick();
+         this.updatingUsingItem();
+         this.updateSwimAmount();
+@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
+         }
+ 
+         if (!this.isRemoved()) {
+-            SpigotTimings.timerEntityBaseTick.stopTiming(); // Spigot
+             this.aiStep();
+-            SpigotTimings.timerEntityTickRest.startTiming(); // Spigot
+         }
+ 
+         double d0 = this.getX() - this.xo;
+@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
+         }
+ 
+         this.elytraAnimationState.tick();
+-        SpigotTimings.timerEntityTickRest.stopTiming(); // Spigot
+     }
+ 
+     public void detectEquipmentUpdatesPublic() { // CraftBukkit
+@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
+         ProfilerFiller gameprofilerfiller = Profiler.get();
+ 
+         gameprofilerfiller.push("ai");
+-        SpigotTimings.timerEntityAI.startTiming(); // Spigot
+         if (this.isImmobile()) {
+             this.jumping = false;
+             this.xxa = 0.0F;
+@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
+             this.serverAiStep();
+             gameprofilerfiller.pop();
+         }
+-        SpigotTimings.timerEntityAI.stopTiming(); // Spigot
+ 
+         gameprofilerfiller.pop();
+         gameprofilerfiller.push("jump");
+@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
+             this.resetFallDistance();
+         }
+ 
+-        SpigotTimings.timerEntityAIMove.startTiming(); // Spigot
+         label112:
+         {
+             LivingEntity entityliving = this.getControllingPassenger();
+@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
+ 
+             this.travel(vec3d1);
+         }
+-        SpigotTimings.timerEntityAIMove.stopTiming(); // Spigot
+ 
+         if (!this.level().isClientSide() || this.isControlledByLocalInstance()) {
+             this.applyEffectsFromBlocks();
+@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
+             this.checkAutoSpinAttack(axisalignedbb, this.getBoundingBox());
+         }
+ 
+-        SpigotTimings.timerEntityAICollision.startTiming(); // Spigot
+         this.pushEntities();
+-        SpigotTimings.timerEntityAICollision.stopTiming(); // Spigot
+         gameprofilerfiller.pop();
+         world = this.level();
+         if (world instanceof ServerLevel worldserver) {
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -0,0 +0,0 @@ import net.minecraft.network.protocol.game.ClientboundSetBorderWarningDistancePa
+ import org.bukkit.Bukkit;
+ import org.bukkit.craftbukkit.CraftServer;
+ import org.bukkit.craftbukkit.CraftWorld;
+-import org.bukkit.craftbukkit.SpigotTimings; // Spigot
+ import org.bukkit.craftbukkit.block.CapturedBlockState;
+ import org.bukkit.craftbukkit.block.CraftBlockState;
+ import org.bukkit.craftbukkit.block.data.CraftBlockData;
+@@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+     }
+     // Paper end - add paper world config
+ 
+-    public final SpigotTimings.WorldTimingsHandler timings; // Spigot
+     public static BlockPos lastPhysicsProblem; // Spigot
+     private org.spigotmc.TickLimiter entityLimiter;
+     private org.spigotmc.TickLimiter tileLimiter;
+@@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+             public void onBorderSetDamageSafeZOne(WorldBorder border, double safeZoneRadius) {}
+         });
+         // CraftBukkit end
+-        this.timings = new SpigotTimings.WorldTimingsHandler(this); // Spigot - code below can generate new world and access timings
+         this.entityLimiter = new org.spigotmc.TickLimiter(this.spigotConfig.entityMaxTickTime);
+         this.tileLimiter = new org.spigotmc.TickLimiter(this.spigotConfig.tileMaxTickTime);
+     }
+@@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+         ProfilerFiller gameprofilerfiller = Profiler.get();
+ 
+         gameprofilerfiller.push("blockEntities");
+-        this.timings.tileEntityPending.startTiming(); // Spigot
+         this.tickingBlockEntities = true;
+         if (!this.pendingBlockEntityTickers.isEmpty()) {
+             this.blockEntityTickers.addAll(this.pendingBlockEntityTickers);
+             this.pendingBlockEntityTickers.clear();
+         }
+-        this.timings.tileEntityPending.stopTiming(); // Spigot
+ 
+-        this.timings.tileEntityTick.startTiming(); // Spigot
+         // Spigot start
+         // Iterator<TickingBlockEntity> iterator = this.blockEntityTickers.iterator();
+         boolean flag = this.tickRateManager().runsNormally();
+@@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+             }
+         }
+ 
+-        this.timings.tileEntityTick.stopTiming(); // Spigot
+         this.tickingBlockEntities = false;
+         gameprofilerfiller.pop();
+         this.spigotConfig.currentPrimedTnt = 0; // Spigot
+@@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+ 
+     public <T extends Entity> void guardEntityTick(Consumer<T> tickConsumer, T entity) {
+         try {
+-            SpigotTimings.tickEntityTimer.startTiming(); // Spigot
+             tickConsumer.accept(entity);
+-            SpigotTimings.tickEntityTimer.stopTiming(); // Spigot
+         } catch (Throwable throwable) {
+             CrashReport crashreport = CrashReport.forThrowable(throwable, "Ticking entity");
+             CrashReportCategory crashreportsystemdetails = crashreport.addCategory("Entity being ticked");
+diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java
++++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+@@ -0,0 +0,0 @@ public final class NaturalSpawner {
+         ProfilerFiller gameprofilerfiller = Profiler.get();
+ 
+         gameprofilerfiller.push("spawner");
+-        world.timings.mobSpawn.startTiming(); // Spigot
+         Iterator iterator = spawnableGroups.iterator();
+ 
+         while (iterator.hasNext()) {
+@@ -0,0 +0,0 @@ public final class NaturalSpawner {
+             }
+         }
+ 
+-        world.timings.mobSpawn.stopTiming(); // Spigot
+         gameprofilerfiller.pop();
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
+@@ -0,0 +0,0 @@ import org.bukkit.craftbukkit.persistence.CraftPersistentDataTypeRegistry;
+ import org.bukkit.inventory.InventoryHolder;
+ // CraftBukkit end
+ 
+-import org.spigotmc.CustomTimingsHandler; // Spigot
+-
+ public abstract class BlockEntity {
+ 
+-    public CustomTimingsHandler tickTimer = org.bukkit.craftbukkit.SpigotTimings.getTileEntityTimings(this); // Spigot
+     // CraftBukkit start - data containers
+     private static final CraftPersistentDataTypeRegistry DATA_TYPE_REGISTRY = new CraftPersistentDataTypeRegistry();
+     public CraftPersistentDataContainer persistentDataContainer;
+diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
++++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+@@ -0,0 +0,0 @@ public class LevelChunk extends ChunkAccess {
+                         ProfilerFiller gameprofilerfiller = Profiler.get();
+ 
+                         gameprofilerfiller.push(this::getType);
+-                        this.blockEntity.tickTimer.startTiming(); // Spigot
+                         BlockState iblockdata = LevelChunk.this.getBlockState(blockposition);
+ 
+                         if (this.blockEntity.getType().isValid(iblockdata)) {
+@@ -0,0 +0,0 @@ public class LevelChunk extends ChunkAccess {
+                         this.blockEntity.fillCrashReportCategory(crashreportsystemdetails);
+                         throw new ReportedException(crashreport);
+                         // Spigot start
+-                    } finally {
+-                        this.blockEntity.tickTimer.stopTiming();
+-                        // Spigot end
+                     }
+                 }
+             }
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java b/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java
++++ b/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java
+@@ -0,0 +0,0 @@ public record SerializableChunkData(Registry<Biome> biomeRegistry, ChunkPos chun
+     @Nullable
+     private static LevelChunk.PostLoadProcessor postLoadChunk(ServerLevel world, List<CompoundTag> entities, List<CompoundTag> blockEntities) {
+         return entities.isEmpty() && blockEntities.isEmpty() ? null : (chunk) -> {
+-            world.timings.syncChunkLoadEntitiesTimer.startTiming(); // Spigot
+             if (!entities.isEmpty()) {
+                 world.addLegacyChunkEntities(EntityType.loadEntitiesRecursive(entities, world, EntitySpawnReason.LOAD));
+             }
+-            world.timings.syncChunkLoadEntitiesTimer.stopTiming(); // Spigot
+ 
+             Iterator iterator = blockEntities.iterator();
+ 
+-            world.timings.syncChunkLoadTileEntitiesTimer.startTiming(); // Spigot
+             while (iterator.hasNext()) {
+                 CompoundTag nbttagcompound = (CompoundTag) iterator.next();
+                 boolean flag = nbttagcompound.getBoolean("keepPacked");
+@@ -0,0 +0,0 @@ public record SerializableChunkData(Registry<Biome> biomeRegistry, ChunkPos chun
+                     }
+                 }
+             }
+-            world.timings.syncChunkLoadTileEntitiesTimer.stopTiming(); // Spigot
+ 
+         };
+     }
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
+         this.saveCommandsConfig();
+         this.overrideAllCommandBlockCommands = this.commandsConfiguration.getStringList("command-block-overrides").contains("*");
+         this.ignoreVanillaPermissions = this.commandsConfiguration.getBoolean("ignore-vanilla-permissions");
+-        this.pluginManager.useTimings(this.configuration.getBoolean("settings.plugin-profiling"));
+         this.overrideSpawnLimits();
+         console.autosavePeriod = this.configuration.getInt("ticks-per.autosave");
+         this.warningState = WarningState.value(this.configuration.getString("settings.deprecated-verbose"));
+@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
+     private final org.bukkit.Server.Spigot spigot = new org.bukkit.Server.Spigot()
+     {
+ 
++        @Deprecated
+         @Override
+         public YamlConfiguration getConfig()
+         {
+             return org.spigotmc.SpigotConfig.config;
+         }
+ 
++        @Override
++        public YamlConfiguration getBukkitConfig()
++        {
++            return configuration;
++        }
++
++        @Override
++        public YamlConfiguration getSpigotConfig()
++        {
++            return org.spigotmc.SpigotConfig.config;
++        }
++
++        @Override
++        public YamlConfiguration getPaperConfig()
++        {
++            return CraftServer.this.console.paperConfigurations.createLegacyObject(CraftServer.this.console);
++        }
++
+         @Override
+         public void restart() {
+             org.spigotmc.RestartCommand.restart();
+diff --git a/src/main/java/org/bukkit/craftbukkit/SpigotTimings.java b/src/main/java/org/bukkit/craftbukkit/SpigotTimings.java
+deleted file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- a/src/main/java/org/bukkit/craftbukkit/SpigotTimings.java
++++ /dev/null
+@@ -0,0 +0,0 @@
+-package org.bukkit.craftbukkit;
+-
+-import java.util.HashMap;
+-import net.minecraft.world.entity.Entity;
+-import net.minecraft.world.level.Level;
+-import net.minecraft.world.level.block.entity.BlockEntity;
+-import net.minecraft.world.level.storage.PrimaryLevelData;
+-import org.bukkit.craftbukkit.scheduler.CraftTask;
+-import org.bukkit.plugin.java.JavaPluginLoader;
+-import org.bukkit.scheduler.BukkitTask;
+-import org.spigotmc.CustomTimingsHandler;
+-
+-public class SpigotTimings {
+-
+-    public static final CustomTimingsHandler serverTickTimer = new CustomTimingsHandler("** Full Server Tick");
+-    public static final CustomTimingsHandler playerListTimer = new CustomTimingsHandler("Player List");
+-    public static final CustomTimingsHandler commandFunctionsTimer = new CustomTimingsHandler("Command Functions");
+-    public static final CustomTimingsHandler connectionTimer = new CustomTimingsHandler("Connection Handler");
+-    public static final CustomTimingsHandler playerConnectionTimer = new CustomTimingsHandler("** PlayerConnection");
+-    public static final CustomTimingsHandler tickablesTimer = new CustomTimingsHandler("Tickables");
+-    public static final CustomTimingsHandler schedulerTimer = new CustomTimingsHandler("Scheduler");
+-    public static final CustomTimingsHandler timeUpdateTimer = new CustomTimingsHandler("Time Update");
+-    public static final CustomTimingsHandler serverCommandTimer = new CustomTimingsHandler("Server Command");
+-    public static final CustomTimingsHandler worldSaveTimer = new CustomTimingsHandler("World Save");
+-
+-    public static final CustomTimingsHandler entityMoveTimer = new CustomTimingsHandler("** entityMove");
+-    public static final CustomTimingsHandler tickEntityTimer = new CustomTimingsHandler("** tickEntity");
+-    public static final CustomTimingsHandler activatedEntityTimer = new CustomTimingsHandler("** activatedTickEntity");
+-    public static final CustomTimingsHandler tickTileEntityTimer = new CustomTimingsHandler("** tickTileEntity");
+-
+-    public static final CustomTimingsHandler timerEntityBaseTick = new CustomTimingsHandler("** livingEntityBaseTick");
+-    public static final CustomTimingsHandler timerEntityAI = new CustomTimingsHandler("** livingEntityAI");
+-    public static final CustomTimingsHandler timerEntityAICollision = new CustomTimingsHandler("** livingEntityAICollision");
+-    public static final CustomTimingsHandler timerEntityAIMove = new CustomTimingsHandler("** livingEntityAIMove");
+-    public static final CustomTimingsHandler timerEntityTickRest = new CustomTimingsHandler("** livingEntityTickRest");
+-
+-    public static final CustomTimingsHandler processQueueTimer = new CustomTimingsHandler("processQueue");
+-    public static final CustomTimingsHandler schedulerSyncTimer = new CustomTimingsHandler("** Scheduler - Sync Tasks", JavaPluginLoader.pluginParentTimer);
+-
+-    public static final CustomTimingsHandler playerCommandTimer = new CustomTimingsHandler("** playerCommand");
+-
+-    public static final CustomTimingsHandler entityActivationCheckTimer = new CustomTimingsHandler("entityActivationCheck");
+-    public static final CustomTimingsHandler checkIfActiveTimer = new CustomTimingsHandler("** checkIfActive");
+-
+-    public static final HashMap<String, CustomTimingsHandler> entityTypeTimingMap = new HashMap<String, CustomTimingsHandler>();
+-    public static final HashMap<String, CustomTimingsHandler> tileEntityTypeTimingMap = new HashMap<String, CustomTimingsHandler>();
+-    public static final HashMap<String, CustomTimingsHandler> pluginTaskTimingMap = new HashMap<String, CustomTimingsHandler>();
+-
+-    /**
+-     * Gets a timer associated with a plugins tasks.
+-     * @param task
+-     * @param period
+-     * @return
+-     */
+-    public static CustomTimingsHandler getPluginTaskTimings(BukkitTask task, long period) {
+-        if (!task.isSync()) {
+-            return null;
+-        }
+-        String plugin;
+-        final CraftTask ctask = (CraftTask) task;
+-
+-        if (task.getOwner() != null) {
+-            plugin = task.getOwner().getDescription().getFullName();
+-        } else {
+-            plugin = "Unknown";
+-        }
+-        String taskname = ctask.getTaskName();
+-
+-        String name = "Task: " + plugin + " Runnable: " + taskname;
+-        if (period > 0) {
+-            name += "(interval:" + period + ")";
+-        } else {
+-            name += "(Single)";
+-        }
+-        CustomTimingsHandler result = SpigotTimings.pluginTaskTimingMap.get(name);
+-        if (result == null) {
+-            result = new CustomTimingsHandler(name, SpigotTimings.schedulerSyncTimer);
+-            SpigotTimings.pluginTaskTimingMap.put(name, result);
+-        }
+-        return result;
+-    }
+-
+-    /**
+-     * Get a named timer for the specified entity type to track type specific timings.
+-     * @param entity
+-     * @return
+-     */
+-    public static CustomTimingsHandler getEntityTimings(Entity entity) {
+-        String entityType = entity.getClass().getName();
+-        CustomTimingsHandler result = SpigotTimings.entityTypeTimingMap.get(entityType);
+-        if (result == null) {
+-            result = new CustomTimingsHandler("** tickEntity - " + entity.getClass().getSimpleName(), SpigotTimings.activatedEntityTimer);
+-            SpigotTimings.entityTypeTimingMap.put(entityType, result);
+-        }
+-        return result;
+-    }
+-
+-    /**
+-     * Get a named timer for the specified tile entity type to track type specific timings.
+-     * @param entity
+-     * @return
+-     */
+-    public static CustomTimingsHandler getTileEntityTimings(BlockEntity entity) {
+-        String entityType = entity.getClass().getName();
+-        CustomTimingsHandler result = SpigotTimings.tileEntityTypeTimingMap.get(entityType);
+-        if (result == null) {
+-            result = new CustomTimingsHandler("** tickTileEntity - " + entity.getClass().getSimpleName(), SpigotTimings.tickTileEntityTimer);
+-            SpigotTimings.tileEntityTypeTimingMap.put(entityType, result);
+-        }
+-        return result;
+-    }
+-
+-    /**
+-     * Set of timers per world, to track world specific timings.
+-     */
+-    public static class WorldTimingsHandler {
+-        public final CustomTimingsHandler mobSpawn;
+-        public final CustomTimingsHandler doChunkUnload;
+-        public final CustomTimingsHandler doTickPending;
+-        public final CustomTimingsHandler doTickTiles;
+-        public final CustomTimingsHandler doChunkMap;
+-        public final CustomTimingsHandler doSounds;
+-        public final CustomTimingsHandler entityTick;
+-        public final CustomTimingsHandler tileEntityTick;
+-        public final CustomTimingsHandler tileEntityPending;
+-        public final CustomTimingsHandler tracker;
+-        public final CustomTimingsHandler doTick;
+-        public final CustomTimingsHandler tickEntities;
+-
+-        public final CustomTimingsHandler syncChunkLoadTimer;
+-        public final CustomTimingsHandler syncChunkLoadStructuresTimer;
+-        public final CustomTimingsHandler syncChunkLoadEntitiesTimer;
+-        public final CustomTimingsHandler syncChunkLoadTileEntitiesTimer;
+-        public final CustomTimingsHandler syncChunkLoadTileTicksTimer;
+-        public final CustomTimingsHandler syncChunkLoadPostTimer;
+-
+-        public WorldTimingsHandler(Level server) {
+-            String name = ((PrimaryLevelData) server.levelData).getLevelName() + " - ";
+-
+-            this.mobSpawn = new CustomTimingsHandler("** " + name + "mobSpawn");
+-            this.doChunkUnload = new CustomTimingsHandler("** " + name + "doChunkUnload");
+-            this.doTickPending = new CustomTimingsHandler("** " + name + "doTickPending");
+-            this.doTickTiles = new CustomTimingsHandler("** " + name + "doTickTiles");
+-            this.doChunkMap = new CustomTimingsHandler("** " + name + "doChunkMap");
+-            this.doSounds = new CustomTimingsHandler("** " + name + "doSounds");
+-            this.entityTick = new CustomTimingsHandler("** " + name + "entityTick");
+-            this.tileEntityTick = new CustomTimingsHandler("** " + name + "tileEntityTick");
+-            this.tileEntityPending = new CustomTimingsHandler("** " + name + "tileEntityPending");
+-
+-            this.syncChunkLoadTimer = new CustomTimingsHandler("** " + name + "syncChunkLoad");
+-            this.syncChunkLoadStructuresTimer = new CustomTimingsHandler("** " + name + "chunkLoad - Structures");
+-            this.syncChunkLoadEntitiesTimer = new CustomTimingsHandler("** " + name + "chunkLoad - Entities");
+-            this.syncChunkLoadTileEntitiesTimer = new CustomTimingsHandler("** " + name + "chunkLoad - TileEntities");
+-            this.syncChunkLoadTileTicksTimer = new CustomTimingsHandler("** " + name + "chunkLoad - TileTicks");
+-            this.syncChunkLoadPostTimer = new CustomTimingsHandler("** " + name + "chunkLoad - Post");
+-
+-
+-            this.tracker = new CustomTimingsHandler(name + "tracker");
+-            this.doTick = new CustomTimingsHandler(name + "doTick");
+-            this.tickEntities = new CustomTimingsHandler(name + "tickEntities");
+-        }
+-    }
+-}
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+ 
+             CraftPlayer.this.getHandle().connection.send(new net.minecraft.network.protocol.game.ClientboundSystemChatPacket(components, position == net.md_5.bungee.api.ChatMessageType.ACTION_BAR));
+         }
++
++        // Paper start
++        @Override
++        public int getPing()
++        {
++            return CraftPlayer.this.getPing();
++        }
++        // Paper end
+     };
+ 
+     public Player.Spigot spigot()
+diff --git a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
++++ b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
+@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
+             if (task.isSync()) {
+                 this.currentTask = task;
+                 try {
+-                    task.timings.startTiming(); // Spigot
+                     task.run();
+-                    task.timings.stopTiming(); // Spigot
+                 } catch (final Throwable throwable) {
+                     task.getOwner().getLogger().log(
+                             Level.WARNING,
+diff --git a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftTask.java b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftTask.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftTask.java
++++ b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftTask.java
+@@ -0,0 +0,0 @@
+ package org.bukkit.craftbukkit.scheduler;
+ 
+ import java.util.function.Consumer;
++
+ import org.bukkit.Bukkit;
+ import org.bukkit.plugin.Plugin;
+ import org.bukkit.scheduler.BukkitTask;
+ 
+-import org.bukkit.craftbukkit.SpigotTimings; // Spigot
+-import org.spigotmc.CustomTimingsHandler; // Spigot
+-
+ public class CraftTask implements BukkitTask, Runnable { // Spigot
+ 
+     private volatile CraftTask next = null;
+@@ -0,0 +0,0 @@ public class CraftTask implements BukkitTask, Runnable { // Spigot
+      */
+     private volatile long period;
+     private long nextRun;
+-    private final Runnable rTask;
+-    private final Consumer<BukkitTask> cTask;
++    public final Runnable rTask;
++    public final Consumer<BukkitTask> cTask;
+     private final Plugin plugin;
+     private final int id;
+     private final long createdAt = System.nanoTime();
+ 
+-    final CustomTimingsHandler timings; // Spigot
+     CraftTask() {
+         this(null, null, CraftTask.NO_REPEATING, CraftTask.NO_REPEATING);
+     }
+@@ -0,0 +0,0 @@ public class CraftTask implements BukkitTask, Runnable { // Spigot
+         }
+         this.id = id;
+         this.period = period;
+-        this.timings = this.isSync() ? SpigotTimings.getPluginTaskTimings(this, period) : null; // Spigot
+     }
+ 
+     @Override
+@@ -0,0 +0,0 @@ public class CraftTask implements BukkitTask, Runnable { // Spigot
+         return true;
+     }
+ 
+-    // Spigot start
+-    public String getTaskName() {
+-        return (this.getTaskClass() == null) ? "Unknown" : this.getTaskClass().getName();
+-    }
+-    // Spigot end
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftIconCache.java b/src/main/java/org/bukkit/craftbukkit/util/CraftIconCache.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/CraftIconCache.java
++++ b/src/main/java/org/bukkit/craftbukkit/util/CraftIconCache.java
+@@ -0,0 +0,0 @@
+ package org.bukkit.craftbukkit.util;
+ 
+ import org.bukkit.util.CachedServerIcon;
++import org.jetbrains.annotations.Nullable;
+ 
+ public class CraftIconCache implements CachedServerIcon {
+     public final byte[] value;
+@@ -0,0 +0,0 @@ public class CraftIconCache implements CachedServerIcon {
+     public CraftIconCache(final byte[] value) {
+         this.value = value;
+     }
++
++    @Override
++    public @Nullable String getData() {
++        if (this.value == null) {
++            return null;
++        }
++        return "data:image/png;base64," + new String(java.util.Base64.getEncoder().encode(this.value), java.nio.charset.StandardCharsets.UTF_8);
++    }
+ }
+diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/spigotmc/ActivationRange.java
++++ b/src/main/java/org/spigotmc/ActivationRange.java
+@@ -0,0 +0,0 @@ import net.minecraft.world.entity.projectile.ThrownTrident;
+ import net.minecraft.world.entity.raid.Raider;
+ import net.minecraft.world.level.Level;
+ import net.minecraft.world.phys.AABB;
+-import org.bukkit.craftbukkit.SpigotTimings;
+ 
+ public class ActivationRange
+ {
+@@ -0,0 +0,0 @@ public class ActivationRange
+      */
+     public static void activateEntities(Level world)
+     {
+-        SpigotTimings.entityActivationCheckTimer.startTiming();
+         final int miscActivationRange = world.spigotConfig.miscActivationRange;
+         final int raiderActivationRange = world.spigotConfig.raiderActivationRange;
+         final int animalActivationRange = world.spigotConfig.animalActivationRange;
+@@ -0,0 +0,0 @@ public class ActivationRange
+ 
+             world.getEntities().get(ActivationRange.maxBB, ActivationRange::activateEntity);
+         }
+-        SpigotTimings.entityActivationCheckTimer.stopTiming();
+     }
+ 
+     /**
+@@ -0,0 +0,0 @@ public class ActivationRange
+      */
+     public static boolean checkIfActive(Entity entity)
+     {
+-        SpigotTimings.checkIfActiveTimer.startTiming();
+         // Never safe to skip fireworks or entities not yet added to chunk
+         if ( entity instanceof FireworkRocketEntity ) {
+-            SpigotTimings.checkIfActiveTimer.stopTiming();
+             return true;
+         }
+ 
+@@ -0,0 +0,0 @@ public class ActivationRange
+         {
+             isActive = false;
+         }
+-        SpigotTimings.checkIfActiveTimer.stopTiming();
+         return isActive;
+     }
+ }

patches/server/Server-Tick-Events.patch

@@ -10,17 +10,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         });
-         isOversleep = false;MinecraftTimings.serverOversleep.stopTiming();
-         // Paper end
-+        new com.destroystokyo.paper.event.server.ServerTickStartEvent(this.tickCount+1).callEvent(); // Paper - Server Tick Events
+             }
+         }
  
++        new com.destroystokyo.paper.event.server.ServerTickStartEvent(this.tickCount+1).callEvent(); // Paper - Server Tick Events
          ++this.tickCount;
          this.tickRateManager.tick();
+         this.tickChildren(shouldKeepTicking);
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-             this.runAllTasks();
-         }
-         // Paper end
+         ProfilerFiller gameprofilerfiller = Profiler.get();
+ 
+         this.runAllTasks(); // Paper - move runAllTasks() into full server tick (previously for timings)
 +        // Paper start - Server Tick Events
 +        long endTime = System.nanoTime();
 +        long remaining = (TICK_TIME - (endTime - lastTick)) - catchupTime;

patches/server/Throw-exception-on-world-create-while-being-ticked.patch

@@ -19,8 +19,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public static <S extends MinecraftServer> S spin(Function<Thread, S> serverFactory) {
          AtomicReference<S> atomicreference = new AtomicReference();
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         gameprofilerfiller.push("commandFunctions");
          this.getFunctions().tick();
-         MinecraftTimings.commandFunctionsTimer.stopTiming(); // Spigot // Paper
          gameprofilerfiller.popPush("levels");
 -        Iterator iterator = this.getAllLevels().iterator();
 +        //Iterator iterator = this.getAllLevels().iterator(); // Paper - Throw exception on world create while being ticked; moved down
@@ -28,8 +28,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          // CraftBukkit start
          // Run tasks that are waiting on processing
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         // Paper end - Perf: Optimize time updates
-         MinecraftTimings.timeUpdateTimer.stopTiming(); // Spigot // Paper
+             }
+         }
  
 +        this.isIteratingOverLevels = true; // Paper - Throw exception on world create while being ticked
 +        Iterator iterator = this.getAllLevels().iterator(); // Paper - Throw exception on world create while being ticked; move down
@@ -43,7 +43,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.isIteratingOverLevels = false; // Paper - Throw exception on world create while being ticked
  
          gameprofilerfiller.popPush("connection");
-         MinecraftTimings.connectionTimer.startTiming(); // Spigot // Paper
+         this.tickConnection();
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java

patches/server/Time-scoreboard-search.patch

@@ -1,43 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Tue, 21 Apr 2020 01:53:22 -0700
-Subject: [PATCH] Time scoreboard search
-
-Plugins leaking scoreboards will make this very expensive,
-let server owners debug it easily
-
-diff --git a/src/main/java/co/aikar/timings/MinecraftTimings.java b/src/main/java/co/aikar/timings/MinecraftTimings.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/co/aikar/timings/MinecraftTimings.java
-+++ b/src/main/java/co/aikar/timings/MinecraftTimings.java
-@@ -0,0 +0,0 @@ public final class MinecraftTimings {
- 
-     public static final Timing antiXrayUpdateTimer = Timings.ofSafe("anti-xray - update");
-     public static final Timing antiXrayObfuscateTimer = Timings.ofSafe("anti-xray - obfuscate");
-+    public static final Timing scoreboardScoreSearch = Timings.ofSafe("Scoreboard score search"); // Paper - add timings for scoreboard search
- 
-     private static final Map<Class<?>, String> taskNameCache = new MapMaker().weakKeys().makeMap();
- 
-diff --git a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardManager.java b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardManager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardManager.java
-+++ b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardManager.java
-@@ -0,0 +0,0 @@ public final class CraftScoreboardManager implements ScoreboardManager {
- 
-     // CraftBukkit method
-     public void forAllObjectives(ObjectiveCriteria criteria, ScoreHolder holder, Consumer<ScoreAccess> consumer) {
-+        // Paper start - add timings for scoreboard search
-+        // plugins leaking scoreboards will make this very expensive, let server owners debug it easily
-+        co.aikar.timings.MinecraftTimings.scoreboardScoreSearch.startTimingIfSync();
-+        try {
-+        // Paper end - add timings for scoreboard search
-         for (CraftScoreboard scoreboard : this.scoreboards) {
-             Scoreboard board = scoreboard.board;
-             board.forAllObjectives(criteria, holder, (score) -> consumer.accept(score));
-         }
-+        } finally { // Paper start - add timings for scoreboard search
-+            co.aikar.timings.MinecraftTimings.scoreboardScoreSearch.stopTimingIfSync();
-+        }
-+        // Paper end - add timings for scoreboard search
-     }
- }

patches/server/Use-a-Queue-for-Queueing-Commands.patch

@@ -27,7 +27,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public void handleConsoleInputs() {
-         MinecraftTimings.serverCommandTimer.startTiming(); // Spigot
 -        while (!this.consoleInput.isEmpty()) {
 -            ConsoleInput servercommand = (ConsoleInput) this.consoleInput.remove(0);
 +        // Paper start - Perf: use proper queue

patches/server/remove-null-possibility-for-getServer-singleton.patch

@@ -9,7 +9,7 @@ diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -0,0 +0,0 @@ import co.aikar.timings.MinecraftTimings; // Paper
+@@ -0,0 +0,0 @@ import org.bukkit.event.server.ServerLoadEvent;
  
  public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTask> implements ServerInfo, ChunkIOErrorReporter, CommandSource {