int head,       // 这个链表的头是哪个节点
    idx,        // 当前链表里面有几个节点  
    val[MAXN],  // val[i]:=编号为i的格子里的数据
    nxt[MAXN];  // nxt[i]:=编号为i的格子的下一个格子编号

void prep(int x){
  val[idx] = x, nxt[idx] = head, head = idx++;
}

void add(int k, int x){
  val[idx] = x;
  nxt[idx] = nxt[k];
  nxt[k] = idx++;
}

int val[N], // val[i]:=表示结点i存储的数值
    prv[N], // prv[i]:=节点i的前一个节点是哪个节点
    nxt[N], // nxt[i]:=节点i的下一个节点是哪个节点
    idx;    // 内存池现在用了几个节点

void init() {
    nxt[0] = 1;
    prv[1] = 0;
    idx = 2;// 此时, 内存池已经有2个元素了. 分别是0和1
}

//在内存池中编号为k的节点插入的点的右边插入x
void add(int k, int x) {
    val[idx] = x;
    nxt[idx] = nxt[k];
    prv[idx] = k;
    prv[nxt[k]] = idx;
    nxt[k] = idx++;
}

//删除内存池里面编号为k的点
void remove(int k) {
    //就是将k的左端点和右端点相互连接
    prv[nxt[k]] = prv[k];
    nxt[prv[k]] = nxt[k];
}

struct DLL{
  int prv, nxt;
  int val;
}dlls[MAXN];

struct A{
  int x, y;
};

// 比如一个引用
A *a = &...;
// 现在要得到修改A引用的x元素?
// *a.x = 3;  错! 因为*的优先级低一些, 要写(*a).x = 3;
// 简写为
a->x = 3;

typedef struct __tasks_lst{
  struct task dummy; // 第一个节点
  int nr_node;       // 总共节点的个数
} TSKLST;

struct task{
    struct task *nxt, *prv;
    char name[20];
    // .... 别的什么东西 ....
};

void init_tsklst(TSKLST *tsklst){
  tsklst->nr_node = 0;
  // 初始的内容让空白节点的前后都指着自己
  tsklst->dummy.prv = tsklst->dummy.nxt = &(tsklst->dummy);
}

void prepend_tnode(TSKLST *bd, task_t *tsk){
  if(bd->nr_node == 0){
    bd->dummy.nxt = bd->dummy.prv = tsk;
    tsk->nxt = tsk->prv = &bd->dummy;
    bd->nr_node++;
    return ;
  }

  task_t *u = tsk;
  task_t *w = bd->dummy.nxt;
  u->prv = w->prv;
  u->nxt = w;
  u->nxt->prv = u;
  u->prv->nxt = u;

  bd->nr_node++;
}

void remove_tnode(TSKLST *bd, task_t *bitmap){
  task_t *w = bitmap;
  w->prv->nxt = w->nxt;
  w->nxt->prv = w->prv;
  bd->nr_node--;
  panic_on(bd->nr_node < 0, "Linked list count is lower than 0!");
}

void __attribute__((unused)) inspect_tnode(TSKLST *bd){
  task_t *start = &bd->dummy;
  // Log("%p\n", start);
  int count = 0;
  start = start->nxt;
  while(start != &bd->dummy){
    panic_on(start->prv->nxt != start, "Did not maintain the llist well.");
    printf("[%s]->", start->name);
    count++;
    start = start->nxt;
  }
  printf("NIL\n");
  panic_on(count != bd->nr_node, "Did not maintain size well.");
}

mylist.push_back(30);
mylist.push_front(5);
for (const auto& elem : mylist) {
    std::cout << elem << " ";
}
std::cout << std::endl;

void hanoi(int n, char from, char to, char via) {
  if (n == 1) printf("%c -> %c\n", from, to);
  else {
    hanoi(n - 1, from, via, to);
    hanoi(1,     from, to,  via);
    hanoi(n - 1, via,  to,  from);
  }
  return;
}

mystack.push(10);
mystack.top();
mystack.pop();
while (!mystack.empty()) {
    std::cout << mystack.top() << " ";
    mystack.pop();
}

    int data[NR_DAT];
    int front, rear;
    bool init(){
        front = rear = 0;
        return 1;
    } 

    int size(){
        return (rear - front + NR_DAT) % NR_DAT;
    }
    bool isempty(){
        return (size() == 0);
    }

    bool push(int e){
        if((rear+1)%NR_DAT==front) return false; // full!
        data[rear] = e;
        rear = (rear+1)%NR_DAT;
        return true;
    }
    bool pop(int &e){ 
        //       ^ Using reference will make the argument change
        // equivalent to int *eptr
        if(front == rear) return false;
        e = data[front];
        // *etpr = data[front];
        front = (front + 1)%NR_DAT;
        return true;
    }

myqueue.push(10);
myqueue.front();
myqueue.back();
myqueue.pop();;

mydeque.push_back(10);
mydeque.push_front(5);
for (const auto& elem : mydeque) {
    std::cout << elem << " ";
}
mydeque.pop_back();
mydeque.pop_front();