Trying to toggle between walk and run

I've been re-writing the standard assets First Person Controller script to allow me to more easily add/ edit behaviors. So far it's been a great success I even got a smooth double jump going but I can't figure out how to properly toggle between walking speed and running speed. I'd like it so the player can press the Tab key once and movement speed will increase, upon pressing it a second time it should decrease. Here's the script thanks in advance:

     [RequireComponent(typeof(CharacterController))]
     public class FPS_Movement : MonoBehaviour
     {
         [SerializeField] private bool m_IsWalking;
         [SerializeField] private bool m_IsRunning;
         [SerializeField] private float m_WalkSpeed;
         [SerializeField] private float m_RunSpeed;
         [SerializeField] [Range(0f, 1f)] private float m_RunStepLengthen;
         [SerializeField] private float m_GravityMultiplier;
         [SerializeField] private MouseLook m_MouseLook;
         [SerializeField] private bool m_UseHeadBob;
         [SerializeField] private CurveControlledBob m_HeadBob = new CurveControlledBob();
         [SerializeField] private LerpControlledBob m_JumpBob = new LerpControlledBob();
         [SerializeField] private float m_StepInterval;
 
         private Camera m_Camera;
         private bool m_Jump;
         private bool m_DJump;
         private float m_Speed;
         private float m_JumpSpeed = 10;
         private CharacterController m_CharacterController;
         private CollisionFlags m_CollisionFlags;
         private Vector2 m_Input;
         private Vector3 m_MoveDir = Vector3.zero;
         private Vector3 m_OriginalCameraPosition;
         private float m_StepCycle;
         private float m_NextStep;
         private int m_AirJumps = 1;
         private int m_AirJumpCounter = 0;
 
         void Start()
         {
             m_CharacterController = GetComponent<CharacterController>();
             m_Camera = Camera.main;
             m_OriginalCameraPosition = m_Camera.transform.localPosition;
             m_MouseLook.Init(transform, m_Camera.transform);
             m_Speed = m_WalkSpeed;
             m_IsWalking = true;
         }
 
         void Update()
         {
             RotateView();
             
             if(m_IsWalking && Input.GetKeyDown(KeyCode.Tab))
             {
                 m_IsWalking = false;
                 m_IsRunning = true;
                 m_Speed = m_RunSpeed;
             }
             if (m_IsRunning && m_CharacterController.isGrounded && Input.GetKeyDown(KeyCode.Tab))
             {
                 m_IsRunning = false;
                 m_IsWalking = true;
                 m_Speed = m_WalkSpeed;
             }
             //Nailed it!!!!
             if(!m_Jump && m_CharacterController.isGrounded)
             {
                 m_Jump = Input.GetKeyDown(KeyCode.Space);
             }
 
             if(!m_DJump && !m_CharacterController.isGrounded && m_AirJumpCounter < m_AirJumps)
             {
                 m_DJump = Input.GetKeyDown(KeyCode.Space);
             }
 
             if(m_CharacterController.isGrounded)
             {
                 m_AirJumpCounter = 0;
             }
         }
 
         void FixedUpdate()
         {
             float speed;
             GetInput(out speed);
             Vector3 desiredMove = transform.forward * m_Input.y + transform.right * m_Input.x;
 
             RaycastHit hitInfo;
             Physics.SphereCast(transform.position, m_CharacterController.radius, Vector3.down, out hitInfo,
                 m_CharacterController.height / 2f, Physics.AllLayers, QueryTriggerInteraction.Ignore);
             desiredMove = Vector3.ProjectOnPlane(desiredMove, hitInfo.normal).normalized;
 
             m_MoveDir.x = desiredMove.x * speed;
             m_MoveDir.z = desiredMove.z * speed;
             
             if(!m_CharacterController.isGrounded && m_AirJumpCounter < m_AirJumps)
             {
                 if(m_DJump)
                 {
                     m_MoveDir.y = m_JumpSpeed;
                     m_AirJumpCounter++;
                     m_DJump = false;
                 }
                 else
                 {
                     m_MoveDir += Physics.gravity * m_GravityMultiplier * Time.fixedDeltaTime;
                 }
             }
 
             if(m_CharacterController.isGrounded)
             {
                 if(m_Jump)
                 {
                     m_MoveDir.y = m_JumpSpeed;
                     m_Jump = false;
                 }
             }
             else if(m_AirJumpCounter >= m_AirJumps)
             {
                 m_MoveDir += Physics.gravity * m_GravityMultiplier * Time.fixedDeltaTime;
             }
 
             m_CollisionFlags = m_CharacterController.Move(m_MoveDir * Time.fixedDeltaTime);
 
             UpdateCameraPosition(speed);
             m_MouseLook.UpdateCursorLock();
         }
 
         void UpdateCameraPosition(float speed)
         {
             Vector3 newCameraPosition;
             if(!m_UseHeadBob)
             {
                 return;
             }
 
             if(m_CharacterController.velocity.magnitude > 0 && m_CharacterController.isGrounded)
             {
                 m_Camera.transform.localPosition =
                     m_HeadBob.DoHeadBob(m_CharacterController.velocity.magnitude +
                     (speed * (m_IsWalking ? 1f : m_RunStepLengthen)));
                 newCameraPosition = m_Camera.transform.localPosition;
                 newCameraPosition.y = m_Camera.transform.localPosition.y - m_JumpBob.Offset();
             }
             else
             {
                 newCameraPosition = m_Camera.transform.localPosition;
                 newCameraPosition.y = m_OriginalCameraPosition.y - m_JumpBob.Offset();
             }
 
             m_Camera.transform.localPosition = newCameraPosition;
         }
 
         void GetInput(out float speed)
         {
             float horizontal = Input.GetAxis("Horizontal");
             float vertical = Input.GetAxis("Vertical");
 
             speed = m_Speed;
             m_Input = new Vector2(horizontal, vertical);
 
             if (m_Input.sqrMagnitude > 1)
             {
                 m_Input.Normalize();
             }
         }
 
         void RotateView()
         {
             m_MouseLook.LookRotation(transform, m_Camera.transform);
         }
     }