Image Effect problem on mobile & optimization

Anyone can help me to improve the optimization of this image effect (CRT)?

SHADER:

 Shader "Custom/CRTShader"
 {
     Properties{
         _MainTex("Base (RGB)", 2D) = "white" {}
         _VertsColor("Verts fill color", Float) = 0
         _VertsColor2("Verts fill color 2", Float) = 0
         _Contrast("Contrast", Float) = 0
         _Br("Brightness", Float) = 0
     }
 
         SubShader{
         Pass{
         ZTest Always Cull Off ZWrite Off Fog{ Mode off }
 
         CGPROGRAM
 
     #pragma vertex vert
     #pragma fragment frag
     //#pragma fragmentoption ARB_precision_hint_fastest
     #include "UnityCG.cginc"
 //#pragma target 3.0
 
     struct v2f
     {
         float4 pos      : POSITION;
         float2 uv       : TEXCOORD0;
         float4 scr_pos : TEXCOORD1;
     };
 
     uniform sampler2D _MainTex;
     uniform float _VertsColor;
     uniform float _VertsColor2;
     uniform float _Contrast;
     uniform float _Br;
 
 
     v2f vert(appdata_img v)
     {
         v2f o;
         o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
         o.uv = MultiplyUV(UNITY_MATRIX_TEXTURE0, v.texcoord);
         o.scr_pos = ComputeScreenPos(o.pos);
         return o;
     }
 
     half4 frag(v2f i) : COLOR
     {
         half4 color = tex2D(_MainTex, i.uv);
 
         float2 ps = i.scr_pos.xy *_ScreenParams.xy / i.scr_pos.w;
 
 
         int pp = ps.x % 3;        
 
         float4 muls = float4(0, 0, 0, 1);
         if (pp == 1) 
         { 
             muls.r = 1; 
             muls.g = _VertsColor2; 
         }
         else
             if (pp == 2) 
             { 
             muls.g = 1; 
             muls.b = _VertsColor2; 
             }
             else
             {
                 muls.b = 1; muls.r = _VertsColor2;
             }
         color = color * muls;
 
         color += (_Br / 255);
         color = color - _Contrast * (color - 1.0) * color *(color - 0.5);
         
         return color;
     }
 
         ENDCG
     }
     }
         FallBack "Diffuse"
 }

IMAGE EFFECT SCRIPT:

 using UnityEngine;
 
 [ExecuteInEditMode]
 [RequireComponent(typeof(Camera))]
 
 public class TVShader : MonoBehaviour
 {
     public Shader shader;
     private Material _material;
 
     [Range(0, 1)]
     public float verts_force = 0.0f;
     [Range(0, 1)]
     public float verts_force_2 = 0.0f;
 
     [Range(-3, 20)]
     public float contrast = 0.0f;
     [Range(-200, 200)]
     public float brightness = 0.0f;
 
     protected Material material
     {
         get
         {
             if (_material == null)
             {
                 _material = new Material(shader);
                 _material.hideFlags = HideFlags.HideAndDontSave;
             }
             return _material;
         }
     }
 
 
     public int horizontalResolution = 320;
     public int verticalResolution = 240;
 
 
         // To draw the shader at full resolution, use:
         // Graphics.Blit (source, destination, material);
     private void OnRenderImage(RenderTexture source, RenderTexture destination)
     {
         if (shader == null) return;
         Material mat = material;
         mat.SetFloat("_VertsColor", 1 - verts_force);
         mat.SetFloat("_VertsColor2", 1 - verts_force_2);
         mat.SetFloat("_Contrast", contrast);
         mat.SetFloat("_Br", brightness);
 
 //        // To draw the shader at scaled down resolution, use:
 //        RenderTexture scaled = RenderTexture.GetTemporary (horizontalResolution, verticalResolution);
 //
 //        Graphics.Blit (source, scaled, mat);
 //        Graphics.Blit (scaled, destination,mat,0);
 //        RenderTexture.ReleaseTemporary (scaled);
 //
         Graphics.Blit(source, destination, mat,0);
     }
 
     void OnDisable()
     {
         if (_material)
         {
             DestroyImmediate(_material);
         }
     }
 }

I've followed this Tutorial on Gamasutra and in the final lines he sad:

PS: Also you can achieve this effect just by multiplying one texture by another. That will be faster. But the aim of this article was not to write an optimal shader, the aim was to show you how it is done.

How can i get this result in term of optimization?

Also....

this is the horrible effect ONLY on android devices:

Thanks!