All C# Shader Scripts giving CS 8025 Parsing Error.

I've created basic scripts using Project create->C#Script, so I know it works. But, whenever I attempt to use any Shader script, I get the CS8025 Parsing Error for the -- Shader "Name" { -- portion on every Shader Script I attempt to use. I've played with the { } brackets, but since it wasn't working, I went searching for other Shader scripts. Each Shader script gave me the same error. So far, I've tried 4 Shader Scripts, all with red ! errors. I'm using Unity v5.3.4f1 and these scripts have been used by others.

Am I bugged, or are { } brackets actually missing?

Below are 2 scripts I've tried, with links to their source.

 // WATCH FULL EXPLANATION ON YOUTUBE-VIDEO: https://www.youtube.com/watch?v=3qBDTh9zWrQ 

 Shader "Our Toonshader Vol. 3" {
   Properties {
 _Color ("Diffuse Material Color", Color) = (1,1,1,1) 
 _UnlitColor ("Unlit Color", Color) = (0.5,0.5,0.5,1)
 _DiffuseThreshold ("Lighting Threshold", Range(-1.1,1)) = 0.1
 _SpecColor ("Specular Material Color", Color) = (1,1,1,1) 
 _Shininess ("Shininess", Range(0.5,1)) = 1    
 _OutlineThickness ("Outline Thickness", Range(0,1)) = 0.1
 _MainTex ("Main Texture", 2D) = "AK47" {}
     
   }
   
  SubShader {
  Pass {
 Tags{ "LightMode" = "ForwardBase" }
     // pass for ambient light and first light source
   
       CGPROGRAM
       
       #pragma vertex vert 
       //tells the cg to use a vertex-shader called vert
       #pragma fragment frag
       //tells the cg to use a fragment-shader called frag
       
       //== User defined ==//
       
       //TOON SHADING UNIFORMS
       uniform float4 _Color;
       uniform float4 _UnlitColor;
       uniform float _DiffuseThreshold;
       uniform float4 _SpecColor;
       uniform float _Shininess;
       uniform float _OutlineThickness;
   
       
       //== UNITY defined ==//
       uniform float4 _LightColor0;
       uniform sampler2D _MainTex;
       uniform float4 _MainTex_ST;          
       
       struct vertexInput {
           
       //TOON SHADING VAR
       float4 vertex : POSITION;
       float3 normal : NORMAL;
       float4 texcoord : TEXCOORD0;
            
       };
       
       struct vertexOutput {
            
            float4 pos : SV_POSITION;
            float3 normalDir : TEXCOORD1;
            float4 lightDir : TEXCOORD2;
            float3 viewDir : TEXCOORD3;
           float2 uv : TEXCOORD0; 
       };
       
       vertexOutput vert(vertexInput input)
       {
           vertexOutput output;
           
           //normalDirection
           output.normalDir = normalize ( mul( float4( input.normal, 0.0 ), _World2Object).xyz );
            
           //World position
           float4 posWorld = mul(_Object2World, input.vertex);
           
           //view direction
           output.viewDir = normalize( _WorldSpaceCameraPos.xyz - posWorld.xyz ); //vector from object to the camera
           
           //light direction
           float3 fragmentToLightSource = ( _WorldSpaceCameraPos.xyz - posWorld.xyz);
           output.lightDir = float4(
               normalize( lerp(_WorldSpaceLightPos0.xyz , fragmentToLightSource, _WorldSpaceLightPos0.w) ),
               lerp(1.0 , 1.0/length(fragmentToLightSource), _WorldSpaceLightPos0.w)
           );
           
           //fragmentInput output;
           output.pos = mul( UNITY_MATRIX_MVP, input.vertex );  
           
           //UV-Map
           output.uv =input.texcoord;
           
           return output;
         
       }
       
       float4 frag(vertexOutput input) : COLOR
       {

 float nDotL = saturate(dot(input.normalDir, input.lightDir.xyz)); 
         
 //Diffuse threshold calculation
 float diffuseCutoff = saturate( ( max(_DiffuseThreshold, nDotL) - _DiffuseThreshold ) *1000 );
         
 //Specular threshold calculation
 float specularCutoff = saturate( max(_Shininess, dot(reflect(-input.lightDir.xyz, input.normalDir), input.viewDir))-_Shininess ) * 1000;
         
 //Calculate Outlines
 float outlineStrength = saturate( (dot(input.normalDir, input.viewDir ) - _OutlineThickness) * 1000 );
     
         
 float3 ambientLight = (1-diffuseCutoff) * _UnlitColor.xyz; //adds general ambient illumination
 float3 diffuseReflection = (1-specularCutoff) * _Color.xyz * diffuseCutoff;
 float3 specularReflection = _SpecColor.xyz * specularCutoff;
     
 float3 combinedLight = (ambientLight + diffuseReflection) * outlineStrength + specularReflection;
         
 return float4(combinedLight, 1.0); // + tex2D(_MainTex, input.uv); // DELETE LINE COMMENTS & ';' TO ENABLE TEXTURE
     

       }
       
       ENDCG
   
      }

   
   }

  } 

