diff --git a/Spigot-API-Patches/Ability-to-get-Tile-Entities-from-a-chunk-without-sn.patch b/Spigot-API-Patches/Ability-to-get-Tile-Entities-from-a-chunk-without-sn.patch
index ac98f63d6b..65accef4f7 100644
--- a/Spigot-API-Patches/Ability-to-get-Tile-Entities-from-a-chunk-without-sn.patch
+++ b/Spigot-API-Patches/Ability-to-get-Tile-Entities-from-a-chunk-without-sn.patch
@@ -5,7 +5,7 @@ Subject: [PATCH] Ability to get Tile Entities from a chunk without snapshots
 
 
 diff --git a/src/main/java/org/bukkit/Chunk.java b/src/main/java/org/bukkit/Chunk.java
-index c75bce07..dc847340 100644
+index b347a3ccf..8a8043351 100644
 --- a/src/main/java/org/bukkit/Chunk.java
 +++ b/src/main/java/org/bukkit/Chunk.java
 @@ -0,0 +0,0 @@ public interface Chunk {
diff --git a/Spigot-API-Patches/Add-Force-Loaded-Chunk-API.patch b/Spigot-API-Patches/Add-Force-Loaded-Chunk-API.patch
index 1f7b90f579..bfcb16173d 100644
--- a/Spigot-API-Patches/Add-Force-Loaded-Chunk-API.patch
+++ b/Spigot-API-Patches/Add-Force-Loaded-Chunk-API.patch
@@ -5,7 +5,7 @@ Subject: [PATCH] Add Force-Loaded Chunk API
 
 
 diff --git a/src/main/java/org/bukkit/Chunk.java b/src/main/java/org/bukkit/Chunk.java
-index dc847340..51bc051f 100644
+index 8a8043351..4b9e0ca46 100644
 --- a/src/main/java/org/bukkit/Chunk.java
 +++ b/src/main/java/org/bukkit/Chunk.java
 @@ -0,0 +0,0 @@ public interface Chunk {
@@ -30,14 +30,13 @@ index dc847340..51bc051f 100644
 +    // Paper end
  }
 diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
-index 53764fae..00b02e36 100644
+index 9c06fc163..5379a649e 100644
 --- a/src/main/java/org/bukkit/World.java
 +++ b/src/main/java/org/bukkit/World.java
 @@ -0,0 +0,0 @@ public interface World extends PluginMessageRecipient, Metadatable {
-      * @return true if the chunk has been generated, otherwise false
       */
      public boolean isChunkGenerated(int x, int z);
-+
+ 
 +    /**
 +     * Checks if a chunk is force-loaded.
 +     * Note: This will only return true if the chunk is also generated
@@ -47,7 +46,8 @@ index 53764fae..00b02e36 100644
 +     * @return true if the chunk is force-loaded. otherwise false
 +     */
 +    public boolean isChunkForceLoaded(int x, int z);
-     // Paper end
- 
++
      /**
+      * This is the Legacy API before Java 8 was supported. Java 8 Consumer is provided,
+      * as well as future support
 --
\ No newline at end of file
diff --git a/Spigot-API-Patches/Add-TNTPrimeEvent.patch b/Spigot-API-Patches/Add-TNTPrimeEvent.patch
index e7ec2b09ff..e77176f7ed 100644
--- a/Spigot-API-Patches/Add-TNTPrimeEvent.patch
+++ b/Spigot-API-Patches/Add-TNTPrimeEvent.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] Add TNTPrimeEvent
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/block/TNTPrimeEvent.java b/src/main/java/com/destroystokyo/paper/event/block/TNTPrimeEvent.java
 new file mode 100644
-index 00000000..2ae8826b
+index 000000000..2ae8826bb
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/block/TNTPrimeEvent.java
 @@ -0,0 +0,0 @@
diff --git a/Spigot-API-Patches/Add-async-chunk-load-API.patch b/Spigot-API-Patches/Add-async-chunk-load-API.patch
deleted file mode 100644
index b64688d08e..0000000000
--- a/Spigot-API-Patches/Add-async-chunk-load-API.patch
+++ /dev/null
@@ -1,90 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Mon, 29 Feb 2016 17:43:33 -0600
-Subject: [PATCH] Add async chunk load API
-
-
-diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
-index 5e6cb56a..dbbcfec9 100644
---- a/src/main/java/org/bukkit/World.java
-+++ b/src/main/java/org/bukkit/World.java
-@@ -0,0 +0,0 @@ public interface World extends PluginMessageRecipient, Metadatable {
-      */
-     public Chunk getChunkAt(Block block);
- 
-+    /**
-+     * Used by {@link World#getChunkAtAsync(Location,ChunkLoadCallback)} methods
-+     * to request a {@link Chunk} to be loaded, with this callback receiving
-+     * the chunk when it is finished.
-+     *
-+     * This callback will be executed on synchronously on the main thread.
-+     *
-+     * Timing and order this callback is fired is intentionally not defined and
-+     * and subject to change.
-+     */
-+    public static interface ChunkLoadCallback {
-+        public void onLoad(Chunk chunk);
-+    }
-+
-+    /**
-+     * Requests a {@link Chunk} to be loaded at the given coordinates
-+     *
-+     * This method makes no guarantee on how fast the chunk will load,
-+     * and will return the chunk to the callback at a later time.
-+     *
-+     * You should use this method if you need a chunk but do not need it
-+     * immediately, and you wish to let the server control the speed
-+     * of chunk loads, keeping performance in mind.
-+     *
-+     * The {@link ChunkLoadCallback} will always be executed synchronously
-+     * on the main Server Thread.
-+     *
-+     * @param x Chunk X-coordinate of the chunk - (world coordinate / 16)
-+     * @param z Chunk Z-coordinate of the chunk - (world coordinate / 16)
-+     * @param cb Callback to receive the chunk when it is loaded.
-+     *           will be executed synchronously
-+     */
-+    public void getChunkAtAsync(int x, int z, ChunkLoadCallback cb);
-+
-+    /**
-+     * Requests a {@link Chunk} to be loaded at the given {@link Location}
-+     *
-+     * This method makes no guarantee on how fast the chunk will load,
-+     * and will return the chunk to the callback at a later time.
-+     *
-+     * You should use this method if you need a chunk but do not need it
-+     * immediately, and you wish to let the server control the speed
-+     * of chunk loads, keeping performance in mind.
-+     *
-+     * The {@link ChunkLoadCallback} will always be executed synchronously
-+     * on the main Server Thread.
-+     *
-+     * @param location Location of the chunk
-+     * @param cb Callback to receive the chunk when it is loaded.
-+     *           will be executed synchronously
-+     */
-+    public void getChunkAtAsync(Location location, ChunkLoadCallback cb);
-+
-+    /**
-+     * Requests {@link Chunk} to be loaded that contains the given {@link Block}
-+     *
-+     * This method makes no guarantee on how fast the chunk will load,
-+     * and will return the chunk to the callback at a later time.
-+     *
-+     * You should use this method if you need a chunk but do not need it
-+     * immediately, and you wish to let the server control the speed
-+     * of chunk loads, keeping performance in mind.
-+     *
-+     * The {@link ChunkLoadCallback} will always be executed synchronously
-+     * on the main Server Thread.
-+     *
-+     * @param block Block to get the containing chunk from
-+     * @param cb Callback to receive the chunk when it is loaded.
-+     *           will be executed synchronously
-+     */
-+    public void getChunkAtAsync(Block block, ChunkLoadCallback cb);
-+
-     /**
-      * Checks if the specified {@link Chunk} is loaded
-      *
---
\ No newline at end of file
diff --git a/Spigot-API-Patches/Add-hand-to-bucket-events.patch b/Spigot-API-Patches/Add-hand-to-bucket-events.patch
index d402920ad1..7a76b8fb74 100644
--- a/Spigot-API-Patches/Add-hand-to-bucket-events.patch
+++ b/Spigot-API-Patches/Add-hand-to-bucket-events.patch
@@ -5,7 +5,7 @@ Subject: [PATCH] Add hand to bucket events
 
 
 diff --git a/src/main/java/org/bukkit/event/player/PlayerBucketEmptyEvent.java b/src/main/java/org/bukkit/event/player/PlayerBucketEmptyEvent.java
-index 8fb121a9..7b9596f3 100644
+index 8fb121a91..7b9596f30 100644
 --- a/src/main/java/org/bukkit/event/player/PlayerBucketEmptyEvent.java
 +++ b/src/main/java/org/bukkit/event/player/PlayerBucketEmptyEvent.java
 @@ -0,0 +0,0 @@ import org.bukkit.block.Block;
@@ -30,7 +30,7 @@ index 8fb121a9..7b9596f3 100644
      public HandlerList getHandlers() {
          return handlers;
 diff --git a/src/main/java/org/bukkit/event/player/PlayerBucketEvent.java b/src/main/java/org/bukkit/event/player/PlayerBucketEvent.java
-index 56584687..3dbe428b 100644
+index 56584687f..3dbe428ba 100644
 --- a/src/main/java/org/bukkit/event/player/PlayerBucketEvent.java
 +++ b/src/main/java/org/bukkit/event/player/PlayerBucketEvent.java
 @@ -0,0 +0,0 @@ import org.bukkit.block.Block;
@@ -82,7 +82,7 @@ index 56584687..3dbe428b 100644
          return cancelled;
      }
 diff --git a/src/main/java/org/bukkit/event/player/PlayerBucketFillEvent.java b/src/main/java/org/bukkit/event/player/PlayerBucketFillEvent.java
-index 94e042a3..884b9240 100644
+index 94e042a36..884b9240b 100644
 --- a/src/main/java/org/bukkit/event/player/PlayerBucketFillEvent.java
 +++ b/src/main/java/org/bukkit/event/player/PlayerBucketFillEvent.java
 @@ -0,0 +0,0 @@ import org.bukkit.block.Block;
diff --git a/Spigot-API-Patches/Allow-disabling-armour-stand-ticking.patch b/Spigot-API-Patches/Allow-disabling-armour-stand-ticking.patch
index 67092293db..27c13d816d 100644
--- a/Spigot-API-Patches/Allow-disabling-armour-stand-ticking.patch
+++ b/Spigot-API-Patches/Allow-disabling-armour-stand-ticking.patch
@@ -5,7 +5,7 @@ Subject: [PATCH] Allow disabling armour stand ticking
 
 
 diff --git a/src/main/java/org/bukkit/entity/ArmorStand.java b/src/main/java/org/bukkit/entity/ArmorStand.java
-index 099da6ce..859f166f 100644
+index 099da6ce1..859f166fb 100644
 --- a/src/main/java/org/bukkit/entity/ArmorStand.java
 +++ b/src/main/java/org/bukkit/entity/ArmorStand.java
 @@ -0,0 +0,0 @@ public interface ArmorStand extends LivingEntity {
diff --git a/Spigot-API-Patches/AnvilDamageEvent.patch b/Spigot-API-Patches/AnvilDamageEvent.patch
index d6d5ec79e7..76879f6245 100644
--- a/Spigot-API-Patches/AnvilDamageEvent.patch
+++ b/Spigot-API-Patches/AnvilDamageEvent.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] AnvilDamageEvent
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/block/AnvilDamagedEvent.java b/src/main/java/com/destroystokyo/paper/event/block/AnvilDamagedEvent.java
 new file mode 100644
-index 00000000..fd3c5c02
+index 000000000..fd3c5c02e
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/block/AnvilDamagedEvent.java
 @@ -0,0 +0,0 @@
diff --git a/Spigot-API-Patches/Async-Chunks-API.patch b/Spigot-API-Patches/Async-Chunks-API.patch
new file mode 100644
index 0000000000..31716ec834
--- /dev/null
+++ b/Spigot-API-Patches/Async-Chunks-API.patch
@@ -0,0 +1,397 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 29 Feb 2016 17:43:33 -0600
+Subject: [PATCH] Async Chunks API
+
+Adds API's to load or generate chunks asynchronously.
+
+Also adds utility methods to Entity to teleport asynchronously.
+
+diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
+index e451ca611..bf5c21814 100644
+--- a/src/main/java/org/bukkit/World.java
++++ b/src/main/java/org/bukkit/World.java
+@@ -0,0 +0,0 @@ public interface World extends PluginMessageRecipient, Metadatable {
+     public default Chunk getChunkAt(long chunkKey) {
+         return getChunkAt((int) chunkKey, (int) (chunkKey >> 32));
+     }
++
++    /**
++     * This is the Legacy API before Java 8 was supported. Java 8 Consumer is provided,
++     * as well as future support
++     *
++     * Used by {@link World#getChunkAtAsync(Location,ChunkLoadCallback)} methods
++     * to request a {@link Chunk} to be loaded, with this callback receiving
++     * the chunk when it is finished.
++     *
++     * This callback will be executed on synchronously on the main thread.
++     *
++     * Timing and order this callback is fired is intentionally not defined and
++     * and subject to change.
++     *
++     * @deprecated Use either the Future or the Consumer based methods
++     */
++    @Deprecated
++    public static interface ChunkLoadCallback extends java.util.function.Consumer<Chunk> {
++        public void onLoad(Chunk chunk);
++
++        // backwards compat to old api
++        @Override
++        default void accept(Chunk chunk) {
++            onLoad(chunk);
++        }
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link ChunkLoadCallback} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @deprecated Use either the Future or the Consumer based methods
++     * @param x Chunk X-coordinate of the chunk - (world coordinate / 16)
++     * @param z Chunk Z-coordinate of the chunk - (world coordinate / 16)
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    @Deprecated
++    public default void getChunkAtAsync(int x, int z, ChunkLoadCallback cb) {
++        getChunkAtAsync(x, z, true).thenAccept(cb::onLoad);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given {@link Location}
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link ChunkLoadCallback} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @deprecated Use either the Future or the Consumer based methods
++     * @param loc Location of the chunk
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    @Deprecated
++    public default void getChunkAtAsync(Location loc, ChunkLoadCallback cb) {
++        getChunkAtAsync(loc, true).thenAccept(cb::onLoad);
++    }
++
++    /**
++     * Requests {@link Chunk} to be loaded that contains the given {@link Block}
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link ChunkLoadCallback} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @deprecated Use either the Future or the Consumer based methods
++     * @param block Block to get the containing chunk from
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    @Deprecated
++    public default void getChunkAtAsync(Block block, ChunkLoadCallback cb) {
++        getChunkAtAsync(block, true).thenAccept(cb::onLoad);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link java.util.function.Consumer<Chunk>} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param x Chunk X-coordinate of the chunk - (world coordinate / 16)
++     * @param z Chunk Z-coordinate of the chunk - (world coordinate / 16)
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    public default void getChunkAtAsync(int x, int z, java.util.function.Consumer<Chunk> cb) {
++        getChunkAtAsync(x, z, true).thenAccept(cb);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link java.util.function.Consumer<Chunk>} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param x Chunk X-coordinate of the chunk - (world coordinate / 16)
++     * @param z Chunk Z-coordinate of the chunk - (world coordinate / 16)
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    public default void getChunkAtAsync(int x, int z, boolean gen, java.util.function.Consumer<Chunk> cb) {
++        getChunkAtAsync(x, z, gen).thenAccept(cb);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given {@link Location}
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link java.util.function.Consumer<Chunk>} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param loc Location of the chunk
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    public default void getChunkAtAsync(Location loc, java.util.function.Consumer<Chunk> cb) {
++        getChunkAtAsync((int)loc.getX() >> 4, (int)Math.floor(loc.getZ()) >> 4, true, cb);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given {@link Location}
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link java.util.function.Consumer<Chunk>} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param loc Location of the chunk
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    public default void getChunkAtAsync(Location loc, boolean gen, java.util.function.Consumer<Chunk> cb) {
++        getChunkAtAsync((int)loc.getX() >> 4, (int)Math.floor(loc.getZ()) >> 4, gen, cb);
++    }
++
++    /**
++     * Requests {@link Chunk} to be loaded that contains the given {@link Block}
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link java.util.function.Consumer<Chunk>} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param block Block to get the containing chunk from
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    public default void getChunkAtAsync(Block block, java.util.function.Consumer<Chunk> cb) {
++        getChunkAtAsync(block.getX() >> 4, block.getZ() >> 4, true, cb);
++    }
++
++    /**
++     * Requests {@link Chunk} to be loaded that contains the given {@link Block}
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link java.util.function.Consumer<Chunk>} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param block Block to get the containing chunk from
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    public default void getChunkAtAsync(Block block, boolean gen, java.util.function.Consumer<Chunk> cb) {
++        getChunkAtAsync(block.getX() >> 4, block.getZ() >> 4, gen, cb);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The future will always be executed synchronously
++     * on the main Server Thread.
++     * @param loc Location to load the corresponding chunk from
++     * @return Future that will resolve when the chunk is loaded
++     */
++    public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(Location loc) {
++        return getChunkAtAsync((int)loc.getX() >> 4, (int)Math.floor(loc.getZ()) >> 4, true);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The future will always be executed synchronously
++     * on the main Server Thread.
++     * @param loc Location to load the corresponding chunk from
++     * @param gen Should the chunk generate
++     * @return Future that will resolve when the chunk is loaded
++     */
++    public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(Location loc, boolean gen) {
++        return getChunkAtAsync((int)loc.getX() >> 4, (int)Math.floor(loc.getZ()) >> 4, gen);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The future will always be executed synchronously
++     * on the main Server Thread.
++     * @param block Block to load the corresponding chunk from
++     * @return Future that will resolve when the chunk is loaded
++     */
++    public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(Block block) {
++        return getChunkAtAsync(block.getX() >> 4, block.getZ() >> 4, true);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The future will always be executed synchronously
++     * on the main Server Thread.
++     * @param block Block to load the corresponding chunk from
++     * @param gen Should the chunk generate
++     * @return Future that will resolve when the chunk is loaded
++     */
++    public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(Block block, boolean gen) {
++        return getChunkAtAsync(block.getX() >> 4, block.getZ() >> 4, gen);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The future will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param x X Coord
++     * @param z Z Coord
++     * @return Future that will resolve when the chunk is loaded
++     */
++    public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(int x, int z) {
++        return getChunkAtAsync(x, z, true);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The future will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param x Chunk X-coordinate of the chunk - (world coordinate / 16)
++     * @param z Chunk Z-coordinate of the chunk - (world coordinate / 16)
++     * @param gen Should we generate a chunk if it doesn't exists or not
++     * @return Future that will resolve when the chunk is loaded
++     */
++    public java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(int x, int z, boolean gen);
+     // Paper end
+ 
+     /**
+diff --git a/src/main/java/org/bukkit/entity/Entity.java b/src/main/java/org/bukkit/entity/Entity.java
+index 72ebe35fb..cd835edce 100644
+--- a/src/main/java/org/bukkit/entity/Entity.java
++++ b/src/main/java/org/bukkit/entity/Entity.java
+@@ -0,0 +0,0 @@ public interface Entity extends Metadatable, CommandSender, Nameable {
+      */
+     public boolean teleport(Entity destination, TeleportCause cause);
+ 
++    // Paper start
++    /**
++     * Loads/Generates(in 1.13+) the Chunk asynchronously, and then teleports the entity when the chunk is ready.
++     * @param loc Location to teleport to
++     * @return A future that will be completed with the result of the teleport
++     */
++    public default java.util.concurrent.CompletableFuture<Boolean> teleportAsync(Location loc) {
++        return teleportAsync(loc, TeleportCause.PLUGIN);
++    }
++    /**
++     * Loads/Generates(in 1.13+) the Chunk asynchronously, and then teleports the entity when the chunk is ready.
++     * @param loc Location to teleport to
++     * @param cause Reason for teleport
++     * @return A future that will be completed with the result of the teleport
++     */
++    public default java.util.concurrent.CompletableFuture<Boolean> teleportAsync(Location loc, TeleportCause cause) {
++        java.util.concurrent.CompletableFuture<Boolean> future = new java.util.concurrent.CompletableFuture<>();
++        loc.getWorld().getChunkAtAsync(loc).thenAccept((chunk) -> future.complete(teleport(loc, cause)));
++        return future;
++    }
++    // Paper end
++
+     /**
+      * Returns a list of entities within a bounding box centered around this
+      * entity
+--
\ No newline at end of file
diff --git a/Spigot-API-Patches/EnderDragon-Events.patch b/Spigot-API-Patches/EnderDragon-Events.patch
index 62125a9d5a..891cdfd29a 100644
--- a/Spigot-API-Patches/EnderDragon-Events.patch
+++ b/Spigot-API-Patches/EnderDragon-Events.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] EnderDragon Events
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonFireballHitEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonFireballHitEvent.java
 new file mode 100644
-index 00000000..ef2a8dab
+index 000000000..ef2a8dab9
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonFireballHitEvent.java
 @@ -0,0 +0,0 @@
@@ -84,7 +84,7 @@ index 00000000..ef2a8dab
 +}
 diff --git a/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonFlameEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonFlameEvent.java
 new file mode 100644
-index 00000000..d8c3ab33
+index 000000000..d8c3ab330
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonFlameEvent.java
 @@ -0,0 +0,0 @@
@@ -146,7 +146,7 @@ index 00000000..d8c3ab33
 +}
 diff --git a/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonShootFireballEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonShootFireballEvent.java
 new file mode 100644
-index 00000000..aa70dda1
+index 000000000..aa70dda10
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonShootFireballEvent.java
 @@ -0,0 +0,0 @@
diff --git a/Spigot-API-Patches/EntityTransformedEvent.patch b/Spigot-API-Patches/EntityTransformedEvent.patch
index 65681a00c5..8e824fcfe4 100644
--- a/Spigot-API-Patches/EntityTransformedEvent.patch
+++ b/Spigot-API-Patches/EntityTransformedEvent.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] EntityTransformedEvent
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/entity/EntityTransformedEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/EntityTransformedEvent.java
 new file mode 100644
-index 00000000..d9e5cab9
+index 000000000..d9e5cab95
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/entity/EntityTransformedEvent.java
 @@ -0,0 +0,0 @@
diff --git a/Spigot-API-Patches/Expand-ArmorStand-API.patch b/Spigot-API-Patches/Expand-ArmorStand-API.patch
index 8f4cc2b8e7..de79323a33 100644
--- a/Spigot-API-Patches/Expand-ArmorStand-API.patch
+++ b/Spigot-API-Patches/Expand-ArmorStand-API.patch
@@ -8,7 +8,7 @@ Add the following:
 - Enable/Disable slot interactions
 
 diff --git a/src/main/java/org/bukkit/entity/ArmorStand.java b/src/main/java/org/bukkit/entity/ArmorStand.java
-index 859f166f..eda4873d 100644
+index 859f166fb..eda4873d5 100644
 --- a/src/main/java/org/bukkit/entity/ArmorStand.java
 +++ b/src/main/java/org/bukkit/entity/ArmorStand.java
 @@ -0,0 +0,0 @@
diff --git a/Spigot-API-Patches/Expand-Location-Manipulation-API.patch b/Spigot-API-Patches/Expand-Location-Manipulation-API.patch
index 871d24565d..d6fc5e59de 100644
--- a/Spigot-API-Patches/Expand-Location-Manipulation-API.patch
+++ b/Spigot-API-Patches/Expand-Location-Manipulation-API.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] Expand Location Manipulation API
 Adds set(x, y, z), add(base, x, y, z), subtract(base, x, y, z);
 
 diff --git a/src/main/java/org/bukkit/Location.java b/src/main/java/org/bukkit/Location.java
-index 056a4d6b..8dcb15fb 100644
+index 056a4d6bb..8dcb15fb8 100644
 --- a/src/main/java/org/bukkit/Location.java
 +++ b/src/main/java/org/bukkit/Location.java
 @@ -0,0 +0,0 @@ public class Location implements Cloneable, ConfigurationSerializable {
diff --git a/Spigot-API-Patches/PlayerElytraBoostEvent.patch b/Spigot-API-Patches/PlayerElytraBoostEvent.patch
index a0079e2839..b55b338c3b 100644
--- a/Spigot-API-Patches/PlayerElytraBoostEvent.patch
+++ b/Spigot-API-Patches/PlayerElytraBoostEvent.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] PlayerElytraBoostEvent
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerElytraBoostEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerElytraBoostEvent.java
 new file mode 100644
-index 00000000..cecb2182
+index 000000000..cecb2182c
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerElytraBoostEvent.java
 @@ -0,0 +0,0 @@
diff --git a/Spigot-API-Patches/PlayerLaunchProjectileEvent.patch b/Spigot-API-Patches/PlayerLaunchProjectileEvent.patch
index 2fc6099b14..8e9ed08bab 100644
--- a/Spigot-API-Patches/PlayerLaunchProjectileEvent.patch
+++ b/Spigot-API-Patches/PlayerLaunchProjectileEvent.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] PlayerLaunchProjectileEvent
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerLaunchProjectileEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerLaunchProjectileEvent.java
 new file mode 100644
-index 00000000..d2b244a4
+index 000000000..d2b244a41
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerLaunchProjectileEvent.java
 @@ -0,0 +0,0 @@
diff --git a/Spigot-API-Patches/Provide-Chunk-Coordinates-as-a-Long-API.patch b/Spigot-API-Patches/Provide-Chunk-Coordinates-as-a-Long-API.patch
index e1ef532510..8aa2328980 100644
--- a/Spigot-API-Patches/Provide-Chunk-Coordinates-as-a-Long-API.patch
+++ b/Spigot-API-Patches/Provide-Chunk-Coordinates-as-a-Long-API.patch
@@ -7,7 +7,7 @@ Allows you to easily access the chunks X/z as a long, and a method
 to look up by the long key too.
 
 diff --git a/src/main/java/org/bukkit/Chunk.java b/src/main/java/org/bukkit/Chunk.java
-index 079b9feb..c75bce07 100644
+index 079b9febe..b347a3ccf 100644
 --- a/src/main/java/org/bukkit/Chunk.java
 +++ b/src/main/java/org/bukkit/Chunk.java
 @@ -0,0 +0,0 @@ public interface Chunk {
@@ -19,7 +19,24 @@ index 079b9feb..c75bce07 100644
 +     * @return The Chunks X and Z coordinates packed into a long
 +     */
 +    default long getChunkKey() {
-+        return (long) getX() & 0xffffffffL | ((long) getZ() & 0xffffffffL) << 32;
++        return getChunkKey(getX(), getZ());
++    }
++
++    /**
++     * @param loc Location to get chunk key
++     * @return Location's chunk coordinates packed into a long
++     */
++    static long getChunkKey(Location loc) {
++        return getChunkKey((int) Math.floor(loc.getX()) << 4, (int) Math.floor(loc.getZ()) << 4);
++    }
++
++    /**
++     * @param x X Coordinate
++     * @param z Z Coordinate
++     * @return Chunk coordinates packed into a long
++     */
++    static long getChunkKey(int x, int z) {
++        return (long) x & 0xffffffffL | ((long) z & 0xffffffffL) << 32;
 +    }
 +    // Paper end
 +
@@ -27,7 +44,7 @@ index 079b9feb..c75bce07 100644
       * Gets the world containing this chunk
       *
 diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
-index dbbcfec9..724088ec 100644
+index 5e6cb56ab..e451ca611 100644
 --- a/src/main/java/org/bukkit/World.java
 +++ b/src/main/java/org/bukkit/World.java
 @@ -0,0 +0,0 @@ public interface World extends PluginMessageRecipient, Metadatable {
@@ -50,6 +67,6 @@ index dbbcfec9..724088ec 100644
 +    // Paper end
 +
      /**
-      * Used by {@link World#getChunkAtAsync(Location,ChunkLoadCallback)} methods
-      * to request a {@link Chunk} to be loaded, with this callback receiving
+      * Checks if the specified {@link Chunk} is loaded
+      *
 --
\ No newline at end of file
diff --git a/Spigot-API-Patches/Remove-deadlock-risk-in-firing-async-events.patch b/Spigot-API-Patches/Remove-deadlock-risk-in-firing-async-events.patch
index b52582cd9e..ada45a3bee 100644
--- a/Spigot-API-Patches/Remove-deadlock-risk-in-firing-async-events.patch
+++ b/Spigot-API-Patches/Remove-deadlock-risk-in-firing-async-events.patch
@@ -16,7 +16,7 @@ which results in a hard crash.
 This change removes the synchronize and adds some protection around enable/disable
 
 diff --git a/src/main/java/org/bukkit/plugin/SimplePluginManager.java b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
-index cb2b0b9c..a7dd902f 100644
+index cb2b0b9cb..a7dd902fb 100644
 --- a/src/main/java/org/bukkit/plugin/SimplePluginManager.java
 +++ b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
 @@ -0,0 +0,0 @@ public final class SimplePluginManager implements PluginManager {
@@ -79,7 +79,7 @@ index cb2b0b9c..a7dd902f 100644
          RegisteredListener[] listeners = handlers.getRegisteredListeners();
  
 diff --git a/src/test/java/org/bukkit/plugin/PluginManagerTest.java b/src/test/java/org/bukkit/plugin/PluginManagerTest.java
-index 6b86128e..56308c0c 100644
+index 6b86128e1..56308c0c6 100644
 --- a/src/test/java/org/bukkit/plugin/PluginManagerTest.java
 +++ b/src/test/java/org/bukkit/plugin/PluginManagerTest.java
 @@ -0,0 +0,0 @@ public class PluginManagerTest {
diff --git a/Spigot-API-Patches/SkeletonHorse-Additions.patch b/Spigot-API-Patches/SkeletonHorse-Additions.patch
index 718d5499b6..58c1e84788 100644
--- a/Spigot-API-Patches/SkeletonHorse-Additions.patch
+++ b/Spigot-API-Patches/SkeletonHorse-Additions.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] SkeletonHorse Additions
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/entity/SkeletonHorseTrapEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/SkeletonHorseTrapEvent.java
 new file mode 100644
-index 00000000..55bae018
+index 000000000..55bae018e
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/entity/SkeletonHorseTrapEvent.java
 @@ -0,0 +0,0 @@
@@ -54,7 +54,7 @@ index 00000000..55bae018
 +}
 +
 diff --git a/src/main/java/org/bukkit/entity/SkeletonHorse.java b/src/main/java/org/bukkit/entity/SkeletonHorse.java
-index b2c6b6a8..ba998346 100644
+index b2c6b6a86..ba9983463 100644
 --- a/src/main/java/org/bukkit/entity/SkeletonHorse.java
 +++ b/src/main/java/org/bukkit/entity/SkeletonHorse.java
 @@ -0,0 +0,0 @@ package org.bukkit.entity;
diff --git a/Spigot-API-Patches/isChunkGenerated-API.patch b/Spigot-API-Patches/isChunkGenerated-API.patch
index f7d3712077..0f4bfc67e0 100644
--- a/Spigot-API-Patches/isChunkGenerated-API.patch
+++ b/Spigot-API-Patches/isChunkGenerated-API.patch
@@ -3,10 +3,9 @@ From: cswhite2000 <18whitechristop@gmail.com>
 Date: Tue, 21 Aug 2018 19:39:46 -0700
 Subject: [PATCH] isChunkGenerated API
 
-Resolves #1329
 
 diff --git a/src/main/java/org/bukkit/Location.java b/src/main/java/org/bukkit/Location.java
-index 7e1ee875..9457832b 100644
+index 7e1ee875e..9457832bc 100644
 --- a/src/main/java/org/bukkit/Location.java
 +++ b/src/main/java/org/bukkit/Location.java
 @@ -0,0 +0,0 @@ import org.bukkit.util.NumberConversions;
@@ -34,14 +33,13 @@ index 7e1ee875..9457832b 100644
      /**
       * Sets the position of this Location and returns itself
 diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
-index d4bfbad3..53764fae 100644
+index 348f1c98d..9c06fc163 100644
 --- a/src/main/java/org/bukkit/World.java
 +++ b/src/main/java/org/bukkit/World.java
 @@ -0,0 +0,0 @@ public interface World extends PluginMessageRecipient, Metadatable {
-     public default Chunk getChunkAt(long chunkKey) {
          return getChunkAt((int) chunkKey, (int) (chunkKey >> 32));
      }
-+
+ 
 +    /**
 +     * Checks if a {@link Chunk} has been generated at the specified chunk key,
 +     * which is the X and Z packed into a long.
@@ -61,7 +59,8 @@ index d4bfbad3..53764fae 100644
 +     * @return true if the chunk has been generated, otherwise false
 +     */
 +    public boolean isChunkGenerated(int x, int z);
-     // Paper end
- 
++
      /**
+      * This is the Legacy API before Java 8 was supported. Java 8 Consumer is provided,
+      * as well as future support
 --
\ No newline at end of file
diff --git a/Spigot-Server-Patches/Add-async-chunk-load-API.patch b/Spigot-Server-Patches/Add-async-chunk-load-API.patch
index 25054be153..ac48175a62 100644
--- a/Spigot-Server-Patches/Add-async-chunk-load-API.patch
+++ b/Spigot-Server-Patches/Add-async-chunk-load-API.patch
@@ -5,7 +5,7 @@ Subject: [PATCH] Add async chunk load API
 
 
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index e4c4cdb980..af977b171a 100644
+index e4c4cdb980..c2aa3917bf 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 @@ -0,0 +0,0 @@ public class CraftWorld implements World {
@@ -13,23 +13,14 @@ index e4c4cdb980..af977b171a 100644
      }
  
 +    // Paper start - Async chunk load API
-+    public void getChunkAtAsync(final int x, final int z, final ChunkLoadCallback callback) {
++    @Override
++    public java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(final int x, final int z, final boolean gen) {
 +        final ChunkProviderServer cps = this.world.getChunkProviderServer();
-+        callback.onLoad(cps.getChunkAt(x, z, true, true).bukkitChunk); // TODO: Add back async variant
-+        /*cps.getChunkAt(x, z, new Runnable() {
-+            @Override
-+            public void run() {
-+                callback.onLoad(cps.getChunkAt(x, z).bukkitChunk);
-+            }
-+        });*/
-+    }
-+
-+    public void getChunkAtAsync(Block block, ChunkLoadCallback callback) {
-+        getChunkAtAsync(block.getX() >> 4, block.getZ() >> 4, callback);
-+    }
-+
-+    public void getChunkAtAsync(Location location, ChunkLoadCallback callback) {
-+        getChunkAtAsync(location.getBlockX() >> 4, location.getBlockZ() >> 4, callback);
++        java.util.concurrent.CompletableFuture<Chunk> future = new java.util.concurrent.CompletableFuture<>();
++        net.minecraft.server.Chunk chunk = cps.getChunkAt(x, z, true, gen);
++        // TODO: Add back async variant
++        future.complete(chunk != null ? chunk.bukkitChunk : null);
++        return future;
 +    }
 +    // Paper end
 +
diff --git a/Spigot-Server-Patches/Ignore-Dead-Entities-in-entityList-iteration.patch b/Spigot-Server-Patches/Ignore-Dead-Entities-in-entityList-iteration.patch
index b5a74c18ae..05467591b4 100644
--- a/Spigot-Server-Patches/Ignore-Dead-Entities-in-entityList-iteration.patch
+++ b/Spigot-Server-Patches/Ignore-Dead-Entities-in-entityList-iteration.patch
@@ -71,7 +71,7 @@ index 597169b4cc..b18ea7154f 100644
              if (entity instanceof EntityInsentient) {
                  EntityInsentient entityinsentient = (EntityInsentient) entity;
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index af977b171a..80fd49b6e1 100644
+index c2aa3917bf..edf2e39e3d 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 @@ -0,0 +0,0 @@ public class CraftWorld implements World {
diff --git a/Spigot-Server-Patches/Implement-Force-Loaded-Chunk-API.patch b/Spigot-Server-Patches/Implement-Force-Loaded-Chunk-API.patch
index 9d93b8c12a..581676c6f3 100644
--- a/Spigot-Server-Patches/Implement-Force-Loaded-Chunk-API.patch
+++ b/Spigot-Server-Patches/Implement-Force-Loaded-Chunk-API.patch
@@ -40,7 +40,7 @@ index 12c6d850d2..55394e0c15 100644
          Arrays.fill(emptySkyLight, (byte) 0xFF);
      }
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 1ccf2a7609..755d2632fd 100644
+index 99d8199996..f8ef782f14 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 @@ -0,0 +0,0 @@ public class CraftWorld implements World {
diff --git a/Spigot-Server-Patches/Make-CraftWorld-loadChunk-int-int-false-load-unconve.patch b/Spigot-Server-Patches/Make-CraftWorld-loadChunk-int-int-false-load-unconve.patch
index 5534cf03ba..1f0c775bf6 100644
--- a/Spigot-Server-Patches/Make-CraftWorld-loadChunk-int-int-false-load-unconve.patch
+++ b/Spigot-Server-Patches/Make-CraftWorld-loadChunk-int-int-false-load-unconve.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] Make CraftWorld#loadChunk(int, int, false) load unconverted
 
 
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 585a0c7fd2..b38e394f83 100644
+index b411776c3c..262363999d 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 @@ -0,0 +0,0 @@ public class CraftWorld implements World {
diff --git a/Spigot-Server-Patches/Optimize-getChunkIfLoaded-type-calls.patch b/Spigot-Server-Patches/Optimize-getChunkIfLoaded-type-calls.patch
index 6e927ce963..fd65f77a2b 100644
--- a/Spigot-Server-Patches/Optimize-getChunkIfLoaded-type-calls.patch
+++ b/Spigot-Server-Patches/Optimize-getChunkIfLoaded-type-calls.patch
@@ -55,7 +55,7 @@ index 2ff8536d59..0c42d042b1 100644
              return chunk != null && !chunk.isEmpty();
          }
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 755d2632fd..585a0c7fd2 100644
+index f8ef782f14..b411776c3c 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 @@ -0,0 +0,0 @@ public class CraftWorld implements World {
diff --git a/Spigot-Server-Patches/Send-nearby-packets-from-world-player-list-not-serve.patch b/Spigot-Server-Patches/Send-nearby-packets-from-world-player-list-not-serve.patch
index 571d3b7464..6bc4de4aa0 100644
--- a/Spigot-Server-Patches/Send-nearby-packets-from-world-player-list-not-serve.patch
+++ b/Spigot-Server-Patches/Send-nearby-packets-from-world-player-list-not-serve.patch
@@ -119,7 +119,7 @@ index 911d03c70b..f837e6c36c 100644
          }
  
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 80fd49b6e1..ba2e768594 100644
+index edf2e39e3d..2611971575 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 @@ -0,0 +0,0 @@ public class CraftWorld implements World {
diff --git a/Spigot-Server-Patches/isChunkGenerated-API.patch b/Spigot-Server-Patches/isChunkGenerated-API.patch
index c67c611523..3eb6a4c043 100644
--- a/Spigot-Server-Patches/isChunkGenerated-API.patch
+++ b/Spigot-Server-Patches/isChunkGenerated-API.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] isChunkGenerated API
 Resolves #1329
 
 diff --git a/src/main/java/net/minecraft/server/ChunkProviderServer.java b/src/main/java/net/minecraft/server/ChunkProviderServer.java
-index 0ca071b879..96d49b469a 100644
+index 60f249a031..fc621911e0 100644
 --- a/src/main/java/net/minecraft/server/ChunkProviderServer.java
 +++ b/src/main/java/net/minecraft/server/ChunkProviderServer.java
 @@ -0,0 +0,0 @@ public class ChunkProviderServer implements IChunkProvider {
@@ -20,7 +20,7 @@ index 0ca071b879..96d49b469a 100644
      public final Long2ObjectMap<Chunk> chunks = Long2ObjectMaps.synchronize(new ChunkMap(8192));
      private Chunk lastChunk;
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index ba2e768594..1ccf2a7609 100644
+index 2611971575..99d8199996 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 @@ -0,0 +0,0 @@ public class CraftWorld implements World {