#include <iostream>
#include <string>

template <typename T>
class Deque {
 private:
    int head, tail;
    int capacity;
    T *deque;
    int s;

    bool isFull() {
        return (head == 0 && tail == capacity - 1) || (head == tail + 1);
    }

    void expand() {
        T *buffer = new T[capacity];
        int index = 0;
        while (!empty()) {
            buffer[index++] = pop_front();
        }
        delete[] deque;
        deque = new T[capacity * 2];
        capacity *= 2;
        for (size_t i = 0; i < index; i++) {
            push_back(buffer[i]);
        }
    }

 public:
    Deque() {
        capacity = 10;
        head = -1;
        tail = 0;
        deque = new T[capacity];
        s = 0;
    }

    void push_front(T x) {
        if (isFull()) {
            expand();
        }
        s++;
        if (head == -1) {
            head = 0;
            tail = 0;
        } else if (head == 0) {
            head = capacity - 1;
        } else {
            head--;
        }
        deque[head] = x;
    }

    void push_back(T x) {
        if (isFull()) {
            expand();
        }
        s++;
        if (head == -1) {
            head = 0;
            tail = 0;
        } else if (tail == capacity - 1) {
            tail = 0;
        } else {
            tail++;
        }

        deque[tail] = x;
    }

    bool empty() {
        return head == -1;
    }

    T pop_front() {
        s--;
        if (head == tail) {
            int result = deque[head];
            head = -1;
            tail = -1;
            return result;
        } else {
            if (head == capacity - 1) {
                T result = deque[head];
                head = 0;
                return result;
            } else {
                T result = deque[head];
                head++;
                return result;
            }
        }
    }

    T pop_back() {
        s--;
        if (head == tail) {
            T result = deque[head];
            head = -1;
            tail = -1;
            return result;
        } else if (tail == 0) {
            tail = capacity - 1;
            return deque[0];
        } else {
            T result = deque[tail];
            tail--;
            return result;
        }
    }

    T front() {
        return deque[head];
    }

    T back() {
        return deque[tail];
    }

    int size() {
        return s;
    }

    void clear() {
        delete[] deque;
        tail = 0;
        head = -1;
        s = 0;
        capacity = 10;
        deque = new T[capacity];
    }
};

int HandleCommand(const std::string &command, Deque<int> *deque) {
    if (command == "push_back") {
        int number;
        std::cin >> number;
        deque->push_back(number);
        std::cout << "ok\n";
    } else if (command == "push_front") {
        int number;
        std::cin >> number;
        deque->push_front(number);
        std::cout << "ok\n";
    } else if (command == "pop_back") {
        if (deque->empty()) {
            std::cout << "error\n";
        } else {
            std::cout << deque->pop_back() << "\n";
        }
    } else if (command == "pop_front") {
        if (deque->empty()) {
            std::cout << "error\n";
        } else {
            std::cout << deque->pop_front() << "\n";
        }
    } else if (command == "back") {
        if (deque->empty()) {
            std::cout << "error\n";
        } else {
            std::cout << deque->back() << "\n";
        }
    } else if (command == "front") {
        if (deque->empty()) {
            std::cout << "error\n";
        } else {
            std::cout << deque->front() << "\n";
        }
    } else if (command == "size") {
        std::cout << deque->size() << "\n";
    } else if (command == "clear") {
        deque->clear();
        std::cout << "ok\n";
    } else if (command == "exit") {
        std::cout << "bye\n";
        return 0;
    } else {
        std::cout << "invalid command";
        return 0;
    }

    return 1;
}

int main() {
    Deque<int> deque;

    std::string command;
    int result;

    do {
        std::cin >> command;
        result = HandleCommand(command, &deque);
    } while (result > 0);

    return 0;
}