gt:                 BlockPos blockpos1 = pos.offset(enumfacing);
context: /*package com.camp.block;
  
  import java.util.ArrayList;
  import java.util.EnumSet;
  import java.util.Iterator;
  import java.util.Random;
  import java.util.Set;
  
  import net.minecraft.block.Block;
  import net.minecraft.block.BlockRedstoneDiode;
  import net.minecraft.block.BlockRedstoneRepeater;
  import net.minecraft.block.BlockRedstoneWire;
  import net.minecraft.block.material.Material;
  import net.minecraft.block.properties.IProperty;
  import net.minecraft.block.properties.PropertyEnum;
  import net.minecraft.block.properties.PropertyInteger;
  import net.minecraft.block.state.BlockState;
  import net.minecraft.block.state.IBlockState;
  import net.minecraft.init.Blocks;
  import net.minecraft.init.Items;
  import net.minecraft.item.Item;
  import net.minecraft.util.AxisAlignedBB;
  import net.minecraft.util.BlockPos;
  import net.minecraft.util.EnumFacing;
  import net.minecraft.util.EnumParticleTypes;
  import net.minecraft.util.EnumWorldBlockLayer;
  import net.minecraft.util.IStringSerializable;
  import net.minecraft.util.MathHelper;
  import net.minecraft.world.IBlockAccess;
  import net.minecraft.world.World;
  import net.minecraftforge.fml.relauncher.Side;
  import net.minecraftforge.fml.relauncher.SideOnly;
  
  import com.example.examplemod.cm;
  import com.google.common.collect.Lists;
  import com.google.common.collect.Sets;
  
  public class BluestoneWire extends BlockRedstoneWire
  {
  	public static final String name = "BluestoneWire";
      public static final PropertyEnum NORTH = PropertyEnum.create("north", BluestoneWire.EnumAttachPosition.class);
      public static final PropertyEnum EAST = PropertyEnum.create("east", BluestoneWire.EnumAttachPosition.class);
      public static final PropertyEnum SOUTH = PropertyEnum.create("south", BluestoneWire.EnumAttachPosition.class);
      public static final PropertyEnum WEST = PropertyEnum.create("west", BluestoneWire.EnumAttachPosition.class);
      public static final PropertyInteger POWER = PropertyInteger.create("power", 0, 100);
      private boolean canProvidePower = true;
      private final Set blocksNeedingUpdate = Sets.newHashSet();
      private static final String __OBFID = "CL_00000295";
  
      public BluestoneWire()
      {
      	
          super(Material.circuits);
          this.setDefaultState(this.blockState.getBaseState().withProperty(NORTH, BluestoneWire.EnumAttachPosition.NONE).withProperty(EAST, BluestoneWire.EnumAttachPosition.NONE).withProperty(SOUTH, BluestoneWire.EnumAttachPosition.NONE).withProperty(WEST, BluestoneWire.EnumAttachPosition.NONE).withProperty(POWER, Integer.valueOf(0)));
          this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.0625F, 1.0F);
          this.setCreativeTab(cm.tabIke);
          this.setUnlocalizedName(this.name);
      }
  
      public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos)
      {
          state = state.withProperty(WEST, this.getAttachPosition(worldIn, pos, EnumFacing.WEST));
          state = state.withProperty(EAST, this.getAttachPosition(worldIn, pos, EnumFacing.EAST));
          state = state.withProperty(NORTH, this.getAttachPosition(worldIn, pos, EnumFacing.NORTH));
          state = state.withProperty(SOUTH, this.getAttachPosition(worldIn, pos, EnumFacing.SOUTH));
          return state;
      }
  
      private BluestoneWire.EnumAttachPosition getAttachPosition(IBlockAccess worldIn, BlockPos pos, EnumFacing direction)
      {
          BlockPos blockpos1 = pos.offset(direction);
          Block block = worldIn.getBlockState(pos.offset(direction)).getBlock();
  
          if (!canRestoneConnect(worldIn, blockpos1, direction) && (block.isSolidFullCube() || !canRestoneConnect(worldIn, blockpos1.down(), null)))
          {
              Block block1 = worldIn.getBlockState(pos.up()).getBlock();
              return !block1.isSolidFullCube() && block.isSolidFullCube() && canRestoneConnect(worldIn, blockpos1.up(), null) ? BluestoneWire.EnumAttachPosition.UP : BluestoneWire.EnumAttachPosition.NONE;
          }
          else
          {
              return BluestoneWire.EnumAttachPosition.SIDE;
          }
      }
  
      public AxisAlignedBB getCollisionBoundingBox(World worldIn, BlockPos pos, IBlockState state)
      {
          return null;
      }
  
      public boolean isOpaqueCube()
      {
          return false;
      }
  
      public boolean isFullCube()
      {
          return false;
      }
  
      @SideOnly(Side.CLIENT)
      public int colorMultiplier(IBlockAccess worldIn, BlockPos pos, int renderPass)
      {
          IBlockState iblockstate = worldIn.getBlockState(pos);
          return iblockstate.getBlock() != this ? super.colorMultiplier(worldIn, pos, renderPass) : this.colorMultiplier(15);
      }
  
      public boolean canPlaceBlockAt(World worldIn, BlockPos pos)
      {
          return World.doesBlockHaveSolidTopSurface(worldIn, pos.down()) || worldIn.getBlockState(pos.down()).getBlock() == Blocks.glowstone;
      }
  
      private IBlockState updateSurroundingRedstone(World worldIn, BlockPos pos, IBlockState state)
      {
          state = this.calculateCurrentChanges(worldIn, pos, pos, state);
          ArrayList arraylist = Lists.newArrayList(this.blocksNeedingUpdate);
          this.blocksNeedingUpdate.clear();
          Iterator iterator = arraylist.iterator();
  
          while (iterator.hasNext())
          {
              BlockPos blockpos1 = (BlockPos)iterator.next();
              worldIn.notifyNeighborsOfStateChange(blockpos1, this);
          }
  
          return state;
      }
  
      private IBlockState calculateCurrentChanges(World worldIn, BlockPos pos1, BlockPos pos2, IBlockState state)
      {
          IBlockState iblockstate1 = state;
          int i = ((Integer)state.getValue(POWER)).intValue();
          byte b0 = 0;
          int l = this.getMaxCurrentStrength(worldIn, pos2, b0);
          this.canProvidePower = false;
          int j = worldIn.isBlockIndirectlyGettingPowered(pos1);
          this.canProvidePower = true;
  
          if (j > 0 && j > l - 1)
          {
              l = j;
          }
  
          int k = 0;
          Iterator iterator = EnumFacing.Plane.HORIZONTAL.iterator();
  
          while (iterator.hasNext())
          {
              EnumFacing enumfacing = (EnumFacing)iterator.next();
              BlockPos blockpos2 = pos1.offset(enumfacing);
              boolean flag = blockpos2.getX() != pos2.getX() || blockpos2.getZ() != pos2.getZ();
  
              if (flag)
              {
                  k = this.getMaxCurrentStrength(worldIn, blockpos2, k);
              }
  
              if (worldIn.getBlockState(blockpos2).getBlock().isNormalCube() && !worldIn.getBlockState(pos1.up()).getBlock().isNormalCube())
              {
                  if (flag && pos1.getY() >= pos2.getY())
                  {
                      k = this.getMaxCurrentStrength(worldIn, blockpos2.up(), k);
                  }
              }
              else if (!worldIn.getBlockState(blockpos2).getBlock().isNormalCube() && flag && pos1.getY() <= pos2.getY())
              {
                  k = this.getMaxCurrentStrength(worldIn, blockpos2.down(), k);
              }
          }
  
          if (k > l)
          {
              l = k - 1;
          }
          else if (l > 0)
          {
              --l;
          }
          else
          {
              l = 0;
          }
  
          if (j > l - 1)
          {
              l = j;
          }
  
          if (i != l)
          {
              state = state.withProperty(POWER, Integer.valueOf(l));
  
              if (worldIn.getBlockState(pos1) == iblockstate1)
              {
                  worldIn.setBlockState(pos1, state, 2);
              }
  
              this.blocksNeedingUpdate.add(pos1);
              EnumFacing[] aenumfacing = EnumFacing.values();
              int i1 = aenumfacing.length;
  
              for (int j1 = 0; j1 < i1; ++j1)
              {
                  EnumFacing enumfacing1 = aenumfacing[j1];
                  this.blocksNeedingUpdate.add(pos1.offset(enumfacing1));
              }
          }
  
          return state;
      }
  
      private void notifyWireNeighborsOfStateChange(World worldIn, BlockPos pos)
      {
          if (worldIn.getBlockState(pos).getBlock() == this)
          {
              worldIn.notifyNeighborsOfStateChange(pos, this);
              EnumFacing[] aenumfacing = EnumFacing.values();
              int i = aenumfacing.length;
  
              for (int j = 0; j < i; ++j)
              {
                  EnumFacing enumfacing = aenumfacing[j];
                  worldIn.notifyNeighborsOfStateChange(pos.offset(enumfacing), this);
              }
          }
      }
  
      public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state)
      {
          if (!worldIn.isRemote)
          {
              this.updateSurroundingRedstone(worldIn, pos, state);
              Iterator iterator = EnumFacing.Plane.VERTICAL.iterator();
              EnumFacing enumfacing;
  
              while (iterator.hasNext())
              {
                  enumfacing = (EnumFacing)iterator.next();
                  worldIn.notifyNeighborsOfStateChange(pos.offset(enumfacing), this);
              }
  
              iterator = EnumFacing.Plane.HORIZONTAL.iterator();
  
              while (iterator.hasNext())
              {
                  enumfacing = (EnumFacing)iterator.next();
                  this.notifyWireNeighborsOfStateChange(worldIn, pos.offset(enumfacing));
              }
  
              iterator = EnumFacing.Plane.HORIZONTAL.iterator();
  
              while (iterator.hasNext())
              {
                  enumfacing = (EnumFacing)iterator.next();
  