Ошибка компиляции E0020 "идентификатор "“pause”" не определен"

#include <iostream>
#include <time.h>
using namespace std;
 
///////////////////////////////////Очередь массивом////////////////////////////////
struct Queue1 {
    int head, tail, size; // head - поле, где хранится позиция первого элеменета, tail - последнего, size - размер массива
    int* data; // указатель на первый элемент массива
};
void nullQueue1(Queue1& q) {
    q.head = 0;
    q.tail = q.size - 1;
}
void InitQueue1(Queue1& q, int capacity) {// установка размера очереди
    q.size = capacity + 1;
    q.data = new int[q.size];
    nullQueue1(q);
}
int next(Queue1& q, int n) { // функция, возвращающая значение следующего элементу
    return (n + 1) % q.size;
}
bool empty(Queue1& q) {// функция, проверяющая очередь на пустоту
    return next(q, q.tail) == q.head;
}
void add(Queue1& q, int value) {// добавление в очередь элементов
    if (next(q, next(q, q.tail)) == q.head)// проверка на переполнение
    {
        cout << "Очередь переполнена" << endl;
    }
    else {
        q.tail = next(q, q.tail);
        q.data[q.tail] = value;
    }
}
 
 
int del(Queue1& q) {//вывод очереди
    if (empty(q)) { cout << "Очередь пуста" << endl; return 0; }
    else {
        int d = q.data[q.head];
        q.head = next(q, q.head);
        return d;
    }
}
void printqueue(Queue1& q) {
    if (empty(q)) { cout << "Очередь пуста" << endl; }
    else {
        int i = q.head;
        while (i != q.tail + 1) {
            cout << q.data[i] << " ";
            i = next(q, i);
        } cout << endl;
    }
}
int max_queue(Queue1& q) {//нахождение максимального значения очереди 
    if (!empty(q))
    {
        int max = q.data[q.head], x;//начальное максимальное значение инициализируется значением первого элемента
        int save = q.head;
        while (next(q, q.tail) != q.head)
        {
            x = q.data[q.head];
            q.head = next(q, q.head);
            if (x > max) max = x;
        }
        q.head = save;
        return max;
    }
    else return 0;
}
 
////////////////////////////////Стек массивом////////////////////////////////
 
struct Stack 
{
    int top; int* data; //top - индекс верхнего элемента стека, data - указатель на элемент массива
};
void InitStack(Stack& st, int capacity) 
{
    st.data = new int[capacity];
    st.top = -1;
}
void push(Stack& st, int value) //добавление в стек
{
    st.data[++st.top] = value;
}
int pop(Stack& st) //удаление из стека
{
    return st.data[st.top--];
}
void nullStack(Stack& st) //обнуление стека
{
    st.top = -1;
}
bool empty(Stack& st) //проверка на пустоту
{
    return st.top == -1;
}
void printstack(Stack& st) //вывод стека с опустошением
{
    if (!empty(st)) 
    {
        int i = st.top;
        while (i >= 0) 
        {
            cout << st.data[i--] << " ";
        } cout << endl;
    }
    else cout << " пусто" << endl;
}
 
//////////////////////////Очередь динамическим списком//////////////////////////////
class Queue 
{
private:
    struct Node 
    {
        int data;// поле, где храниться данные 
        Node* next;//указатель на следущий элемент списка
    };
    Node* head, * tail;// указатель на начало списка и конец
public:
    Queue() 
    { head = NULL; tail = NULL; }
    bool empty() 
    {
        return head == NULL;
    }
    void add(int value) {//добавление элементов в очередь
        if (empty()) {
            head = new Node;
            head->data = value;
            head->next = NULL;
            tail = head;
        }// в создании первого узла, первый элемент и хвост и голова. 
        else {
            tail->next = new Node;
            tail = tail->next;
            tail->data = value;
            tail->next = NULL;
        }
    }
 
    int del() {//удаление элемента очереди
        if (empty()) {
            cout << "Очередь пуста" << endl;
            return 0;
        }
        else {
            int d = head->data;
            Node* tmp = head;
            head = head->next;
            delete(tmp);
            return d;
        }
    }
    int next() {//переход к следующему элементу очереди
        if (empty()) {
            cout << "Очередь пуста" << endl;
            return 0;
        }
        else {
            int d = head->data;
            Node* tmp = head;
            head = head->next;
            return d;
        }
    }
    void nullQueue() {//обнуление очереди
        Node* tmp;
        while (!empty()) {
            tmp = head;
            head = head->next;
            delete(tmp);
        }
    }
    void printqueue() {//вывод очереди
        Node* tmp;
        tmp = head;
        while (!tmp == NULL) {
            int d = tmp->data;
            tmp = tmp->next;
            cout << d << " ";
        } delete(tmp);
    }
    int max_queue() {//нахождение максимального значения очереди
        if (!empty()) {
            Node* tmp;
            tmp = head;
            int max = tmp->data;//начальное значение максимума инициализируется значением первого элемента
            while (tmp != NULL) {
                if (tmp->data > max) max = tmp->data;
                tmp = tmp->next;
            }
            delete tmp;
            return max;
        }
        else return 0;
    }
};
 
