Unhandled exception at 0x006A549C in myApplication.exe: 0xC00000FD: Stack overflow (parameters: 0x00000001, 0x01202FFC)

I am writing a program with C++ that needs to read a CSV file and store it in a binary search tree. But, when the program is reading the file, it fails in the library debugger.jmc.c and in the method void __fastcall __CheckForDebuggerJustMyCode(unsigned char *JMC_flag). Could someone help me? Thanks!

#include <algorithm>
#include <iostream>
#include <ctime>
#include <string>

#include "CSVparser.hpp"

using namespace std;

using namespace std;

    struct Bid {
    string bidId;
    string title;
    string fund;
    double amount;
    Bid() {
        amount = 0.0;
    }
};


struct Node {

    Bid bid;

    Node* left;
    Node* right;
    Node() {
        left = nullptr;
        right = nullptr;
    }
    Node(Bid aBid) : Node() {
        this->bid = aBid;
    }
};


class BinarySearchTree {




private:

    Node* root;

    void addNode(Node* node, Bid bid);
    void inOrder(Node* node);
    Node* removeNode(Node* node, string bidId);

public:

    BinarySearchTree();
    virtual ~BinarySearchTree();
    void InOrder();
    void Insert(Bid bid);
    void Remove(string bidId);
    Bid Search(string bidId);
    Node* SearchNode(Node* node, string bidId);
};  

BinarySearchTree::BinarySearchTree() {

    root = nullptr;
}

/**
 * Destructor
 */
BinarySearchTree::~BinarySearchTree() {
    // recurse from root deleting every node
    
}

/**
 * Traverse the tree in order
 */
void BinarySearchTree::InOrder() {
}
/**
 * Insert a bid
 */
void BinarySearchTree::Insert(Bid bid) {
    // FIXME (2a) Implement inserting a bid into the tree

    if (root == nullptr) {
        root = new Node(bid);
    }
    else {
        addNode(root, bid);
    }

}

/**
 * Remove a bid
 */
void BinarySearchTree::Remove(string bidId) {
    // FIXME (4a) Implement removing a bid from the tree
    Node* nodePtr = SearchNode(root, bidId);
    if (nodePtr == nullptr) {
        return;
    }
    else {
        //not yet implemented
    }
}

/**
 * Search for a bid
 */
Bid BinarySearchTree::Search(string bidId) {
    // FIXME (3) Implement searching the tree for a bid

}


void BinarySearchTree::addNode(Node* node, Bid bid) {
    // FIXME (2b) Implement inserting a bid into the tree))

    //if node is larger than the bid add to the left subtree
    if (stoi(node->bid.bidId) > stoi(bid.bidId)) {
        if (node->left == nullptr) {
            node->left = new Node(bid);
        
        }
        else {
            addNode(node->left, bid);
        }

    }
    //add to right subtree
    else {
        if (node->right == nullptr) {
            node->right = new Node(bid);
        
        }
        else {
            addNode(node->right, bid);
        }


    }
    return;
}


void displayBid(Bid bid) {
    cout << bid.bidId << ": " << bid.title << " | " << bid.amount << " | "
        << bid.fund << endl;
    return;
}

/**
 * Load a CSV file containing bids into a container
 *
 * @param csvPath the path to the CSV file to load
 * @return a container holding all the bids read
 */
void loadBids(string csvPath, BinarySearchTree* bst) {
    cout << "Loading CSV file " << csvPath << endl;

    // initialize the CSV Parser using the given path
    csv::Parser file = csv::Parser(csvPath);

    try {
        
        for (unsigned int i = 0; i < file.rowCount(); i++) {

            // Create a data structure and add to the collection of bids
            Bid bid;
            bid.bidId = file[i][1];
            bid.title = file[i][0];
            bid.fund = file[i][8];
            bid.amount = strToDouble(file[i][4], '$');

            // push this bid to the end
            bst->Insert(bid);
        }
    }
    catch (csv::Error& e) {
        std::cerr << e.what() << std::endl;
    }
}

double strToDouble(string str, char ch) {
    str.erase(remove(str.begin(), str.end(), ch), str.end());
    return atof(str.c_str());
}

int main(int argc, char* argv[]) {

    // process command line arguments
    string csvPath, bidKey;
    switch (argc) {
    case 2:
        csvPath = argv[1];
        bidKey = "98105";
        break;
    case 3:
        csvPath = argv[1];
        bidKey = argv[2];
        break;
    default:
        csvPath = "eBid_Monthly_Sales_Dec_2016.csv";
        bidKey = "98105";
    }

    clock_t ticks;

    // Define a binary search tree to hold all bids
    BinarySearchTree* bst = nullptr;

    Bid bid;

    int choice = 0;
    while (choice != 9) {
        cout << "Menu:" << endl;
        cout << "  1. Load Bids" << endl;
        cout << "  2. Display All Bids" << endl;
        cout << "  3. Find Bid" << endl;
        cout << "  4. Remove Bid" << endl;
        cout << "  9. Exit" << endl;
        cout << "Enter choice: ";
        cin >> choice;

        switch (choice) {

        case 1:
            bst = new BinarySearchTree();

            ticks = clock();


            loadBids("eBid_Monthly_Sales.csv", bst);

            //cout << bst->Size() << " bids read" << endl;

            // Calculate elapsed time and display result
            ticks = clock() - ticks; 
            cout << "time: " << ticks << " clock ticks" << endl;
            cout << "time: " << ticks * 1.0 / CLOCKS_PER_SEC << " seconds" << endl;
        break;

    case 2:
        bst->InOrder();
        break;

    case 3:
        ticks = clock();

        bid = bst->Search(bidKey);

        ticks = clock() - ticks; // current clock ticks minus starting clock ticks

        if (!bid.bidId.empty()) {
            displayBid(bid);
        }
        else {
            cout << "Bid Id " << bidKey << " not found." << endl;
        }

        cout << "time: " << ticks << " clock ticks" << endl;
        cout << "time: " << ticks * 1.0 / CLOCKS_PER_SEC << " seconds" << endl;

        break;

    case 4:
        bst->Remove(bidKey);
        break;
    }
}

cout << "Good bye." << endl;

return 0;
}