#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h> //~ O_RDWR, S_IRWXU etc.
#include <pthread.h>
#include <time.h>
#include <limits.h>
#include <signal.h>
 
void daemonize();
 
//~ thread functions
void *listen_ms(void *);
void *listen_kb(void *);
 
//~ time stamp, keeping the time
//~ when the last KB or Mouse event happened.
volatile time_t stamp;
 
//~ mutex keeping stamp consistent.
pthread_mutex_t stamp_mutex;
 
int
main()
{
    daemonize();
    //~ initialize the mutex, stamp
    pthread_mutex_init(&stamp_mutex, NULL);
    //time(&stamp);
    stamp = time(NULL);
 
    //~ create two threads monitoring the Mouse and Keyboard.
    pthread_t ms_tid, kb_tid;
    if(pthread_create(&ms_tid, NULL, listen_ms, NULL) != 0)
    {
        perror("pthread_create");
        exit(1);
    }
    if(pthread_create(&kb_tid, NULL, listen_kb, NULL) != 0)
    {
        perror("pthread_create");
        exit(1);
    }
 
    unsigned int interval = 60 * 30;
    while(1)
    {
        sleep(1);
        pthread_mutex_lock(&stamp_mutex);
        if( time(NULL) - stamp > interval )
        {
            /*printf("shutdown\n");*/
            /*fflush(stdin);*/
            system("init 0");
        }
        pthread_mutex_unlock(&stamp_mutex);
    }
    //~ join the threads, though it'll never be excuted.
    pthread_join(ms_tid, NULL);
    pthread_join(kb_tid, NULL);
 
    return 0;
}
 
void *
listen_ms(void * arg)
{
    int fd = open("/dev/input/mice", O_RDONLY);
    if(fd < 0)
    {
        perror("open mice");
        exit(1);
    }
    char buf[256];
    while( read(fd, buf, sizeof(buf)) > 0 )
    {
        /*printf("Moused Moved.\n");*/
        pthread_mutex_lock(&stamp_mutex);
        //time(&stamp);
        stamp = time(NULL);
        pthread_mutex_unlock(&stamp_mutex);
    }
    close(fd);
}
 
void *
listen_kb(void * arg)
{
    int fd = open("/dev/input/event3", O_RDONLY);
    if(fd < 0)
    {
        perror("open event3");
        exit(1);
    }
    char buf[256];
    while( read(fd, buf, sizeof(buf)) > 0 )
    {
        /*printf("Key Hit.\n");*/
        pthread_mutex_lock(&stamp_mutex);
        //time(&stamp);
        stamp = time(NULL);
        pthread_mutex_unlock(&stamp_mutex);
    }
    close(fd);
}
 
void
daemonize()
{
    if( fork() > 0)
        exit(0);
    setsid();
    close(0);
    close(1);
    close(2);
    int fd = open("/dev/null", O_RDWR);
    //int fd = open("log.txt", O_RDWR);
    dup2(fd, 1);
    dup2(fd, 2);
    chdir("/");
    umask(0);
    signal(SIGCHLD, SIG_IGN);
}

if( fork() > 0)
    exit(0);

int close_all_fd(void)
{
        struct rlimit lim;
        unsigned int i;
 
        if (getrlimit(RLIMIT_NOFILE, &lim) < 0)
                return -1;
        if (lim.rlim_cur == RLIM_INFINITY)
                lim.rlim_cur = 1024;
        for (i = 0; i < lim.rlim_cur; i ++) {
#ifdef MYPERF
                if (i == 1)
                        continue;
#endif
                if (close(i) < 0 && errno != EBADF)
                        return -1;
        }
        return 0;
}

void daemonize();
int
main()
{
    daemonize();
    //~ other operations here.
    return 0;
}
void
daemonize()
{
    if( fork() > 0)
        exit(0);
    setsid();
    close(0); //~ im so lazy a guy.
    close(1);
    close(2);
    //~ you can use I/O functions, but to/from the black hole...
    int fd = open("/dev/null", O_RDWR);
    dup2(fd, 1);
    dup2(fd, 2);
    chdir("/");
    umask(0);
    signal(SIGCHLD, SIG_IGN);
}

