Singly Linked List inserting and deleting value in order

I was tasked with creating functions to add and delete nodes in a linked list given input data as an int and the char for with function to call. I'm not sure what I'm doing wrong. The only error I was given was: Exited with return code -11 (SIGSEGV). And a compiler method: main.cpp: In function ‘void listInsertValue(ListNode*&, ListNode*&, int)’: main.cpp:111:23: warning: ‘toGoAfter’ may be used uninitialized in this function [-Wmaybe-uninitialized] 111 | toGoAfter->next = head;

Any help is appreciated. Thanks!

#include <iostream>
using namespace std;

struct ListNode
{
    int data;
    ListNode* next;
};

void listRemoveAfter(ListNode*&, ListNode*&, ListNode*);
void listPrepend(ListNode*&, ListNode*&, ListNode*&);
void listDeleteValue(ListNode*&, ListNode*&, int);
void listInsertValue(ListNode*&, ListNode*&, int);
void listInsertAfter(ListNode*&, ListNode*&, ListNode*, ListNode*);

int main()
{
    
    ListNode *head = nullptr, *tail = nullptr;
    ListNode *temp;
   char choice;
   int val;

   //Write a main like you did in the previous lab
   char command;
   int number;
   
   cin >> command;
   while(command != 'Q')
   {
        if(command == 'I')
        {
            cin >> number;
            listInsertValue(head,tail,number);
        }
        else
        {
            cin >> number;
            listDeleteValue(head,tail,number);
        }
        
      cin >> command;
   }
   ListNode* current;
   current = head;
    while (current != nullptr)
    {
        cout << current->data << " ";
        current = current->next;
    }
    cout << endl;
    return 0;

}

//From previous lab - already complete
void listPrepend(ListNode*& h, ListNode*& t, ListNode*& n)
{
    if (h == nullptr)
    {
        h = n;
        t = n;
    }
    else
    {
        n->next = h;
        h = n;
    }
}

//From book, write yourself using the book code in 17.6 as a starting point
void listInsertAfter(ListNode*&head, ListNode*&tail, ListNode* curNode, ListNode* newNode)
{
   if (head->next == nullptr) 
   { 
      head= newNode;
      tail = newNode;
   }
   else if (curNode->next == tail) 
   { 
      tail->next = newNode;
      tail = newNode;
   }
   else 
   {
      newNode->next = curNode;
      curNode->next = newNode;
   }
}


//This function is mostly written, but you will need to add some code near the TODOs to complete the algorithm from the slides
void listInsertValue(ListNode*& head, ListNode*& tail, int val)
{
    ListNode* toGoAfter, *newNode;

   //TODO - create a new ListNode (newNode) with a data value of val (3 lines of code)
   newNode = new ListNode;
   newNode->data = val;
   newNode->next = nullptr;
    //TODO - check whether the list is empty in the if condition
    if (head == nullptr)
    {
        listInsertAfter(head, tail, nullptr, newNode);
    }
    //TODO - use the else if to check whether the the value passed in is smaller than the value in the head
    else if (head->data > val)  //need to add to beginning of the list
    {
        listPrepend(head, tail, newNode);
    }
    else //need to add somewhere else in the list
    {
       //TODO - set toGoAfter to point to the head
      toGoAfter->next = head;
      //loop to find the location to insert the value
        while (toGoAfter->next != nullptr && toGoAfter->next->data < val)
        {
           //TODO - set toGoAfter to point to the node after toGoAfter, like is done in traversals
           toGoAfter = toGoAfter->next;
        }

      //We have found the location, so we can insert
        listInsertAfter(head, tail, toGoAfter, newNode);

    }
}

//modify
void listDeleteValue(ListNode* &head, ListNode*& tail, int val)
{
    ListNode *temp;

   //TODO - check if list is not empty in if condition
    if (head->next == nullptr)
    {
       // TODO - check if value of head matches val passed in
        if (head->data == val)
            listRemoveAfter(head, tail, nullptr);
    }
        else
        {
           //loop searches for value to delete in node following temp
           //TODO - set temp to point to the head
           temp->next = head;
            while (temp->next != nullptr && temp->next->data != val)
            {
               //TODO - set temp to point to the node after temp, like is done in traversals
               temp = temp->next;
            }

         //TODO - make sure a node exists after temp, meaning the value to delete was found
            if (temp->next != nullptr)
                listRemoveAfter(head, tail, temp);
        }
    
}

//From book, write yourself using the book code in 17.7 as a starting point
//Also add to the book's code, the code to delete nodes from memory
void listRemoveAfter(ListNode* & head, ListNode*& tail, ListNode* curNode) 
{
    ListNode *sucNode, *toDelete;
    
     if (curNode->next == nullptr && head->next != nullptr) 
     {
       sucNode = head->next;
      head->next = sucNode;

      if (sucNode->next == nullptr) 
      { // Removed last item
         tail->next = nullptr;
         toDelete = head;
      }
   }
   else if (curNode->next != nullptr)
   {
      sucNode = curNode->next->next;
      curNode->next = sucNode;

      if (sucNode-> next == nullptr)
      { // Removed tail
         tail->next = curNode;
         toDelete = curNode->next;
      }
      
   }

    delete toDelete;  //needed after the if/else if to remove the deleted node from memory

}