//////////////////////////Стек динамическим списком//////////////////////////////
struct Node {
    int data; Node* next;// data -  поле, где храниться данные, next - указатель на следущий элемент списка
};
void InitNode(Node*& top) {
    top = NULL;
}
void push(Node*& top, int value) {//добавление элемента в стек
    Node* tmp = new Node;
    tmp->next = top;
    top = tmp;
    top->data = value;
}
int pop(Node*& top) {//удаление элемента из стека
    Node* tmp = top;
    int d = top->data;
    top = top->next;
    delete(tmp);
    return d;
}
bool empty(Node*& top) {// проверка стека на пустоту
    return top == NULL;
}
void nullStack(Node*& top) {//обнуление стека
    Node* tmp;
    while (!empty(top)) 
    {
        tmp = top;
        top = top->next;
        delete(tmp);
    }
}
void printstack(Node*& top) {// вывод стека с очищением стека
    Node* tmp;
    tmp = top;
    if (tmp == NULL) cout << " Стек пуст" << endl;
    while (!tmp == NULL) 
    {
        int d = tmp->data;
        tmp = tmp->next;
        cout << d << " ";
    } delete (tmp);
}
 
int main() {
    setlocale(LC_ALL, "rus");
    srand(time(0));
    cout << "Выбор механизма работы программы: 1)Реализация массивом  2) Реализация динамическим списком" << endl;
    cout << "Механизм - ";
    int n;
    cin >> n;
    cout << endl;
    switch (n) {
    case 1: {//Реализация массивом
        Queue1 q1, q2;;// объявление объектов структуры Queue
        Stack s;// объявление объектов структуры Stack1
        int size_q1 = rand() % 20, size_q2 = rand() % 10;// размеры очередей
        if (size_q1 != 0 && size_q2 != 0)
        {
            cout << "Размер первой очереди: " << size_q1 << "\n" << "Размер второй очереди: " << size_q2 << endl;
            InitQueue1(q1, size_q1);//с помощью функции установил размер очереди q1
            InitQueue1(q2, size_q2);//с помощью функции установил размер очереди q2
            InitStack(s, size_q1);//с помощью функции установил размер стака q1
            for (int i = 0; i < size_q1; i++) {// добавление элементов в очереди
                int j = rand() % 100;
                add(q1, j);
            }
            for (int i = 0; i < size_q2; i++) {
                int j = rand() % 10 - 20;
                add(q2, j);
            }
 
            cout << "Первая очередь: ";
            if (!empty(q1)) printqueue(q1);//вывод очереди q1
            else cout << "Пусто" << endl;
            cout << "Вторая очередь: ";
            if (!empty(q2)) printqueue(q2);//вывод очереди q2
            else cout << "Пусто" << endl;
            if (max_queue(q2))
            {
                cout << "Максимальное значение во второй очереди: " << max_queue(q2) << endl;//вывод максимального элемента из очереди два с помощью функции, которая этот элемент ищет и возвращает
 
                cout << "Стек их чисел кратных " << max_queue(q2) << ": ";
                while (!empty(q1)) {
                    int d = del(q1);// через функцию в цикле принимает значения из очереди q1
                    if (max_queue(q2) != 0 && d % max_queue(q2) == 0) {
                        push(s, d);// добавление элементов в стек
                    }
                }
                printstack(s); cout << endl;//вывод элементов стека, опустошение стека
            }
            else cout << "Максимальное значение второй равно нулю" << endl;
        }
        else cout << "Одна из очередей пуста" << endl;
        break;
    }
 
    case 2: {//динамический список
        Queue qu1, qu2;
        Node* n;
        InitNode(n);
        int size_qu1 = rand() % 20, size_qu2 = rand() % 10;// определение размера очередей
        if (size_qu1 != 0 && size_qu2 != 0) {
 
            cout << "Размер первой очереди: " << size_qu1 << "\n" << "Размер второй очереди: " << size_qu2 << endl;
            for (int i = 0; i < size_qu1; i++) {
                int j = rand() % 100;
                qu1.add(j);
            }
            for (int i = 0; i < size_qu2; i++) {
                int j = rand() % 10 - 20;
                qu2.add(j);
            }
 
            cout << "Первая очередь: ";
            if (!qu1.empty()) { qu1.printqueue(); cout << endl; }
            else cout << "Пусто" << endl;
            cout << "Вторая очередь: ";
            if (!qu2.empty()) { qu2.printqueue(); cout << endl; }
            else cout << "Пусто" << endl;
            if (qu2.max_queue())
            {
                cout << "Максимальное значение во второй очереди: " << qu2.max_queue() << endl;
                cout << "Стек их чисел кратных " << qu2.max_queue() << ": ";
                while (!qu1.empty()) {
                    int d = qu1.next();
                    if (qu2.max_queue() != 0 && d % qu2.max_queue() == 0) {
                        push(n, d);
                    }
                }
                printstack(n); cout << endl;
            }
            else cout << "Максимальное значение второй равно нулю" << endl;
        }
        else cout << "Одна из очередей пуста" << endl;
    }
    default: break;
    }
    return 0;
    system(“pause”);
}