Concurrent coroutines working on same datastructure hang unity!

I have a list of gameobjects that represent the nodes of snake character in my game. I have 2 coroutines, one that adds more nodes to this list, and one that pulls all the nodes towards the head node when a certain condition is met. This pull coroutine is basically just sucking all the nodes towards the first node position using a lerp on their positions. But sometimes when the pull coroutine and the increment length coroutine run concurrently unity hangs.

  // This is the pull coroutine
  IEnumerator Pull() {
             List<GameObject> nodes = GameObjectAccessor.instance.getSnakeData().getSnakeNodes();
             Vector3 [] positions = new Vector3[nodes.Count + 1];
             positions[0] = m_orbPos;
             for(int i = 1; i < positions.Length; i++) {
                 positions[i] = nodes[i - 1].transform.position;
             }
             float distTailTravels = (nodes.Count - 1) * getGreedyHeadScale();
             float pullSpeed = distTailTravels / orbPullTime;
             float targetResetTime = getGreedyHeadScale() / pullSpeed;
             float lastResetTime = 0.0f;
             int targetOffset = 1;
             bool finished = false;
     
             while(!finished) {
                 Logger.Log("Starting Pull");
                 if(lastResetTime > targetResetTime) {
                     targetOffset++;
                     lastResetTime = 0.0f;
                 }
                 for(int i = 1; i < positions.Length; i++) {
                     if(i - targetOffset >= 0) {
                         Vector3 destination = positions[i - targetOffset];
                         nodes[i - 1].transform.position = Vector3.Lerp(nodes[i - 1].transform.position, destination, pullSpeed * Time.deltaTime);
                     } else {
                         nodes[i - 1].transform.position = positions[0];
                         nodes[i - 1].transform.rotation = nodes[0].transform.rotation;
                         NewSnakeMovement bodyMovement = nodes[i - 1].GetComponent<NewSnakeMovement>();
                         bodyMovement.resetTarget(positions[0]);
                         if(i == positions.Length - 1 && nodes[i - 1].transform.position == positions[0]) {
                             finished = true;
                             Logger.Log("######################### Pull completed ###########################");
                         }
                     }
                 }
     
                 yield return null;
                 lastResetTime += Time.deltaTime;
             }
             GameObjectAccessor.instance.getSnakeData().decrementLengthOnEvolution();
             incrementScale();
             // start countdown
             GamePlayScreen.instance.go();
     }
     
     // This is the coroutine to increment length
     IEnumerator incrementLengthCoroutine(int value) {
             Logger.Log("Starting increment coroutine");
             GameObject tail = null;
             if (mSnakeNodes.Count > 1) {
                 tail = mSnakeNodes[mSnakeNodes.Count - 1];
                 GameObject tailParent = mSnakeNodes[mSnakeNodes.Count - 2];
                 mSnakeNodes.RemoveAt(mSnakeNodes.Count - 1);
                 tailParent.GetComponent<NewSnakeMovement>().ChildNode = null;
             }
             if(tail != null) {
     //            tail.GetComponent<NewSnakeMovement>().pauseForTime((value) * mSnakeMovement.getTimePerGrid());
                 tail.GetComponent<NewSnakeMovement>().pause();
             }
     
             for(int i = 0; i < value; i++) {
                 GameObject tailParent = mSnakeNodes[mSnakeNodes.Count - 1];
                 // get the body from pool
                 GameObject body = SnakeBodyPooler.instance.getObjectFromPool();
                 body.transform.position = tailParent.transform.position;
                 body.transform.rotation = tailParent.transform.rotation;
                 body.transform.localScale = tailParent.transform.localScale;
                 body.SetActive(true);
                 body.GetComponent<NewSnakeMovement>().pauseForTime((i) * mSnakeMovement.getTimePerGrid());
                 addSnakeNode(body);
                 yield return new WaitForEndOfFrame();
             }
     
            addSnakeNode (tail);
             tail.GetComponent<NewSnakeMovement>().unPause();
             Logger.Log("Ending increment coroutine");
     }
     
     // adds a node to the list
     public void addSnakeNode(GameObject node) {
             if(mSnakeNodes.Count > 0) {
                 GameObject lastNode = mSnakeNodes[mSnakeNodes.Count - 1];
                 NewSnakeMovement move = lastNode.GetComponent<NewSnakeMovement>();
                 move.ChildNode = node;
                 move.BodyIndex = mSnakeNodes.Count;
             }
             mSnakeNodes.Add(node);
         }

If I change the increment length coroutine to be a simple for loop that runs in one frame then i dont face this problem. Also, its the Pull coroutine that hangs, and once it does it does NOT even log the "Starting Pull" statement at the start of the while loop. So its not even going into an infinite loop. Let me know if anyone spots a major flaw with this code. I have been looking at it for hours and my mind maybe just skipping over something obvious. Any suggestions to modify this approach are welcomed too. Thanks in advance.