#include <iostream>

bool is_zero(int arr[], int size)
{
    for (int i = 0; i < size; i++)
        if (arr[i] != 0)
            return false;
    return true;
}

int truncate(int arr[], int size, int result[] = nullptr)
{
    int zero_count = 0;

    if (!is_zero(arr, size))
    {
        for (int i = 0; i < size; i++)
        {
            if (arr[i] == 0)
                zero_count++;
            else
            {
                break;
            }
        }
    }

    if (result != nullptr)
    {
        for (int i = 0; i < size - zero_count; i++)
            result[i] = arr[i + zero_count];

        for (int i = size - zero_count; i < size; i++)
            result[i] = -1;
    }

    return size - zero_count;
}

bool smaller_than(int n[], int m[], int size1, int size2)
{
    int trun_n[size1], trun_m[size2];

    int trun_size1 = truncate(n, size1, trun_n);
    int trun_size2 = truncate(m, size2, trun_m);

    if (trun_size1 < trun_size2)
        return true;

    if (trun_size1 > trun_size2)
        return false;

    for (int i = 0; i < trun_size1; i++)
    {
        if (trun_n[i] < trun_m[i])
            return true;
    }

    return false;
}

inline bool bigger_than(int n[], int m[], int size1, int size2)
{
    return smaller_than(m, n, size2, size1);
}

bool equal(int n[], int m[], int size1, int size2)
{
    if (size1 != size2)
        return false;
    else
    {
        for (int i = 0; i < size1; i++)
        {
            if (n[i] != m[i])
                return false;
        }
    }

    return true;
}

int* subtract(int n[], int m[], int result[], int size1, int size2)
{
    int n_reverse[size1];
    int m_reverse[size2];

    for (int i = size1 - 1; i >= 0; i--)
    {
        n_reverse[size1 - i - 1] = n[i];
    }

    for (int i = size2 - 1; i >= 0; i--)
    {
        m_reverse[size2 - i - 1] = m[i];
    }

    int *first;
    int *second;

    if (smaller_than(n, m, size1, size2))
    {
        first = m_reverse;
        second = n_reverse;
    }
    else
    {
        first = n_reverse;
        second = m_reverse;
    }

    int max_size = std::max(size1, size2);
    int min_size = std::min(size1, size2);

    int carry = 0;

    int sub;

    for (int i = 0; i < max_size; i++)
    {
        if (i < min_size)
        {
            sub = first[i] - second[i] - carry;

            if (sub < 0)
            {
                sub = sub + 10;
                carry = 1;
            }
            else
            {
                carry = 0;
            }

            result[max_size - i - 1] = sub;
        }
        else
        {
            if (carry == 1)
            {
                result[max_size - i - 1] = first[i] - carry;
                carry = 0;
            }
            else
                result[max_size - i - 1] = first[i];
        }
    }

    return result;
}

int* remainder(int n[], int m[], int result[], int size1, int size2)
{
    if (!is_zero(m, size2))
    {
        if (is_zero(n, size1) || equal(n, m, size1, size2))
        {
            for (int i = 0; i < std::max(size1, size2); i++)
                result[i] = 0;
        }
        else if (smaller_than(n, m, size1, size2))
        {
            for (int i = 0; i < size1; i++)
                result[i] = n[i];
        }
        else
        {
            for (int i = 0; i < std::max(size1, size2); i++)
                result[i] = n[i];
            // assume m > 0
            while (bigger_than(result, m, size1, size2))
            {
                subtract(result, m, result, size1, size2);
            }

        }
    }

    return result;
}

int main() {
    int n[100];
    int m[100];
    int size1, size2;

    for (int i = 0; i < 100; i++)
    {
        std::cin >> n[i];
        if (n[i] == -1)
        {
            size1 = i;
            break;
        }
    }

    for (int i = 0; i < 100; i++)
    {
        std::cin >> m[i];
        if (m[i] == -1)
        {
            size2 = i;
            break;
        }
    }

    int result[std::max(size1, size2)];

    remainder(n, m, result, size1, size2);

    for (int i = 0; i < std::max(size1, size2); i++)
        std::cout << result[i];
}