Shader Shadow Effect Issues

I've been working on this shader and I have not received any errors from the console. But I'm not getting all the effects from the shader. There should be a shadow effect along with the rest of the shader's effects. But it's not appearing. Did I not implement my shadow effect correctly? How do I determine what is wrong if the console doesn't say there's anything wrong?

 Shader "Custom/Shadow Shader" {
     Properties {
         _MainTex ("Base (RGB)", 2D) = "white" {}
         _Bump ("Bump", 2D) = "bump" {}
         _ColorMerge ("Color Merge", Range(0.1,20000)) = 8
         _Ramp ("Ramp Texture", 2D) = "white" {}
         _Outline ("Outline", Range(0, 0.15)) = 0.08
         _Color ("Diffuse Color", Color) = (1,1,1,1) 
       _UnlitColor ("Unlit Diffuse Color", Color) = (0.5,0.5,0.5,1) 
       _DiffuseThreshold ("Threshold for Diffuse Colors", Range(0,1)) 
          = 0.1 
       _ShadowColor ("Outline Color", Color) = (0,0,0,1)
       _LitShadowThickness ("Lit Outline Thickness", Range(0,1)) = 0.1
       _UnlitShadowThickness ("Unlit Outline Thickness", Range(0,1)) 
          = 0.4
       _SpecColor ("Specular Color", Color) = (1,1,1,1) 
       _Shininess ("Shininess", Float) = 10
     }
     SubShader {
         Tags { "RenderType"="Opaque" }
         LOD 200
  
         Pass {
  
             Cull Front
             Lighting Off
             ZWrite On
             Tags { "LightMode"="ForwardBase" }
  
             CGPROGRAM
             #pragma vertex vert
             #pragma fragment frag
  
             #include "UnityCG.cginc"
             uniform float4 _LightColor0; 
             // color of light source (from "Lighting.cginc")
  
          // User-specified properties
          uniform float4 _Color; 
          uniform float4 _UnlitColor;
          uniform float _DiffuseThreshold;
          uniform float4 _ShadowColor;
          uniform float _LitShadowThickness;
          uniform float _UnlitShadowThickness;
          uniform float4 _SpecColor; 
          uniform float _Shininess;
  
          struct vertexInput {
             float4 vertex : POSITION;
             float3 normal : NORMAL;
          };
          struct vertexOutput {
             float4 pos : SV_POSITION;
             float4 posWorld : TEXCOORD0;
             float3 normalDir : TEXCOORD1;
          };
  
          vertexOutput vert(vertexInput input) 
          {
             vertexOutput output;
  
             float4x4 modelMatrix = _Object2World;
             float4x4 modelMatrixInverse = _World2Object; 
                // multiplication with unity_Scale.w is unnecessary 
                // because we normalize transformed vectors
  
             output.posWorld = mul(modelMatrix, input.vertex);
             output.normalDir = normalize(
                mul(float4(input.normal, 0.0), modelMatrixInverse).xyz);
             output.pos = mul(UNITY_MATRIX_MVP, input.vertex);
             return output;
          }
                   float4 frag(vertexOutput input) : COLOR
          {
             float3 normalDirection = normalize(input.normalDir);
  
             float3 viewDirection = normalize(
                _WorldSpaceCameraPos - input.posWorld.xyz);
             float3 lightDirection;
             float attenuation;
  
             if (0.0 == _WorldSpaceLightPos0.w) // directional light?
             {
                attenuation = 1.0; // no attenuation
                lightDirection = normalize(_WorldSpaceLightPos0.xyz);
             } 
             else // point or spot light
             {
                float3 vertexToLightSource = 
                   _WorldSpaceLightPos0.xyz - input.posWorld.xyz;
                float distance = length(vertexToLightSource);
                attenuation = 1.0 / distance; // linear attenuation 
                lightDirection = normalize(vertexToLightSource);
             }
  
             // default: unlit 
             float3 fragmentColor = _UnlitColor.rgb; 
  
             // low priority: diffuse illumination
             if (attenuation 
                * max(0.0, dot(normalDirection, lightDirection)) 
                >= _DiffuseThreshold)
             {
                fragmentColor = _LightColor0.rgb * _Color.rgb; 
             }
  
             // higher priority: outline
             if (dot(viewDirection, normalDirection) 
                < lerp(_UnlitShadowThickness, _LitShadowThickness, 
                max(0.0, dot(normalDirection, lightDirection))))
             {
                fragmentColor = _LightColor0.rgb * _ShadowColor.rgb; 
             }
  
             // highest priority: highlights
             if (dot(normalDirection, lightDirection) > 0.0 
                // light source on the right side?
                && attenuation *  pow(max(0.0, dot(
                reflect(-lightDirection, normalDirection), 
                viewDirection)), _Shininess) > 0.5) 
                // more than half highlight intensity? 
             {
                fragmentColor = _SpecColor.a 
                   * _LightColor0.rgb * _SpecColor.rgb
                   + (1.0 - _SpecColor.a) * fragmentColor;
             }
             return float4(fragmentColor, 1.0);
          }
             struct a2v
             {
                 float4 vertex : POSITION;
                 float3 normal : NORMAL;
                 float3 tangent : TANGENT;
             };
  
             struct v2f
             {
                 float4 pos : POSITION;
             };
  
             float _Outline;
  
             v2f vert (a2v v)
             {
                 v2f o;
                 float4 pos = mul( UNITY_MATRIX_MV, v.vertex);
                 float3 normal = mul( (float3x3)UNITY_MATRIX_IT_MV, v.normal); 
                 normal.z = -0.4;
                 pos = pos + float4(normalize(normal),0) * _Outline;
                 o.pos = mul(UNITY_MATRIX_P, pos);
  
                 return o;
             }
  
             float4 frag (v2f IN) : COLOR
             {
                 return float(0);
             }
  
             ENDCG
  
         }
  
         Pass {
  
             Cull Back
             Lighting On
             Tags { "LightMode"="ForwardBase" }
             Blend SrcAlpha OneMinusSrcAlpha 
             CGPROGRAM
             #pragma vertex vert
             #pragma fragment frag
  
             #include "UnityCG.cginc"
              uniform float4 _LightColor0; 
             // color of light source (from "Lighting.cginc")
  
          // User-specified properties
          uniform float4 _Color; 
          uniform float4 _UnlitColor;
          uniform float _DiffuseThreshold;
          uniform float4 _ShadowColor;
          uniform float _LitShadowThickness;
          uniform float _UnlitShadowThickness;
          uniform float4 _SpecColor; 
          uniform float _Shininess;
  
          struct vertexInput {
             float4 vertex : POSITION;
             float3 normal : NORMAL;
          };
          struct vertexOutput {
             float4 pos : SV_POSITION;
             float4 posWorld : TEXCOORD0;
             float3 normalDir : TEXCOORD1;
          };
  
          vertexOutput vert(vertexInput input) 
          {
             vertexOutput output;
  
             float4x4 modelMatrix = _Object2World;
             float4x4 modelMatrixInverse = _World2Object; 
                // multiplication with unity_Scale.w is unnecessary 
                // because we normalize transformed vectors
  
             output.posWorld = mul(modelMatrix, input.vertex);
             output.normalDir = normalize(
                mul(float4(input.normal, 0.0), modelMatrixInverse).rgb);
             output.pos = mul(UNITY_MATRIX_MVP, input.vertex);
             return output;
          }
                   float4 frag(vertexOutput input) : COLOR
          {
             float3 normalDirection = normalize(input.normalDir);
  
             float3 viewDirection = normalize(
                _WorldSpaceCameraPos - input.posWorld.rgb);
             float3 lightDirection;
             float attenuation;
  
             if (0.0 == _WorldSpaceLightPos0.w) // directional light?
             {
                attenuation = 1.0; // no attenuation
                lightDirection = normalize(_WorldSpaceLightPos0.xyz);
             } 
             else // point or spot light
             {
                float3 vertexToLightSource = 
                   _WorldSpaceLightPos0.xyz - input.posWorld.xyz;
                float distance = length(vertexToLightSource);
                attenuation = 1.0 / distance; // linear attenuation 
                lightDirection = normalize(vertexToLightSource);
             }
  
             float4 fragmentColor = float4(0.0, 0.0, 0.0, 0.0);
             if (dot(normalDirection, lightDirection) > 0.0 
                // light source on the right side?
                && attenuation *  pow(max(0.0, dot(
                reflect(-lightDirection, normalDirection), 
                viewDirection)), _Shininess) > 0.5) 
                // more than half highlight intensity? 
             {
                fragmentColor = 
                   float4(_LightColor0.rgb, 1.0) * _SpecColor;
             }
             return fragmentColor;
          }
  
             sampler2D _MainTex;
             sampler2D _Bump;
             sampler2D _Ramp;
  
             float4 _MainTex_ST;
             float4 _Bump_ST;
  
             float _Tooniness;
             float _ColorMerge;
  
             struct a2v
             {
                 float4 vertex : POSITION;
                 float3 normal : NORMAL;
                 float4 texcoord : TEXCOORD0;
                 float4 tangent : TANGENT;
  
             };
  
             struct v2f
             {
                 float4 pos : POSITION;
                 float2 uv : TEXCOORD0;
                 float2 uv2 : TEXCOORD1;
                 float3 lightDirection : TEXCOORD2;
  
             };
  
             v2f vert (a2v v)
             {
                 v2f o;
                 //Create a rotation matrix for tangent space
                 TANGENT_SPACE_ROTATION;
                 //Store the light's direction in tangent space
                 o.lightDirection = mul(rotation, ObjSpaceLightDir(v.vertex));
                 //Transform the vertex to projection space
                 o.pos = mul( UNITY_MATRIX_MVP, v.vertex);
                 //Get the UV coordinates
                 o.uv = TRANSFORM_TEX (v.texcoord, _MainTex); 
                 o.uv2 = TRANSFORM_TEX (v.texcoord, _Bump);
                 return o;
             }
  
             float4 frag(v2f i) : COLOR 
             {
                 //Get the color of the pixel from the texture
                 float4 c = tex2D (_MainTex, i.uv); 
                 //Merge the colours
                 c.rgb = (floor(c.rgb*_ColorMerge)/_ColorMerge);
  
                 //Get the normal from the bump map
                 float3 n =  UnpackNormal(tex2D (_Bump, i.uv2));
  
                 //Based on the ambient light
                 float3 lightColor = UNITY_LIGHTMODEL_AMBIENT.xyz;
  
                 //Work out this distance of the light
                 float lengthSq = dot(i.lightDirection, i.lightDirection);
                 //Fix the attenuation based on the distance
                 float atten = 1.0 / (1.0 + lengthSq);
                 //Angle to the light
                 float diff = saturate (dot (n, normalize(i.lightDirection))); 
                 //Perform our toon light mapping
                 diff = tex2D(_Ramp, float2(diff, 0.5));
                 //Update the colour
                 lightColor += _LightColor0.rgb * (diff * atten);
                 //Product the final color
                 c.rgb = lightColor * c.rgb * 2;
                 return c;
  
             }
  
             ENDCG
         }
  
     }
     FallBack "Diffuse"
 }