gt:         int i = b0 | ((EnumFacing)state.getValue(FACING)).getIndex();
context: package net.minecraft.block;
  
  import com.google.common.base.Predicate;
  import java.util.List;
  import net.minecraft.block.material.Material;
  import net.minecraft.block.properties.IProperty;
  import net.minecraft.block.properties.PropertyBool;
  import net.minecraft.block.properties.PropertyDirection;
  import net.minecraft.block.state.BlockState;
  import net.minecraft.block.state.IBlockState;
  import net.minecraft.creativetab.CreativeTabs;
  import net.minecraft.entity.Entity;
  import net.minecraft.entity.EntityLivingBase;
  import net.minecraft.entity.player.EntityPlayer;
  import net.minecraft.inventory.Container;
  import net.minecraft.inventory.InventoryHelper;
  import net.minecraft.item.ItemStack;
  import net.minecraft.tileentity.TileEntity;
  import net.minecraft.tileentity.TileEntityHopper;
  import net.minecraft.util.AxisAlignedBB;
  import net.minecraft.util.BlockPos;
  import net.minecraft.util.EnumFacing;
  import net.minecraft.util.EnumWorldBlockLayer;
  import net.minecraft.world.IBlockAccess;
  import net.minecraft.world.World;
  import net.minecraftforge.fml.relauncher.Side;
  import net.minecraftforge.fml.relauncher.SideOnly;
  
  public class BlockHopper extends BlockContainer
  {
      public static final PropertyDirection FACING = PropertyDirection.create("facing", new Predicate()
      {
          private static final String __OBFID = "CL_00002106";
          public boolean apply(EnumFacing facing)
          {
              return facing != EnumFacing.UP;
          }
          public boolean apply(Object p_apply_1_)
          {
              return this.apply((EnumFacing)p_apply_1_);
          }
      });
      public static final PropertyBool ENABLED = PropertyBool.create("enabled");
      private static final String __OBFID = "CL_00000257";
  
      public BlockHopper()
      {
          super(Material.iron);
          this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.DOWN).withProperty(ENABLED, Boolean.valueOf(true)));
          this.setCreativeTab(CreativeTabs.tabRedstone);
          this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
      }
  
      public void setBlockBoundsBasedOnState(IBlockAccess worldIn, BlockPos pos)
      {
          this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
      }
  
      /**
       * Add all collision boxes of this Block to the list that intersect with the given mask.
       *  
       * @param collidingEntity the Entity colliding with this Block
       */
      public void addCollisionBoxesToList(World worldIn, BlockPos pos, IBlockState state, AxisAlignedBB mask, List list, Entity collidingEntity)
      {
          this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.625F, 1.0F);
          super.addCollisionBoxesToList(worldIn, pos, state, mask, list, collidingEntity);
          float f = 0.125F;
          this.setBlockBounds(0.0F, 0.0F, 0.0F, f, 1.0F, 1.0F);
          super.addCollisionBoxesToList(worldIn, pos, state, mask, list, collidingEntity);
          this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, f);
          super.addCollisionBoxesToList(worldIn, pos, state, mask, list, collidingEntity);
          this.setBlockBounds(1.0F - f, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
          super.addCollisionBoxesToList(worldIn, pos, state, mask, list, collidingEntity);
          this.setBlockBounds(0.0F, 0.0F, 1.0F - f, 1.0F, 1.0F, 1.0F);
          super.addCollisionBoxesToList(worldIn, pos, state, mask, list, collidingEntity);
          this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
      }
  
      public IBlockState onBlockPlaced(World worldIn, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer)
      {
          EnumFacing enumfacing1 = facing.getOpposite();
  
          if (enumfacing1 == EnumFacing.UP)
          {
              enumfacing1 = EnumFacing.DOWN;
          }
  
          return this.getDefaultState().withProperty(FACING, enumfacing1).withProperty(ENABLED, Boolean.valueOf(true));
      }
  
      /**
       * Returns a new instance of a block's tile entity class. Called on placing the block.
       */
      public TileEntity createNewTileEntity(World worldIn, int meta)
      {
          return new TileEntityHopper();
      }
  
      public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack)
      {
          super.onBlockPlacedBy(worldIn, pos, state, placer, stack);
  
          if (stack.hasDisplayName())
          {
              TileEntity tileentity = worldIn.getTileEntity(pos);
  
              if (tileentity instanceof TileEntityHopper)
              {
                  ((TileEntityHopper)tileentity).setCustomName(stack.getDisplayName());
              }
          }
      }
  
      public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state)
      {
          this.updateState(worldIn, pos, state);
      }
  
      public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumFacing side, float hitX, float hitY, float hitZ)
      {
          if (worldIn.isRemote)
          {
              return true;
          }
          else
          {
              TileEntity tileentity = worldIn.getTileEntity(pos);
  
              if (tileentity instanceof TileEntityHopper)
              {
                  playerIn.displayGUIChest((TileEntityHopper)tileentity);
              }
  
              return true;
          }
      }
  
      /**
       * Called when a neighboring block changes.
       */
      public void onNeighborBlockChange(World worldIn, BlockPos pos, IBlockState state, Block neighborBlock)
      {
          this.updateState(worldIn, pos, state);
      }
  
      private void updateState(World worldIn, BlockPos pos, IBlockState state)
      {
          boolean flag = !worldIn.isBlockPowered(pos);
  
          if (flag != ((Boolean)state.getValue(ENABLED)).booleanValue())
          {
              worldIn.setBlockState(pos, state.withProperty(ENABLED, Boolean.valueOf(flag)), 4);
          }
      }
  
      public void breakBlock(World worldIn, BlockPos pos, IBlockState state)
      {
          TileEntity tileentity = worldIn.getTileEntity(pos);
  
          if (tileentity instanceof TileEntityHopper)
          {
              InventoryHelper.dropInventoryItems(worldIn, pos, (TileEntityHopper)tileentity);
              worldIn.updateComparatorOutputLevel(pos, this);
          }
  
          super.breakBlock(worldIn, pos, state);
      }
  
      /**
       * The type of render function that is called for this block
       */
      public int getRenderType()
      {
          return 3;
      }
  
      public boolean isFullCube()
      {
          return false;
      }
  
      public boolean isOpaqueCube()
      {
          return false;
      }
  
      @SideOnly(Side.CLIENT)
      public boolean shouldSideBeRendered(IBlockAccess worldIn, BlockPos pos, EnumFacing side)
      {
          return true;
      }
  
      public static EnumFacing getFacing(int meta)
      {
          return EnumFacing.getFront(meta & 7);
      }
  
      /**
       * Get's the hopper's active status from the 8-bit of the metadata. Note that the metadata stores whether the block
       * is powered, so this returns true when that bit is 0.
       */
      public static boolean isEnabled(int meta)
      {
          return (meta & 8) != 8;
      }
  
      public boolean hasComparatorInputOverride()
      {
          return true;
      }
  
      public int getComparatorInputOverride(World worldIn, BlockPos pos)
      {
          return Container.calcRedstone(worldIn.getTileEntity(pos));
      }
  
      @SideOnly(Side.CLIENT)
      public EnumWorldBlockLayer getBlockLayer()
      {
          return EnumWorldBlockLayer.CUTOUT_MIPPED;
      }
  
      /**
       * Convert the given metadata into a BlockState for this Block
       */
      public IBlockState getStateFromMeta(int meta)
      {
          return this.getDefaultState().withProperty(FACING, getFacing(meta)).withProperty(ENABLED, Boolean.valueOf(isEnabled(meta)));
      }
  
      /**
       * Convert the BlockState into the correct metadata value
       */
      public int getMetaFromState(IBlockState state)
      {
          byte b0 = 0;
  