1 files changed, 70 insertions, 70 deletions
diff --git a/feature-patches/1050-Optimize-Bit-Operations-by-inlining.patch b/feature-patches/1050-Optimize-Bit-Operations-by-inlining.patch
index 7d7f2d776f..a453424d45 100644
--- a/feature-patches/1050-Optimize-Bit-Operations-by-inlining.patch
+++ b/feature-patches/1050-Optimize-Bit-Operations-by-inlining.patch
@@ -6,11 +6,12 @@ Subject: [PATCH] Optimize Bit Operations by inlining
 Inline bit operations and reduce instruction count to make these hot
 operations faster
 
-diff --git a/src/main/java/net/minecraft/core/BlockPos.java b/src/main/java/net/minecraft/core/BlockPos.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/core/BlockPos.java
-+++ b/src/main/java/net/minecraft/core/BlockPos.java
-@@ -0,0 +0,0 @@ public class BlockPos extends Vec3i {
+
+diff --git a/net/minecraft/core/BlockPos.java b/net/minecraft/core/BlockPos.java
+index 98f0b1cf19d7a035849a9a2fa25e2be3a4c5a980..01ba7bc16e30440e35ce062bc21dae7e59bb6f8d 100644
+--- a/net/minecraft/core/BlockPos.java
++++ b/net/minecraft/core/BlockPos.java
+@@ -51,15 +51,17 @@ public class BlockPos extends Vec3i {
      };
      private static final Logger LOGGER = LogUtils.getLogger();
      public static final BlockPos ZERO = new BlockPos(0, 0, 0);
@@ -36,18 +37,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public BlockPos(int x, int y, int z) {
          super(x, y, z);
-@@ -0,0 +0,0 @@ public class BlockPos extends Vec3i {
-         this(pos.getX(), pos.getY(), pos.getZ());
+@@ -69,28 +71,29 @@ public class BlockPos extends Vec3i {
+         this(vector.getX(), vector.getY(), vector.getZ());
      }
  
-+    public static long getAdjacent(int baseX, int baseY, int baseZ, Direction enumdirection) { return asLong(baseX + enumdirection.getStepX(), baseY + enumdirection.getStepY(), baseZ + enumdirection.getStepZ()); } // Paper
-     public static long offset(long value, Direction direction) {
-         return offset(value, direction.getStepX(), direction.getStepY(), direction.getStepZ());
++    public static long getAdjacent(int baseX, int baseY, int baseZ, Direction direction) { return asLong(baseX + direction.getStepX(), baseY + direction.getStepY(), baseZ + direction.getStepZ()); } // Paper
+     public static long offset(long pos, Direction direction) {
+         return offset(pos, direction.getStepX(), direction.getStepY(), direction.getStepZ());
      }
  
-     public static long offset(long value, int x, int y, int z) {
--        return asLong(getX(value) + x, getY(value) + y, getZ(value) + z);
-+        return asLong((int) (value >> 38) + x, (int) ((value << 52) >> 52) + y, (int) ((value << 26) >> 38) + z); // Paper - simplify/inline
+     public static long offset(long pos, int dx, int dy, int dz) {
+-        return asLong(getX(pos) + dx, getY(pos) + dy, getZ(pos) + dz);
++        return asLong((int) (pos >> 38) + dx, (int) ((pos << 52) >> 52) + dy, (int) ((pos << 26) >> 38) + dz); // Paper - simplify/inline
      }
  
      public static int getX(long packedPos) {
@@ -71,23 +72,23 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public static BlockPos containing(double x, double y, double z) {
-@@ -0,0 +0,0 @@ public class BlockPos extends Vec3i {
+@@ -114,10 +117,7 @@ public class BlockPos extends Vec3i {
      }
  
      public static long asLong(int x, int y, int z) {
 -        long l = 0L;
--        l |= ((long)x & PACKED_X_MASK) << X_OFFSET;
--        l |= ((long)y & PACKED_Y_MASK) << 0;
--        return l | ((long)z & PACKED_Z_MASK) << Z_OFFSET;
-+        return (((long) x & (long) 67108863) << 38) | (((long) y & (long) 4095)) | (((long) z & (long) 67108863) << 12); // Paper - inline constants and simplify
+-        l |= (x & PACKED_X_MASK) << X_OFFSET;
+-        l |= (y & PACKED_Y_MASK) << 0;
+-        return l | (z & PACKED_Z_MASK) << Z_OFFSET;
++        return ((x & 67108863L) << 38) | ((y &  4095L)) | ((z & 67108863L) << 12); // Paper - inline constants and simplify
      }
  
-     public static long getFlatIndex(long y) {
-diff --git a/src/main/java/net/minecraft/core/SectionPos.java b/src/main/java/net/minecraft/core/SectionPos.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/core/SectionPos.java
-+++ b/src/main/java/net/minecraft/core/SectionPos.java
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
+     public static long getFlatIndex(long packedPos) {
+diff --git a/net/minecraft/core/SectionPos.java b/net/minecraft/core/SectionPos.java
+index 1780d8e14cea62971da75e4dcc80d1805434037b..737f853a264d720ce15f6bbffc206e3003fff380 100644
+--- a/net/minecraft/core/SectionPos.java
++++ b/net/minecraft/core/SectionPos.java
+@@ -38,7 +38,7 @@ public class SectionPos extends Vec3i {
      }
  
      public static SectionPos of(BlockPos pos) {
@@ -96,7 +97,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public static SectionPos of(ChunkPos chunkPos, int y) {
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
+@@ -54,7 +54,7 @@ public class SectionPos extends Vec3i {
      }
  
      public static SectionPos of(long packed) {
@@ -105,109 +106,108 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public static SectionPos bottomOf(ChunkAccess chunk) {
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
+@@ -65,8 +65,16 @@ public class SectionPos extends Vec3i {
          return offset(packed, direction.getStepX(), direction.getStepY(), direction.getStepZ());
      }
  
 +    // Paper start
-+    public static long getAdjacentFromBlockPos(int x, int y, int z, Direction enumdirection) {
-+        return (((long) ((x >> 4) + enumdirection.getStepX()) & 4194303L) << 42) | (((long) ((y >> 4) + enumdirection.getStepY()) & 1048575L)) | (((long) ((z >> 4) + enumdirection.getStepZ()) & 4194303L) << 20);
++    public static long getAdjacentFromBlockPos(int x, int y, int z, Direction direction) {
++        return (((long) ((x >> 4) + direction.getStepX()) & 4194303L) << 42) | (((long) ((y >> 4) + direction.getStepY()) & 1048575L)) | (((long) ((z >> 4) + direction.getStepZ()) & 4194303L) << 20);
 +    }
-+    public static long getAdjacentFromSectionPos(int x, int y, int z, Direction enumdirection) {
-+        return (((long) (x + enumdirection.getStepX()) & 4194303L) << 42) | (((long) ((y) + enumdirection.getStepY()) & 1048575L)) | (((long) (z + enumdirection.getStepZ()) & 4194303L) << 20);
++    public static long getAdjacentFromSectionPos(int x, int y, int z, Direction direction) {
++        return (((long) (x + direction.getStepX()) & 4194303L) << 42) | (((long) ((y) + direction.getStepY()) & 1048575L)) | (((long) (z + direction.getStepZ()) & 4194303L) << 20);
 +    }
 +    // Paper end
-     public static long offset(long packed, int x, int y, int z) {
--        return asLong(x(packed) + x, y(packed) + y, z(packed) + z);
-+        return (((long) ((int) (packed >> 42) + x) & 4194303L) << 42) | (((long) ((int) (packed << 44 >> 44) + y) & 1048575L)) | (((long) ((int) (packed << 22 >> 42) + z) & 4194303L) << 20); // Simplify to reduce instruction count
+     public static long offset(long packed, int dx, int dy, int dz) {
+-        return asLong(x(packed) + dx, y(packed) + dy, z(packed) + dz);
++        return (((long) ((int) (packed >> 42) + dx) & 4194303L) << 42) | (((long) ((int) (packed << 44 >> 44) + dy) & 1048575L)) | (((long) ((int) (packed << 22 >> 42) + dz) & 4194303L) << 20); // Simplify to reduce instruction count
      }
  
-     public static int posToSectionCoord(double coord) {
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
+     public static int posToSectionCoord(double pos) {
+@@ -86,10 +94,7 @@ public class SectionPos extends Vec3i {
      }
  
      public static short sectionRelativePos(BlockPos pos) {
--        int i = sectionRelative(pos.getX());
--        int j = sectionRelative(pos.getY());
--        int k = sectionRelative(pos.getZ());
--        return (short)(i << 8 | k << 4 | j << 0);
+-        int relativeBlockPosX = sectionRelative(pos.getX());
+-        int relativeBlockPosY = sectionRelative(pos.getY());
+-        int relativeBlockPosZ = sectionRelative(pos.getZ());
+-        return (short)(relativeBlockPosX << 8 | relativeBlockPosZ << 4 | relativeBlockPosY << 0);
 +        return (short) ((pos.getX() & 15) << 8 | (pos.getZ() & 15) << 4 | pos.getY() & 15); // Paper - simplify/inline
      }
  
-     public static int sectionRelativeX(short packedLocalPos) {
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
+     public static int sectionRelativeX(short x) {
+@@ -152,16 +157,16 @@ public class SectionPos extends Vec3i {
          return this.getZ();
      }
  
 -    public int minBlockX() {
 -        return sectionToBlockCoord(this.x());
-+    public final int minBlockX() { // Paper - make final
++    public final int minBlockX() { // Paper - final
 +        return this.getX() << 4; // Paper - inline
      }
  
 -    public int minBlockY() {
 -        return sectionToBlockCoord(this.y());
-+    public final int minBlockY() { // Paper - make final
++    public final int minBlockY() { // Paper - final
 +        return this.getY() << 4; // Paper - inline
      }
  
 -    public int minBlockZ() {
 -        return sectionToBlockCoord(this.z());
-+    public int minBlockZ() { // Paper - make final
++    public final int minBlockZ() { // Paper - final
 +        return this.getZ() << 4; // Paper - inline
      }
  
      public int maxBlockX() {
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
+@@ -177,7 +182,7 @@ public class SectionPos extends Vec3i {
      }
  
-     public static long blockToSection(long blockPos) {
--        return asLong(blockToSectionCoord(BlockPos.getX(blockPos)), blockToSectionCoord(BlockPos.getY(blockPos)), blockToSectionCoord(BlockPos.getZ(blockPos)));
-+        // b(a(BlockPosition.b(i)), a(BlockPosition.c(i)), a(BlockPosition.d(i)));
-+        return (((long) (int) (blockPos >> 42) & 4194303L) << 42) | (((long) (int) ((blockPos << 52) >> 56) & 1048575L)) | (((long) (int) ((blockPos << 26) >> 42) & 4194303L) << 20); // Simplify to reduce instruction count
+     public static long blockToSection(long levelPos) {
+-        return asLong(blockToSectionCoord(BlockPos.getX(levelPos)), blockToSectionCoord(BlockPos.getY(levelPos)), blockToSectionCoord(BlockPos.getZ(levelPos)));
++        return (((long) (int) (levelPos >> 42) & 4194303L) << 42) | (((long) (int) ((levelPos << 52) >> 56) & 1048575L)) | (((long) (int) ((levelPos << 26) >> 42) & 4194303L) << 20); // Simplify to reduce instruction count
      }
  
      public static long getZeroNode(int x, int z) {
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
-         return asLong(blockToSectionCoord(pos.getX()), blockToSectionCoord(pos.getY()), blockToSectionCoord(pos.getZ()));
+@@ -205,15 +210,17 @@ public class SectionPos extends Vec3i {
+         return asLong(blockToSectionCoord(blockPos.getX()), blockToSectionCoord(blockPos.getY()), blockToSectionCoord(blockPos.getZ()));
      }
  
 +    // Paper start
-+    public static long blockPosAsSectionLong(int i, int j, int k) {
-+        return (((long) (i >> 4) & 4194303L) << 42) | (((long) (j >> 4) & 1048575L)) | (((long) (k >> 4) & 4194303L) << 20);
++    public static long blockPosAsSectionLong(int x, int y, int z) {
++        return (((long) (x >> 4) & 4194303L) << 42) | (((long) (y >> 4) & 1048575L)) | (((long) (z >> 4) & 4194303L) << 20);
 +    }
 +    // Paper end
-+
      public static long asLong(int x, int y, int z) {
 -        long l = 0L;
--        l |= ((long)x & 4194303L) << 42;
--        l |= ((long)y & 1048575L) << 0;
--        return l | ((long)z & 4194303L) << 20;
-+        return (((long) x & 4194303L) << 42) | (((long) y & 1048575L)) | (((long) z & 4194303L) << 20); // Paper - Simplify to reduce instruction count
+-        l |= (x & 4194303L) << 42;
+-        l |= (y & 1048575L) << 0;
+-        return l | (z & 4194303L) << 20;
++        return ((x & 4194303L) << 42) | ((y & 1048575L)) | ((z & 4194303L) << 20); // Paper - Simplify to reduce instruction count
      }
  
      public long asLong() {
 -        return asLong(this.x(), this.y(), this.z());
-+        return (((long) getX() & 4194303L) << 42) | (((long) getY() & 1048575L)) | (((long) getZ() & 4194303L) << 20); // Paper - Simplify to reduce instruction count
++        return ((this.getX() & 4194303L) << 42) | ((this.getY() & 1048575L)) | ((this.getZ() & 4194303L) << 20); // Paper - Simplify to reduce instruction count
      }
  
      @Override
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
+@@ -226,16 +233,13 @@ public class SectionPos extends Vec3i {
      }
  
      public static Stream<SectionPos> cube(SectionPos center, int radius) {
--        int i = center.x();
--        int j = center.y();
--        int k = center.z();
--        return betweenClosedStream(i - radius, j - radius, k - radius, i + radius, j + radius, k + radius);
+-        int sectionX = center.x();
+-        int sectionY = center.y();
+-        int sectionZ = center.z();
+-        return betweenClosedStream(sectionX - radius, sectionY - radius, sectionZ - radius, sectionX + radius, sectionY + radius, sectionZ + radius);
 +        return betweenClosedStream(center.getX() - radius, center.getY() - radius, center.getZ() - radius, center.getX() + radius, center.getY() + radius, center.getZ() + radius); // Paper - simplify/inline
      }
  
-     public static Stream<SectionPos> aroundChunk(ChunkPos center, int radius, int minY, int maxY) {
--        int i = center.x;
--        int j = center.z;
--        return betweenClosedStream(i - radius, minY, j - radius, i + radius, maxY, j + radius);
-+        return betweenClosedStream(center.x - radius, minY, center.z - radius, center.x + radius, maxY, center.z + radius); // Paper - simplify/inline
+-    public static Stream<SectionPos> aroundChunk(ChunkPos chunkPos, int x, int y, int z) {
++    public static Stream<SectionPos> aroundChunk(ChunkPos chunkPos, int radius, int minY, int maxY) { // Paper - fix params
+         int i = chunkPos.x;
+         int i1 = chunkPos.z;
+-        return betweenClosedStream(i - x, y, i1 - x, i + x, z, i1 + x);
++        return betweenClosedStream(i - radius, minY, i1 - radius, i + radius, maxY, i1 + radius); // Paper - simplify/inline
      }
  
-     public static Stream<SectionPos> betweenClosedStream(int minX, int minY, int minZ, int maxX, int maxY, int maxZ) {
+     public static Stream<SectionPos> betweenClosedStream(final int x1, final int y1, final int z1, final int x2, final int y2, final int z2) {