chenshuo

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

class UnsignedInt // copyable
{

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 <boost/noncopyable.hpp>
#include <pthread.h>
#include <stdlib.h>

// a superfluous check for pedantic people
inline void CHECK_SUCCESS(int ret)
{
  if (ret != 0)
  {
    abort();

chenshuo

#include <event2/listener.h>
#include <event2/bufferevent.h>
#include <event2/buffer.h>

#include <arpa/inet.h>
#include <netinet/tcp.h>

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

chenshuo

#include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

bool covered(const vector<string>& filters, const string& line)
{

chenshuo

#include <muduo/base/Mutex.h>
#include <muduo/base/Thread.h>
#include <boost/shared_ptr.hpp>
#include <stdio.h>

boost::shared_ptr<int> g;
muduo::MutexLock mutex;

void read_g()
{

chenshuo

#include <set>

#include <stdio.h>
#include <sys/time.h>

double now()
{
  struct timeval tv;
  gettimeofday(&tv, NULL);
  return tv.tv_sec + tv.tv_usec / 1000000.0;

chenshuo

#include <algorithm>
#include <iostream>
#include <unordered_map>
#include <vector>

typedef std::unordered_map<std::string, int> WordCount;

struct Greater
{
  bool operator()(const std::pair<int, WordCount::iterator>& lhs,

chenshuo

#include <assert.h>
#include <memory.h>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <string>

using namespace std;

struct Node;

chenshuo

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;

import JaCoP.constraints.Alldifferent;
import JaCoP.constraints.Distance;
import JaCoP.constraints.XeqC;
import JaCoP.constraints.XeqY;
import JaCoP.constraints.XplusCeqZ;
import JaCoP.core.Domain;