int n = 0;
int
main()
{
    while(!n)
        ;
    return 0;
}

int n = 0;
void *foo(void*);
int
main()
{
    pthread_t pth_id;
    pthread_create(&pth_id, NULL, foo, NULL);
    while(!n)
        ;
    pthread_join(pth_id, NULL);
    return 0;
}
 
void *foo(void* arg)
{
    printf("n: %d\n", n);
    sleep(5);
    ++n;
    printf("++n: %d\n", n);
    return NULL;
}

main:
    movl    n(%rip), %eax #从内存中取n值至寄存器eax
.L3:
    testl   %eax, %eax # 与测试eax
    je  .L3 # eax为0时跳转至标号L3处
    movl    $0, %eax
    ret

int
main(int argc, char **argv)
{
    const int N = 10;
    int a[N] = { 1, 2, 3 };
    return 0;
}

int
main(int argc, char **argv)
{
    const int N = 10;
    int a[N];
    return 0;
}

 
	.file	"main.c"
	.text
.globl main
	.type	main, @function
main:
	leal	4(%esp), %ecx
	andl	$-16, %esp
	pushl	-4(%ecx)
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%esi
	pushl	%ebx
	pushl	%ecx
	subl	$60, %esp
	movl	%ecx, %eax
	movl	4(%eax), %eax
	movl	%eax, -44(%ebp)
	movl	%gs:20, %eax
	movl	%eax, -28(%ebp)
[ ... ] # 此处略去n行
	movl	%ecx, %esp
	movl	-28(%ebp), %edx
	xorl	%gs:20, %edx
	je	.L3
	call	__stack_chk_fail
.L3:
	leal	-12(%ebp), %esp
	addl	$0, %esp
	popl	%ecx
	popl	%ebx
	popl	%esi
	popl	%ebp
	leal	-4(%ecx), %esp
	ret

	.file	"main.c"
	.text
.globl main
	.type	main, @function
main:
.LFB0:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	subl	$48, %esp
	movl	$10, -4(%ebp)
	movl	$0, %eax
	leave
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
	.section	.note.GNU-stack,"",@progbits

#include <stdio.h>
 
int foo(void)
{
    int i = 0;
    while(i++ < 20);
    return i;
}
int
main(int argc, char **argv)
{
    int i = foo();
    int j = i;
    int k = i;
    printf("%d, %d, %d\n", i, j, k);
    return 0;
}

$ gcc -S -O1 main.c # 优化等级1

[ ... ]
.LC0:
	.string	"%d, %d, %d\n"
[ ... ]
main:
[ ... ]
	call	foo # 调用函数foo，返回值保存至寄存器eax
	movl	%eax, 16(%esp) # 参数k入栈
	movl	%eax, 12(%esp) # 参数j入栈
	movl	%eax, 8(%esp) # 参数i入栈
	movl	$.LC0, 4(%esp) # 格式字符串地址入栈
	movl	$1, (%esp)
	call	__printf_chk
	movl	$0, %eax
	leave
	ret
[ ... ]

[ ... ]
main:
[ ... ]
	call	foo # 调用函数foo，返回值保存至寄存器eax
	movl	%eax, 44(%esp) # 为i赋值
	movl	44(%esp), %edx # 读取i值
	movl	44(%esp), %ecx # 读取i值
	movl	44(%esp), %eax # 读取i值
	movl	%ecx, 16(%esp) # 参数k入栈，使用i值
	movl	%edx, 12(%esp) # 参数j入栈，使用i值
	movl	%eax, 8(%esp) # 参数i入栈
	movl	$.LC0, 4(%esp) # 格式字符串地址入栈
	call	__printf_chk
	movl	$0, %eax
	leave
	ret
[ ... ]

const int N = 4;
char *str[N] = { "xyz", "cdef", "abcd", "caaa"};
 
int cmp(const void *l, const void *r)
{
    const char *a = *((char**)l);
    const char *b = *((char**)r);
    return strcmp(a, b);
}
int
main(int argc, char **argv)
{
    qsort( (void*)str, N, sizeof(int*), cmp );
    for(int i = 0; i < N; ++i)
    {
        printf("%s\n", str[i]);
    }
    return 0;
}

