anchor.diff:  #ifdef GL_ES
   	precision mediump float;
  +
  +	// Not all GPUs support high precision, so we should fall back to medium precision.
  +    #ifndef GL_FRAGMENT_PRECISION_HIGH
  +        #define highp
  +    #endif
   #else
   	// Since glsl 1.1 doesn't define precision qualifiers but GL_ES does, 
   	// Define them as nothing to avoid compilation issues.
   	#define highp
  +	#define lowp
   #endif
   
   #include "sh_Utils.h"
   
  -varying vec2 v_MaskingPosition;
  -varying vec4 v_Colour;
  +varying highp vec2 v_MaskingPosition;
  +varying lowp vec4 v_Colour;
   varying vec2 v_TexCoord;
  -varying vec4 v_TexRect;
  -varying vec2 v_BlendRange;
  +varying highp vec4 v_TexRect;
  +varying highp vec2 v_BlendRange;
   
   uniform sampler2D m_Sampler;
  -uniform float g_CornerRadius;
  -uniform vec4 g_MaskingRect;
  -uniform float g_BorderThickness;
  -uniform vec4 g_BorderColour;
  +uniform highp float g_CornerRadius;
  +uniform highp vec4 g_MaskingRect;
  +uniform highp float g_BorderThickness;
  +uniform lowp vec4 g_BorderColour;
   
   uniform float g_MaskingBlendRange;
   
   uniform float g_AlphaExponent;
   
  -uniform vec2 g_EdgeOffset;
  +uniform highp vec2 g_EdgeOffset;
   
   uniform bool g_DiscardInner;
  -uniform float g_InnerCornerRadius;
  +uniform highp float g_InnerCornerRadius;
   
  -float distanceFromRoundedRect(vec2 offset, float radius)
  +float distanceFromRoundedRect(highp vec2 offset, highp float radius)
   {
  -	// highp precision is required for calculations that operate on position
  -	// screen coordinates may need higher precision on higher resolution phones.
   	highp vec2 maskingPosition = v_MaskingPosition + offset;
   
   	// Compute offset distance from masking rect in masking space.
  
positive.code: 		bottomRightOffset + vec2(radius),
  		topLeftOffset + vec2(radius));
  
  	float maxDist = max(distanceFromShrunkRect.x, distanceFromShrunkRect.y);
  
  	// Inside the shrunk rectangle
  	if (maxDist <= 0.0)
  
negative.code: 	dist /= g_MaskingBlendRange;
  
  	// This correction is needed to avoid fading of the alpha value for radii below 1px.
  	highp float radiusCorrection = g_CornerRadius <= 0.0 ? g_MaskingBlendRange : max(0.0, g_MaskingBlendRange - g_CornerRadius);
  	highp float fadeStart = (g_CornerRadius + radiusCorrection) / g_MaskingBlendRange;
  	alphaFactor *= min(fadeStart - dist, 1.0);
  
  	if (v_BlendRange.x > 0.0 || v_BlendRange.y > 0.0)
  