process exited due to signal 6 na sprawdzarce "Szczopuł"

Robię zadanie z OI i podczas wysyłania rozwiązania wyświetla mi się "process exited due to signal 6". Ma ktoś pomysł jak to rozwiązać ?

Mój kod:

#include <iostream>

using namespace std;

int n, z, j;
char c;
string dl_wew, dl_zew, oper;
int main()
{
    cin >> n >> z;
    cin >> dl_wew;
    cin >> dl_zew;
    for (int i = 0; i < z; i++)
    {
        cin >> oper;
        if (oper == "S")
        {
            cin >> j;
            int dl_wew_int = stoi(dl_wew);
            int dl_zew_int = stoi(dl_zew);
            int suma = dl_wew_int + dl_zew_int;
            string suma_s = to_string(suma);
            cout << suma_s[size(suma_s) - j] << endl;
        }
        else
        {
            cin >> j >> c;
            if (oper == "W")
            {

                dl_wew[size(dl_wew) - j] = c;
            }
            if (oper == "Z")
            {

                dl_zew[size(dl_zew) - j] = c;
            }
        }
    }

    return 0;
}

Sprawdzarka: https://szkopul.edu.pl/problemset/problem/w3anjkOGa2eMEBt_-GYEosat/site/?key=submit

Ma ktoś pomysł jak to rozwiązać ?

Tak, przetestować to najpierw lokalnie.

terminate called after throwing an instance of 'std::invalid_argument'
  what():  stoi

Prawdopodobnie dl_wew albo dl_zew zawierają coś innego niż liczby i libc++ rzuca wyjątek.

W pierwszym wierszu wejścia są dwie liczby całkowite n i z (2 ≤ n ≤ 100 000, 1 ≤ z ≤ 100 000) oznaczające
długość wyświetlacza i liczbę operacji do wykonania.
W drugim wierszu znajduje się liczba całkowita oznaczająca początkową wartość długu wewnętrznego
Bajtocji w postaci napisu złożonego z n − 1 cyfr (napis może posiadać zera wiodące). W trzecim wierszu
w takim samym formacie znajduje się początkowa wartość długu zewnętrznego.

Czyli chcesz zmieścić w int liczbę składającej się z 99999 cyfr w zapisie dziesiętnym!
Z treści wynika, że nie musisz wykonywać żadnej operacji konwertującej napis do wartości. Masz wykonywać jedynie operacje na napisie!
A sumę masz wyznaczyć korzystając z arytmetyki dużych liczb.

Zwróć uwagę na fakt, że organicznie na pozycję cyfry sumy jest nieco inne niż na pozycję cyfry długów!

To przechodzi podstawowe testy, ale nie mieści się w limicie czasu, dla specjalnych przypadków dużych danych: https://godbolt.org/z/Ejsa3qG6E
Kod trzeba zoptymalizować, by uzyskać 100% punktów.

#include <cassert>
#include <iostream>
#include <string>

class Debt {
public:
    explicit Debt(std::string internal, std::string external)
        : in { std::move(internal) }
        , ex { std::move(external) }
    {
        assert(in.size() == ex.size());
    }

    void updateIn(size_t pos, char digit)
    {
        in[index(pos)] = digit;
    }

    void updateEx(size_t pos, char digit)
    {
        ex[index(pos)] = digit;
    }

    char get(size_t pos) const
    {
        auto i = index(pos);
        auto result = 0;
        if (i < in.size()) {
            result = digit(in[i]) + digit(ex[i]);
        }
        result += carryFrom(i + 1);
        result -= 10 * (result >= 10);
        return '0' + result;
    }

private:
    size_t index(size_t pos) const
    {
        return in.size() - pos;
    }

    bool carryFrom(size_t index) const
    {
        if (index < in.size()) {
            auto result = digit(in[index]) + digit(ex[index]);
            return result >= 10 || (result == 9 && carryFrom(index + 1));
        }
        return false;
    }

    static int digit(char ch)
    {
        return ch - '0';
    }

private:
    std::string in;
    std::string ex;
};

void setupIO()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
}

void processData(std::istream& in, std::ostream& out)
{
    size_t n, z;
    std::string internal, external;
    if (in >> n >> z >> internal >> external) {
        Debt debt { std::move(internal), std::move(external) };
        while (z--) {
            char operation;
            size_t i;
            in >> operation >> i;
            if (operation == 'S') {
                out << debt.get(i) << '\n';
            } else {
                char digit;
                in >> digit;
                if (operation == 'W') {
                    debt.updateIn(i, digit);
                } else if (operation == 'Z') {
                    debt.updateEx(i, digit);
                }
            }
        }
    }
}

int main()
{
    setupIO();
    processData(std::cin, std::cout);
    return 0;
}