const int N = 4;
char str[N][10] = { "xyz", "cdef", "abcd", "caaa"};
 
int
main(int argc, char **argv)
{
    qsort( (void*)str, N,
            sizeof(char)*10,
            ( int(*)(const void*, const void*) )strcmp );
    for(int i = 0; i < N; ++i)
    {
        printf("%s\n", str[i]);
    }
    return 0;
}

#include "plus.h"
int
plus(int a, int b)
{
    return a + b;
}

#include "sub.h"
int
sub(int a, int b)
{
    return a - b;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "plus.h"
int
main(int argc, char **argv)
{
    int a = plus(1, 2);
    printf("%d\n", a);
    return 0;
}

$ cc -c plus.c sub.c
$ ar rc libmath.a plus.o sub.o
$ ranlib libmath.a

$ cc main.c -L. -lmath -o main
$ ./main
3

$ cc -c -fpic plus.c sub.c
$ cc -shared -o libmath.so *.o

$ cc main.c -L. -lmath -o main

$ LD_LIBRARY_PATH=$LD_LIBRARY_PATH:. # 添加当前目录
$ export LD_LIBRARY_PATH # 将环境变量导出，使其在子shell中可用
$ ./main
3

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dlfcn.h>
#include "plus.h"
int
main(int argc, char **argv)
{
    void * lib_handle = dlopen("./libmath.so", RTLD_LAZY);
    if(lib_handle)
    {
        int (*plus_ptr)(int, int) = dlsym(lib_handle, "plus");
        if(plus_ptr)
        {
            int a = plus_ptr(1, 2);
            printf("%d\n", a);
        }
        dlclose(lib_handle);
    }
    return 0;
}

$ cc main.c -ldl -o main
$ ./main
3

struct structName {
    int n;
};
//~ typedef struct structName structName;
int
main()
{
    struct structName n;
    return 0;
}

struct structName {
    int n;
};
void structName() {
    ;
}
int
main()
{
    structName n;
    return 0;
}

const int MAXINT = 0xFFFF; //~ 不可达的路径长度上限
struct Node
{
    Node(): w(MAXINT){}
    int src, //~ 最短路径上的上一个顶点
        w; //~ 到该节点的路径长度
};
struct Edge
{
    Edge(){}
    Edge(int f, int t): from(f), to(t){}
    int from,
        to;
};
int
main(int argc, char **argv)
{
    vector<vector<int> > Adj;
    int n, // 顶点数
        m, //~ 边数
        from,
        to,
        w,
        start; //~ 源点
    cin>>n;
    vector<Node> Dist(n);
    for(int i = 0; i < n; ++i)
    {
        Adj.push_back(vector<int>(n, MAXINT));
        Adj[i][i] = 0;
    }
    cin>>m;
    vector<Edge> Edges;
    for(int i = 0; i < m; ++i)
    {
        cin>>from>>to>>w;
        Adj[from][to] = w;
        Edges.push_back(Edge(from, to));
    }
    cin>>start; //~ 从顶点start开始的最短路径
    Dist[start].w = 0; //~
    bool flag = true;
    for( int i = 0; i < n - 1; ++i)
    {
        for(int j = 0; j < Edges.size(); ++j)
        {
            from = Edges[j].from;
            to = Edges[j].to;
            if(Dist[from].w == MAXINT || Adj[from][to] == MAXINT)
                continue;
            if(Dist[from].w + Adj[from][to] < Dist[to].w)
            {
                Dist[to].w = Dist[from].w + Adj[from][to];
                Dist[to].src = from;
                flag = false;
            }
        }
        if(flag == true)
            break;
        else
            flag = true;
    }
    //~ 检测有无负环路
    for(int j = 0; j < Edges.size(); ++j)
    {
        from = Edges[j].from;
        to = Edges[j].to;
        if(Dist[from].w == MAXINT || Adj[from][to] == MAXINT)
            continue;
        if(Dist[from].w + Adj[from][to] < Dist[to].w)
        {
            cout<<"Negative Length Cycle Detected!"<<endl;
            return 1;
        }
    }
    //~ 下面代码供测试用
    while(cin>>to)
    {
        int rp = to;
        cout<<Dist[to].w<<" ";
        while(rp != start) //~ 反向输出路径
        {
            cout<<rp<<" <- ";
            if(Dist[to].w == MAXINT) break;
            rp = Dist[rp].src;
        }
        cout<<start<<endl;
    }
    return 0;
}

int foo(int n)
{
	return n;
}
void bar(int n)
{
	return ;
}
struct wrap_int
{
	wrap_int(int _n): n(n) {}
	operator int() { return n; }
	operator int()const { return n; }
	wrap_int operator ++() { return ++n; }
	int n;
};
wrap_int foo(wrap_int n)
{
	return n;
}
int main()
{
	bar(++foo(372)); //~ 此行报错
	bar(++foo(wrap_int(372))); //~ 无错
	return 0;
}

int
main()
{
    vector<int> vec;
    vec.push_back(5);
    vec.push_back(4);
    vec.push_back(3);
    vec.push_back(2);
    vec.push_back(1);
    sort(++vec.begin(), vec.end());
    deque<int> deq;
    deq.push_back(5);
    deq.push_back(4);
    deq.push_back(3);
    deq.push_back(2);
    deq.push_back(1);
    sort(++deq.begin(), deq.end());
    return 0;
}

std::vector<int> ivec;
//~ or
using std::vector;
vector<int> ivec;
//~ or
using namespace std;
vector<int> ivec;

#include <iostream>
#include <string>
using namespace std;
bool operator<(const string& l, const string& r)
{
    return l > r; //~ 逆天而行了 :-)
}
int
main(int argc, char **argv)
{
    cout<<string("dutor")<string("ivan")<<endl;
    return 0;
}

#include <iostream>
#include <string>
#include <set>
using namespace std;
bool operator<(const string& l, const string& r)
{
    return l > r;
}
int
main(int argc, char **argv)
{
    set<string> Set;
    Set.insert("ivan");
    Set.insert("dutor");
    for(set<string>::iterator it = Set.begin();
            it != Set.end(); ++it)
    {
        cout<<*it<<endl;
    }
    return 0;
}

namespace std{
    bool operator<(const string& l, const string& r)
    {
        return l > r;
    }
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
 
struct Edge 
{
	int from, to, w; //~ 不要被假象迷惑，这里是无向图
	Edge(int f, int t, int _w): from(f), to(t), w(_w){}
	/*
	//~ bool operator <(const Edge& e){ return w < e.w; }
	bool operator >(const Edge& e){ return w > e.w; }
	*/
};
//~ 为什么我把operator<重载为成员会出错？
//~ bool operator <(const Edge& e1, const Edge& e2){ return e1.w < e2.w; }
bool operator >(const Edge& e1, const Edge& e2){ return e1.w > e2.w; } 
bool AddEdge(vector<int> & V, const Edge& e);
int main(int argc, char* argv[])
{
	vector<Edge> E;
	int from, to, w;
	int n; //~ 顶点数
	cin>>n;
	vector<int> V(n+1, -1); //~ 顶点并查集
	while (cin>>from>>to>>w) E.push_back(Edge(from, to, w));
 
	make_heap(E.begin(), E.end(), greater<Edge>());
	int count = 0; //~ 已添加边数
	while (E.size())
	{
		Edge e = E[0];
		if(AddEdge(V, e)) //~ 将成功添加的边输出
		{
			count++;
			if(count == n - 1) break; //~ 树已生成完毕
			cout<<e.from<<"->"<<e.to<<": "<<e.w<<endl;
		}
		pop_heap(E.begin(), E.end(),greater<Edge>());
		E.pop_back();
	}
	if (count != n - 1) cout<<"I cannot do what you want."<<endl;
	return 0;
}
 
bool AddEdge(vector<int> & V, const Edge& e)
{
	int i = e.from;
	for (; V[i] > 0;) i = V[i]; //~ 寻找根节点
	int j = e.to;
	for (; V[j] > 0;) j = V[j]; //~ 寻找根节点
	if (i == j)	return false; //~ i,j两节点已经联通
	if (V[i] > V[j]) //~ 将小集合合并至大集合上
		V[i] = j;
	else
		V[j] = i;
	return true; //~ ^_^
}

#include <iostream>
#include <set>
#include <algorithm>
using namespace std;
class cmp
{
public:
	bool operator()(long long l, long long r)
	{
		//~ 此间内容可略去不看。
		//~ 如果l和r含有的digits完全相同则返回false,
		//~ 如125 vs. 512
		char tmp1[1024], tmp2[1024];
		sprintf(tmp1,"%ld",l);
		sprintf(tmp2,"%ld",r);
		sort(tmp1, tmp1+strlen(tmp1));
		sort(tmp2, tmp2+strlen(tmp2));
		if (!strcmp(tmp1, tmp2))
		{
			return false;
		}
		return true;
	}
};
int main(int argc, char* argv[])
{
	set<long long,cmp > Set;
	int a[15];
	Set.insert(1);
	Set.insert(2); //~ 此处疯狂
	return 0;
}

template<class _Pr, class _Ty1, class _Ty2> inline
    bool __CLRCALL_OR_CDECL _Debug_lt_pred(_Pr _Pred, _Ty1& _Left, _Ty2& _Right,
        const wchar_t *_Where, unsigned int _Line)
    {    // test if _Pred(_Left, _Right)  and _Pred is strict weak ordering
    if (!_Pred (_Left, _Right))
        return (false);
    else if (_Pred(_Right, _Left))
        _DEBUG_ERROR2("invalid operator<", _Where, _Line);
    return (true);
    }

class cmp
{
public:
	bool operator()(long long l, long long r)
	{
		//~ ……
		if (!strcmp(tmp1, tmp2))
		{
			return false;
		}
                else
		        return l < r;
	}
};

int (a);

int (a) = 0;

int a = 0;

int G = 0xFF;
class Mary
{
public:
    Mary()
    {
        Mary(G);
    }
    Mary(int n){ /*Constructing... */}
};
int
main(int argc, char **argv)
{
    Mary M;
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
int
main (int argc, char **argv)
{
    const int N = 1;
    //~const int N = 4096;
    char buf[N];
    int fdin = open("51.tar.gz", O_RDONLY);
    int fdout = open("51.tar.gz.bak", O_WRONLY|O_CREAT|O_TRUNC, S_IRWXU);
    if (fdout == -1 || fdin == -1)
    {
        fprintf(stderr, "open failure\n");
        exit(1);
    }
    int count;
    while (count = read(fdin, buf, sizeof(buf)))
    {
        write(fdout, buf, count);
    }
    close(fdout);
    close(fdin);
    return 0;
}

int
main (int argc, char **argv)
{
    int c; //~ fgetc()返回int
    FILE* fdin = fopen("51.tar.gz", "r");
    FILE* fdout = fopen("51.tar.gz.bak", "w");
    if (!fdout || !fdin)
    {
        fprintf(stderr, "open failure\n");
        exit(1);
    }
    while ((c = fgetc(fdin)) != EOF)
    {
        fputc(c, fdout);
    }
    fclose(fdout);
    fclose(fdin);
    return 0;
}

    while ((c = fgetc(fdin)) != EOF)
    {
        fputc(c, fdout);
    }

#include <stdio.h>
int
main()
{
    int a[] = {1, 2, 3, 4, 5};
    int *ptr1 = (int*) (&a + 1) - 1;
    int *ptr2 = (int*) ((int)a + 1);
    printf("%x, %x\n", *ptr1, *ptr2);
    return 0;
}

#include <iostream>
using namespace std;
class Base
{
public:
    static void foo() { cout<<"Base"<<endl; }
    virtual void bar() { foo(); }
};
class Derived: public Base
{
public:
    static void foo() { cout<<"Derived"<<endl; }
    virtual void bar() { foo(); }
};
int main
{
    Base * p = new Derived;
    p->bar();
    delete p;
    return 0;
}

#include <iostream>
class Test
{
public:
    void print() const
    {
        std::cout<<_int<<std::endl;
    }
private:
    static int _int;
};
int Test::_int = 0;
int
main(int argc, char **argv)
{
    Test TArray[10];
    TArray[100].print();
    return 0;
}