--- a/net/minecraft/world/level/block/WallHangingSignBlock.java
+++ b/net/minecraft/world/level/block/WallHangingSignBlock.java
@@ -38,49 +38,46 @@
 import net.minecraft.world.phys.shapes.VoxelShape;
 
 public class WallHangingSignBlock extends SignBlock {
-    public static final MapCodec<WallHangingSignBlock> CODEC = RecordCodecBuilder.mapCodec(
-        instance -> instance.group(WoodType.CODEC.fieldOf("wood_type").forGetter(SignBlock::type), propertiesCodec())
-                .apply(instance, WallHangingSignBlock::new)
-    );
+
+    public static final MapCodec<WallHangingSignBlock> CODEC = RecordCodecBuilder.mapCodec((instance) -> {
+        return instance.group(WoodType.CODEC.fieldOf("wood_type").forGetter(SignBlock::type), propertiesCodec()).apply(instance, WallHangingSignBlock::new);
+    });
     public static final DirectionProperty FACING = HorizontalDirectionalBlock.FACING;
-    public static final VoxelShape PLANK_NORTHSOUTH = Block.box(0.0, 14.0, 6.0, 16.0, 16.0, 10.0);
-    public static final VoxelShape PLANK_EASTWEST = Block.box(6.0, 14.0, 0.0, 10.0, 16.0, 16.0);
-    public static final VoxelShape SHAPE_NORTHSOUTH = Shapes.or(PLANK_NORTHSOUTH, Block.box(1.0, 0.0, 7.0, 15.0, 10.0, 9.0));
-    public static final VoxelShape SHAPE_EASTWEST = Shapes.or(PLANK_EASTWEST, Block.box(7.0, 0.0, 1.0, 9.0, 10.0, 15.0));
-    private static final Map<Direction, VoxelShape> AABBS = Maps.newEnumMap(
-        ImmutableMap.of(Direction.NORTH, SHAPE_NORTHSOUTH, Direction.SOUTH, SHAPE_NORTHSOUTH, Direction.EAST, SHAPE_EASTWEST, Direction.WEST, SHAPE_EASTWEST)
-    );
+    public static final VoxelShape PLANK_NORTHSOUTH = Block.box(0.0D, 14.0D, 6.0D, 16.0D, 16.0D, 10.0D);
+    public static final VoxelShape PLANK_EASTWEST = Block.box(6.0D, 14.0D, 0.0D, 10.0D, 16.0D, 16.0D);
+    public static final VoxelShape SHAPE_NORTHSOUTH = Shapes.or(WallHangingSignBlock.PLANK_NORTHSOUTH, Block.box(1.0D, 0.0D, 7.0D, 15.0D, 10.0D, 9.0D));
+    public static final VoxelShape SHAPE_EASTWEST = Shapes.or(WallHangingSignBlock.PLANK_EASTWEST, Block.box(7.0D, 0.0D, 1.0D, 9.0D, 10.0D, 15.0D));
+    private static final Map<Direction, VoxelShape> AABBS = Maps.newEnumMap(ImmutableMap.of(Direction.NORTH, WallHangingSignBlock.SHAPE_NORTHSOUTH, Direction.SOUTH, WallHangingSignBlock.SHAPE_NORTHSOUTH, Direction.EAST, WallHangingSignBlock.SHAPE_EASTWEST, Direction.WEST, WallHangingSignBlock.SHAPE_EASTWEST));
 
     @Override
     public MapCodec<WallHangingSignBlock> codec() {
-        return CODEC;
+        return WallHangingSignBlock.CODEC;
     }
 
     public WallHangingSignBlock(WoodType type, BlockBehaviour.Properties settings) {
         super(type, settings.sound(type.hangingSignSoundType()));
-        this.registerDefaultState(this.stateDefinition.any().setValue(FACING, Direction.NORTH).setValue(WATERLOGGED, Boolean.valueOf(false)));
+        this.registerDefaultState((BlockState) ((BlockState) ((BlockState) this.stateDefinition.any()).setValue(WallHangingSignBlock.FACING, Direction.NORTH)).setValue(WallHangingSignBlock.WATERLOGGED, false));
     }
 
     @Override
-    protected ItemInteractionResult useItemOn(
-        ItemStack stack, BlockState state, Level world, BlockPos pos, Player player, InteractionHand hand, BlockHitResult hit
-    ) {
-        if (world.getBlockEntity(pos) instanceof SignBlockEntity signBlockEntity
-            && this.shouldTryToChainAnotherHangingSign(state, player, hit, signBlockEntity, stack)) {
-            return ItemInteractionResult.SKIP_DEFAULT_BLOCK_INTERACTION;
+    protected ItemInteractionResult useItemOn(ItemStack stack, BlockState state, Level world, BlockPos pos, Player player, InteractionHand hand, BlockHitResult hit) {
+        BlockEntity tileentity = world.getBlockEntity(pos);
+
+        if (tileentity instanceof SignBlockEntity tileentitysign) {
+            if (this.shouldTryToChainAnotherHangingSign(state, player, hit, tileentitysign, stack)) {
+                return ItemInteractionResult.SKIP_DEFAULT_BLOCK_INTERACTION;
+            }
         }
 
         return super.useItemOn(stack, state, world, pos, player, hand, hit);
     }
 
     private boolean shouldTryToChainAnotherHangingSign(BlockState state, Player player, BlockHitResult hitResult, SignBlockEntity sign, ItemStack stack) {
-        return !sign.canExecuteClickCommands(sign.isFacingFrontText(player), player)
-            && stack.getItem() instanceof HangingSignItem
-            && !this.isHittingEditableSide(hitResult, state);
+        return !sign.canExecuteClickCommands(sign.isFacingFrontText(player), player) && stack.getItem() instanceof HangingSignItem && !this.isHittingEditableSide(hitResult, state);
     }
 
     private boolean isHittingEditableSide(BlockHitResult hitResult, BlockState state) {
-        return hitResult.getDirection().getAxis() == state.getValue(FACING).getAxis();
+        return hitResult.getDirection().getAxis() == ((Direction) state.getValue(WallHangingSignBlock.FACING)).getAxis();
     }
 
     @Override
@@ -90,7 +87,7 @@
 
     @Override
     protected VoxelShape getShape(BlockState state, BlockGetter world, BlockPos pos, CollisionContext context) {
-        return AABBS.get(state.getValue(FACING));
+        return (VoxelShape) WallHangingSignBlock.AABBS.get(state.getValue(WallHangingSignBlock.FACING));
     }
 
     @Override
@@ -100,42 +97,47 @@
 
     @Override
     protected VoxelShape getCollisionShape(BlockState state, BlockGetter world, BlockPos pos, CollisionContext context) {
-        switch ((Direction)state.getValue(FACING)) {
+        switch ((Direction) state.getValue(WallHangingSignBlock.FACING)) {
             case EAST:
             case WEST:
-                return PLANK_EASTWEST;
+                return WallHangingSignBlock.PLANK_EASTWEST;
             default:
-                return PLANK_NORTHSOUTH;
+                return WallHangingSignBlock.PLANK_NORTHSOUTH;
         }
     }
 
     public boolean canPlace(BlockState state, LevelReader world, BlockPos pos) {
-        Direction direction = state.getValue(FACING).getClockWise();
-        Direction direction2 = state.getValue(FACING).getCounterClockWise();
-        return this.canAttachTo(world, state, pos.relative(direction), direction2) || this.canAttachTo(world, state, pos.relative(direction2), direction);
+        Direction enumdirection = ((Direction) state.getValue(WallHangingSignBlock.FACING)).getClockWise();
+        Direction enumdirection1 = ((Direction) state.getValue(WallHangingSignBlock.FACING)).getCounterClockWise();
+
+        return this.canAttachTo(world, state, pos.relative(enumdirection), enumdirection1) || this.canAttachTo(world, state, pos.relative(enumdirection1), enumdirection);
     }
 
     public boolean canAttachTo(LevelReader world, BlockState state, BlockPos toPos, Direction direction) {
-        BlockState blockState = world.getBlockState(toPos);
-        return blockState.is(BlockTags.WALL_HANGING_SIGNS)
-            ? blockState.getValue(FACING).getAxis().test(state.getValue(FACING))
-            : blockState.isFaceSturdy(world, toPos, direction, SupportType.FULL);
+        BlockState iblockdata1 = world.getBlockState(toPos);
+
+        return iblockdata1.is(BlockTags.WALL_HANGING_SIGNS) ? ((Direction) iblockdata1.getValue(WallHangingSignBlock.FACING)).getAxis().test((Direction) state.getValue(WallHangingSignBlock.FACING)) : iblockdata1.isFaceSturdy(world, toPos, direction, SupportType.FULL);
     }
 
     @Nullable
     @Override
     public BlockState getStateForPlacement(BlockPlaceContext ctx) {
-        BlockState blockState = this.defaultBlockState();
-        FluidState fluidState = ctx.getLevel().getFluidState(ctx.getClickedPos());
-        LevelReader levelReader = ctx.getLevel();
-        BlockPos blockPos = ctx.getClickedPos();
+        BlockState iblockdata = this.defaultBlockState();
+        FluidState fluid = ctx.getLevel().getFluidState(ctx.getClickedPos());
+        Level world = ctx.getLevel();
+        BlockPos blockposition = ctx.getClickedPos();
+        Direction[] aenumdirection = ctx.getNearestLookingDirections();
+        int i = aenumdirection.length;
 
-        for (Direction direction : ctx.getNearestLookingDirections()) {
-            if (direction.getAxis().isHorizontal() && !direction.getAxis().test(ctx.getClickedFace())) {
-                Direction direction2 = direction.getOpposite();
-                blockState = blockState.setValue(FACING, direction2);
-                if (blockState.canSurvive(levelReader, blockPos) && this.canPlace(blockState, levelReader, blockPos)) {
-                    return blockState.setValue(WATERLOGGED, Boolean.valueOf(fluidState.getType() == Fluids.WATER));
+        for (int j = 0; j < i; ++j) {
+            Direction enumdirection = aenumdirection[j];
+
+            if (enumdirection.getAxis().isHorizontal() && !enumdirection.getAxis().test(ctx.getClickedFace())) {
+                Direction enumdirection1 = enumdirection.getOpposite();
+
+                iblockdata = (BlockState) iblockdata.setValue(WallHangingSignBlock.FACING, enumdirection1);
+                if (iblockdata.canSurvive(world, blockposition) && this.canPlace(iblockdata, world, blockposition)) {
+                    return (BlockState) iblockdata.setValue(WallHangingSignBlock.WATERLOGGED, fluid.getType() == Fluids.WATER);
                 }
             }
         }
@@ -145,29 +147,27 @@
 
     @Override
     protected BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
-        return direction.getAxis() == state.getValue(FACING).getClockWise().getAxis() && !state.canSurvive(world, pos)
-            ? Blocks.AIR.defaultBlockState()
-            : super.updateShape(state, direction, neighborState, world, pos, neighborPos);
+        return direction.getAxis() == ((Direction) state.getValue(WallHangingSignBlock.FACING)).getClockWise().getAxis() && !state.canSurvive(world, pos) ? Blocks.AIR.defaultBlockState() : super.updateShape(state, direction, neighborState, world, pos, neighborPos);
     }
 
     @Override
     public float getYRotationDegrees(BlockState state) {
-        return state.getValue(FACING).toYRot();
+        return ((Direction) state.getValue(WallHangingSignBlock.FACING)).toYRot();
     }
 
     @Override
     protected BlockState rotate(BlockState state, Rotation rotation) {
-        return state.setValue(FACING, rotation.rotate(state.getValue(FACING)));
+        return (BlockState) state.setValue(WallHangingSignBlock.FACING, rotation.rotate((Direction) state.getValue(WallHangingSignBlock.FACING)));
     }
 
     @Override
     protected BlockState mirror(BlockState state, Mirror mirror) {
-        return state.rotate(mirror.getRotation(state.getValue(FACING)));
+        return state.rotate(mirror.getRotation((Direction) state.getValue(WallHangingSignBlock.FACING)));
     }
 
     @Override
     protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
-        builder.add(FACING, WATERLOGGED);
+        builder.add(WallHangingSignBlock.FACING, WallHangingSignBlock.WATERLOGGED);
     }
 
     @Override
@@ -183,6 +183,6 @@
     @Nullable
     @Override
     public <T extends BlockEntity> BlockEntityTicker<T> getTicker(Level world, BlockState state, BlockEntityType<T> type) {
-        return createTickerHelper(type, BlockEntityType.HANGING_SIGN, SignBlockEntity::tick);
+        return null; // Craftbukkit - remove unnecessary sign ticking
     }
 }
