chenshuo

#include <algorithm>
#include <atomic>
#include <thread>
#include <vector>

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/time.h>

chenshuo

#include <algorithm>
#include <map>
#include <string>
#include <vector>
#include <ext/numeric>
#include <assert.h>
#include <stdint.h>

class UnsignedInt // copyable
{

chenshuo

#include <string>
#include <unordered_set>

#include <boost/intrusive_ptr.hpp>
#include <boost/noncopyable.hpp>

#include <gperftools/malloc_extension.h>

#include <assert.h>
#include <string.h>

chenshuo

#include <atomic>
#include <mutex>
#include <condition_variable>
#include <memory>
#include <queue>
#include <thread>
#include <unistd.h>

// Listing 4.5
template<typename T>

chenshuo

#include <boost/rational.hpp>
#include <iostream>
#include <vector>
#include <stdio.h>

using boost::rational;
using std::cout;
using std::vector;
typedef vector<rational<int>> Numbers;

chenshuo

#pragma once

#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include <type_traits>

typedef uint32_t khint_t;
typedef khint_t khiter_t;

chenshuo

#include <assert.h>
#include <fcntl.h>
#include <stdio.h>
#include <zlib.h>
#include <boost/noncopyable.hpp>
#include <deque>

// FIXME: re-implement this with disk buffer.
class Buffer : boost::noncopyable
{

chenshuo

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ThreadTest {

	enum Work {
		RUN, STOP
	}

	static class Worker implements Runnable {

chenshuo

#include "nontype.h"

const char tag[] = "abc";

int main()
{
}

chenshuo

#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <deque>

struct Node
{
  Node(char v) : val(v) {}

  bool isOperator() const