There's one. Here's another that I pulled from https://www.assetstore.unity3d.com/en/#!/content/21288.

 Shader "TSF/Base1" 
 {
     Properties 
 {
     [MaterialToggle(_TEX_ON)] _DetailTex ("Enable Detail texture", Float) = 0     //1
     _MainTex ("Detail", 2D) = "white" {}                                        //2
     _ToonShade ("Shade", 2D) = "white" {}                                          //3
     [MaterialToggle(_COLOR_ON)] _TintColor ("Enable Color Tint", Float) = 0     //4
     _Color ("Base Color", Color) = (1,1,1,1)                                    //5    
     [MaterialToggle(_VCOLOR_ON)] _VertexColor ("Enable Vertex Color", Float) = 0//6        
     _Brightness ("Brightness 1 = neutral", Float) = 1.0                            //7    
 }
   
 Subshader 
 {
     Tags { "RenderType"="Opaque" }
     LOD 250
     ZWrite On
        Cull Back
     Lighting Off
     Fog { Mode Off }
     
     Pass 
     {
         Name "BASE"
         CGPROGRAM
             #pragma vertex vert
             #pragma fragment frag
             #pragma fragmentoption ARB_precision_hint_fastest
             #include "UnityCG.cginc"
             #pragma glsl_no_auto_normalization
             #pragma multi_compile _TEX_OFF _TEX_ON
             #pragma multi_compile _COLOR_OFF _COLOR_ON

             
             #if _TEX_ON
             sampler2D _MainTex;
             half4 _MainTex_ST;
             #endif
             
             struct appdata_base0 
             {
                 float4 vertex : POSITION;
                 float3 normal : NORMAL;
                 float4 texcoord : TEXCOORD0;
             };
             
              struct v2f 
              {
                 float4 pos : SV_POSITION;
                 #if _TEX_ON
                 half2 uv : TEXCOORD0;
                 #endif
                 half2 uvn : TEXCOORD1;
              };
            
             v2f vert (appdata_base0 v)
             {
                 v2f o;
                 o.pos = mul ( UNITY_MATRIX_MVP, v.vertex );
                 float3 n = mul((float3x3)UNITY_MATRIX_IT_MV, normalize(v.normal));
                 normalize(n);
                 n = n * float3(0.5,0.5,0.5) + float3(0.5,0.5,0.5);
                 o.uvn = n.xy;
                  #if _TEX_ON
                 o.uv = TRANSFORM_TEX ( v.texcoord, _MainTex );
                 #endif
                 return o;
             }

               sampler2D _ToonShade;
             fixed _Brightness;
             
             #if _COLOR_ON
             fixed4 _Color;
             #endif
             
             fixed4 frag (v2f i) : COLOR
             {
                 #if _COLOR_ON
                 fixed4 toonShade = tex2D( _ToonShade, i.uvn )*_Color;
                 #else
                 fixed4 toonShade = tex2D( _ToonShade, i.uvn );
                 #endif
                 
                 #if _TEX_ON
                 fixed4 detail = tex2D ( _MainTex, i.uv );
                 return  toonShade * detail*_Brightness;
                 #else
                 return  toonShade * _Brightness;
                 #endif
             }
         ENDCG
     }
 }
 Fallback "Legacy Shaders/Diffuse"
 }