gt:             ModelRenderer modelrenderer = this.getArmForSide(enumhandside);
context: package net.minecraft.client.model;
  
  import net.minecraft.client.renderer.GlStateManager;
  import net.minecraft.entity.Entity;
  import net.minecraft.entity.EntityLivingBase;
  import net.minecraft.util.EnumHandSide;
  import net.minecraft.util.math.MathHelper;
  import net.minecraftforge.fml.relauncher.Side;
  import net.minecraftforge.fml.relauncher.SideOnly;
  
  @SideOnly(Side.CLIENT)
  public class ModelBiped extends ModelBase
  {
      public ModelRenderer bipedHead;
      /** The Biped's Headwear. Used for the outer layer of player skins. */
      public ModelRenderer bipedHeadwear;
      public ModelRenderer bipedBody;
      /** The Biped's Right Arm */
      public ModelRenderer bipedRightArm;
      /** The Biped's Left Arm */
      public ModelRenderer bipedLeftArm;
      /** The Biped's Right Leg */
      public ModelRenderer bipedRightLeg;
      /** The Biped's Left Leg */
      public ModelRenderer bipedLeftLeg;
      public ModelBiped.ArmPose leftArmPose;
      public ModelBiped.ArmPose rightArmPose;
      public boolean isSneak;
  
      public ModelBiped()
      {
          this(0.0F);
      }
  
      public ModelBiped(float modelSize)
      {
          this(modelSize, 0.0F, 64, 32);
      }
  
      public ModelBiped(float modelSize, float p_i1149_2_, int textureWidthIn, int textureHeightIn)
      {
          this.leftArmPose = ModelBiped.ArmPose.EMPTY;
          this.rightArmPose = ModelBiped.ArmPose.EMPTY;
          this.textureWidth = textureWidthIn;
          this.textureHeight = textureHeightIn;
          this.bipedHead = new ModelRenderer(this, 0, 0);
          this.bipedHead.addBox(-4.0F, -8.0F, -4.0F, 8, 8, 8, modelSize);
          this.bipedHead.setRotationPoint(0.0F, 0.0F + p_i1149_2_, 0.0F);
          this.bipedHeadwear = new ModelRenderer(this, 32, 0);
          this.bipedHeadwear.addBox(-4.0F, -8.0F, -4.0F, 8, 8, 8, modelSize + 0.5F);
          this.bipedHeadwear.setRotationPoint(0.0F, 0.0F + p_i1149_2_, 0.0F);
          this.bipedBody = new ModelRenderer(this, 16, 16);
          this.bipedBody.addBox(-4.0F, 0.0F, -2.0F, 8, 12, 4, modelSize);
          this.bipedBody.setRotationPoint(0.0F, 0.0F + p_i1149_2_, 0.0F);
          this.bipedRightArm = new ModelRenderer(this, 40, 16);
          this.bipedRightArm.addBox(-3.0F, -2.0F, -2.0F, 4, 12, 4, modelSize);
          this.bipedRightArm.setRotationPoint(-5.0F, 2.0F + p_i1149_2_, 0.0F);
          this.bipedLeftArm = new ModelRenderer(this, 40, 16);
          this.bipedLeftArm.mirror = true;
          this.bipedLeftArm.addBox(-1.0F, -2.0F, -2.0F, 4, 12, 4, modelSize);
          this.bipedLeftArm.setRotationPoint(5.0F, 2.0F + p_i1149_2_, 0.0F);
          this.bipedRightLeg = new ModelRenderer(this, 0, 16);
          this.bipedRightLeg.addBox(-2.0F, 0.0F, -2.0F, 4, 12, 4, modelSize);
          this.bipedRightLeg.setRotationPoint(-1.9F, 12.0F + p_i1149_2_, 0.0F);
          this.bipedLeftLeg = new ModelRenderer(this, 0, 16);
          this.bipedLeftLeg.mirror = true;
          this.bipedLeftLeg.addBox(-2.0F, 0.0F, -2.0F, 4, 12, 4, modelSize);
          this.bipedLeftLeg.setRotationPoint(1.9F, 12.0F + p_i1149_2_, 0.0F);
      }
  
      /**
       * Sets the models various rotation angles then renders the model.
       */
      public void render(Entity entityIn, float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, float scale)
      {
          this.setRotationAngles(limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale, entityIn);
          GlStateManager.pushMatrix();
  
          if (this.isChild)
          {
              float f = 2.0F;
              GlStateManager.scale(0.75F, 0.75F, 0.75F);
              GlStateManager.translate(0.0F, 16.0F * scale, 0.0F);
              this.bipedHead.render(scale);
              GlStateManager.popMatrix();
              GlStateManager.pushMatrix();
              GlStateManager.scale(0.5F, 0.5F, 0.5F);
              GlStateManager.translate(0.0F, 24.0F * scale, 0.0F);
              this.bipedBody.render(scale);
              this.bipedRightArm.render(scale);
              this.bipedLeftArm.render(scale);
              this.bipedRightLeg.render(scale);
              this.bipedLeftLeg.render(scale);
              this.bipedHeadwear.render(scale);
          }
          else
          {
              if (entityIn.isSneaking())
              {
                  GlStateManager.translate(0.0F, 0.2F, 0.0F);
              }
  
              this.bipedHead.render(scale);
              this.bipedBody.render(scale);
              this.bipedRightArm.render(scale);
              this.bipedLeftArm.render(scale);
              this.bipedRightLeg.render(scale);
              this.bipedLeftLeg.render(scale);
              this.bipedHeadwear.render(scale);
          }
  
          GlStateManager.popMatrix();
      }
  
      /**
       * Sets the model's various rotation angles. For bipeds, par1 and par2 are used for animating the movement of arms
       * and legs, where par1 represents the time(so that arms and legs swing back and forth) and par2 represents how
       * "far" arms and legs can swing at most.
       */
      @SuppressWarnings("incomplete-switch")
      public void setRotationAngles(float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, float scaleFactor, Entity entityIn)
      {
          boolean flag = entityIn instanceof EntityLivingBase && ((EntityLivingBase)entityIn).getTicksElytraFlying() > 4;
          this.bipedHead.rotateAngleY = netHeadYaw * 0.017453292F;
  
          if (flag)
          {
              this.bipedHead.rotateAngleX = -((float)Math.PI / 4F);
          }
          else
          {
              this.bipedHead.rotateAngleX = headPitch * 0.017453292F;
          }
  
          this.bipedBody.rotateAngleY = 0.0F;
          this.bipedRightArm.rotationPointZ = 0.0F;
          this.bipedRightArm.rotationPointX = -5.0F;
          this.bipedLeftArm.rotationPointZ = 0.0F;
          this.bipedLeftArm.rotationPointX = 5.0F;
          float f = 1.0F;
  
          if (flag)
          {
              f = (float)(entityIn.motionX * entityIn.motionX + entityIn.motionY * entityIn.motionY + entityIn.motionZ * entityIn.motionZ);
              f = f / 0.2F;
              f = f * f * f;
          }
  
          if (f < 1.0F)
          {
              f = 1.0F;
          }
  
          this.bipedRightArm.rotateAngleX = MathHelper.cos(limbSwing * 0.6662F + (float)Math.PI) * 2.0F * limbSwingAmount * 0.5F / f;
          this.bipedLeftArm.rotateAngleX = MathHelper.cos(limbSwing * 0.6662F) * 2.0F * limbSwingAmount * 0.5F / f;
          this.bipedRightArm.rotateAngleZ = 0.0F;
          this.bipedLeftArm.rotateAngleZ = 0.0F;
          this.bipedRightLeg.rotateAngleX = MathHelper.cos(limbSwing * 0.6662F) * 1.4F * limbSwingAmount / f;
          this.bipedLeftLeg.rotateAngleX = MathHelper.cos(limbSwing * 0.6662F + (float)Math.PI) * 1.4F * limbSwingAmount / f;
          this.bipedRightLeg.rotateAngleY = 0.0F;
          this.bipedLeftLeg.rotateAngleY = 0.0F;
          this.bipedRightLeg.rotateAngleZ = 0.0F;
          this.bipedLeftLeg.rotateAngleZ = 0.0F;
  
          if (this.isRiding)
          {
              this.bipedRightArm.rotateAngleX += -((float)Math.PI / 5F);
              this.bipedLeftArm.rotateAngleX += -((float)Math.PI / 5F);
              this.bipedRightLeg.rotateAngleX = -1.4137167F;
              this.bipedRightLeg.rotateAngleY = ((float)Math.PI / 10F);
              this.bipedRightLeg.rotateAngleZ = 0.07853982F;
              this.bipedLeftLeg.rotateAngleX = -1.4137167F;
              this.bipedLeftLeg.rotateAngleY = -((float)Math.PI / 10F);
              this.bipedLeftLeg.rotateAngleZ = -0.07853982F;
          }
  
          this.bipedRightArm.rotateAngleY = 0.0F;
          this.bipedRightArm.rotateAngleZ = 0.0F;
  
          switch (this.leftArmPose)
          {
              case EMPTY:
                  this.bipedLeftArm.rotateAngleY = 0.0F;
                  break;
              case BLOCK:
                  this.bipedLeftArm.rotateAngleX = this.bipedLeftArm.rotateAngleX * 0.5F - 0.9424779F;
                  this.bipedLeftArm.rotateAngleY = 0.5235988F;
                  break;
              case ITEM:
                  this.bipedLeftArm.rotateAngleX = this.bipedLeftArm.rotateAngleX * 0.5F - ((float)Math.PI / 10F);
                  this.bipedLeftArm.rotateAngleY = 0.0F;
          }
  
          switch (this.rightArmPose)
          {
              case EMPTY:
                  this.bipedRightArm.rotateAngleY = 0.0F;
                  break;
              case BLOCK:
                  this.bipedRightArm.rotateAngleX = this.bipedRightArm.rotateAngleX * 0.5F - 0.9424779F;
                  this.bipedRightArm.rotateAngleY = -0.5235988F;
                  break;
              case ITEM:
                  this.bipedRightArm.rotateAngleX = this.bipedRightArm.rotateAngleX * 0.5F - ((float)Math.PI / 10F);
                  this.bipedRightArm.rotateAngleY = 0.0F;
          }
  
          if (this.swingProgress > 0.0F)
          {
              EnumHandSide enumhandside = this.getMainHand(entityIn);
  