blendtree animator float value does not return to zero after i have stopped giving input

I have a blend tree with idle, run forward, backward, and side to side animations. When i provide input, via left stick of gamepad , i move in all the given directions and animations play properly. Although when i release the stick and stop giving input, the player stops moving as expected, but the animation continues to play. In the editor, in the animator controller window, it shows the float value of the last input direction, ie. -1 or 1 on x axis or -1 or 1 on y axis , and i am using new input system, and i am using the example demo script that comes with input system 1.0.0 download. here is that script, thanks in advance for any help...

 using System.Collections;
  using UnityEngine;
  using UnityEngine.InputSystem;
  using UnityEngine.InputSystem.Interactions;
 
 // Use a separate PlayerInput component for setting up input.
 public class NewController_UsingPlayerInput : MonoBehaviour
 {
     public float moveSpeed;
     public float rotateSpeed;
     public float burstSpeed;
     public GameObject projectile;
     public GameObject bulletpoint;
 
     private Animator animator;
     private bool m_Charging;
     private Vector2 m_Rotation;
     private Vector2 m_Look;
     private Vector2 m_Move;
 
     public void OnMove(InputAction.CallbackContext context)
     {
         m_Move = context.ReadValue<Vector2>();
        
     }
 
     public void OnLook(InputAction.CallbackContext context)
     {
         m_Look = context.ReadValue<Vector2>();
     }
 
     public void OnFire(InputAction.CallbackContext context)
     {
         switch (context.phase)
         {
             case InputActionPhase.Performed:
                 if (context.interaction is SlowTapInteraction)
                 {
                     StartCoroutine(BurstFire((int)(context.duration * burstSpeed)));
                 }
                 else
                 {
                     Fire();
                 }
                 m_Charging = false;
                 break;
 
             case InputActionPhase.Started:
                 if (context.interaction is SlowTapInteraction)
                     m_Charging = true;
                 break;
 
             case InputActionPhase.Canceled:
                 m_Charging = false;
                 break;
         }
     }
 
     public void OnGUI()
     {
         if (m_Charging)
             GUI.Label(new Rect(100, 100, 200, 100), "Charging...");
     }
 
     public void Update()
     {
         // Update orientation first, then move. Otherwise move orientation will lag
         // behind by one frame.
         Look(m_Look);
         Move(m_Move);
     }
 
     private void Move(Vector2 direction)
     {
         if (direction.sqrMagnitude < 0.01)
             return;
         var scaledMoveSpeed = moveSpeed * Time.deltaTime;
         // For simplicity's sake, we just keep movement in a single plane here. Rotate
         // direction according to world Y rotation of player.
         var move = Quaternion.Euler(0, transform.eulerAngles.y, 0) * new Vector3(direction.x, 0, direction.y);
         transform.position += move * scaledMoveSpeed;
         animator = GetComponent<Animator>();
         if (direction.x > 0.1 || direction.x < -0.1 || direction.y > 0.1 || direction.y < -0.1)
         {
             animator.SetFloat("RunX", direction.x);
             animator.SetFloat("RunY", direction.y);
         }
         else
         {
             animator.SetFloat("RunX", 0);
             animator.SetFloat("RunY", 0);
         }
     }
     
 
     private void Look(Vector2 rotate)
     {
         if (rotate.sqrMagnitude < 0.01)
             return;
         var scaledRotateSpeed = rotateSpeed * Time.deltaTime;
         m_Rotation.y += rotate.x * scaledRotateSpeed;
         m_Rotation.x = Mathf.Clamp(m_Rotation.x - rotate.y * scaledRotateSpeed, -15, 15);
         transform.localEulerAngles = m_Rotation;
     }
 
     private IEnumerator BurstFire(int burstAmount)
     {
         for (var i = 0; i < burstAmount; ++i)
         {
             Fire();
             yield return new WaitForSeconds(0.1f);
         }
     }
 
     private void Fire()
     {
         var transform = this.transform;
         var newProjectile = Instantiate(projectile);
         newProjectile.transform.position = bulletpoint.transform.position + transform.forward * 0.5f;
       //  newProjectile.transform.position = transform.position + transform.up * 6.5f;
         newProjectile.transform.rotation = bulletpoint.transform.rotation;
         const int size = 1;
         newProjectile.transform.localScale *= size;
         newProjectile.GetComponent<Rigidbody>().mass = Mathf.Pow(size, 3);
         newProjectile.GetComponent<Rigidbody>().AddForce(transform.forward * 20f, ForceMode.Impulse);
         newProjectile.GetComponent<MeshRenderer>().material.SetColor("_Color", Color.red);
            // new Color(Random.value, Random.value, Random.value, 1.0f);
     }