axcel.cpp

Go to the documentation of this file.

#include "axcel.h"

namespace axcel {

/*
string net::dns::addrs(const char* lookup) {
#ifdef _WIN32
        WSADATA wd;
        WSAStartup(MAKEWORD(2, 0), &wd);
#endif
        string s;
        char buf[48];
        struct addrinfo *ai, *ent;
        if (getaddrinfo(lookup, 0, 0, &ai))
                return s;
        for (ent = ai; ent; ent = ent->ai_next) {
                if (ent->ai_family == AF_INET)
                        s += inet_ntop(AF_INET, &((struct sockaddr_in*)ent->ai_addr)->sin_addr, buf, 48);
                else if (ent->ai_family == AF_INET6)
                        s += inet_ntop(AF_INET6, &((struct sockaddr_in6*)ent->ai_addr)->sin6_addr, buf, 48);
                s += "\n";
        }
        freeaddrinfo(ai);
#ifdef _WIN32
        WSACleanup();
#endif
        return s;
}*/
string io::ios::type() { return string("io::ios"); }
io::ios::operator string () { return string(); }
io::ios& io::ios::operator<< (object& o) { this->output::operator<<(o); return *this; }
io::ios& io::ios::operator<< (bool val) { this->output::operator<<(val); return *this; }
io::ios& io::ios::operator<< (short val) { this->output::operator<<(val); return *this; }
io::ios& io::ios::operator<< (unsigned short val) { this->output::operator<<(val); return *this; }
io::ios& io::ios::operator<< (int val) { this->output::operator<<(val); return *this; }
io::ios& io::ios::operator<< (unsigned int val) { this->output::operator<<(val); return *this; }
io::ios& io::ios::operator<< (long val) { this->output::operator<<(val); return *this; }
io::ios& io::ios::operator<< (unsigned long val) { this->output::operator<<(val); return *this; }
io::ios& io::ios::operator<< (float val) { this->output::operator<<(val); return *this; }
io::ios& io::ios::operator<< (double val) { this->output::operator<<(val); return *this; }
io::ios& io::ios::operator<< (long double val) { this->output::operator<<(val); return *this; }
io::ios& io::ios::operator<< (const void* val) { this->output::operator<<(val); return *this; }
io::ios& io::ios::operator<< (char c) { this->output::operator<<(c); return *this; }
io::ios& io::ios::operator<< (signed char c) { this->output::operator<<(c); return *this; }
io::ios& io::ios::operator<< (unsigned char c) { this->output::operator<<(c); return *this; }
io::ios& io::ios::operator<< (const char* s) { this->output::operator<<(s); return *this; }
io::ios& io::ios::operator<< (string s) { this->output::operator<<(s); return *this; }
io::ios& io::ios::put(object& o) { this->output::put(o); return *this; }
io::ios& io::ios::put(string s) { this->output::put(s); return *this; }
io::ios& io::ios::echo(object& o) { this->output::echo(o); return *this; }
io::ios& io::ios::echo(string s) { this->output::echo(s); return *this; }
io::ios& io::ios::put(bool val) { this->output::put(val); return *this; }
io::ios& io::ios::put(short val) { this->output::put(val); return *this; }
io::ios& io::ios::put(unsigned short val) { this->output::put(val); return *this; }
io::ios& io::ios::put(int val) { this->output::put(val); return *this; }
io::ios& io::ios::put(long val) { this->output::put(val); return *this; }
io::ios& io::ios::put(unsigned long val) { this->output::put(val); return *this; }
io::ios& io::ios::put(float val) { this->output::put(val); return *this; }
io::ios& io::ios::put(double val) { this->output::put(val); return *this; }
io::ios& io::ios::put(long double val) { this->output::put(val); return *this; }
io::ios& io::ios::put(const void* val) { this->output::put(val); return *this; }
io::ios& io::ios::put(char c) { this->output::put(c); return *this; }
io::ios& io::ios::put(signed char c) { this->output::put(c); return *this; }
io::ios& io::ios::put(unsigned char c) { this->output::put(c); return *this; }
io::ios& io::ios::put(const char* s) { this->output::put(s); return *this; }
io::ios& io::ios::echo() { this->output::echo(); return *this; }
io::ios& io::ios::echo(bool val) { this->output::echo(val); return *this; }
io::ios& io::ios::echo(short val) { this->output::echo(val); return *this; }
io::ios& io::ios::echo(unsigned short val) { this->output::echo(val); return *this; }
io::ios& io::ios::echo(int val) { this->output::echo(val); return *this; }
io::ios& io::ios::echo(size_t val) { this->output::echo(val); return *this; }
io::ios& io::ios::echo(long val) { this->output::echo(val); return *this; }
io::ios& io::ios::echo(unsigned long val) { this->output::echo(val); return *this; }
io::ios& io::ios::echo(float val) { this->output::echo(val); return *this; }
io::ios& io::ios::echo(double val) { this->output::echo(val); return *this; }
io::ios& io::ios::echo(long double val) { this->output::echo(val); return *this; }
io::ios& io::ios::echo(const void* val) { this->output::echo(val); return *this; }
io::ios& io::ios::echo(char c) { this->output::echo(c); return *this; }
io::ios& io::ios::echo(signed char c) { this->output::echo(c); return *this; }
io::ios& io::ios::echo(unsigned char c) { this->output::echo(c); return *this; }
io::ios& io::ios::echo(const char* s) { this->output::echo(s); return *this; }
io::ios& io::ios::operator>> (bool& val) { this->input::operator>>(val); return *this; }
io::ios& io::ios::operator>> (short& val) { this->input::operator>>(val); return *this; }
io::ios& io::ios::operator>> (unsigned short& val) { this->input::operator>>(val); return *this; }
io::ios& io::ios::operator>> (int& val) { this->input::operator>>(val); return *this; }
io::ios& io::ios::operator>> (unsigned int& val) { this->input::operator>>(val); return *this; }
io::ios& io::ios::operator>> (long& val) { this->input::operator>>(val); return *this; }
io::ios& io::ios::operator>> (unsigned long& val) { this->input::operator>>(val); return *this; }
io::ios& io::ios::operator>> (long long& val) { this->input::operator>>(val); return *this; }
io::ios& io::ios::operator>> (unsigned long long& val) { this->input::operator>>(val); return *this; }
io::ios& io::ios::operator>> (float& val) { this->input::operator>>(val); return *this; }
io::ios& io::ios::operator>> (double& val) { this->input::operator>>(val); return *this; }
io::ios& io::ios::operator>> (long double& val) { this->input::operator>>(val); return *this; }
io::ios& io::ios::operator>> (void*& val) { this->input::operator>>(val); return *this; }
io::ios& io::ios::operator>> (char& c) { this->input::operator>>(c); return *this; }
io::ios& io::ios::operator>> (char* s) { this->input::operator>>(s); return *this; }
io::ios& io::ios::operator>> (string& s) { this->input::operator>>(s); return *this; }

struct errno_str errno_strs[] = {
        {0, "unknown error"},
        {EPERM, "operation not permitted"},
        {ENOENT, "no such file or directory"},
        {ESRCH, "no such process"},
        {EINTR, "interrupted function call"},
        {EIO, "input/output error"},
        {ENXIO, "no such device or address"},
        {E2BIG, "argument list too long"},
        {ENOEXEC, "exec format error"},
        {EBADF, "bad file descriptor"},
        {ECHILD, "no child process"},
        {EAGAIN, "resource temporarily unavailable"},
        {ENOMEM, "not enough space"},
        {EACCES, "permission denied"},
        {EFAULT, "bad address"},
        {EBUSY, "device or resource busy"},
        {EEXIST, "file exists"},
        {EXDEV, "improper link"},
        {ENODEV, "no such device"},
        {ENOTDIR, "not a directory"},
        {EISDIR, "is a directory"},
        {ENFILE, "too many open files in system"},
        {EMFILE, "too many open files"},
        {ENOTTY, "inappropriate i/o control operation"},
        {EFBIG, "file too large"},
        {ENOSPC, "no space left on device"},
        {ESPIPE, "invalid seek"},
        {EROFS, "read-only file system"},
        {EMLINK, "too many links"},
        {EPIPE, "broken pipe"},
        {EDOM, "mathematics argument out of domain of function"},
        {EDEADLK, "resource deadlock avoided"},
        {ENAMETOOLONG, "filename too long"},
        {ENOLCK, "no locks available"},
        {ENOSYS, "function not implemented"},
        {ENOTEMPTY, "directory not empty"},
        {EINVAL, "invalid argument"},
        {ERANGE, "result too large"},
        {EILSEQ, "illegal byte sequence"},
        {EADDRINUSE, "address already in use"},
        {EADDRNOTAVAIL, "address not available"},
        {EAFNOSUPPORT, "address family not supported"},
        {EALREADY, "connection already in progress"},
        {EBADMSG, "bad message"},
        {ECANCELED, "operation canceled"},
        {ECONNABORTED, "connection aborted"},
        {ECONNREFUSED, "connection refused"},
        {ECONNRESET, "connection reset"},
        {EDESTADDRREQ, "destination address required"},
        {EHOSTUNREACH, "host is unreachable"},
        {EIDRM, "identifier removed"},
        {EINPROGRESS, "operation in progress"},
        {EISCONN, "socket is connected"},
        {ELOOP, "too many levels of symbolic links"},
        {EMSGSIZE, "message too long"},
        {ENETDOWN, "network is down"},
        {ENETRESET, "connection aborted by network"},
        {ENETUNREACH, "network unreachable"},
        {ENOBUFS, "no buffer space available"},
        {ENODATA, "no message is available"},
        {ENOLINK, "link has been severed"},
        {ENOMSG, "no message of the desired type"},
        {ENOPROTOOPT, "protocol not available"},
        {ENOSR, "no stream resources"},
        {ENOSTR, "not a stream"},
        {ENOTCONN, "the socket is not connected"},
        {ENOTRECOVERABLE, "state not recoverable"},
        {ENOTSOCK, "not a socket"},
        {ENOTSUP, "operation not supported"},
        {EOVERFLOW, "value too large too be stored in datatype"},
        {EOWNERDEAD, "owner died"},
        {EPROTO, "protocol error"},
        {EPROTONOSUPPORT, "protocol not supported"},
        {EPROTOTYPE, "protocol wrong type for socket"},
        {ETIME, "timer expired"},
        {ETIMEDOUT, "connection timed out"},
        {ETXTBSY, "text file busy"},
        {0, 0}
};

exception::exception() { no = 0; }
exception::exception(int number) { no = number; }
exception::exception(const exception& e) { no = e.no; desc = e.desc; }
exception::exception(const char* msg) { this->operator=(msg); }
string exception::type() { return string("exception"); }
exception& exception::operator= (int number) { no = number; return *this; }
exception& exception::operator= (const exception e) { no = e.no; desc = e.desc; return *this; }
exception& exception::operator= (const char* msg) {
        register int i;
        for (i = 0; errno_strs[i].str; i++)
                if (!strcmp(errno_strs[i].str, msg)) { no = errno_strs[i].no; return *this; }
        no = 0;
        return *this;
}
exception::operator string() {
        register int i;
        for (i = 0; errno_strs[i].str; i++)
                if (no == errno_strs[i].no) return string(errno_strs[i].str);
        return string("unknown error");
}
exception object::error() { return exception(errnum); }
bool exception::operator== (exception e) { return no == e.no; }
bool exception::operator== (const char* s) { return this->operator string() == s; }
bool exception::operator== (int num) { return no == num; }
bool exception::operator!= (exception e) { return no != e.no; }
bool exception::operator!= (const char* s) { return this->operator string() != s; }
bool exception::operator!= (int num) { return no != num; }

char* strcpy2(char* s1, const char* s2) {
        if (s2 == NULL) return s1;
        return strcpy(s1, s2);
}

char* strncpy2(char* s1, const char* s2, size_t n) {
        if (s2 == NULL) return s1;
        return strncpy(s1, s2, n);
}

data console::dump() {
        data d;
        char c;
        do { c = this->getche(); d << c; } while (c);
        //while (this->kbhit()) d << this->getche();
        return d;
}

string fs::tmpnam() {
        string s;
        s.realloc(256);
	::tmpnam(s.buf);
        return s;
}

data& data::operator= (const char* s) {
        if (buf) free(buf);
        rewind();
        realloc(strlen(s) + 1);
        strcpy(buf, s);
        return *this;
}
data& data::operator= (object& o) {
        if (buf) free(buf);
        rewind();
        realloc(((string)o).len() + 1);
        string q = (string)o;
        strcpy(buf, q.buf);
        return *this;
}

//object::operator const char* () { static string cstrbuf = this->operator string (); return cstrbuf.buf; }
string io::iofmt::type() { return string("io::iofmt"); }
string io::iob::type() { return string("io::iob"); }
string io::input::type() { return string("io::input"); }
string io::output::type() { return string("io::output"); }
string fs::file::type() { return string("fs::file"); }
string net::socket::tcp::type() { return string("net::socket::tcp"); }
string string::type() { return string("string"); }
string console::type() { return string("console"); }
string timer::type() { return string("timer"); }
string proc::thread::type() { return string("proc::thread"); }
string proc::library::type() { return string("proc::library"); }
string net::irc::msg::type() { return string("net::irc::msg"); }
string proc::mutex::type() { return string("proc::mutex"); }
string proc::semaphore::type() { return string("proc::semaphore"); }
net::irc::msg::operator string () { return buf; }

io::iofmt::operator string () {
        string s;
        s.printf("%d", width);
        return s;
}
io::iob::operator string () {
        string s;
        if (ok()) s = "ok";
        else if (hurt()) s = "hurt";
        else if (dead()) s = "dead";
        else if (eof()) s = "eof";
        return s;
}

fs::file::operator string () { return filename; }
net::socket::tcp::operator string () { return ip(); }
string::operator string () { return *this; }
console::operator string () { string s; s.printf("io::input: %d io::output: %d", ::fileno(in), ::fileno(out)); return s; }
timer::operator string () { return str(); }
proc::thread::operator string () { string s; s.printf("%ld", tid); return s; }
proc::library::operator string () { return libraryname; }
proc::mutex::operator string () { string s; s.printf("%ld", id); return s; }
proc::semaphore::operator string () { string s; s.printf("%ld", id); return s; }

io::output& io::output::operator<< (object& o) { this->operator<< (((string)o).buf); return *this; }

io::output& io::output::put(object& o) { return this->operator<<(((string)o).buf); }

io::output& io::output::echo(object& o) { this->operator<<(((string)o).buf); this->operator<<('\n'); return *this; }
//io::output& io::output::operator<< (string s) { this->operator<< (s.buf); return *this; }
io::output& io::output::put(string s) { return this->operator<<(s.buf); }
io::output& io::output::echo(string s) { this->operator<<(s.buf); this->operator<<('\n'); return *this; }

io::iofmt::iofmt() {
        lfmt = 0;
        dec(1);
        ltrim(1);
        width = 0;
        precis = 0;
        ltrim(1);
}

bool io::iofmt::gsbit(int i, long j) {
        if (i == -1) return lfmt & j;
        else if (i) lfmt |= j;
        else lfmt &= ~j;
        return i;
}

//bool io::iofmt::num(int i) { return gsbit(i, 1); }


bool io::iofmt::bin(int i) { return gsbit(i, 1); }
 
bool io::iofmt::btoa(int i) { return gsbit(i, 1 << 1); }

bool io::iofmt::base(int i) { return gsbit(i, 1 << 2); }

bool io::iofmt::zpad(int i) { return gsbit(i, 1 << 3); }

bool io::iofmt::sign(int i) { return gsbit(i, 1 << 4); }

bool io::iofmt::deaf(int i) { return gsbit(i, 1 << 5); }

bool io::iofmt::dec(int i) { if (i == 1) { lfmt &= ~(1 << 7); lfmt &= ~(1 << 8); }return gsbit(i, 1 << 6); }

bool io::iofmt::hex(int i) { if (i == 1) { lfmt &= ~(1 << 6); lfmt &= ~(1 << 8); } return gsbit(i, 1 << 7); }

bool io::iofmt::oct(int i) { if (i == 1) { lfmt &= ~(1 << 6); lfmt &= ~(1 << 7); } return gsbit(i, 1 << 8); }

bool io::iofmt::ltrim(int i) { return gsbit(i, 1 << 9); }

bool io::iofmt::endnl(int i) { return gsbit(i, 1 << 10); }

bool io::iofmt::left(int i) { return gsbit(i, 1 << 11); }

bool io::iofmt::right(int i) { return left(0); }

bool io::iofmt::fix(int i) { if (i == 1) lfmt &= ~(1 << 13); return gsbit(i, 1 << 12); }

bool io::iofmt::sci(int i) { if (i == 1) lfmt &= ~(1 << 12); return gsbit(i, 1 << 13); }

bool io::iob::ok() { return istat & 1; }

bool io::iob::hurt() { return istat & (1 << 1); }

bool io::iob::dead() { return istat & (1 << 2); }

bool io::iob::eof() { return istat & (1 << 3); }

void io::iob::heal() {  istat = 1; }

void io::iob::hit() { istat = 1 << 1; }

void io::iob::kill() { istat = 1 << 2; }

void io::iob::drain() { istat = 1 << 3; }

char* io::input::gets(char* s, int size) {
        register int c;
        for (c = getc(); size ? size > 0 : 1; c = getc(), s++) {
                switch (c) {
                case EOF: *s = 0; s = NULL; break;
                case '\n': *s = '\n'; *(++s) = 0; return s;
                default: *s = c;
                }
                if (size) size--;
        }
        if (s) *s = 0;
        return s;
}

/*Charp io::input::gets(int size) {
        Charp s;
        int i = 32, j = 0;
        register int c;
        s.ptr = (char*)malloc(i);
        s.free = true;
        for (c = getc(); ; c = getc(), j++) {
                if (size) if (j >= size) break;
                if (j >= i - 4) { i *= 2; s.ptr = (char*)realloc(s, i); }
                switch (c) {
                case EOF: s.ptr[0] = 0; return s;
                case '\n': s.ptr[j] = '\n'; s.ptr[++j] = 0; return s;
                default: s.ptr[j] = c;
                }
        }
        s.ptr[j] = 0;
        return s;
}*/

size_t io::input::read(char* ptr, size_t size, size_t nmemb) {
        register int c;
        size_t i, j;
        for (i = 0; i < nmemb; i++)
                for (j = 0; j < size; j++) {
                        c = getc();
                        if (!ok()) return i;
                        else ptr[size * i + j] = c;
                }
        return i;
}

int io::input::scanf(const char* format, ...) {
        int \
                matched = 0,            //Number of matched tokens
                mods,                                   //Conversion modifier flags
                base;                           //for numeric base
        size_t i;                               //a loopy thing
        size_t width;                   //field width
        register int last;      //Char accumulator
        bool \
        sign,                                           //signed or unsigned flag
        ate = false;                    //leftover character input from last token?
        const char* cp;
        std::deque<unsigned char> b;    //THE BUFFER
        char* tomato;
        va_list v;                              //...
        //modifier flags
        enum {
                unclog = 1,                     //Flush stream after reading?
                discard = 1 << 1,       //Discard input
                mb = 1 << 2,            //byte
                mh = 1 << 3,            //half
                mw = 1 << 4,            //word
                ml = 1 << 5,            //long
                addws = 1 << 6, //do not discard leading whitespace?
                dienl = 1 << 7          //End input on newline?
        };
        //flush an existing tied stream
        //if (knot) knot->flush();
        va_start(v, format);
        //Loop through format string
        for (; *format; format++) {
                mods = 0;
                width = 0;
                b.clear();
                if (*format == '%') {
                        format++;
                        for (; !isdigit(*format) && !isalpha(*format); format++) {
                                switch (*format) {
                                case '*': mods |= discard; break;
                                case '^': mods |= addws; break;
                                case '$': mods |= dienl; break;
                                case '%':
                                        if (!ate) if ((last = getc()) == EOF) goto in_scanf_end;
                                        if (last != '%') { hit(); goto in_scanf_end; }
                                        ate = false;
                                        continue;
                                }
                        }
                        if (isdigit(*format)) width = stoi<int>(format, 10);
                        while (isdigit(*format)) format++;
                        if (strpbrk(format, "bhwl") == format) {
                                switch (format[0]) {
                                case 'b': mods |= mb; break;
                                case 'h': mods |= mh; break;
                                case 'w': mods |= mw; break;
                                case 'l': mods |= ml; break;
                                }
                                format++;
                        }
                        if (strpbrk(format, "DOXIdoxi") == format) {                    
                                if (!ate) if ((last = getc()) == EOF) goto in_scanf_end;
                                if (!(mods & addws))
                                        for (; isspace(last); )
                                                if ((last = getc()) == EOF) goto in_scanf_end;
                                if (last == EOF) goto in_scanf_end;
                                else b.push_back(last);
                                if ((last == '+' || last == '-'))
                                        if (isupper(*format)) {
                                                hurt(); goto in_scanf_end;
                                        } else if ((last = getc()) == EOF)  { goto in_scanf_end;
                                        } else { b.push_back(last); }
                                        
                                if (last == '0') {;
                                        if ((last = getc()) == EOF) goto in_scanf_end;
                                        else b.push_back(last);
                                        if ((last = 'x' || last == 'X') && (strpbrk(format, "XxIi") != format)) {
                                                hit(); goto in_scanf_end;
                                        } else if (strpbrk(format, "OoIi") != format) {
                                                hit(); goto in_scanf_end;
                                        }
                                }
                                for (;;) {
                                        if ((last = getc()) == EOF) break;
                                        if (!(mods & dienl))
                                                if (!(islower(*format) == 'x' ? isxdigit(last) : isdigit(last)))
                                                        break;
                                        if (last == '\n') break;
                                        b.push_back(last);
                                        if (width) if (b.size() == width) break;
                                }
                                ate = true;
                                if (mods & discard) break;
                                //null terminate string!
                                b.push_back(0); 
                                //Get numeric base
                                switch (*format) {
                                case 'D': case 'd': base = 10; break;
                                case 'O': case 'o': base = 8; break;
                                case 'X': case 'x': base = 16; break;
                                case 'I': case 'i': base = 0; break;
                                }
                                //Apply modifiers and convert to number
                                if (mods & mb) {
                                        if (isupper(*format))
                                                *(va_arg(v, unsigned char*)) = stoi<unsigned char>((char*)&(b[0]), base);
                                        else
                                                *(va_arg(v, signed char*)) = stoi<signed char>((char*)&(b[0]), base);
                                } else if (mods & mh) {
                                        if (isupper(*format))
                                                *(va_arg(v, unsigned short*)) = stoi<unsigned short>((char*)&(b[0]), base);
                                        else
                                                *(va_arg(v, signed short*)) = stoi<signed short>((char*)&(b[0]), base);
                                } else if (mods & mw) {
                                        if (isupper(*format))
                                                *(va_arg(v, unsigned long*)) = stoi<unsigned long>((char*)&(b[0]), base);
                                        else
                                                *(va_arg(v, signed long*)) = stoi<signed long>((char*)&(b[0]), base);
                                } else if (mods & ml) {
                                        if (isupper(*format))
                                                *(va_arg(v, unsigned long long*)) = stoi<unsigned long long>((char*)&(b[0]), base);
                                        else
                                                *(va_arg(v, signed long long*)) = stoi<signed long long>((char*)&(b[0]), base);
                                } else {
                                        if (isupper(*format))
                                                *(va_arg(v, unsigned int*)) = stoi<unsigned int>((char*)&(b[0]), base);
                                        else
                                                *(va_arg(v, signed int*)) = stoi<signed int>((char*)&(b[0]), base);
                                }
                        } else if (*format == 'c') {
                                if (!ate) last = getc();
                                if (!(mods & addws))
                                        for (; isspace(last); last = getc())
                                                if (last == EOF) goto in_scanf_end;
                                if (last != EOF) b.push_back(last);
                                else goto in_scanf_end;
                                if (!width) width = 1;
                                for (i = 1; ; i++) {
                                        if (!(mods & dienl)) if (i == width) break;
                                        if (last == EOF) goto in_scanf_end;
                                        if (last == '\n') break;
                                        b.push_back(last);
                                        last = getc();
                                }
                                if (!(mods & discard)) {
                                        tomato = va_arg(v, char*);
                                        for (; !b.empty(); b.pop_front(), tomato++)
                                                *tomato = b.front();
                                }
                                ate = false;
                        } else if (*format == 's') {
                                if (!ate) if ((last = getc()) == EOF)
                                        goto in_scanf_end;
                                if (!(mods & addws)) {
                                        for (; isspace(last); last = getc())
                                                if (last == EOF) goto in_scanf_end;
                                } else {
                                        for (; isspace(last); last = getc())
                                                if (last == EOF) goto in_scanf_end;
                                                else b.push_back(last);
                                }
                                for (i = 1; ; i++) {
                                        if (last == EOF) break;
                                        if (!(mods & dienl)) {
                                                if (isspace(last)) { ate = false; break; }
                                        } else if (last == '\n') { ate = false; break; }
                                        if (width) if (i == width) { ate = true; break; }
                                        b.push_back(last);
                                        last = getc();
                                }
                                b.push_back(0);
                                if (mods & discard) continue;
                                tomato = va_arg(v, char*);
                                for (; !b.empty(); b.pop_front(), tomato++)
                                        *tomato = b.front();
                        } else if (*format == 'f') {
                                sign = false;
                                if (!ate) last = getc();
                                if (!(mods & addws))
                                        for (; isspace(last); )
                                                if ((last = getc()) == EOF) goto in_scanf_end;
                                if (last != EOF) b.push_back(last);
                                else goto in_scanf_end;
                                if (!(
                                last == '+' ||
                                last == '-' ||
                                isdigit(last)
                                )) { hit(); goto in_scanf_end; }
                                for (;;) {
                                        if ((last = getc()) == EOF) break;
                                        if (!(mods & dienl)) {
                                                if (last == '.' && sign) break;
                                                if (!isdigit(last) && last != '.') break;
                                        }
                                        if (last == '\n') break;
                                        else if (last == '.') sign = true;
                                        b.push_back(last);
                                        if (width) if (b.size() == width) break;
                                }
                                b.push_back(0);
                                ate = true;
                                if (mods & discard) break;
                                if (mods & mw)
                                        *(va_arg(v, double*)) = stof<double>((char*)&(b[0]));
                                else if (mods & ml)
                                        *(va_arg(v, long double*)) = stof<long double>((char*)&(b[0]));
                                else
                                        *(va_arg(v, float*)) = stof<float>((char*)&(b[0]));
                        }
                        matched++;
                } else if (isspace(*format)) {
                        do format++; while (isspace(*format));
                        format--;
                        if (!ate) if ((last = getc()) == EOF) goto in_scanf_end;
                        if (isspace(last)) ate = false;
                        while (isspace(last))
                                if ((last = getc()) == EOF) goto in_scanf_end;
                        if (!isspace(last)) ate = true;
                } else {
                        if (!ate) if ((last = getc()) == EOF) goto in_scanf_end;
                        if (last != *format) { hit(); goto in_scanf_end; }
                        ate = false;
                }
        } // 149
in_scanf_end:
        va_end(v);
        return matched;
}

char* io::input::in_fmt(char* s, char d, char m) {
        int i = 0;
        if (fmt.hex()) {
                if (isupper(d)) d = 'X';
                else d = 'x';
        } else if (fmt.oct()) {
                if (isupper(d)) d = 'O';
                else d = 'o';
        }
        s[i++] = '%';
        if (!fmt.ltrim()) s[i++] = '^';
        if (fmt.endnl()) s[i++] = '$';
        if (fmt.deaf()) s[i++] = '*';
        i += sprintf(&(s[i]), "%d", fmt.width);
        if (m) s[i++] = m;
        s[i++] = d;
        s[i] = 0;
        return s;
}

io::input& io::input::operator>> (bool& val) {
        if (fmt.bin()) {
                read((char*)&val, sizeof(bool), 1);
                return *this;
        }
        char s[8];
        char t[24];
        if (fmt.btoa()) {
                scanf(in_fmt(t, 's', 0), s);
                if (!fmt.deaf()) {
                        if (!strcmp(s, "true")) val = true;
                        else val = false;
                }
        } else {
                scanf(in_fmt(t, 'd', 'b'), &val);
        }
        return *this;
}
io::input& io::input::operator>> (short& val) {
        if (fmt.bin()) {
                read((char*)&val, sizeof(short), 1);
                return *this;
        }
        char s[24];
        scanf(in_fmt(s, 'd', 'h'), &val);
        return *this;
}
io::input& io::input::operator>> (unsigned short &val) {
        if (fmt.bin()) {
                read((char*)&val, sizeof(unsigned short), 1);
                return *this;
        }
        char s[24];
        scanf(in_fmt(s, 'D', 'h'), &val);
        return *this;
}
io::input& io::input::operator>> (int& val) {
        if (fmt.bin()) {
                read((char*)&val, sizeof(int), 1);
                return *this;
        }
        char s[24];
        scanf(in_fmt(s, 'd', 0), &val);
        return *this;
}
io::input& io::input::operator>> (unsigned int& val) {
        if (fmt.bin()) {
                read((char*)&val, sizeof(unsigned int), 1);
                return *this;
        }
        char s[24];
        scanf(in_fmt(s, 'D', 0), &val);
        return *this;
}
io::input& io::input::operator>> (long& val) {
        if (fmt.bin()) {
                read((char*)&val, sizeof(long), 1);
                return *this;
        }
        char s[24];
        scanf(in_fmt(s, 'd', 'w'), &val);
        return *this;
}
io::input& io::input::operator>> (unsigned long& val) {
        if (fmt.bin()) {
                read((char*)&val, sizeof(unsigned long), 1);
                return *this;
        }
        char s[24];
        scanf(in_fmt(s, 'D', 'w'), &val);
        return *this;
}
io::input& io::input::operator>> (long long& val) {
        if (fmt.bin()) {
                read((char*)&val, sizeof(long long), 1);
                return *this;
        }
        char s[24];
        scanf(in_fmt(s, 'd', 'l'), &val);
        return *this;
}
io::input& io::input::operator>> (unsigned long long& val) {
        if (fmt.bin()) {
                read((char*)&val, sizeof(unsigned long long), 1);
                return *this;
        }
        char s[24];
        scanf(in_fmt(s, 'D', 'l'), &val);
        return *this;
}
io::input& io::input::operator>> (float& val) {
        if (fmt.bin()) {
                read((char*)&val, sizeof(float), 1);
                return *this;
        }
        char s[24];
        scanf(in_fmt(s, 'f', 0), &val);
        return *this;
}
io::input& io::input::operator>> (double& val) {
        if (fmt.bin()) {
                read((char*)&val, sizeof(double), 1);
                return *this;
        }
        char s[24];
        scanf(in_fmt(s, 'f', 'w'), &val);
        return *this;
}
io::input& io::input::operator>> (long double& val) {
        if (fmt.bin()) {
                read((char*)&val, sizeof(long double), 1);
                return *this;
        }
        char s[24];
        scanf(in_fmt(s, 'f', 'l'), &val);
        return *this;
}
io::input& io::input::operator>> (void*& val) {
        if (fmt.bin()) {
                read((char*)&val, sizeof(void*), 1);
                return *this;
        }
        char s[24];
        scanf(in_fmt(s, 'X', 'w'), &val);
        return *this;
}
io::input& io::input::operator>> (char& c) {
        if (fmt.bin()) {
                read(&c, sizeof(char), 1);
                return *this;
        }
        char s[24];
        scanf(in_fmt(s, 'c', 0), &c);
        return *this;
}
io::input& io::input::operator>> (char* s) {
        if (fmt.bin()) {
                register int i;
                int j;
                for (i = 0, j = getc(); j; j = getc(), i++) {
                        if (j == -1) break;
                        s[i] = j;
                }
                s[i] = 0;
                return *this;
        }
        char t[24];
        scanf(in_fmt(t, 's', 0), s);
        return *this;
}

int io::output::puts(const char* s) {
        register const char* t = s;
        for (; *t; t++)
                if (putc(*t) == EOF)
                        return EOF;
        return t - s;
}

size_t io::output::write(const char* ptr, size_t size, size_t nmemb) {
        size_t i, j;
        for (i = 0; i < nmemb; i++)
                for (j = 0; j < size; j++) {
                        putc(ptr[size * i + j]);
                        if (!ok()) return i;
                }
        return i;
}

int io::output::printf(const char* format, ...) {
        char* s;
        va_list v;
        size_t i;
        int ret = 0;
        i = 32;
        va_start(v, format);
        s = (char*)malloc(i);
#ifndef _WIN32
        while ((ret = vsnprintf(s, i, format, v)) >= i) {
                i *= 2;
                s = (char*)::realloc(s, i);
        }
#else 
        for (;;) {
                ret = vsnprintf(s, i, format, v);
                if (ret != -1 && ret < i) break;
                i *= 2;
                s = (char*)::realloc(s, i);
        }
#endif
        if (ret == -1) { hit(); free(s); va_end(v); return -1; }
        puts(s);
        free(s);
        va_end(v);
        return ret;
}

char* io::output::out_fmt(char* s, char t, const char* m) {
        int i = 0;
        switch (t) {
        case 'd': case 'i': case 'o': case 'u':
        case 'x': case 'X': 
        if (fmt.hex()) {
                if (isupper(t)) t = 'X';
                else t = 'x';
        } else if (fmt.oct()) {
                if (isupper(t)) t = 'O';
                else t = 'o';
        }
        default: ;
        }
        if (t == 'G')
                if (fmt.fix()) t = 'F';
                else if (fmt.sci()) t = 'E';
        s[i++] = '%';
        if (fmt.base()) s[i++] = '#';
        if (fmt.zpad()) s[i++] = '0';
        if (fmt.left()) s[i++] = '-';
        if (fmt.sign()) s[i++] = '+';
        if (fmt.width) i += sprintf(&(s[i]), "%d", fmt.width);
        if (fmt.precis) {
                s[i++] = '.';
                i += sprintf(&(s[i]), "%d", fmt.precis);
        }
        if (m) { strcpy(s + i, m); i += strlen(m); }
        s[i++] = t;
        s[i] = 0;
        return s;
}
io::output& io::output::operator<< (bool val) {
        if (fmt.bin()) {
                write((const char*)&val, sizeof(bool), 1);
                return *this;
        }
        if (fmt.btoa()) {
                if (val) puts("true");
                else puts("false");
        } else printf("%hhd", val);
        return *this;
}
io::output& io::output::operator<< (short val) {
        if (fmt.bin()) {
                write((const char*)&val, sizeof(short), 1);
                return *this;
        }
        char s[24];
        printf(out_fmt(s, 'd', "h"), val);
        return *this;
}
io::output& io::output::operator<< (unsigned short val) {
        if (fmt.bin()) {
                write((const char*)&val, sizeof(unsigned short), 1);
                return *this;
        }
        char s[24];
        printf(out_fmt(s, 'u', "h"), val);
        return *this;
}
io::output& io::output::operator<< (int val) {
        if (fmt.bin()) {
                write((const char*)&val, sizeof(int), 1);
                return *this;
        }
        char s[24];
        printf(out_fmt(s, 'd', 0), val);
        return *this;
}
io::output& io::output::operator<< (unsigned int val) {
        if (fmt.bin()) {
                write((const char*)&val, sizeof(unsigned int), 1);
                return *this;
        }
        char s[24];
        printf(out_fmt(s, 'u', 0), val);
        return *this;
}
io::output& io::output::operator<< (long val) {
        if (fmt.bin()) {
                write((const char*)&val, sizeof(long), 1);
                return *this;
        }
        char s[24];
        printf(out_fmt(s, 'd', "l"), val);
        return *this;
}
io::output& io::output::operator<< (unsigned long val) {
        if (fmt.bin()) {
                write((const char*)&val, sizeof(unsigned long), 1);
                return *this;
        }
        char s[24];
        printf(out_fmt(s, 'u', "l"), val);
        return *this;
}
io::output& io::output::operator<< (float val) {
        if (fmt.bin()) {
                write((const char*)&val, sizeof(float), 1);
                return *this;
        }
        char s[24];
        printf(out_fmt(s, 'G', 0), val);
        return *this;
}
io::output& io::output::operator<< (double val) {
        if (fmt.bin()) {
                write((const char*)&val, sizeof(double), 1);
                return *this;
        }
        char s[24];
        printf(out_fmt(s, 'G', 0), val);
        return *this;
}
io::output& io::output::operator<< (long double val) {
        if (fmt.bin()) {
                write((const char*)&val, sizeof(long double), 1);
                return *this;
        }
        char s[24];
        printf(out_fmt(s, 'G', "L"), val);
        return *this;
}
io::output& io::output::operator<< (const void* val) {
        if (fmt.bin()) {
                write((const char*)&val, sizeof(const void*), 1);
                return *this;
        }
        char s[24];
        printf(out_fmt(s, 'p', 0), val);
        return *this;
}
io::output& io::output::operator<< (char c) {
        if (fmt.bin()) {
                write((const char*)&c, sizeof(char), 1);
                return *this;
        }
        char s[24];
        printf(out_fmt(s, 'c', 0), c);
        return *this;
}
io::output& io::output::operator<< (signed char c) {
        if (fmt.bin()) {
                write((const char*)&c, sizeof(signed char), 1);
                return *this;
        }
        char s[24];
        printf(out_fmt(s, 'c', 0), c);
        return *this;
}
io::output& io::output::operator<< (unsigned char c) {
        if (fmt.bin()) {
                write((const char*)&c, sizeof(unsigned char), 1);
                return *this;
        }
        char s[24];
        printf(out_fmt(s, 'c', 0), c);
        return *this;
}
io::output& io::output::operator<< (const char* s) {
        if (fmt.bin()) {
                register int i;
                for (i = 0; s[i]; i++);
                write((const char*)&s, sizeof(char), ++i);
                return *this;
        }
        char t[24];
        printf(out_fmt(t, 's', 0), s);
        return *this;
}
/*io::output& io::output::echo(string s) {
        operator<<(s.buf);
        putc('\n');
        return *this;
}
io::output& io::output::put(string s) {
        operator<<(s.buf);
        return *this;
}
io::output& io::output::echo(timer c) {
        operator<<(c.str().buf);
        putc('\n');
        return *this;
}
io::output& io::output::put(timer c) {
        operator<<(c.str().buf);
        return *this;
}*/

string net::dgram::type() { return string("net::dgram"); }
net::dgram::operator string () { string s; s << ip << '/' << port; return s; }

data fs::fbread(const char* fname, size_t len) {
        FILE* f;
        data d;
        if (!len) len = fsize(fname);
        if ((f = fopen(fname, "rb")) == NULL) return d;
        d.realloc(len);
        fread(d.buf, 1, len, f);
        return d;
}

size_t fs::fbwrite(const char* fname, data d, size_t len) {
        FILE* f;
        if ((f = fopen(fname, "w+b")) == NULL) return 0;
        if (!len) len = d.len();
        register size_t i = fwrite(d.buf, 1, len, f);
        return i;
}

string data::type() { return string("data"); }
data::operator string() {
        string s;
        register size_t i;
        for (i = 0; i < slen; i++)
                s.printf("%02x ", ((unsigned char*)buf)[i]);
        return s;
}
size_t data::len() const { return slen; }
bool data::operator== (data d) { if (len() != d.len()) return false; return !memcmp(buf, d.buf, len()); }
bool data::operator!= (data d) { return !memcmp(buf, d.buf, len()); }
data::data(const data& d) {
        fmt.bin(1);
        buf = 0; pos = 0; mlen = 0; slen = 0;
        realloc(d.len());
        memmove(buf, d.buf, d.len());
}
char& data::operator [](int i) { realloc(i + 1); return buf[i]; }
data& data::operator= (data d) {
        if (buf) free(buf);
        rewind();
        buf = d.buf;
        slen = d.len();
        d.buf = 0;
        return *this;
}

void data::realloc(size_t i) {
        slen = i;
        register size_t n = i;
        while (n & (n - 1)) n++;
        if (mlen < n) {
                if (buf) buf = (char*)::realloc(buf, n);
                else { buf = (char*)malloc(n); buf[0] = 0; }
                mlen = n;
                buf[i - 1] = 0;
        }
}
data::data() { fmt.bin(1); buf = 0; pos = 0; mlen = 0; slen = 0; }
data::~data() { if (buf) free(buf); }
int string::getc() {
        if (pos > mlen) { kill(); return -1; }
        unsigned char c = buf[pos++];
        if (!c) { drain(); return -1; }
        else { heal(); return c; }
}

int data::getc() {
        if (pos > mlen) { drain(); return -1; }
        unsigned char c = buf[pos++];
        heal();
        return c;
}
int data::putc(int c) {
        (this->operator[] (pos++)) = c;
        heal(); return c;
}
bool data::seek(long offset, int whence) {
        if (whence == SEEK_SET) pos = offset;
        else if (whence == SEEK_END) pos = len() + offset;
        else if (whence == SEEK_CUR) pos += offset;
        else pos = offset + whence;
        if (pos > len()) return false;
        return true;
}
size_t data::tell() { return pos; }
void data::rewind() { pos = 0; }
void data::unwind() { pos = len(); }
bool data::ffwd(size_t offset) {
        pos += offset;
        if (pos > len()) return false;
        return true;
}
bool data::prev(size_t offset) {
        pos -= offset;
        if (pos > len()) return false;
        return true;
}

string::string() { fmt.bin(0); buf = 0; pos = 0; mlen = 0; }

string::string(const char* s) { 
        fmt.bin(0);
        buf = 0; pos = 0; mlen = 0;
        if (s) {
                size_t i = strlen(s) + 1;
                while (i & (i - 1)) i++;
                buf = (char*)malloc(i);
                mlen = i;
                strcpy(buf, s);
        }
}

string::string(size_t n) { fmt.bin(0); buf = 0; pos = 0; mlen = 0; realloc(n); buf[0] = 0; }

string::string(const string& s) {
        fmt.bin(0);
        buf = 0; pos = 0; mlen = s.msize();
        if (s.buf) {
                buf = (char*)malloc(mlen);
                strcpy(buf, s.buf);
        }
}

string::~string() { if (buf) { free(buf); buf = 0; }}

/*int string::getc() {
        unsigned char c = buf[pos++];
        if (!c) { drain(); return -1; }
        else { heal(); return c; }
}*/

int string::putc(int c) {
        if (!buf) realloc(2);
        if (buf[pos] == 0 || pos >= mlen) {
                realloc(pos + 4);
                buf[pos + 1] = 0;
        }
        buf[pos++] = c; heal(); return c;
}
/*
bool string::seek(long offset, int whence) {
        if (whence == SEEK_SET) pos = offset;
        else if (whence == SEEK_END) pos = len() + offset;
        else if (whence == SEEK_CUR) pos += offset;
        else pos = offset + whence;
        if (pos > len()) return false;
        return true;
}
size_t string::tell() { return pos; }
string& string::rewind() { pos = 0; return *this; }
string& string::unwind() { pos = len(); return *this; }
bool string::ffwd(size_t offset) {
        pos += offset;
        if (pos > len()) return false;
        return true;
}
bool string::prev(size_t offset) {
        pos -= offset;
        if (pos > len()) return false;
        return true;
}*/

string string::esc(const char* format, int (*charfilter)(int)) {
        if (empty()) return string();
        string s;
        size_t i = tell();
        register int c;
        char d;
        rewind();
        for (c = getc(); c != EOF; c = getc()) {
                d = c;
                if (charfilter == NULL) s.printf(format, d);
                else if (charfilter(d)) s.printf(format, d);
                else s.putc(d);
        }
        seek(i, SEEK_SET);
        return s;
}

string string::esc(const char* format, const char* chrs) {
        string s;
        size_t i = tell();
        register int c;
        char d;
        rewind();
        for (c = getc(); c != EOF; c = getc()) {
                d = c;
                if (strchr(chrs, d)) s.printf(format, d);
                else s.putc(d);
        }
        seek(i, SEEK_SET);
        return s;
}

string string::uesc(const char* format, const char* chrs) {
        string s(buf);
        string t;
        char c[2];
        c[1] = 0;
        for (*c = 0; *c < CHAR_MAX; (*c)++) {
                if (strchr(chrs, *c)) {
                        t.printf(format, *c);
                        s = s.rep(t, c);
                }
                t.clear();
        }
        t.clear();
        if (strchr(chrs, *c)) {
                t.printf(format, *c);
                s = s.rep(t, c);
        }
        return s;
}

string string::uesc(const char* format, int (*charfilter)(int)) {
        string s(buf);
        string t;
        char c[2];
        c[1] = 0;
        for (*c = 0; *c < CHAR_MAX; (*c)++) {
                if (charfilter == NULL) {
                        t.printf(format, *c);
                        s = s.rep(t, c);
                } else if (charfilter(*c)) {
                        t.printf(format, *c);
                        s = s.rep(t, c);
                }
                t.clear();
        }
        t.clear();
        if (charfilter == NULL) {
                t.printf(format, *c);
                s = s.rep(t, c);
        } else if (charfilter(*c)) {
                t.printf(format, *c);
                s = s.rep(t, c);
        }
        return s;
}

/*string string::gets(int size) {
        string s;
        int i = 32, j = 0;
        register int c;
        s.realloc(i);
        for (c = getc(); ; c = getc(), j++) {
                if (size) if (j >= size) break;
                if (j >= i - 4) { i *= 2; s.realloc(i); }
                switch (c) {
                case EOF: s.buf[0] = 0; return s;
                case '\n': s.buf[j] = '\n'; s.buf[++j] = 0; return s;
                default: s.buf[j] = c;
                }
        }
        s.buf[j] = 0;
        return s;
}*/

string string::q() {
        register size_t i = strlen(buf);
        string s(i + 3);
        strcpy(s.buf + 1, buf);
        s.buf[0] = '\'';
        s.buf[++i] = '\'';
        s.buf[++i] = 0;
        return s;
}

string string::qq() {
        register size_t i = strlen(buf);
        string s(i + 3);
        strcpy(s.buf + 1, buf);
        s.buf[0] = '\"';
        s.buf[++i] = '\"';
        s.buf[++i] = 0;
        return s;
}

string string::qx() {
        string s;
        fs::file pipe;
        pipe.fd = popen(buf, "r");
        if (!pipe.fd) return s;
        until (pipe.eof()) s += pipe.getc();
        s = s.chop();
        pclose(pipe.fd);
        return s;
}

/*string string::htmlesc() {
        string s(buf);
        string t;
        register int i;
        for (i = 0; entnames[i].c; i++)
                t.puts(entnames[i].c);
        t.putc(0);
        s = s.esc("&#%d;", t);
        return s;
}
string string::htmluesc() {
        string s(buf);
        string t;
        char b[2];
        register int i;
        b[1] = 0;
        for (i = 0; entnames[i].c; i++) {
                t.putc(entnames[i].c);
                b[0] = entnames[i].c;
                s = s.rep(entnames[i].name, b);
        }
        t.putc(0);
        s = s.uesc("&#%d;", t);
        //s = s.uesc("&#%d;", "\"'&<> ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿×÷ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ");
        return s;
}*/

char& string::front() { return buf[0]; };

char& string::back() { return buf[strlen(buf) - 1]; }

string& string::clear() { realloc(2); pos = 0; buf[0] = 0; return *this; }

bool string::empty() { if (buf) return buf[0] == 0; else return true; }

size_t string::len() { if (buf) return strlen(buf); else return 0; }


io::output& io::output::operator<< (string s) { return operator<<(s.buf); }

/*string& string::realloc(size_t i) {
        register size_t n = i;
        while (n & (n - 1)) n++;
        if (mlen < n) {
                if (buf) buf = (char*)::realloc(buf, n);
                else { buf = (char*)malloc(n); buf[0] = 0; }
                mlen = n;
                buf[i - 1] = 0;
        }
        return *this;
}*/

size_t string::msize() const { return mlen; }

string string::cat(const char* s, size_t n) {
        string t;
        register size_t i = this->len();
        if (!n) n = strlen(s) + 1;
        t.realloc(i + n);
        strcpy2(t.buf, buf);
        for (; n > 0; i++, n--, s++)
                t.buf[i] = *s;
        t.buf[i] = 0;
        return t;
}

string string::wrap(size_t len, const char* eol) {
        string s;
        size_t i, j, k = strlen(buf);
        for (i = 0, j = 0; i < k; i++, j++) {
                if (j == len) {
                        s << eol;
                        j = 0;
                }
                s << buf[i];
        }
        s.rewind();
        return s;
}

string string::cat(int c, size_t n) {
        string t;
        register size_t i;
        if (buf) i = strlen(buf);
        else i = 0;
        t.realloc(i + n + 1);
        if (buf) strcpy(t.buf, buf);
        for (; n > 0; n--, i++)
                t.buf[i] = c;
        t.buf[i] = 0;
        return t;
}

string string::prep(const char* s, size_t n) {
        string t;
        if (!n) n = strlen(s);
        register size_t i;
        if (buf) i = strlen(buf);
        else i = 0;
        t.realloc(n + i + 1);
        strncpy(t.buf, s, n);
        t.buf[n] = 0;
        if (buf) strcat(t.buf, buf);
        return t;
}

string string::prep(int c, size_t n) {
        string t;
        register size_t i;
        if (buf) i = strlen(buf);

        else i = 0;
        t.realloc(i + n + 1);
        for (i = 0; i < n; i++) t.buf[0] = c;
        if (buf) strcpy(&(t.buf[i]), buf);
        t.buf[strlen(t.buf)] = 0;
        return t;
}

long string::chr(int c, size_t index) {
        if (len() == 0) return -1;
        register char* s = strchr(buf + index, c);
        if (s == NULL) return -1;
        return s - (buf + index);
}

long string::rchr(int c) {
        if (len() == 0) return -1;
        register char* s = strrchr(buf, c);
        if (s == NULL) return -1;
        return s - buf;
}

long string::str(const char* s, size_t index) {
        if (len() == 0) return -1;
        register char* t = strstr(buf + index, s);
        if (t == NULL) return -1;
        return t - (buf + index);
}

long string::rstr(const char* s) {
        if (len() == 0) return -1;
        char *t, *u;
        for(t = strstr(buf, s), u = t; t; t = strstr(u, s))
                if (t) u = t;
        return u - buf;
}

size_t string::nchr(int ch) {
        if (len() == 0) return 0;
        register size_t i, j;
        for (i = 0, j = 0; buf[i]; i++)
                if (buf[i] == ch) j++;
        return j;
}

size_t string::nstr(const char* str) {
        char* t = buf;
        register size_t i;
        size_t j = strlen(str);
        for (i = 0, t = strstr(t, str); t != NULL; i++, t = strstr(t, str))
                t += j;
        return i;
}

bool string::starts(const char* s) { if (!buf) return false; return !strncmp(buf, s, strlen(s)); }

bool string::starts(int c) { if (!buf) return false; return (buf[0] == c); }

bool string::ends(const char* s) {
        if (!buf) return false;
        register size_t i = strlen(buf), j = strlen(s);
        return !strncmp(buf + i - j, s, j);
}

bool string::ends(int c) { if (!buf) return false; return (buf[strlen(buf) - 1] == c); }

bool string::is(const char* s) { if (!buf) return false; return !strcmp(buf, s); }

bool string::is(int c) { if (!buf) return false; return (buf[0] == c && buf[1] == 0); }

string string::left(size_t n) {
        string s;
        s.realloc(n + 1);
        strncpy(s.buf, buf, n);
        s.buf[n] = 0;
        return s;
}

string string::right(size_t n) {
        string s;
        s.realloc(n + 1);
        strcpy(s.buf, buf + strlen(buf) - n);
        return s;
}

string string::cpy(const char* src, size_t index, size_t count) {
        if (!count) count = strlen(src);
        string t(index + count + 1);
        strncpy(t.buf, buf, index);
        strncpy(t.buf + index, src, count);
        t.buf[index + count] = 0;
        return t;
}

string string::cpy(int c, size_t index, size_t count) {
        string t(index + count + 1);
        strncpy(t.buf, buf, index);
        for (; count > 0; index++, count--) t.buf[index] = c;
        t.buf[index] = 0;
        return t;
}

/*
string string::ncpy(const char* src, size_t n, size_t index) {
        if (!n) n = strlen(src);
        size_t i = strlen(buf);
        string t(i + n + 1);
        strcpy(t.buf, buf);
        strncpy(t.buf, src, n);
        return t;
}*/

size_t string::spn(const char* accept, size_t index) { if (len() == 0) return 0; return strspn(buf + index, accept); }

size_t string::cspn(const char* reject, size_t index) { if (len() == 0) return 0; return strcspn(buf + index, reject); }

size_t string::spn(int c, size_t index) {
        if (len() == 0) return 0;
        register size_t i;
        for (i = 0; buf[index] == c; index++) i++;
        return i;
}

size_t string::cspn(int c, size_t index) {
        if (len() == 0) return 0;
        register size_t i;
        for (i = 0; buf[index] != c; index++) i++;
        return i;
}

string string::fry() {
        string t(buf);
        if (!buf[1]) return t;
        static unsigned int seed;
        unsigned int ck = t.cksum();
        srand(seed ^ time(NULL));
        char *a, *b, c;
        int i, j = strlen(buf);
        for (i = 0; i < j; i++) {
                a = &(t.buf[rand() % j]);
                b = &(t.buf[rand() % j]);
                c = *a;
                *a = *b;
                *b = c;
        }
        seed = rand();
        if (t.cksum() == ck) t = t.fry();
        return t;
}

long string::pbrk(const char* accept, size_t index) {
        if (len() == 0) return 0;
        register char* s = strpbrk(buf + index, accept);
        if (s == NULL) return -1;
        return s - (buf + index);
}

long string::rpbrk(const char* accept, size_t index) {
        if (len() == 0) return 0;
        char *s, *t;
        for(s = strpbrk(buf + index, accept), t = s; s; s = strpbrk(t + 1, accept))
                if (s) t = s;
        return t - (buf + index);
}

string string::substr(size_t start, size_t count) {
        string t;
        if (len() == 0) return t;
        t.realloc(count + 1);
        strncpy(t.buf, buf + start, count);
        t.buf[count] = 0;
        return t;
}

string string::tok(size_t index, const char* delim) {
        if (empty()) return *this;
        string s(buf);
        char *u;
        s = s.squeeze(delim);
        while (s.pbrk(delim) == 0) s = s.shl(1);
        while (s.pbrk(delim) == s.len() - 1) s = s.shr(1);
        u = strtok(s.buf, delim);
        for (; index > 0 && u; index--)
                u = strtok(NULL, delim);
        if (u) memmove(s.buf, u, strlen(u) + 1);
        else s.clear();
        return s;
}

string string::tok(size_t index, int delim) {
        char x[2];
        x[0] = delim;
        x[1] = 0;
        return tok(index, x);
}

size_t string::ntok(const char* delim) {
        if (empty()) return 0;
        size_t i;
        char *p, *tmp = (char*)malloc(strlen(buf) + 1);
        strcpy(tmp, buf);
        for (
                p = strtok(tmp, delim), i = 0;
                p; p = strtok(0, delim), i++
        );
        free(tmp);
        return i;
}

size_t string::ntok(int delim) {
        char s[2]; s[0] = delim; s[1] = 0;
        return this->ntok(s);
}

long string::itok(size_t index, const char* delim) {
        register long a;
        for (a = 0; buf[a] && index > 0; a++) {
                if (strchr(delim, buf[a])) {
                        do {
                                a++;
                        } while (strchr(delim, buf[a]));
                        a--;
                        index--;
                }
        }
        if (buf[a] == 0) return -1;
        return a;
}

long string::itok(size_t index, int delim) {
        char x[2];
        x[0] = delim; x[1] = 0;
        return itok(index, x);
}

std::deque<axcel::string> string::split(const char* delim) {
        std::deque<axcel::string> d;
        char* s = (char*)malloc(strlen(buf) + 1);
        strcpy(s, buf);
        const char* t = strtok(s, delim);
        for (; t != NULL; t = strtok(NULL, delim))
                d.push_back(string(t));
        free(s);
        return d;
}

std::deque<axcel::string> string::split(int delim) { char x[2]; x[0] = delim; x[1] = 0; return split(x); }

string string::ins(size_t index, const char* str) {
        if (empty()) return string();
        size_t len1 = strlen(str), len2 = strlen(buf);
        string s(len1 + len2 + 1);
        strncpy(s.buf, buf, index);
        s.buf[index] = 0;
        strncat(s.buf, str, len1);
        strcpy(s.buf + index + len1, buf + index);
        return s;
}

string string::ins(size_t index, int c) {
        if (empty()) return string();
        char x[2]; x[0] = c; x[1] = 0;
        return ins(index, x);
}

string string::rm(size_t index, size_t n) {
        if (empty()) return string();
        size_t i = strlen(buf);
        string s(i - n + 1);
        strncpy(s.buf, buf, index);
        s.buf[index] = 0;
        strcat(s.buf, buf + index + n);
        return s;
}

string string::rev(size_t start, size_t count) {
        if (empty()) return string();
        if (!count) count = strlen(buf) - start;
        string s(strlen(buf) + 1);
        size_t i, j;
        for (i = 0, j = 0; ; i++, j++) {
                if (j == start) {
                        for (j += count - 1; j > start; j--, i++)
                                s.buf[i] = buf[j];
                        s.buf[i++] = buf[j];
                        j += count;
                }
                s.buf[i] = buf[j];
                if (!s.buf[i]) break;
        }
        return s;
}

string string::dup(int i) {
        if (empty()) return string();
        size_t n = strlen(buf);
        string s(n * i + 1);
        strcpy(s.buf, buf);
        for (i--; i > 0; i--)
                strcat(s.buf, buf);
        return s;
}

string string::rol(size_t i, size_t index, size_t count) {
        if (empty()) return string();
        if (!count) count = strlen(buf) - index;
        string s(strlen(buf) + 1);
        strncpy(s.buf, buf, index);
        strncpy(s.buf + index, buf + index + i, count - i);
        strncpy(s.buf + index + count - i, buf + index, i);
        s.buf[index + count] = 0;
        strcat(s.buf, buf + index + count);
        return s;
}

string string::ror(size_t i, size_t index, size_t count) {
        if (empty()) return string();
        if (!count) count = strlen(buf) - index;
        string s(strlen(buf) + 1);
        strncpy(s.buf, buf, index);
        strncpy(s.buf + index, buf + index + count - i, i);
        strncpy(s.buf + index + i, buf + index, count - i);
        s.buf[index + count] = 0;
        strcat(s.buf, buf + index + count);
        return s;
}

string string::shl(size_t n) {
        if (empty()) return string();
        string s(strlen(buf) - n + 1);
        strcpy(s.buf, buf + n);
        return s;
}

string string::shr(size_t n) {
        if (empty()) return string();
        register size_t i = strlen(buf) - n;
        string s(i + 1);
        strncpy(s.buf, buf, i);
        s.buf[i] = 0;
        return s;
}

string string::lc(size_t start, size_t count) {
        if (empty()) return string();
        if (!count) count = strlen(buf) - start;
        string s(strlen(buf) + 1);
        size_t i;
        for (i = 0; i < start; i++) s.buf[i] = buf[i];
        for (; count > 0; count--, i++) s.buf[i] = tolower(buf[i]);
        for (; buf[i]; i++) s.buf[i] = buf[i];
        s.buf[i] = 0;
        return s;
}


string string::uc(size_t start, size_t count) {

        if (empty()) return string();
        if (!count) count = strlen(buf) - start;
        string s(strlen(buf) + 1);
        size_t i;
        for (i = 0; i < start; i++) s.buf[i] = buf[i];
        for (; count > 0; count--, i++) s.buf[i] = toupper(buf[i]);
        for (; buf[i]; i++) s.buf[i] = buf[i];
        s.buf[i] = 0;
        return s;
}


string string::ltrim() {
        if (empty()) return string();
        size_t i = 0;
        for (; ::isspace(buf[i]); i++);
        string s(strlen(buf + i) + 1);
        strcpy(s.buf, buf + i);
        return s;
}

string string::rtrim() {
        if (empty()) return string();
        size_t i = strlen(buf) - 1;
        for (; ::isspace(buf[i]); i--);
        string s(i += 2);
        strncpy(s.buf, buf, --i);
        s.buf[i] = 0;
        return s;
}  

string string::strip() {
        if (empty()) return string();
        string s(buf);
        s = s.rtrim();
        s = s.ltrim();
        return s;
        /*size_t i = 0, j = strlen(buf) - 1, k = strlen(buf);
        for (; isspace(buf[i]); i++);
        if (i >= k) return string();
        for (; isspace(buf[j]); j--);
        string s(k - i - (k - j) + 1);
        strncpy(s.buf, buf + i, j - i + 1);
        s.buf[j - i + 1] = 0;
        return s;*/
}

string string::chop() {
        string s;
        if (empty()) return s;
        size_t i = strlen(buf);
        if (this->ends("\r\n")) {
                s.realloc(--i); i--;
        } else s.realloc(i--);
        s.buf[i] = 0;
        strncpy(s.buf, buf, i);
        return s;
}


string string::chomp(const char* eat) {
        string s;
        if (empty()) return s;
        size_t i = strlen(buf);
        char* t;
        if (!strcmp(eat, "\r\n")) {
                s = buf;
                t = strrchr(s.buf, '\n');
                if (t) *t = 0;
                t = strrchr(s.buf, '\r');
                if (t) *t = 0;
                return s;
        }
        if (this->ends(eat)) {
                i -= strlen(eat);
                i++;
                s.realloc(i); i--;
        } else s.realloc(i + 1);
        s.buf[i] = 0;
        strncpy(s.buf, buf, i);
        return s;
}

string string::cut() {
        string s;
        if (empty()) return s;
        size_t i = strlen(buf);
        if (this->starts("\r\n")) {
                s.realloc(--i); i--;
        } else s.realloc(i--);
        s.buf[i] = 0;
        strncpy(s.buf, buf + (strlen(buf) - i), i);
        return s;
}

string string::munch(const char* eat) {
        string s;
        if (empty()) return s;
        if (this->starts(eat)) s = (buf + strlen(eat));
        else s = buf;
        return s;
}


string& string::swap(string& s) {
        size_t i = s.msize();
        char* t = s.buf;
        s.buf = buf;
        s.realloc(mlen);
        mlen = i;
        buf = t;
        return *this;
}


string string::center(size_t newlen, const char* left, const char* right) {
        string s(buf); 
        if (newlen <= strlen(s.buf) + 1) return s;
        size_t i = (newlen - strlen(s.buf)) / 2;
        s = s.rpad(i + strlen(s.buf), right);
        s = s.lpad(i + strlen(s.buf), left);
        return s;
}

string string::center(size_t newlen, int left, int right) {
        char a[2], b[2];
        a[0] = left; a[1] = 0;
        b[0] = right; b[1] = 0;
        return center(newlen, a, b);
}

string string::center(size_t newlen, const char* pad) {
        return center(newlen, pad, pad);
}

string string::center(size_t newlen, int pad) {
        char a[2];
        a[0] = pad; a[1] = 0;
        return center(newlen, a, a);
}

string string::lpad(size_t newlen, const char* pad) {
        if (newlen <= strlen(buf)) return *this;
        string s(newlen + 1);
        size_t i, j, len1 = strlen(pad), len2 = newlen - strlen(buf);
        strcpy(s.buf + len2, buf);
        for (i = 0, j = 0; i < len2; i++, j++) {
                if (j == len1) j = 0;
                s.buf[i] = pad[j];
        }
        return s;
}

string string::rpad(size_t newlen, const char* pad) {
        if (newlen <= strlen(buf)) return *this;
        string s(newlen + 1);
        size_t i, j, len1 = strlen(pad);
        strcpy(s.buf, buf);
        for (i = strlen(buf), j = 0; i < newlen; i++, j++) {
                if (j == len1) j = 0;
                s.buf[i] = pad[j];
        }
        s.buf[i] = 0;
        return s;
}

string string::lpad(size_t newlen, int pad) {
        char a[2];
        a[0] = pad; a[1] = 0;
        return lpad(newlen, a);
}

string string::rpad(size_t newlen, int pad) {
        char a[2];
        a[0] = pad; a[1] = 0;
        return rpad(newlen, a);
}

string string::squeeze(const char* chrs) {
        string s(strlen(buf) + 1);
        size_t i, k;
        if (!chrs) {
                for (i = 0, k = 0; buf[i]; i++, k++) {
                        s.buf[k] = buf[i];
                        while (buf[i] == buf[i + 1]) i++;
                }
        } else {
                for (i = 0, k = 0; buf[i]; i++, k++) {
                        s.buf[k] = buf[i];
                        if (strchr(chrs, buf[i]))
                                while (buf[i] == buf[i + 1]) i++;
                }
        }
        s.buf[k] = 0;
        return s;
}

string string::squeeze(int chr) {
        char a[2];
        a[0] = chr; a[1] = 0;
        return squeeze(a);
}

string string::ctypes(int (*cfunc)(int)) {
        if (empty()) return *this;
        string s(strlen(buf) + 1);
        register size_t i, j;
        for (i = 0, j = 0; buf[i]; i++)
                if (cfunc(buf[i])) s.buf[j++] = buf[i];
        s.buf[j] = 0;
        return s;
}

string string::ctypes(const char* chrs) {
        if (empty()) return *this;
        string s(strlen(buf) + 1);
        register size_t i, j;
        for (i = 0, j = 0; buf[i]; i++)
                if (strchr(chrs, buf[i])) s.buf[j++] = buf[i];
        s.buf[j] = 0;
        return s;
}

bool string::isctype(int (*cfunc)(int)) {
        if (empty()) return false;
        register size_t i;
        for (i = 0; buf[i]; i++)
                if (!cfunc(buf[i])) return false;
        return true;
}

bool string::isctype(const char* chrs) {
        if (empty()) return false;
        register size_t i;
        for (i = 0; buf[i]; i++)
                if (!strchr(chrs, buf[i])) return false;
        return true;
}

string string::alnums() { return ctypes(::isalnum); }

string string::alphas() { return ctypes(::isalpha); }

string string::cntrls() { return ctypes(::iscntrl); }

string string::digits() { return ctypes(::isdigit); }

string string::graphs() { return ctypes(::isgraph); }

string string::puncts() { return ctypes(::ispunct); }

string string::lowers() { return ctypes(::islower); }

string string::prints() { return ctypes(::isprint); }

string string::spaces() { return ctypes(::isspace); }

string string::uppers() { return ctypes(::isupper); }

string string::xdigits() { return ctypes(::isxdigit); }

bool string::isalnum() { return isctype(::isalnum); }

bool string::isalpha() { return isctype(::isalpha); }

bool string::iscntrl() { return isctype(::iscntrl); }

bool string::isdigit() { return isctype(::isdigit); }

bool string::isgraph() { return isctype(::isgraph); }

bool string::islower() { return isctype(::islower); }

bool string::isprint() { return isctype(::isprint); }

bool string::ispunct() { return isctype(::ispunct); }

bool string::isspace() { return isctype(::isspace); }

bool string::isupper() { return isctype(::isupper); }

bool string::isxdigit() { return isctype(::isxdigit); }

string string::inc() {
        string s(buf); 
        register char carry = 0;
        size_t i = strlen(s.buf) - 1;
        long j;
        do {
                if (s.buf[i] == 'z' || s.buf[i] == 'Z') {
                        carry = 1;
                        s.buf[i] = s.buf[i] - 25;
                } else if (s.buf[i] == '9') {
                        carry = 1;
                        s.buf[i] = '0';
                } else if (::isalnum(s.buf[i])) {
                        carry = 0;
                        s.buf[i] = s.buf[i] + 1;
                        break;
                }
        } while (i--);
        if (carry) {
                j = s.pbrk("Aa0");
                if (s.buf[j] == '0')
                        s = s.ins(j, '1');
                else if (s.buf[j] == 'a')
                        s = s.ins(j, 'a');
                else if (s.buf[j] == 'A')
                        s = s.ins(j, 'A');
        }
        return s;
}

string string::add(int n) {
        register int i;
        string s(buf);
        for (i = 0; i < n; i++) s = s.inc();
        return s;
}

string string::sub(int n) {
        register int i;
        string s(buf);
        for (i = 0; i < n; i++) s = s.dec();
        return s;
}

string string::incn() {
        string s(buf); 
        register char carry = 0;
        size_t i = strlen(s.buf) - 1;
        long j;
        do {
                if (s.buf[i] == '9') {
                        carry = 1;
                        s.buf[i] = '0';
                } else if (::isdigit(s.buf[i])) {
                        carry = 0;
                        s.buf[i] = s.buf[i] + 1;
                        break;
                }
        } while (i--);
        if (carry)
                        s = s.ins(s.chr('0'), '1');
        return s;
}

string string::dec() {
        string s(buf);
        register char borrow = 0;
        long last = -1;
        size_t i = strlen(s.buf) - 1;
        do {
                if (s.buf[i] == 'a' || s.buf[i] == 'A') {
                        borrow = 1;
                        s.buf[i] = s.buf[i] + 25;
                }       else if (s.buf[i] == '0') {
                        borrow = 1;
                        s.buf[i] = '9';
                } else if (::isalnum(s.buf[i])) {
                        borrow = 0;
                        s.buf[i] = s.buf[i] - 1;
                        if (s.buf[i] == '0'/* || buf [i] == 'a' || buf[i] == 'A'*/)
                                last = i;
                        break;
                }
        } while (i--);
        if (borrow)
                if (s.pbrk("9zZ") != s.rpbrk("9zZ"))
                        s = s.rm(s.pbrk("9zZ"), 1);
                else {
                        long c = s.pbrk("9zZ");
                        if (::isalpha(s.buf[c])) s.buf[c] = s.buf[c] - 25;
                        else if (::isdigit(s.buf[c])) s.buf[c] = '0';
                }
        if (last > -1)
                if (s.pbrk("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") == last &&
                         s.rpbrk("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") != last)
                        s = s.rm(last, 1);
        return s;
}

string string::decn() {
        string t(buf); 
        register char borrow = 0;
        long last = -1, s;
        size_t i = strlen(t.buf) - 1;
        do {
                if (t.buf[i] == '0') {
                        borrow = 1;
                        t.buf[i] = '9';
                } else if (::isdigit(t.buf[i])) {
                        borrow = 0;
                        t.buf[i] = t.buf[i] - 1;
                        if (t.buf[i] == '0')
                                last = i;
                        break;
                }
        } while (i--);
        if (borrow) {
                s = t.chr('9');
                if (s != t.rchr('9'))
                        t = t.rm(s, 1);
                else t.buf[s] = '0';
        }
        if (last > -1)
                if (t.pbrk("1234567890") == last &&
                         t.rpbrk("1234567890") != last)
                        t = t.rm(last, 1);
        return t;
}

string string::add(const char* s) {
        string t(s);
        string u(buf);
        t = t.alnums();
        if (t == 'a' || t == 'A' || t == '0') {
                u = u.inc();
                return u;
        } else if (u == 'a' || u == 'A' || u == '0') {
                u = t;
                u = u.inc();
                return u;
        }
        do {
                u = u.inc();
                t = t.dec();
        } while (t != 'a' && t != 'A' && t != '0' && t.len());
        if (t == 'a' || t == 'A') u = u.inc();
        return u;
}
string string::sub(const char* s) {
        string t(s);
        string u(buf); 
        t = t.alnums();
        if (t == 'a' || t == 'A' || t == '0') {
                u = u.dec();
                return u;
        } else if (u == 'a' || u == 'A' || u == '0') {
                u = t;
                u = u.dec();
                return u;
        }
        do {
                u = u.dec();
                t = t.dec();
        } while (t != 'a' && t != 'A' && t != '0' && t.len());
        if (t == 'a' || t == 'A') u = u.dec();
        return u;
}

string string::chomp(char c) {
        char x[2];
        x[0] = c; x[1] = 0;
        return chomp(x);
}

string string::munch(char c) {
        char x[2];
        x[0] = c; x[1] = 0;
        return munch(x);
}

string string::addn(int n) { string s(buf); for (; n; n--) s = s.incn(); return s; }
string string::addn(const char* s) {
        string t(s);
        string u(buf);
        u = u.addn(atoi(t.digits()));
        return u;
}

string string::subn(int n) { string s(buf); for (; n; n--) s = s.decn(); return s; }
string string::subn(const char* s) {
        string t(s);
        string u(buf);
        u = u.subn(atoi(t.digits()));
        return u;
}

unsigned short string::cksum() {
        size_t i;
        unsigned short sum = 0;
        for (i = 0; buf[i]; i++) {
                sum = (sum >> 1) + ((sum & 1) << 15);
                sum += buf[i];
                sum &= 0xffff;
        }
        return sum;
}

string& string::operator =(string s) {
        if (s.empty()) { clear(); return *this; }
        if (buf) free(buf);
        buf = s.buf;
        mlen = s.msize();
        s.buf = 0;
        return *this;
}

string& string::operator =(const char* s) {
        if (s == 0) { clear(); return *this; }
        realloc(strlen(s) + 1);
        strcpy2(buf, s);
        return *this;
}
/*string& string::operator =(char c) {
        ::puts("char");
        this->realloc(2);
        buf[0] = c; buf[1] = 0;
        return *this;
}*/

string string::operator +(const char* str) { return this->cat(str); }

string string::operator +(char c) { return this->cat(c); }

string& string::operator +=(const char* str) { *this = this->cat(str); return *this; }

string& string::operator +=(char c) { *this = this->cat(c); return *this; }

string string::operator -(const char* str) { return this->prep(str); }

string string::operator -(char c) { return this->prep(c); }

string& string::operator -=(const char* str) { *this = this->prep(str); return *this; }

string& string::operator -=(char c) { *this = this->prep(c); return *this; }

bool string::operator ==(const char* str) { if (!buf) return false; return !strcmp(buf, str); }

bool string::operator ==(char c) { if (!buf) return false; if (buf[0] == c && buf[1] == 0) return true; return false; }

bool string::operator !=(const char* str) { if (!buf) return true; return strcmp(buf, str); }

bool string::operator != (char c) { if (!buf) return true; if (buf[0] != c) return true; return false; }

char& string::operator [](int i) { realloc(i + 1); return this->buf[i]; }

string string::operator *(int i) {
        string s(strlen(buf) * i + 1);
        strcpy(s.buf, buf);
        for (i--; i > 0; i--)
                strcat(s.buf, buf);
        return s;
}

string& string::operator *=(int i) {
        *this = this->operator*(i);
        return *this;
}

string string::operator ()() { return this->qx(); }

string& string::operator ++() { *this = this->incn(); return *this; }

string string::operator ++(int foo) { string s(buf); *this = this->incn(); return s; }

string& string::operator --() { *this = this->decn(); return *this; }

string string::operator --(int foo) { string s(buf); *this = this->decn(); return s; }

//io::output& operator<< (io::output& o, string s) { o.operator<<(s.buf); return o; }
//io::input& operator>> (io::input& o, string& s) { o.operator>>(s.buf); return o; }

io::input& io::input::operator>> (string& s) { return operator>>(s.buf); }

int string::cmpstr(const char* s, ...) {
        va_list v;
        va_start(v, s);
        const char* c;
        int i = 0;
        for (c = s; c != NULL; c = va_arg(v, const char*), i++)
                if (!strcmp(buf, c)) break;
        va_end(v);
        if (c == NULL) return -1;
        return i;
}

int string::cmpinstr(const char* s, ...) {
        va_list v;
        va_start(v, s);
        const char* c;
        int i = 0;
        for (c = s; c != NULL; c = va_arg(v, const char*), i++)
                if (strstr(buf, c)) break;
        va_end(v);
        if (c == NULL) return -1;
        return i;
}

int string::cmpleft(const char* s, ...) {
        va_list v;
        va_start(v, s);
        register const char* c;
        int i = 0;
        for (c = s; c != NULL; c = va_arg(v, const char*), i++)
                if (!strncmp(buf, c, strlen(c))) break;
        va_end(v);
        if (c == NULL) return -1;
        return i;
}

int string::cmpright(const char* s, ...) {
        va_list v;
        va_start(v, s);
        const char* c;
        register size_t k = strlen(buf);
        int i = 0;
        for (c = s; c != NULL; c = va_arg(v, const char*), i++)
                if (!strncmp(buf + k - strlen(c), c, strlen(c))) break;
        va_end(v);
        if (c == NULL) return -1;
        return i;
}

int fs::file::putc(int c) {
        register int i = fputc(c, fd);
        if (i == EOF) {
                errnum = errno;
                if (feof(fd)) drain(); 
                else if (ferror(fd)) kill();
                return EOF;
        } else { heal(); return i; }
}

int fs::file::getc() {
        register int i = fgetc(fd);
        if (i == EOF) {
                errnum = errno;
                if (feof(fd)) drain();
                else if (ferror(fd)) kill();
                else hurt();
                return EOF;
        } else { heal(); return i; }
}

/*string fs::file::gets(int size) {
        string s;
        int i = 32, j = 0;
        register int c;
        s.realloc(i);
        for (c = getc(); ; c = getc(), j++) {
                if (size) if (j >= size) break;
                if (j >= i - 4) { i *= 2; s.realloc(i); }
                switch (c) {
                case EOF: s.buf[0] = 0; return s;
                case '\n': s.buf[j] = '\n'; s.buf[++j] = 0; return s;
                default: s.buf[j] = c;
                }
        }
        s.buf[j] = 0;
        return s;
}*/

FILE* fs::file::open(const char* fname, const char* mode) {
        filename = fname;
        if ((fd = fopen(fname, mode)) == NULL) {
                errnum = errno;
                kill();
        } else heal();
        return fd;
}

FILE* fs::file::dopen(int fh, const char* mode) {
        filename.clear();
        filename.printf("%ld", fd);
        if ((fd = fdopen(fh, mode)) == NULL) {
                errnum = errno;
                kill();
        } else heal();
        return fd;
}

FILE* fs::file::reopen(const char* fname, const char* mode) {
        filename = fname;
        if (freopen(fname, mode, fd) == NULL) {
                errnum = errno;
                kill();
                return NULL;
        }
        heal();
        return fd;
}

bool fs::file::close() {
        if (fclose(fd) == EOF) {
                errnum = errno;
                kill();
                return false;
        } else return true;
        drain();
}

bool fs::file::flush() {
        if (fflush(fd) == EOF) {
                errnum = errno;
                kill();
                return false;
        } else { heal(); return true; }
}

bool fs::file::seek(long offset, int whence) {

        if (!fseek(fd, offset, whence)) {
                heal();
                return true;
        } else {
                errnum = errno;
                hit();
                return false;
        }
}

long fs::file::tell() {
        register long i = ftell(fd);
        if (i == -1) {
                errnum = errno;
                hit();
                return -1;
        } else {
                heal();
                return i;
        }
}

bool fs::file::rewind() { return seek(0L, SEEK_SET); }

bool fs::file::unwind() { return seek(0L, SEEK_END); }

bool fs::file::ffwd(long offset) { return seek(offset, SEEK_CUR); }

bool fs::file::prev(long offset) { return seek(offset * -1, SEEK_CUR); }

bool fs::file::nobuf() {
        if (!setvbuf(fd, NULL, _IONBF, 0)) {
                heal(); return true;
        } else { errnum = errno; hit(); return false; }
}

bool fs::file::lbuf() {
        if (!setvbuf(fd, (char*)NULL, _IOLBF, 0)) {
                heal(); return true;
        } else { errnum = errno; hit(); return false; }
}

bool fs::file::fbuf(char* buf, size_t size) {
        if (!setvbuf(fd, buf, _IOFBF, size)) {
                heal(); return true;
        } else { errnum = errno; hit(); return false; }
}

int fs::file::ungetc(int c) {
        register int i = ::ungetc(c, fd);
        if (i == EOF) { hit(); return EOF; }
        else { errnum = errno; heal(); return i; }
}

fs::file::file(const char* name, const char* mode) { open(name, mode); }
fs::file::file(FILE* f) { fd = f; }
fs::file::file(int fh, const char* mode) { dopen(fh, mode); }

int net::socket::tcp::putc(int c) {
        char t = c;
        switch (::send(fd, &t, 1, 0)) {
        case 0: errnum = errno; hurt(); return EOF;
        case -1: errnum = errno; kill(); return EOF;
        default: heal(); return c;
        }
}

int net::socket::tcp::getc() {
        int a;
        char c;
        switch (::recv(fd, &c, 1, 0)) {
        case 0: errnum = errno; drain();  return EOF;
#ifdef _WIN32
        case SOCKET_ERROR: errnum = errno; kill(); return EOF;
#else
        case -1: errnum = errno; kill(); return EOF;
#endif
        default: heal(); a = c; return a;
        }
}

string io::input::gets(int size) {
        string s;
        int i;
        register int c;
        for (i = 0; ; i++) {
                if (size) if (i >= size) return s;
                c = getc();
                switch (c) {
                        case EOF: return s;
                        case '\n': s += '\n'; return s;
                        default:  s += c;
                }
        }
        return s;
}

/*string net::socket::tcp::gets(int size) {
        string s;
        int i;
        register int c;
        for (i = 0; ; i++) {
                if (size) if (i >= size) break;
                c = getc();     
                switch (c) {
                        case EOF: return s;
                        case '\n': s += '\n'; return s;
                        default: s += c;
                }
        }
        return s;
}*/
/*string net::socket::tcp::gets(int size) {
        string s;
        int i = 32, j = 0;
        register int c;
        s.realloc(i);
        for (c = getc(); ; c = getc(), j++) {
                if (size) if (j >= size) break;
                if (j >= i - 4) { i *= 2; s.realloc(i); }
                switch (c) {
                case EOF: s.buf[0] = 0; return s;
                case '\n': s.buf[j] = '\n'; s.buf[++j] = 0; return s;
                default: s.buf[j] = c;
                }
        }
        s.buf[j] = 0;
        return s;
}*/

int net::socket::tcp::send(const char* buf, size_t len) {
        register int i = ::send(fd, buf, len, 0);
        if (i == -1) { errnum = errno; kill(); return EOF; }
        else if (i == 0) { errnum = errno; hurt(); return EOF; }
        else { heal(); return i; }
}

int net::socket::tcp::recv(char* buf, size_t len) {
        register int i = ::recv(fd, buf, len, 0);
        if (i == -1) { errnum = errno; kill(); return EOF; }
        else if (i == 0) { errnum = errno; drain(); return EOF; }
        else { heal(); return i; }
}

bool net::socket::tcp::connect(const char* host, const char* port) {
        struct addrinfo hints, *ai;
        memset(&hints, 0, sizeof(struct addrinfo));
        hints.ai_protocol = IPPROTO_TCP;
        hints.ai_socktype = SOCK_STREAM;
        hints.ai_family = AF_UNSPEC;
        if (getaddrinfo(host, port, &hints, &ai)) {
#ifndef _WIN32
                errnum = errno;
#else
                errnum = wsatoerr(WSAGetLastError());
#endif
                kill();
                return false;
        }
        if (ai->ai_family != af) {
                bool b = blocking();
                fd = ::socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
#ifdef _WIN32
                if (fd == INVALID_SOCKET) {
                        errnum = wsatoerr(WSAGetLastError());
#else
                if (fd == -1) {
                        errnum = errno;
#endif
                        kill();
                        return false;
                }
                blocking(b);
                af = ai->ai_family;
        }
        if (::connect(fd, ai->ai_addr, ai->ai_addrlen)) {
#ifndef _WIN32
                errnum = errno;
#else
                errnum = wsatoerr(WSAGetLastError());
#endif
                kill();
                return false;
        }
        heal();
        freeaddrinfo(ai);
        return true;
}

bool net::socket::tcp::listen(const char* port, int backlog) {
        struct addrinfo hints, *ai;
        memset(&hints, 0, sizeof(struct addrinfo));
        hints.ai_family = AF_UNSPEC;
        hints.ai_socktype = SOCK_STREAM;
        hints.ai_protocol = IPPROTO_TCP;
        hints.ai_flags = AI_PASSIVE;
        if (getaddrinfo(0, port, &hints, &ai)) {
#ifndef _WIN32
                errnum = errno;
#else
                errnum = wsatoerr(WSAGetLastError());
#endif
                kill();
                return false;
        }
        if (ai->ai_family != af) {
                bool b = blocking();
                fd = ::socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
#ifdef _WIN32
                if (fd == INVALID_SOCKET) {
                        errnum = wsatoerr(WSAGetLastError());
#else
                if (fd == -1) {
                        errnum = errno;
#endif
                        kill();
                        return false;
                }
                blocking(b);
                af = ai->ai_family;
        }
        if (bind(fd, ai->ai_addr, ai->ai_addrlen)) {
#ifndef _WIN32
                errnum = errno; 
#else
                errnum = wsatoerr(WSAGetLastError());
#endif
                freeaddrinfo(ai); return false;
        }
        freeaddrinfo(ai);
        if (::listen(fd, backlog) == -1) {
#ifndef _WIN32
                errnum = errno;
#else
                errnum = wsatoerr(WSAGetLastError());
#endif
                kill();
                return false;
        }
        heal();
        return true;
}


bool net::socket::tcp::accept(net::socket::tcp& f) {
        if ((f.fd = ::accept(fd, NULL, NULL)) == -1) {
#ifndef _WIN32
                errnum = errno; 
#else
                errnum = wsatoerr(WSAGetLastError());
#endif
                hurt();
                return false;
        } else return true;
}

string::string(const data& s) {
        fmt.bin(0);
        buf = 0; pos = 0; mlen = s.len();
        if (s.buf) {
                buf = (char*)malloc(mlen);
                strcpy(buf, s.buf);
        }
}

string& string::operator= (const data& d) {
        return this->operator= (d.buf);
}

data net::http::download(const char* url, const char* port) {
        data d;
        net::socket::tcp sock;
        string s = url;
        s = s.munch("http://");
        unless (sock.connect(s.burn('/'), port)) return d;
        sock << "GET /" << s.slurp('/') << " HTTP/1.1\r\nHost: " << s.burn('/') << "\r\n\r\n";
        s = sock.drink("\r\n\r\n");
        unless (s.slurp("Content-Length: ").burn('\r').empty())
                d = sock.read(1, stoi<size_t>(s.slurp("Content-Length: ").burn('\r')));
        else d = sock.dump();
        sock.close();
        return d;
}

bool net::socket::tcp::close() {
        drain();
#ifdef _WIN32
        if (!closesocket(fd))
                { tcp(); return true; }
        else { errnum = wsatoerr(WSAGetLastError()); tcp();return false; }
#else
        if (::close(fd) == -1) {
                errnum = errno; 
                tcp();
                return false;
        } else { tcp();return true;}
#endif
}

bool net::socket::tcp::blocking(int i) {
#ifndef _WIN32
        if (i == -1)
                return fcntl(fd, F_GETFD) & O_NONBLOCK;
        else if (i == 0)
                return !fcntl(fd, fcntl(fd, F_GETFD) | O_NONBLOCK);
        else if (i)
                return !fcntl(fd, fcntl(fd, F_GETFD) & ~O_NONBLOCK);
#else
        unsigned long t;
        if (i == -1) return blking;
        else if (i == 1) {
                t = 1;
                return !ioctlsocket(fd, FIONBIO, &t);
        } else if (i == 0) {
                t = 0;
                return !ioctlsocket(fd, FIONBIO, &t);
        }
#endif
        return true;
}

net::socket::tcp::tcp() {
#ifdef _WIN32
        struct WSAData* wd = (struct WSAData*)malloc(sizeof(struct WSAData));
        int i;
        if (i = WSAStartup(MAKEWORD(2, 0), wd)) {
                errnum = wsatoerr(i);
                kill();
                free(wd);
                return;
        }
        free(wd);
        blking = true;
#endif
        af = AF_INET;
        fd = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
#ifdef _WIN32
        if (fd == INVALID_SOCKET) {
                errnum = wsatoerr(WSAGetLastError());
                kill();
                return;
        }
#else
        if (fd == -1) { errnum = errno; kill(); return; }
#endif
        
        drain();
}
#ifdef _WIN32
net::socket::tcp::~tcp() {
                WSACleanup();
}
#endif

bool net::socket::tcp::connected() { return !ip().empty(); }

string net::socket::tcp::ip() {
        string s;
#ifdef _WIN32
        DWORD d = 40;
#endif
        s.realloc(40);
        s.clear();
        struct sockaddr_storage ss;
        socklen_t sslen = sizeof(struct sockaddr_storage);
        if (::getpeername(this->fd, (struct sockaddr*)&ss, &sslen)) return s;
        if (ss.ss_family == AF_INET)
#ifndef _WIN32
                inet_ntop(ss.ss_family, &((struct sockaddr_in*)&ss)->sin_addr, s.buf, 40);
#else
                WSAAddressToStringA((struct sockaddr*)&ss, sizeof(struct sockaddr_storage), 0, s.buf, &d);
#endif
        else if (ss.ss_family == AF_INET6)
#ifndef _WIN32
                inet_ntop(ss.ss_family, &((struct sockaddr_in6*)&ss)->sin6_addr, s.buf, 40);
#else
                WSAAddressToStringA((struct sockaddr*)&ss, sizeof(struct sockaddr_storage), 0, s.buf, &d);
#endif
        return s;
}

string net::socket::tcp::name() {
        string s;
        s.realloc(256);
        s.clear();
        struct sockaddr sa;
        socklen_t slen = sizeof(struct sockaddr);
        ::getpeername(this->fd, &sa, &slen);
        getnameinfo(&sa, slen, s.buf, 256, 0, 0, 0);
        return s;
}

string object::type() { return string("object"); }
object::operator string () { return string("(null)"); }

string net::ipaddr::type() { return string("net::ipaddr"); }
net::ipaddr::operator string () {
        string s(42);
#ifndef _WIN32
        inet_ntop(this->af, &(this->addr4), s.buf, 42);
#else
        DWORD d = 42;
        struct sockaddr_in si;
        struct sockaddr_in6 sj;
        memset(&si, 0, sizeof(struct sockaddr_in));
        memset(&sj, 0, sizeof(struct sockaddr_in6));
        if (af == AF_INET) {
                si.sin_family = AF_INET;
                memmove(&(si.sin_addr), &(this->addr4), sizeof(struct in_addr));
                WSAAddressToStringA(
                        (struct sockaddr*)&si,
                        sizeof(struct sockaddr_in),
                        NULL,
                        s.buf,
                        &d
                );
        } else if (af == AF_INET6) {
                sj.sin6_family = AF_INET6;
                sj.sin6_port = 0;
                memmove(&(sj.sin6_addr), &(this->addr6), sizeof(struct in6_addr));
                WSAAddressToStringA(
                        (struct sockaddr*)&sj,
                        sizeof(struct sockaddr_in6),
                        NULL,
                        s.buf,
                        &d
                );
        }
                        
#endif
        return s;
}
#ifdef _WIN32
void net::ipaddr::initwsa() {
        WSAData* wd = (struct WSAData*)malloc(sizeof(struct WSAData));
        WSAStartup(MAKEWORD(2, 0), wd);
        free(wd);
}
#endif
net::ipaddr::ipaddr(const char* s) {
#ifdef _WIN32
        initwsa();
#endif
        this->operator=(s); }
net::ipaddr::ipaddr(struct in_addr* s) {
#ifdef _WIN32
        initwsa();
#endif
this->operator=(s); }
net::ipaddr::ipaddr(struct in6_addr* s) {
#ifdef _WIN32
        initwsa();
#endif
this->operator=(s); }

bool net::ipaddr::cmp(const char* s, struct in_addr * ia4, struct in6_addr * ia6, int op) {
        net::ipaddr ip;
        register size_t t;
        if (s) ip = s;
        else if (ia4) ip = ia4;
        else if (ia6) ip = ia6;
        if (af == AF_INET) t = sizeof(struct in_addr);
        else if (af == AF_INET6) t = sizeof(struct in6_addr);
        if (ip.af != af) return false;
        switch (op) {
        case 0: /* == */
                return !memcmp(&addr4, &(ip.addr4), t);
        case 1: /* != */
                return memcmp(&addr4, &(ip.addr4), t);
        case 2: /* > */
                return memcmp(&addr4, &(ip.addr4), t) > 0;
        case 3: /* >= */
                return memcmp(&addr4, &(ip.addr4), t) >= 0;
        case 4: /* < */
                return memcmp(&addr4, &(ip.addr4), t) < 0;
        case 5: /* <= */
                return memcmp(&addr4, &(ip.addr4), t) <= 0;
        }
        return false;
}

bool net::ipaddr::operator== (const char* s) { return this->cmp(s, 0, 0, 0); }
bool net::ipaddr::operator!= (const char* s) { return this->cmp(s, 0, 0, 1); }
bool net::ipaddr::operator> (const char* s) { return this->cmp(s, 0, 0, 2); }
bool net::ipaddr::operator>= (const char* s) { return this->cmp(s, 0, 0, 3); }
bool net::ipaddr::operator< (const char* s) { return this->cmp(s, 0, 0, 4); }
bool net::ipaddr::operator<= (const char* s) { return this->cmp(s, 0, 0, 5); }
bool net::ipaddr::operator== (struct in_addr * s) { return this->cmp(0, s, 0, 0); }
bool net::ipaddr::operator!= (struct in_addr * s) { return this->cmp(0, s, 0, 1); }
bool net::ipaddr::operator> (struct in_addr * s) { return this->cmp(0, s, 0, 2); }
bool net::ipaddr::operator>= (struct in_addr * s) { return this->cmp(0, s, 0, 3); }
bool net::ipaddr::operator< (struct in_addr * s) { return this->cmp(0, s, 0, 4); }
bool net::ipaddr::operator<= (struct in_addr * s) { return this->cmp(0, s, 0, 5); }
bool net::ipaddr::operator== (struct in6_addr * s) { return this->cmp(0, 0, s, 0); }
bool net::ipaddr::operator!= (struct in6_addr * s) { return this->cmp(0, 0, s, 1); }
bool net::ipaddr::operator> (struct in6_addr * s) { return this->cmp(0, 0, s, 2); }
bool net::ipaddr::operator>= (struct in6_addr * s) { return this->cmp(0, 0, s, 3); }
bool net::ipaddr::operator< (struct in6_addr * s) { return this->cmp(0, 0, s, 4); }
bool net::ipaddr::operator<= (struct in6_addr * s) { return this->cmp(0, 0, s, 5); }

net::ipaddr& net::ipaddr::operator= (const char* s) {
        int f;
        string t = s;
        union { struct in_addr ia; struct in6_addr ia6; } a;
        if (t.chr(':') > -1) f = AF_INET6;
        else if (t.isctype(".0123456789")) f = AF_INET;
        else {
                struct addrinfo *ai;
                if (getaddrinfo(s, 0, 0, &ai)) return *this;
                af = ai->ai_family;
                if (af == AF_INET)
                        memmove(&addr4, &((struct sockaddr_in*)ai->ai_addr)->sin_addr, sizeof(struct sockaddr));
                else if (af == AF_INET6)
                        memmove(&addr6, &((struct sockaddr_in6*)ai->ai_addr)->sin6_addr, sizeof(struct sockaddr));
                freeaddrinfo(ai);
                return *this;
        }
#ifndef _WIN32
        if (inet_pton(f, s, &a) < 1) return *this;
#else
        DWORD d = 42;
        int z = 42, foobar;
        char* crap = (char*)malloc(strlen(s) + 1);
        strcpy(crap, s);
        struct sockaddr_in sa4;
        struct sockaddr_in6 sa6;
        sa4.sin_family = AF_INET;
        sa6.sin6_family = AF_INET6;
        if (f == AF_INET) {
                foobar = sizeof(struct sockaddr_in);
                z = WSAStringToAddressA(
                        crap,
                        f,
                        NULL,
                        (struct sockaddr*)&sa4,
                        &foobar
                );
                memmove(&(a.ia), &(sa4.sin_addr), sizeof(struct in_addr));
        } else if (f == AF_INET6) {
                foobar = sizeof(struct sockaddr_in6);
                z = WSAStringToAddressA(
                        crap,
                        f,
                        NULL,
                        (struct sockaddr*)&sa6,
                        &foobar
                );
                memmove(&(a.ia6), &(sa6.sin6_addr), sizeof(struct in6_addr));
        }
        free(crap);
        if (z) return *this;
#endif
        af = f;
        if (f == AF_INET) this->operator=(&(a.ia));
        else if (f == AF_INET6) this->operator=(&(a.ia6));
        return *this;
}
net::ipaddr& net::ipaddr::operator=(struct in_addr* s) {
        af = AF_INET;
        memmove(&addr4, s, sizeof(struct in_addr));
        return *this;
}
net::ipaddr& net::ipaddr::operator=(struct in6_addr* s) {
        af = AF_INET6;
        memmove(&addr6, s, sizeof(struct in6_addr));
        return *this;
}

net::ipaddr net::ipaddr::operator+ (int i) {
        int m;
        if (af == AF_INET) {
                unsigned int j = ntohl(this->addr4.s_addr);
                unsigned char* k = (unsigned char*)&j;
                struct in_addr ia;
                for (m = 0; m < i; m++) {
                        k[0]++;
                        if (k[0] == 0) {
                                k[1]++;
                                if (k[1] == 0) {
                                        k[2]++;
                                        if (k[2] == 0) {
                                                k[3]++;
                                        }
                                }
                        }
                }
                ia.s_addr = htonl(j);
                return net::ipaddr(&ia);
        } else if (af == AF_INET6) {
                struct in6_addr ia;
                memmove(&ia, &addr6, sizeof(struct in6_addr));
                unsigned short* us = (unsigned short*)&(ia.s6_addr);
                int j;
                /* --------------- LIKE A BOSS --------------- */
                for (j = 0; j < i; j++) {
                        us[7] = htons(ntohs(us[7]) + 1);
                        if (!ntohs(us[7])) {
                                us[6] = htons(ntohs(us[6]) + 1);
                                if (!ntohs(us[6])) {
                                        us[5] = htons(ntohs(us[6]) + 1);
                                        if (!ntohs(us[5])) {
                                                us[4] = htons(ntohs(us[4]) + 1);
                                                if (!ntohs(us[4])) {
                                                        us[3] = htons(ntohs(us[3]) + 1);
                                                        if (!ntohs(us[3])) {
                                                                us[2] = htons(ntohs(us[2]) + 1);
                                                                if (!ntohs(us[2])) {
                                                                        us[1] = htons(ntohs(us[1]) + 1);
                                                                        if (!ntohs(us[1])) {
                                                                                us[0] = htons(ntohs(us[0]) + 1);
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
                return net::ipaddr(&ia);
        }
}
net::ipaddr net::ipaddr::operator- (int i) {
        int m;
        if (af == AF_INET) {
                unsigned int j = ntohl(this->addr4.s_addr);
                unsigned char* k = (unsigned char*)&j;
                struct in_addr ia;
                for (m = 0; m < i; m++) {
                        k[0]--;
                        if (k[0] == 0xff) {
                                k[1]--;
                                if (k[1] == 0xff) {
                                        k[2]--;
                                        if (k[2] == 0xff) {
                                                k[3]--;
                                        }
                                }
                        }
                }
                ia.s_addr = htonl(j);
                return net::ipaddr(&ia);
        } else if (af == AF_INET6) {
                struct in6_addr ia;
                memmove(&ia, &addr6, sizeof(struct in6_addr));
                unsigned short* us = (unsigned short*)&(ia.s6_addr);
                int j;
                /* --------------- LIKE A BOSS --------------- */
                for (j = 0; j < i; j++) {
                        us[7] = htons(ntohs(us[7]) - 1);
                        if (ntohs(us[7]) == 0xffff) {
                                us[6] = htons(ntohs(us[6]) - 1);
                                if (ntohs(us[6]) == 0xffff) {
                                        us[5] = htons(ntohs(us[5]) - 1);
                                        if (ntohs(us[5]) == 0xffff) {
                                                us[4] = htons(ntohs(us[4]) - 1);
                                                if (ntohs(us[4]) == 0xffff) {
                                                        us[3] = htons(ntohs(us[3]) - 1);
                                                        if (ntohs(us[3]) == 0xffff) {
                                                                us[2] = htons(ntohs(us[2]) - 1);
                                                                if (ntohs(us[2]) == 0xffff) {
                                                                        us[1] = htons(ntohs(us[1]) - 1);
                                                                        if (ntohs(us[1]) == 0xffff) {
                                                                                us[0] = htons(ntohs(us[0]) - 1);
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
                return net::ipaddr(&ia);
        }
}
net::ipaddr& net::ipaddr::operator+= (int i) { *this = this->operator+(i); return *this; }
net::ipaddr& net::ipaddr::operator-= (int i) { *this = this->operator-(i); return *this; }
net::ipaddr& net::ipaddr::operator++ () { *this = this->operator+(1); return *this; }
net::ipaddr net::ipaddr::operator++ (int foo) { net::ipaddr i = *this; *this = this->operator+(1); return i; }
net::ipaddr& net::ipaddr::operator-- () { *this = this->operator-(1); return *this; }
net::ipaddr net::ipaddr::operator-- (int foo) { net::ipaddr i = *this; *this = this->operator-(1); return i; }


bool net::socket::udp::bind(const char* port) {
        struct addrinfo hints, *ai;
        memset(&hints, 0, sizeof(struct addrinfo));
        hints.ai_family = AF_INET;
        hints.ai_socktype = SOCK_DGRAM;
        hints.ai_protocol = IPPROTO_UDP;
        hints.ai_flags = AI_PASSIVE;
        if (getaddrinfo(0, port, &hints, &ai)) return false;
        if (::bind(fd, ai->ai_addr, ai->ai_addrlen)) return false;
        freeaddrinfo(ai);
        return true;
}

void net::socket::udp::unbind() {
#ifdef _WIN32
        closesocket(fd);
#else
        close(fd);
#endif
        fd = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
}

int net::socket::udp::post(net::dgram dg) {
        struct sockaddr_in sa;
        sa.sin_family = AF_INET;
        sa.sin_port = htons(dg.port);
        memmove(&(sa.sin_addr), &(dg.ip.addr4), sizeof(struct in_addr));
        return ::sendto(fd, dg.msg.buf, dg.msg.len(), 0, (struct sockaddr*)&sa, sizeof(struct sockaddr_in));
}

net::dgram net::socket::udp::get() {
        net::dgram dg;
        struct sockaddr_in sa;
        socklen_t sl = sizeof(struct sockaddr_in);
        until (this->check() > -1);
        dg.msg.realloc(this->check() + 1);
        ::recvfrom(fd, dg.msg.buf, dg.msg.len(), 0, (struct sockaddr*)&sa, &sl);
        dg.ip = &(sa.sin_addr);
        dg.port = ntohs(sa.sin_port);
        return dg;
}

/*int net::socket::udp::send(const char* buf, size_t len) {
        struct sockaddr_in sa;
        sa.sin_family = AF_INET;
        sa.sin_port = htons(port);
        memmove(&(sa.sin_addr), &(peer.addr4), sizeof(struct in_addr));
        return ::sendto(fd, buf, len, 0, (struct sockaddr*)&sa, sizeof(struct sockaddr_in));
}*/

/*int net::socket::udp::recv(char* buf, size_t len) {
        struct sockaddr_in sa;
        socklen_t sl = sizeof(struct sockaddr_in);
        register int i = ::recvfrom(fd, buf, len, 0, (struct sockaddr*)&sa, &sl);
        peer = &(sa.sin_addr);
        return i;
}*/

/*int net::socket::udp::puts(const char* s) {
        struct sockaddr_in sa;
        sa.sin_family = AF_INET;
        sa.sin_port = htons(port);
        memmove(&(sa.sin_addr), &(peer.addr4), sizeof(struct in_addr));
        register int i = ::sendto(fd, s, strlen(s), 0, (struct sockaddr*)&sa, sizeof(struct sockaddr_in));
        switch (i) {
        case 0: hurt(); return EOF;
        case -1: kill(); return EOF;
        default: heal(); return i;
        }
}*/

int net::socket::tcp::puts(const char* s) {
        register int i = ::send(fd, s, strlen(s), 0);
        switch (i) {
        case 0: hurt(); return EOF;
        case -1: kill(); return EOF;
        default: heal(); return i;
        }
}

net::socket::udp::udp() {
#ifdef _WIN32
        struct WSAData* wd = (struct WSAData*)malloc(sizeof(struct WSAData));
        WSAStartup(MAKEWORD(2, 0), wd);
        free(wd);
#endif
        fd = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
}
net::socket::udp::~udp() {
#ifdef _WIN32
                closesocket(fd);
                WSACleanup();
#else
                close(fd);
#endif
}

bool net::socket::tcp::ready() {
        fd_set rfd;
#ifndef _WIN32
        struct timeval tv = {0, 0};
#else
        TIMEVAL tv = {0, 0};
#endif
        FD_ZERO(&rfd);
        FD_SET(fd, &rfd);
        select(fd + 1, &rfd, 0, 0, &tv);
        return FD_ISSET(fd, &rfd);
}

int net::socket::udp::check() {
        int i = -1;
#ifndef _WIN32
        ioctl(fd, FIONREAD, &i);
#else
        ioctlsocket(fd, FIONREAD, (unsigned long*)&i);
#endif
        if (i == 0) {
#ifndef _WIN32
                struct pollfd pf;
                pf.fd = fd;
                pf.events = POLLIN;
                pf.revents = 0;
                poll(&pf, 1, 0);
                if (pf.revents & POLLIN) return 0;
                else return -1;
#else
                fd_set pf;
                pf.fd_count = 1;
                pf.fd_array[0] = fd;
                TIMEVAL tv = {0, 0};
                select(0, &pf, 0, 0, &tv); 
                if (FD_ISSET(fd, &pf)) return 0;
                else return -1;
#endif
        } else return i;
}

string net::socket::udp::type() { return string("net::socket::udp"); }
net::socket::udp::operator string () { string s; s << fd; return s;}

//net::socket::udp& net::socket::udp::to(const char* ip) { peer = ip; return *this; }
//net::socket::udp& net::socket::udp::on(unsigned short p) { p = htons(p); return *this; }

/*net::socket::udp& net::socket::udp::operator= (const char* endpoint) {
        string s = endpoint;
        if (s[0] != '*')
                peer = s.burn('/');
        if (!s.ends('*')) port = atoi(s.slurp('/'));
        return *this;
}*/

/*int net::socket::udp::getc() {
        int a;
        char c;
        struct sockaddr_in sa;
        socklen_t sl = sizeof(struct sockaddr_in);
        switch (::recvfrom(fd, &c, 1, 0, (struct sockaddr*)&sa, &sl)) {
        case 0: drain();  a = EOF; break;
#ifdef _WIN32
        case SOCKET_ERROR: a = EOF; break;
#else
        case -1: kill(); a = EOF; break;
#endif
        default: heal(); a = c; break;
        }
        peer = &(sa.sin_addr);
        return a;
}

int net::socket::udp::putc(int c) {
        register char d = c;
        struct sockaddr_in sa;
        sa.sin_family = AF_INET;
        sa.sin_port = htons(port);
        memmove(&(sa.sin_addr), &(peer.addr4), sizeof(struct in_addr));
        switch (::sendto(fd, &d, 1, 0, (struct sockaddr*)&sa, sizeof(struct sockaddr_in))) {
        case 0: hurt(); return EOF;
        case -1: kill(); return EOF;
        default: heal(); return c;
        }
}*/

int console::putc(int c) {
        register int i = fputc(c, out);
        if (i == EOF) {
                if (feof(out)) drain();
                else if (ferror(out)) kill();
                return EOF;
        } else { heal(); return i; }
}

int console::getc() {
        register int i = fgetc(in);
        if (i == EOF) {
                if (feof(in)) drain();
                else if (ferror(in)) kill();
                return EOF;
        } else { heal(); return i; }
}
/*string console::gets(int size) {
        string s;
        int i = 32, j = 0;
        register int c;
        s.realloc(i);
        for (c = getc(); ; c = getc(), j++) {
                if (size) if (j >= size) break;
                if (j >= i - 4) { i *= 2; s.realloc(i); }
                switch (c) {
                case EOF: s.buf[0] = 0; return s;
                case '\n': s.buf[j] = '\n'; s.buf[++j] = 0; return s;
                default: s.buf[j] = c;
                }
        }
        s.buf[j] = 0;
        return s;
}*/

#ifndef _WIN32
int console::getch() {
        int i = ::fileno(in);
        struct termios oldt, newt;
        int ch;
        tcgetattr(i, &oldt);
        newt = oldt;
        newt.c_lflag &= ~(ICANON | ECHO);
        tcsetattr(i, TCSANOW, &newt);
        ch = getchar();
        tcsetattr(i, TCSANOW, &oldt);
        return ch;
}
int console::getche() {
        int i = ::fileno(in);
        struct termios oldt, newt;
        int ch;
        tcgetattr(i, &oldt);
        newt = oldt;
        newt.c_lflag &= ~ICANON;
        newt.c_lflag &= ECHO;
        tcsetattr(i, TCSANOW, &newt);
        ch = getchar();
        tcsetattr(i, TCSANOW, &oldt);
        return ch;
}
bool console::kbhit() {
        int i = ::fileno(in);
        struct termios oldt, newt;
        struct timeval tv;
        fd_set fds;
        int ret;
        tcgetattr(i, &oldt);
        newt = oldt;
        newt.c_lflag &= ~(ICANON | ECHO);
        tcsetattr(i, TCSANOW, &newt);
        tv.tv_sec = 0;
        tv.tv_usec = 0;
        FD_ZERO(&fds);
        FD_SET(i, &fds);
        select(i + 1, &fds, 0, 0, &tv);
        ret = FD_ISSET(i, &fds);
        tcsetattr(i, TCSANOW, &oldt);
        return ret;
}
console& console::putcr() { fputc('\r', out); fflush(out); return *this; }
console& console::putbs() { fputc('\b', out); fflush(out); return *this; }
console& console::cls() { fputs("\x1B[2J", out); return *this; }
console& console::bel() { fputc('\a', out); fflush(out); return *this; }
console& console::setxy(int x, int y) { sprintf(s, "\x1B[%d;%df", y, x); fputs(s, out); return *this; }
console& console::setx(int x) { sprintf(s, "\x1B[%dd", x); fputs(s, out); return *this; }
console& console::sety(int y) { sprintf(s, "\x1B%dG", y); fputs(s, out); return *this; }
console& console::up(int n) { sprintf(s, "\x1B[%dA", n); fputs(s, out); return *this; }
console& console::dn(int n) { sprintf(s, "\x1B[%dB", n); fputs(s, out); return *this; }
console& console::rt(int n) { sprintf(s, "\x1B[%dC", n); fputs(s, out); return *this; }
console& console::lt(int n) { sprintf(s, "\x1B[%dD", n); fputs(s, out); return *this; }
console& console::rmln() { fputs("\x1B[1K", out); return *this; }
console& console::fglite() { fputs("\x1B[1m", out); return *this; }
console& console::fgdark() { fputs("\x1B[22m", out); return *this; }
console& console::fgcol(short color) { sprintf(s, "\x1B[%dm", color + 30); fputs(s, out); return *this; }
console& console::bgcol(short color) { sprintf(s, "\x1B[%dm", color + 40); fputs(s, out); return *this; }
#else
HANDLE console::coninfo(HANDLE* h, CONSOLE_SCREEN_BUFFER_INFO* bi) {
        if (h != NULL) {
                *h = GetStdHandle(STD_OUTPUT_HANDLE);
                if (bi != NULL) GetConsoleScreenBufferInfo(*h, bi);
                return *h;
        }
        return NULL;
}
console& console::bel() { MessageBeep(0xffffffff); return *this; }
console& console::setxy(int x, int y) {
        HANDLE h;
        COORD c;
        c.X = x;
        c.Y = y;
        SetConsoleCursorPosition(coninfo(&h, 0), c);
        return *this;
}
console& console::setx(int x) {
        HANDLE h;
        CONSOLE_SCREEN_BUFFER_INFO bi;
        coninfo(&h, &bi);
        bi.dwCursorPosition.X = x;
        SetConsoleCursorPosition(h, bi.dwCursorPosition);
        return *this;
}
console& console::sety(int y) {
        HANDLE h;
        CONSOLE_SCREEN_BUFFER_INFO bi;
        coninfo(&h, &bi);
        bi.dwCursorPosition.Y = y;
        SetConsoleCursorPosition(h, bi.dwCursorPosition);
        return *this;
}
console& console::up(int n) {
        HANDLE h;
        CONSOLE_SCREEN_BUFFER_INFO bi;
        coninfo(&h, &bi);
        bi.dwCursorPosition.Y -= n;
        SetConsoleCursorPosition(h, bi.dwCursorPosition);
        return *this;
}
console& console::dn(int n) {
        HANDLE h;
        CONSOLE_SCREEN_BUFFER_INFO bi;
        coninfo(&h, &bi);
        bi.dwCursorPosition.Y += n;
        SetConsoleCursorPosition(h, bi.dwCursorPosition);
        return *this;
}
console& console::lt(int n) {
        HANDLE h;
        CONSOLE_SCREEN_BUFFER_INFO bi;
        coninfo(&h, &bi);
        bi.dwCursorPosition.X -= n;
        SetConsoleCursorPosition(h, bi.dwCursorPosition);
        return *this;
}
console& console::rt(int n) {
        HANDLE h;
        CONSOLE_SCREEN_BUFFER_INFO bi;
        coninfo(&h, &bi);
        bi.dwCursorPosition.X += n;
        SetConsoleCursorPosition(h, bi.dwCursorPosition);
        return *this;
}
console& console::rmln() {
        HANDLE h;
        CONSOLE_SCREEN_BUFFER_INFO bi;
        COORD c;
        coninfo(&h, &bi);
        c = bi.dwCursorPosition;
        c.X = 0;
        FillConsoleOutputCharacterA(h, ' ', bi.dwCursorPosition.X, c, 0);
        return *this;
}
console& console::fglite() {
        HANDLE h;
        CONSOLE_SCREEN_BUFFER_INFO bi;
        coninfo(&h, &bi);
        bi.wAttributes |= FOREGROUND_INTENSITY;
        SetConsoleTextAttribute(h, bi.wAttributes);
        return *this;
}
console& console::fgdark() {
        HANDLE h;

        CONSOLE_SCREEN_BUFFER_INFO bi;
        coninfo(&h, &bi);
        bi.wAttributes &= ~FOREGROUND_INTENSITY;

        SetConsoleTextAttribute(h, bi.wAttributes);
        return *this;
}
console& console::fgcol(short color) {
        HANDLE h;
        coninfo(&h, 0);
        SetConsoleTextAttribute(h, color);
        return *this;
}
console& console::bgcol(short color) {
        HANDLE h;
        CONSOLE_SCREEN_BUFFER_INFO bi;
        coninfo(&h, &bi);
        switch (color) {
        case color::black:
                bi.wAttributes &= ~(BACKGROUND_BLUE | BACKGROUND_RED | BACKGROUND_GREEN);
                color = bi.wAttributes;
                break;
        case color::blue: color = BACKGROUND_BLUE; break;
        case color::green: color = BACKGROUND_GREEN; break;
        case color::red: color = BACKGROUND_RED; break;
        case color::aqua: color = BACKGROUND_BLUE | BACKGROUND_GREEN; break;
        case color::purple: color = BACKGROUND_BLUE | BACKGROUND_RED; break;
        case color::yellow: color = BACKGROUND_GREEN | BACKGROUND_RED; break;
        case color::white: color = BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE; break;
        }
        SetConsoleTextAttribute(h, color);
        return *this;
}
console& console::cls() {
        HANDLE h;
        coninfo(&h, 0);
        COORD ab, xy;
        xy = GetLargestConsoleWindowSize(h);
        ab.X = 0;
        ab.Y = 0;
        FillConsoleOutputCharacterA(h, ' ', xy.X * xy.Y, ab, 0);
        SetConsoleCursorPosition(h, ab);
        return *this;
}
int console::getch() { return _getch(); }
int console::getche() { return _getche(); }
bool console::kbhit() { return _kbhit(); }
console& console::putcr() {
        HANDLE h;
        CONSOLE_SCREEN_BUFFER_INFO bi;
        coninfo(&h, &bi);
        bi.dwCursorPosition.X = 0;
        SetConsoleCursorPosition(h, bi.dwCursorPosition);
        return *this;
}
console& console::putbs() {
        HANDLE h;
        CONSOLE_SCREEN_BUFFER_INFO bi;
        coninfo(&h, &bi);
        bi.dwCursorPosition.X -= 1;
        SetConsoleCursorPosition(h, bi.dwCursorPosition);
        fputc(0, out);
        bi.dwCursorPosition.X -= 1;
        SetConsoleCursorPosition(h, bi.dwCursorPosition);
        return *this;
}
#endif

console con;

void die(const char* format, ...) {
        va_list v;
        va_start(v, format);
        vfprintf(stderr, format, v);
        exit(1);
}

unsigned short cksum(const char* buf) {
        size_t i;
        unsigned short sum = 0;
        for (i = 0; buf[i]; i++) {
                sum = (sum >> 1) + ((sum & 1) << 15);
                sum += buf[i];
                sum &= 0xffff;
        }
        return sum;
}

int rand(int min, int max) {
        srand(time(NULL));
        if (min == 0 && max == 0) return ::rand();
        return (::rand() % (max - min)) + min;
}
int rands(unsigned int seed, int min, int max) {
        srand(seed);
        if (min == 0 && max == 0) return ::rand();
        return (::rand() % (max - min)) + min;
}

char* memrev(char* s, size_t size, size_t n) {
        char *a = s, *b = s + size * --n, *c = (char*)malloc(size);
        for (; a < b; a = a + size, b = b - size) {
                memmove(c, a, size);
                memmove(a, b, size);
                memmove(b, c, size);
        }
        free(c);
        return s;
}

char* memrol(char* s, size_t size, size_t n) {
        size_t i = size * --n;  
        char* a = (char*)malloc(size);
        memmove(a, s + i, size);
        memmove(s + size, s, i);
        memmove(s, a, size);
        free(a);
        return s; 
}

char* memror(char* s, size_t size, size_t n) {
        size_t i = size * --n;
        char* a = (char*)malloc(size);
        memmove(a, s, size);
        memmove(s, s + size, i);
        memmove(s + i, a, size);
        free(a);
        return s;
}
char* memshr(char* s, size_t size, size_t n) {
        memmove(s + size, s, (n - 1) * size);
        return s + size;
}
char* memshl(char* s, size_t size, size_t n) {
        memmove(s, s + size, (n - 1) * size);
        return s;
}

string chop(const char* str) {
        string s(str);
        s = s.chop();
        return s;
}
string chomp(const char* str, const char* eat) {
        string s(str);
        s = s.chomp(eat);
        return s;
}
string cut(const char* str) {
        string s(str);
        s = s.cut();
        return s;
}
string munch(const char* str, const char* eat) {
        string s(str);
        s = s.munch(eat);
        return s;
}
string ltrim(const char* str) {
        string s(str);
        s = s.ltrim();
        return s;
}
string rtrim(const char* str) {
        string s(str);
        s = s.rtrim();
        return s;
}
string strip(const char* str) {
        string s(str);
        s = s.strip();
        return s;
}
string substr(const char* str, size_t offset, size_t length) {
        string s(str);
        return s.substr(offset, length);
}
string lc(const char* str) {
        string s(str);
        return s.lc();
}
string lcfirst(const char* str) {
        string s(str);
        s[0] = tolower(s[0]);
        return s;
}
string uc(const char* str) {
        string s(str);
        return s.uc();
}
string ucfirst(const char* str) {
        string s(str);
        s[0] = toupper(s[0]);
        return s;
}
long rindex(const char* str, const char* find) {
        const char *t, *u;
        for (t = strstr(str, find), u = t; t; t = strstr(u, find))
                if (t) u = t;
        return u - str;
}
long rindex(const char* str, int find) {
        char a[2];
        a[0] = find; a[1] = 0;
        return rindex(str, a);
}
string q(const char* str) {
        string s(str);
        return s.q();
}
string qq(const char* str) {
        string s(str);
        return s.qq();
}
string qx(const char* exec) {
        string s(exec);
        return s.qx();
}
string scat(const char* s1, const char* s2) {
        string s(s1);
        s = s.cat(s2);
        return s;
}
string sdup(const char* str, int x) {
        string s(str);
        return s * x;
}
string tok(size_t index, const char* str, const char* delim) {
        string s(str);
        return s.tok(index, delim);
}
string tok(size_t index, const char* str, int delim) {
        char a[2];
        a[0] = delim; a[1] = 0;
        return tok(index, str, a);
}
long ntok(const char* str, const char* delim) {
        string s(str);
        return s.ntok(delim);
}
long ntok(const char* str, int delim) {
        char a[2];
        a[0] = delim; a[1] = 0;
        return ntok(str, a);
}
long itok(size_t index, const char* str, const char* delim) {
        string s(str);
        return s.itok(index, delim);
}
long itok(size_t index, const char* str, int delim) {
        char a[2];
        a[0] = delim; a[1] = 0;
        return itok(index, str, a);
}
std::deque<axcel::string> split(const char* str, const char* delim) {
        axcel::string s(str);
        return s.split(delim);
}
std::deque<axcel::string> split(const char* str, int delim) {
        char a[2];
        a[0] = delim; a[1] = 0;
        return split(str, a);
}
string join(std::deque<axcel::string> v, const char* delim) {
        axcel::string s;
        while (!v.empty()) {
                s += v.front();
                s += delim;
                v.pop_front();
        }
        s = s.chomp(delim);
        return s;
}
string join(std::deque<axcel::string> v, int delim) {
        axcel::string s;
        while (!v.empty()) {
                s += v.front();
                s += delim;
                v.pop_front();
        }
        char a[2];
        a[0] = delim; a[1] = 0;
        s = s.chomp(a);
        return s;
}

string string::rep(const char* oldstr, const char* newstr) {
        string s(buf);
        if (s.str(oldstr) == -1) return s;
        long i = 0, k = -1, p;
        size_t j = strlen(oldstr), o = strlen(newstr);
        for (;;) {
                if (i > s.len()) break;
                p = s.shl(i).str(oldstr);
                if (p == -1) break;
                i = p + i;
                s = s.rm(i, j);
                s = s.ins(i, newstr);
                i += o;
        }
        return s;
}

string string::rep(int oldc, int newc) {
        char a[2], b[2];
        a[0] = oldc; a[1] = 0;
        b[0] = newc; b[1] = 0;
        return rep(a, b);
}

string string::prefix(const char* str) {
        string s(buf);
        unless (s.starts(str)) s -= str;
        return s;
}

string string::suffix(const char* str) {
        string s(buf);
        unless (s.ends(str)) s += str;
        return s;
}

string string::untag(int opentag, int closetag) {
        string s;
        if (empty()) return s;
        size_t p = tell();
        rewind();
        int c;
        bool b = false;
        for (;;) {
                c = getc();
                if (c == EOF) break;
                if (c == opentag) { b = true; continue; }
                else if (c == closetag) { b = false; continue; }
                else if (!b) s.putc(c);
        }
        seek(p, SEEK_SET);
        return s;
}




#ifdef _WIN32
struct tm * localtime_r (const time_t *timer, struct tm *result)


{
   struct tm *local_result;
   local_result = localtime (timer);

   if (local_result == NULL || result == NULL)
     return NULL;

   memmove (result, local_result, sizeof (struct tm));
   return result;
}

struct tm * gmtime_r (const time_t *timer, struct tm *result)
{
   struct tm *local_result;
   local_result = gmtime (timer);

   if (local_result == NULL || result == NULL)
     return NULL;

   memmove (result, local_result, sizeof (struct tm));
   return result;
} 
#endif

time_t axcel_timegm(struct tm* tm) {
        time_t ret;
        string tz;
        tz = proc::envget("TZ");
        proc::envset("TZ", "");
        tzset();
        ret = mktime(tm);
        unless (tz.empty())
                proc::envset("TZ", tz);
        tzset();
        return ret;
}

timer::timer() { memset(&t, 0, sizeof(struct tm)); UTC = false; }
timer::timer(const char* s) { UTC = false; this->operator=((const char*)s); }
int timer::sec() { return t.tm_sec; }

int timer::min() { return t.tm_min; }

int timer::hour() { return t.tm_hour; }

int timer::mday() { return t.tm_mday; }

int timer::mon() { return t.tm_mon; }

int timer::year() { return t.tm_year; }

int timer::wday() { return t.tm_wday; }

string timer::str() {
        string s;
        s.realloc(32);
        string fmt;
        if (t.tm_wday != -1) fmt += "%a ";
        if (t.tm_mon != -1) fmt += "%b ";
#ifndef _WIN32
        if (t.tm_mday != -1) fmt += "%e ";
#else
        if (t.tm_mday != -1) fmt += "%d ";
#endif
        if (t.tm_hour != -1) {
                fmt += "%H:";
                if (t.tm_min != -1) fmt += "%M";
                else fmt += "00";
                if (t.tm_sec != -1) fmt += ":%S ";
        }
        if (t.tm_year != -1) fmt += "%Y";
        strftime(s.buf, 32, fmt, &t);
        return s;
}

timer& timer::operator= (const char* s) {
        int i;
        const char* c;
        t.tm_sec = 0;
        t.tm_min = 0;
        t.tm_hour = 0;
        t.tm_mday = 1;
        t.tm_mon = 0;
        t.tm_year = 0;
        t.tm_wday = 0;
        t.tm_isdst = 0;
        if (strstr(s, "Sun")) t.tm_wday = 0;
        else if (strstr(s, "Mon")) t.tm_wday = 1;
        else if (strstr(s, "Tue")) t.tm_wday = 2;
        else if (strstr(s, "Wed")) t.tm_wday = 3;
        else if (strstr(s, "Thu")) t.tm_wday = 4;
        else if (strstr(s, "Fri")) t.tm_wday = 5;
        else if (strstr(s, "Sat")) t.tm_wday = 6;
        if (strstr(s, "Jan")) t.tm_mon = 0;
        else if (strstr(s, "Feb")) t.tm_mon = 1;
        else if (strstr(s, "Mar")) t.tm_mon = 2;
        else if (strstr(s, "Apr")) t.tm_mon = 3;
        else if (strstr(s, "May")) t.tm_mon = 4;
        else if (strstr(s, "Jun")) t.tm_mon = 5;
        else if (strstr(s, "Jul")) t.tm_mon = 6;
        else if (strstr(s, "Aug")) t.tm_mon = 7;
        else if (strstr(s, "Sep")) t.tm_mon = 8;
        else if (strstr(s, "Oct")) t.tm_mon = 9;
        else if (strstr(s, "Nov")) t.tm_mon = 10;
        else if (strstr(s, "Dec")) t.tm_mon = 11;
        for (c = strpbrk(s, "0123456789"); c != NULL; c = strpbrk(c, "0123456789")) {
                i = atoi(c);
                while (isdigit(*c)) c++;
                if (*c == ':') {
                        t.tm_hour = i;
                        c++;
                        t.tm_min = atoi(c);
                        while (isdigit(*c)) c++;
                        if (*c == ':') t.tm_sec = atoi(++c);
                        while (isdigit(*c)) c++;
                        if (*c == ' ') c++;
                        if (
                                !strncmp(c, "PM", 2) ||
                                !strncmp(c, "pm", 2) ||
                                !strncmp(c, "p.m.", 4)
                        ) { if (t.tm_hour != 12) t.tm_hour += 12;
                        } else if (
                                !strncmp(c, "AM", 2) ||
                                !strncmp(c, "am", 2) ||
                                !strncmp(c, "a.m.", 4)
                        ) { if (t.tm_hour == 12) t.tm_hour = 0; }
                } else {
                        if (i > 0 && i < 32) t.tm_mday = i;
                        else t.tm_year = i - 1900;
                }
        }
        return *this;
}


bool timer::operator== (const char* s) { return op<int>(::eq, s); }

const char* strstrs(const char* src, ...) {
        va_list v;
        va_start(v, src);
        const char *a, *b;
        for (a = va_arg(v, const char*); a != NULL; a = va_arg(v, const char*))
                if ((b = strstr(src, a))) break;
        va_end(v);
        return b;
}

int strstrc(const char* src, ...) {
        va_list v;
        va_start(v, src);
        int i = 0;
        const char* a;
        for (a = va_arg(v, const char*); a != NULL; a = va_arg(v, const char*), i++)
                if (strstr(src, a)) break;
        va_end(v);
        if (a == NULL) return -1; else return i;
}

bool timer::operator> (const char* s) { return op<int>(::gt, s); }
bool timer::operator< (const char* s) { return op<int>(::lt, s); }
bool timer::operator<= (const char* s) { return op<int>(::lte, s); }
bool timer::operator>= (const char* s) { return op<int>(::gte, s); }
bool timer::operator!= (const char* s) { return op<int>(::neq, s); }

timer timer::operator+ (const char* s) {
        time_t tm;
        timer c;
        string p = s;
        char u[12];
        if (UTC) tm = axcel_timegm(&t);
        else tm = mktime(&t);
        while (p.pbrk("0123456789") > -1) {
                p = p.shl(p.pbrk("0123456789"));
                strcpy(u, p.tok(1, ' '));
                if (sfront(u, "second")) tm += atoi(p.tok(0, ' '));
                else if (sfront(u, "minute"))tm += atoi(p.tok(0, ' ')) * 60;
                else if (sfront(u, "hour")) tm += atoi(p.tok(0, ' ')) * 60 * 60;
                else if (sfront(u, "day")) tm += atoi(p.tok(0, ' ')) * 60 * 60 * 24;
                else if (sfront(u, "week")) tm += atoi(p.tok(0, ' ')) * 60 * 60 * 24 * 7;
                else if (sfront(u, "month")) tm += atoi(p.tok(0, ' ')) * 60 * 60 * 24 * 30;
                else if (sfront(u, "year")) tm += atoi(p.tok(0, ' ')) * 60 * 60 * 24 * 365;
                p = p.slurp(' ');
        }
        if (UTC) gmtime_r(&tm, &(c.t));
        else localtime_r(&tm, &(c.t));
        return c;
}

timer timer::operator- (const char* s) {
        time_t tm;
        timer c;
        string p = s;
        char u[12];
        if (UTC) tm = axcel_timegm(&t);
        else tm = mktime(&t);
        while (p.pbrk("0123456789") > -1) {
                p = p.shl(p.pbrk("0123456789"));
                strcpy(u, p.tok(1, ' '));
                if (sfront(u, "second")) tm -= atoi(p.tok(0, ' '));
                else if (sfront(u, "minute")) tm -= atoi(p.tok(0, ' ')) * 60;
                else if (sfront(u, "hour")) tm -= atoi(p.tok(0, ' ')) * 60 * 60;
                else if (sfront(u, "day")) tm -= atoi(p.tok(0, ' ')) * 60 * 60 * 24;
                else if (sfront(u, "week")) tm -= atoi(p.tok(0, ' ')) * 60 * 60 * 24 * 7;
                else if (sfront(u, "month")) tm -= atoi(p.tok(0, ' ')) * 60 * 60 * 24 * 30;
                else if (sfront(u, "year")) tm -= atoi(p.tok(0, ' ')) * 60 * 60 * 24 * 365;
                p = p.slurp(' ');
        }
        if (UTC) gmtime_r(&tm, &(c.t));
        else localtime_r(&tm, &(c.t));
        return c;
}

timer& timer::operator+= (const char* s) { *this = this->operator+(s); return *this; }
timer& timer::operator-= (const char* s) { *this = this->operator-(s); return *this; }
timer& timer::operator= (time_t raw) {
        if (UTC) gmtime_r(&raw, &t);
        else localtime_r(&raw, &t);
        return *this;
}
string timer::ltime() {
        string s;
        time_t foo;
        struct tm bar;
        foo = time(NULL);
        localtime_r(&foo, &bar);
        s.realloc(32);
#ifndef _WIN32
        strftime(s.buf, 32, "%a %b %e %H:%M:%S %Y", &bar);
#else
        strftime(s.buf, 32, "%a %b %d %H:%M:%S %Y", &bar);
#endif
        return s;
}

string timer::utime() {
        string s;
        time_t foo;
        struct tm bar;
        foo = time(NULL);
        gmtime_r(&foo, &bar);
        s.realloc(32);
#ifndef _WIN32
        strftime(s.buf, 32, "%a %b %e %H:%M:%S %Y", &bar);
#else
        strftime(s.buf, 32, "%a %b %d %H:%M:%S %Y", &bar);
#endif
        return s;
}


timer& timer::operator= (struct tm* tm) {
        memmove(&t, tm, sizeof(struct tm));
        return *this;
}

namespace fs {

#ifndef _WIN32
timer fatime(const char* fname) {
        timer c;
        struct stat buf;
        if (stat(fname, &buf) == -1) return c;
        c = buf.st_atime;
        return c;
}
timer fmtime(const char* fname) {
        timer c;
        struct stat buf;
        if (stat(fname, &buf) == -1) return c;
        c = buf.st_mtime;
        return c;
}
#else
timer fatime(const char* fname) {
        HANDLE h;
        FILETIME ft; SYSTEMTIME z; SYSTEMTIME r;
        timer c;
        h = CreateFile(fname, GENERIC_READ, 0, NULL, OPEN_EXISTING, NULL, NULL);
        if (h == INVALID_HANDLE_VALUE) return c;
        if (!GetFileTime(h, NULL, &ft, NULL)) return c;
        FileTimeToSystemTime(&ft, &z);
        SystemTimeToTzSpecificLocalTime(NULL, &z, &r);
        struct tm t;
        t.tm_year = r.wYear - 1900;
        t.tm_mon = r.wMonth - 1;
        t.tm_wday = r.wDayOfWeek;
        t.tm_mday = r.wDay;
        t.tm_hour = r.wHour;
        t.tm_min = r.wMinute;
        t.tm_sec = r.wSecond;
        memmove(&c.t, &t, sizeof(struct tm));
        return c;
}

timer fmtime(const char* fname) {
        HANDLE h;
        FILETIME ft; SYSTEMTIME z; SYSTEMTIME r;
        timer c;
        h = CreateFile(fname, GENERIC_READ, 0, NULL, OPEN_EXISTING, NULL, NULL);
        if (h == INVALID_HANDLE_VALUE) return c;
        if (!GetFileTime(h, NULL, NULL, &ft)) return c;
        FileTimeToSystemTime(&ft, &z);
        SystemTimeToTzSpecificLocalTime(NULL, &z, &r);
        struct tm t;
        t.tm_year = r.wYear - 1900;
        t.tm_mon = r.wMonth - 1;
        t.tm_wday = r.wDayOfWeek;
        t.tm_mday = r.wDay;
        t.tm_hour = r.wHour;
        t.tm_min = r.wMinute;
        t.tm_sec = r.wSecond;
        memmove(&c.t, &t, sizeof(struct tm));
        return c;
}
#endif

/*
#ifndef _WIN32
bool mkfifo(const char* fname) { return !mknod(fname, S_IFIFO | 0666, 0); }
bool mkhlnk(const char* ofname, const char* lfname) { return !link(ofname, lfname); }
bool mkslnk(const char* ofname, const char* lfname) { return !symlink(ofname, lfname); }
string rdlnk(const char* lfname) {
        string s(256);
        ssize_t t = readlink(lfname, s, 256);
        if (t == -1) { s[0] = 0; return s; }
        else { s[t] = 0; return s; }
}
#endif
*/

bool mv(const char* src, const char* dst) { return (cp(src, dst) && rm(src)); }

bool cp(const char* src, const char* dst) {
        FILE *f, *g;
        if (!(f = fopen(src, "rb"))) return 0;
        if (fisdir(dst)) {
                char* p = (char*)malloc(4);
                if (strchr(src, '/')) {
                        p = (char*)realloc(p, strlen(dst) + strlen(strrchr(src, '/') + 1));
                        strcpy(p, dst);
                        if (p[strlen(p) - 1] == '/') p[strlen(p) -1] = 0;
                        strcat(p, strrchr(src, '/'));                   
                        if (!(g = fopen(strrchr(p, '/') + 1, "wb"))){
                                free(p); fclose(f); return 0;
                        }
                } else {
                        p = (char*)realloc(p, strlen(dst) + strlen(src) + 2);
                        strcpy(p, dst);
                        if (p[strlen(p) - 1] == '/') p[strlen(p) - 1] = 0;
                        strcat(p, "/");
                        strcat(p, src);
                        if (!(g = fopen(p, "wb"))) {
                                free(p);
                                fclose(f);
                                return 0;
                        }
                }
                free(p);
        } else {
                if (!(g = fopen(dst, "wb"))) {
                        fclose(f);
                        return 0;
                }
        }
        int c;
        while (!feof(f)) {
                c = fgetc(f);
                if (c == EOF) break;
                fputc(c, g);
        }
        fclose(f);
        fclose(g);
        return 1; 
}

string gcd() {
        string s;
        size_t i;
        s.realloc(32);
#ifndef _WIN32
        while (getcwd(s, s.msize()) == NULL)
                s.realloc(s.msize() * 2);
#else
        i = GetCurrentDirectoryA(0, NULL);
        s.realloc(i);
        GetCurrentDirectoryA(i, s);
#endif
        return s;
}

string ls(const char* dir) {
        string s, t;
        s.clear();
#ifndef _WIN32
        DIR* d;
        struct dirent* f;
        if (!dir) d = opendir(gcd());
        else d = opendir(dir);
        if (d == NULL) return s;
        while ((f = readdir(d))) { s.realloc(s.len() + strlen(f->d_name) + 2); strcat(s.buf, f->d_name); strcat(s.buf, "\n"); }
        closedir(d);
#else
        WIN32_FIND_DATA f;
        if (!dir) t = t.cat(gcd()).cat("\\*");
        HANDLE d = FindFirstFileA(t, &f);
        if (d == INVALID_HANDLE_VALUE) return s;
        do {
                s.realloc(s.len() + strlen(f.cFileName) + 2);
                strcat(s.buf, f.cFileName);
                strcat(s.buf, "\n");
        } while (FindNextFileA(d, &f));
        FindClose(d);
#endif
        return s;
}

size_t fread(const char* fname, char* buf, size_t size) {
        size_t i;
        FILE* f;
        if (!(f = fopen(fname, "rb"))) return 0;
        for (i = 0; !feof(f) && (i < size || !size); i++) {
                buf[i] = fgetc(f);
                if (buf[i] == -1) { buf[i] = 0; break; }
        }
        fclose(f);
        return i;
}

string fread(const char* fname, size_t size) {
        size_t i;
        int j;
        FILE* f;
        string s;
        if (!(f = fopen(fname, "rb"))) return s;
        for (i = 0; !feof(f) && (i < size || !size); i++) {
                j = fgetc(f);
                if (j == EOF) break;
                s += (char)j;
        }
        fclose(f);
        return s;
}

size_t fwrite(const char* fname, const char* buf, size_t size) {
        FILE* f;
        if (!(f = fopen(fname, "wb"))) return 0;
        if (!size) size = strlen(buf);
        size_t i = fwrite(buf, 1, size, f);
        fclose(f);
        return i;
}

size_t fcat(const char* fname, const char* buf, size_t len) {
        FILE* f;
        if (!(f = fopen(fname, "ab"))) return 0;
        if (!len) len = strlen(buf);
        size_t i = fwrite(buf, 1, len, f);
        fclose(f);
        return i;
}

bool fcmp(const char* src, const char* dst) {
        FILE *f, *g;
        register char a, b;
        if (!(f = fopen(src, "rb"))) return 0;
        if (!(g = fopen(dst, "rb"))) return 0;
        while (!feof(f) && !feof(g)) {
                a = fgetc(f);
                b = fgetc(g);
                if (a != b) {
                        fclose(f);
                        fclose(g);
                        return 0;
                }
        }
        if (feof(f) && feof(g)) {
                fclose(f);
                fclose(g);
                return 1;
        }
        fclose(f);
        fclose(g);
        return 0;
}

#ifndef _WIN32
bool md(const char* path) { if (::mkdir(path, 00744) == -1) return 0; else return 1; }
bool cd(const char* path) { if (::chdir(path) == -1) return 0; else return 1; }
bool creat(const char* fname) {
        int f = ::open(fname, O_CREAT | O_TRUNC | O_RDWR, 00644);
        if (f == -1) return 0;
        ::close(f);
        return 1;
}
bool trunc(const char* fname, unsigned long len) {
        if (truncate(fname, len) == -1) return 0;
        else return 1;
}
bool rm(const char* fname) { if (remove(fname) == -1) return 0; else return 1; }

bool rd(const char* dir, bool rmsub) {
        if (!rmsub)
                return !rmdir(dir);
        bool ret = true;
        unsigned long i = 0;
        string s = ls(dir), t;
        for (;;) {
                t = s.tok(i++, "\n");
                if (t.empty()) break;
                if (t == ".." || t == ".") continue;
                if (!sback(dir, "/")) t = t.prep('/');
                t = t.prep(dir);
                if (fisdir(t)) rd(t);
                rm(t);
        }
        if (rmdir(dir)) ret = false;
        return ret;
}

size_t fsize(const char* fname) {
        struct stat buf;
        if (stat(fname, &buf) == -1) return 0;
        return buf.st_size;
}
bool fexist(const char* fname) {
        int i;
        struct stat buf;
        i = stat(fname, &buf);
        if (i == -1) return 0;
        return 1;
}
bool fisdir(const char* fname) {
        struct stat buf;
        if (stat(fname, &buf) == -1) return 0;
        return S_ISDIR(buf.st_mode);
}
bool fisreg(const char* fname) {
        struct stat buf;
        if (stat(fname, &buf) == -1) return 0;
        return S_ISREG(buf.st_mode);
}
#else
bool rd(const char* dir, bool rmsub) {
        if (!rmsub)
                return (bool)RemoveDirectory(dir);
        bool ret = true;
        unsigned long i = 0;
        string s = ls(dir), t;
        for (;;) {
                t = s.tok(i++, "\n");
                if (t.empty()) break;
                if (t == ".." || t == ".") continue;
                if (!sback(dir, "/")) t = t.prep('/');
                t = t.prep(dir);
                if (fisdir(t)) rd(t);
                rm(t);
        }
        if (!RemoveDirectory(dir)) ret = false;
        return ret;
}

bool fisdir(const char* fname) {
        DWORD i = GetFileAttributesA(fname);
        if (i == INVALID_FILE_ATTRIBUTES) return 0;
        else if (i & FILE_ATTRIBUTE_DIRECTORY) return 1;
        else return 0;
}
bool fisreg(const char* fname) {
        DWORD i = GetFileAttributesA(fname);
        if (i == INVALID_FILE_ATTRIBUTES) return 0;
        else if (!(i & FILE_ATTRIBUTE_DIRECTORY)) return 1;
        else return 0;
}
bool fexist(const char* fname) {
        if (GetFileAttributesA(fname) == INVALID_FILE_ATTRIBUTES) return 0;
        return 1;
}
bool creat(const char* fname) {
        HANDLE f = CreateFileA(fname, 0, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
        if (f == INVALID_HANDLE_VALUE) return 0;
        CloseHandle(f);
        return 1;
}
bool trunc(const char* fname, unsigned long len) {
        HANDLE f = CreateFileA(fname, 0, 0, 0, OPEN_EXISTING, 0, 0);
        if (f == INVALID_HANDLE_VALUE) return 0;
        if (SetFilePointer(f, len, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) return 0;
        if (!SetEndOfFile(f)) return 0;
        CloseHandle(f);
        return 1;
}
size_t fsize(const char* fname) {
        HANDLE f = CreateFileA(fname, 0, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
        if (f == INVALID_HANDLE_VALUE) return -1;
        long int i = GetFileSize(f, 0);
        CloseHandle(f);
        return i;
}
#endif

};

proc::thread::thread() { tid = 0; sub = 0; stack = 0; }
proc::thread::thread(void* (*tfunc)(void*)) { tid = 0; sub = tfunc; stack = 0; }
proc::thread& proc::thread::operator= (void* (*tfunc)(void*)) { sub = tfunc; return *this; }
proc::thread& proc::thread::operator= (proc::thread t) { sub = t.sub; tid = t.tid; return *this; }
bool proc::thread::operator== (proc::thread t) { return (sub == t.sub && tid == t.tid); }
bool proc::thread::operator== (void* (*tfunc)(void*)) { return sub == tfunc; }
bool proc::thread::operator!= (proc::thread t) { return !(sub == t.sub && tid == t.tid); }
bool proc::thread::operator!= (void* (*tfunc)(void*)) { return sub != tfunc; }

#ifdef _WIN32
proc::thread::~thread() { CloseHandle(fd); }
bool proc::thread::start(void* param) {
        if (!sub) return false;
        DWORD t;
        HANDLE tmp = CreateThread(0, stack, (LPTHREAD_START_ROUTINE)sub, param, 0, &t);
        if (!tmp) return false;
        else { fd = tmp; tid = t; return true; } 
}
bool proc::thread::stop() { return TerminateThread(fd, 0); }
bool proc::thread::join(void ** ret) {
        WaitForSingleObject(fd, INFINITE);
        return getret(ret);
}
bool proc::thread::tjoin(size_t ms, void ** ret) {
        WaitForSingleObject(fd, ms);
        return getret(ret);
}
bool proc::thread::getret(void ** retval) {
        void* r;
        if (GetExitCodeThread(fd, (LPDWORD)&r)) {
                memmove(*retval, r, sizeof(void*));
                return true;
        } else return false;
}

void proc::thread::exit(void* retval) { ExitThread((DWORD)retval); }
proc::thread proc::thread::self() { proc::thread t; t.tid = GetCurrentThreadId(); return t; }
#else
proc::thread::~thread() { pthread_attr_destroy(&attr); }
bool proc::thread::start(void* param) {
        register int err;
        if (err = pthread_attr_init(&attr)) { errnum = err; return false; }
        if (stack)
                if (err = pthread_attr_setstacksize(&attr, stack)) {
                        errnum = err; return false;
                }
        if (err = pthread_create(&tid, &attr, sub, param)) {
                errnum = err; return false;
        }
        
        return true;
}
bool proc::thread::stop() {
        register int err;
        if (err = pthread_cancel(tid)) {
                errnum = err; return false;
        }
        
        return true;
}
bool proc::thread::join(void ** ret) {
        void* r;
        register int err;
        if (ret) {
                if (err = pthread_join(tid, ret)) {
                        errnum = err;
                        return false;
                }
        } else {
                if (err = pthread_join(tid, &r)) {
                        errnum = err;
                        return false;
                }
        }
        
        return true;
}
bool proc::thread::tjoin(size_t ms, void ** ret) {
        void* r;
        struct timespec t;
        register int err;
        t.tv_sec = ms / 1000;
        t.tv_nsec = (ms % 1000) * (1000 * 1000);
        if (ret) {
                if (err = pthread_timedjoin_np(tid, ret, &t)) { errnum = err; return false; }
        } else {
                if (err = pthread_timedjoin_np(tid, &r, &t)) {
                        errnum = err; return false;
                }
        }
        
        return true;
}
bool proc::thread::getret(void ** retval) {
        void* r;
        register int err;
        if (retval == 0) err = pthread_tryjoin_np(tid, &r);
        else err = pthread_tryjoin_np(tid, retval);
        if (!err) {  return true; }
        errnum = err;
        return false;
}
void proc::thread::exit(void* retval) { pthread_exit(retval); }
proc::thread proc::thread::self() { proc::thread t; t.tid = pthread_self(); return t; }
#endif

string proc::environment::type() { return string("proc::environ"); }
proc::environment::operator string () {
        string s;
        std::deque<p>::iterator it;
        for (it = e.begin(); it != e.end(); it++)
                if (it->v.empty()) {
                        e.erase(it--);
                        continue;
                } else
                        s << it->k << '=' << it->v << '\n';
        return s;
}
string proc::environment::vars() {
        string v;
        std::deque<p>::iterator it;
        for (it = e.begin(); it != e.end(); it++)
                if (it->v.empty()) {
                        e.erase(it--);
                        continue;
                } else
                        v << it->k << '\n';
        return v;
}
string& proc::environment::operator[] (const char* s) {
        std::deque<p>::iterator it;
        struct p pair;
        for (it = e.begin(); it != e.end(); it++)
                if (it->k == s) break;
        if (it == e.end()) { pair.k = s; e.push_back(pair); }
        return it->v;
}
string& proc::environment::at(size_t i) {
        return e[i].v;
}
size_t proc::environment::len() {
        std::deque<p>::iterator it;
        for (it = e.begin(); it != e.end(); it++)
                if (it->v.empty()) {
                        e.erase(it--);
                        continue;
                }
        return e.size();
}
proc::environment& proc::environment::clear() {
        e.clear();
        return *this;
}
bool proc::environment::empty() {
        return e.empty();
}

data proc::environment::bake() {
        data d;
        size_t i = 0, j = 0, k = 0;
        char *c, **b;
        std::deque<p>::iterator it;
        for (it = e.begin(); it != e.end(); it++) {
                if (it->v.empty()) {
                        e.erase(it--);
                        continue;
                }
                i++;
                j += it->k.len() + it->v.len() + 2;
        }
        i++;
        d.realloc(sizeof(char*) * i + j);
        c = d.buf + sizeof(char*) * i;
        b = (char**)d.buf;
        for (it = e.begin(); it != e.end(); it++, k++) {
                strcpy(c, it->k);
                strcat(c, "=");
                strcat(c, it->v);
                b[k] = c;
                c += strlen(c) + 1;
        }
        b[k] = (char*)0;
        return d;
}

namespace proc {

#ifndef _WIN32

string lsproc() {
        string s, t, u;
        fs::file f;
        size_t pid;
        std::deque<string> d = fs::ls("/proc").split('\n');
        std::deque<string>::iterator it;
        for (it = d.begin(); it < d.end(); it++) {
                if ((*it)[0] == '.') continue;
                if (!it->isdigit()) continue;
                f.open(it->prep("/proc/").cat("/status"), "rb");
                if (f.dead()) continue;
                until (f.eof()) {
                        t = f.gets();
                        if (t.starts("Name:")) u = t.slurp(':').ltrim();
                        else if (t.starts("Pid:"))
                                pid = stoi<size_t>(t.slurp(':').ltrim());
                }
                f.close();
                s << pid << ':' << u;
        }
        return s;
}

pid_t run(const char* program, const char* argv, void* envp) {
        if (!fs::fexist(program)) return false;
        pid_t p;
        string gay = program;
        if (argv) gay = gay.cat(' ').cat(argv);
        wordexp_t we;
        char** w;
        wordexp(gay, &we, WRDE_NOCMD);
        w = we.we_wordv;
        char *const e[] = {NULL,NULL};
        p = fork();
        if (!p) {
                setsid();
                if (!envp) execve(program, w, e);
                else execve(program, w, (char* *const)envp);
                wordfree(&we);
        } else {
                wordfree(&we);
        }
        return p;
}

bool killp(size_t pid) {
        if (kill(pid, SIGKILL) == -1) return false;
        else return true;
}
bool killp(const char* name) {
        pid_t p;
        size_t i;
        char* s = (char*)malloc(264);
        char buf[128];
        FILE* st;
        DIR* d = opendir("/proc");
        if (d == NULL) { free(s); return false; }
        struct dirent* f;
        while ((f = readdir(d)) != NULL) {
                if (f->d_name[0] == '.') continue;
                for (i = 0; isdigit(f->d_name[i]); i++);
                if (i < strlen(f->d_name)) continue;
                strcpy(s, "/proc/");
                strcat(s, f->d_name);
                strcat(s, "/status");
                st = fopen(s, "r");
                if (st == NULL) { closedir(d); free(s); return false; }
                do {
                        if (fgets(buf, 128, st) == NULL) { fclose(st); closedir(d); free(s); return false; }
                } while (strncmp(buf, "Name:", 5));
                fclose(st);
                for (i = 5; isspace(buf[i]); i++);
                *strchr(buf, '\n') = 0;
                if (!strcmp(&(buf[i]), name)) {
                        sscanf(&(s[6]), "%d", &p);
                        kill(p, SIGKILL);
                }
        }
        closedir(d);
        free(s);
        return true;
}
bool freeze(size_t pid) { if (kill(pid, SIGSTOP) == -1) return false; else return true; }
bool freeze(const char* name) {
        pid_t p;
        size_t i;
        char* s = (char*)malloc(264);
        char buf[128];
        FILE* st;
        DIR* d = opendir("/proc");
        if (d == NULL) { free(s); return false; }
        struct dirent* f;
        while ((f = readdir(d)) != NULL) {
                if (f->d_name[0] == '.') continue;
                for (i = 0; isdigit(f->d_name[i]); i++);
                if (i < strlen(f->d_name)) continue;
                strcpy(s, "/proc/");
                strcat(s, f->d_name);
                strcat(s, "/status");
                st = fopen(s, "r");
                if (st == NULL) { closedir(d); free(s); return false; }
                do {
                        if (fgets(buf, 128, st) == NULL) { fclose(st); closedir(d); free(s); return false; }
                } while (strncmp(buf, "Name:", 5));
                fclose(st);
                for (i = 5; isspace(buf[i]); i++);
                *strchr(buf, '\n') = 0;
                if (!strcmp(&(buf[i]), name)) {
                        sscanf(&(s[6]), "%d", &p);
                        kill(p, SIGSTOP);
                }
        }
        closedir(d);
        free(s);
        return true;
}
bool cont(size_t pid) { if (kill(pid, SIGCONT) == -1) return false; else return true; }
bool cont(const char* name) {
        pid_t p;
        size_t i;
        char* s = (char*)malloc(264);
        char buf[128];
        FILE* st;
        DIR* d = opendir("/proc");
        if (d == NULL) { free(s); return false; }
        struct dirent* f;
        while ((f = readdir(d)) != NULL) {
                if (f->d_name[0] == '.') continue;
                for (i = 0; isdigit(f->d_name[i]); i++);
                if (i < strlen(f->d_name)) continue;
                strcpy(s, "/proc/");
                strcat(s, f->d_name);
                strcat(s, "/status");
                st = fopen(s, "r");
                if (st == NULL) { closedir(d); free(s); return false; }
                do {
                        if (fgets(buf, 128, st) == NULL) { fclose(st); closedir(d); free(s); return false; }
                } while (strncmp(buf, "Name:", 5));
                fclose(st);
                for (i = 5; isspace(buf[i]); i++);
                *strchr(buf, '\n') = 0;
                if (!strcmp(&(buf[i]), name)) {
                        sscanf(&(s[6]), "%d", &p);
                        kill(p, SIGCONT);
                }
        }
        closedir(d);
        free(s);
        return true;
}
void delay(size_t ms) {
        struct timespec t;
        t.tv_sec = ms / 1000;
        t.tv_nsec = (ms % 1000) * (1000 * 1000);
        nanosleep(&t, 0);
}
bool envset(const char* name, const char* value) {
        if (value) return !setenv(name, value, 1);
        else return !unsetenv(name);
}
string envget(const char* name) {
        string s;
        char* t = getenv(name);
        if (t == NULL) {
                s.clear();
                return s;
        }
        s = t;
        return s;
}
#else

string lsproc() {
        string s;
        PROCESSENTRY32 proc;
        HANDLE images = CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0);
        Process32First(images, &proc);
        while (GetLastError() != ERROR_NO_MORE_FILES) {
                s << proc.th32ProcessID << ':' << proc.szExeFile << '\n';
                Process32Next(images, &proc);
        }
        CloseHandle(images);
        return s;
}

DWORD run(const char* program, const char* argv, void* envp) {
        if (!fs::fexist(program)) return false;
        string pname = program;
        string args = program;
        fs::file f;
        string s;
        PROCESS_INFORMATION pi;
        STARTUPINFO si;
        memset(&si, 0, sizeof(STARTUPINFO));
        si.cb = sizeof(STARTUPINFO);
        f.open(program, "rb");
        if (f.getc() == '#')
                if (f.getc() == '!') {
                        s = f.gets().strip();
                        pname = s;
                        if (pname.chr(' ') != -1) {
                                pname = pname.burn(' ');
                                args = pname;
                                args += ' ';
                                args += s.slurp(' ');
                                args += ' ';
                                args += program;
                        }
                }
        f.close();
        if (argv) args = args.cat(' ').cat(argv);
        if (!CreateProcessA(pname, args, NULL, NULL, false, NORMAL_PRIORITY_CLASS, envp, NULL, &si, &pi)) return false;
        return pi.dwProcessId;
}

bool killp(size_t pid) { return TerminateProcess(OpenProcess(PROCESS_TERMINATE, false, pid), 1); }
bool killp(const char* name) {
        PROCESSENTRY32 p;
        HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (!Process32First(snap, &p)) { CloseHandle(snap); return false; }
        do {
                if (!strcmp(name, p.szExeFile))
                        if (!killp(p.th32ProcessID)) { 
                                CloseHandle(snap);
                                return false;
                        }
        } while (Process32Next(snap, &p));
        CloseHandle(snap);
        return true;
}
bool freeze(size_t pid) {
        HANDLE snap;
        THREADENTRY32 t;
        HANDLE th;
        DWORD i;
        snap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
        if (!Thread32First(snap, &t)) { CloseHandle(snap); return false; }
        do {

                if (t.th32OwnerProcessID != pid) continue;
                th = OpenThread(THREAD_SUSPEND_RESUME, false, t.th32ThreadID);
                if (th == NULL) continue;
                i = SuspendThread(th);
                CloseHandle(th);
                if (i == -1) { CloseHandle(snap); return false; }
        } while (Thread32Next(snap, &t));
        CloseHandle(snap);
        return true;
}
bool freeze(const char* name) {
        PROCESSENTRY32 p;
        HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (!Process32First(snap, &p)) { CloseHandle(snap); return false; }
        do {
                if (!strcmp(name, p.szExeFile))
                        if (!freeze(p.th32ProcessID)) { 
                                CloseHandle(snap);
                                return false;
                        }
        } while (Process32Next(snap, &p));
        CloseHandle(snap);
        return true;
}

bool cont(size_t pid) {
        HANDLE snap;
        THREADENTRY32 t;
        HANDLE th;
        DWORD i;
        snap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
        if (!Thread32First(snap, &t)) { CloseHandle(snap); return false; }
        do {
                if (t.th32OwnerProcessID != pid) continue;
                th = OpenThread(THREAD_SUSPEND_RESUME, false, t.th32ThreadID);
                if (th == NULL) continue;
                i = ResumeThread(th);
                CloseHandle(th);
                if (i == -1) { CloseHandle(snap); return false; }
        } while (Thread32Next(snap, &t));
        CloseHandle(snap);
        return true;
}

bool cont(const char* name) {
        PROCESSENTRY32 p;
        HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (!Process32First(snap, &p)) { CloseHandle(snap); return false; }
        do {
                if (!strcmp(name, p.szExeFile))
                        if (!cont(p.th32ProcessID)) { 
                                CloseHandle(snap);
                                return false;
                        }
        } while (Process32Next(snap, &p));
        CloseHandle(snap);
        return true;
}

bool envset(const char* name, const char* value) { return SetEnvironmentVariableA(name, value); }
string envget(const char* name) {
        DWORD i;
        string s;
        s.realloc(128);
        i = GetEnvironmentVariableA(name, s, 128);
        if (i > 128) {
                s = (char*)realloc(s, i);
                if (!GetEnvironmentVariableA(name, s, i)) {
                        s.clear();
                        return s;
                }
        } else if (!i) {
                s.clear();
                return s;
        }
        return s;
}
#endif

};

proc::library::~library() {
        if (fd)
#ifdef _WIN32
                FreeLibrary(fd);
#else
                dlclose(fd);
#endif
}

proc::library& proc::library::operator =(const char* libname) {
        libraryname = libname;
#ifdef _WIN32
        fd = LoadLibraryA(libname);
#else
        fd = dlopen(libname, RTLD_LAZY);
#endif
        return *this;
}

proc::library& proc::library::operator= (library s) {
        if (fd)
#ifdef _WIN32
                FreeLibrary(fd);
#else
                dlclose(fd);
#endif
        fd = s.fd;
        return *this;
}
bool proc::library::operator== (library s) { return fd == s.fd; }
bool proc::library::operator!= (library s) { return fd != s.fd; }
void* proc::library::operator[] (const char* name) {
#ifdef _WIN32
        return (void*)GetProcAddress(fd, name);
#else
        return dlsym(fd, name);
#endif
}
namespace net {
namespace irc {

msg::msg(const char* line) { buf = line; }
msg& msg::operator= (const char* line) { buf = line; return *this; }
bool msg::operator== (const char* line) { return buf == line; }
bool msg::operator!= (const char* line) { return buf != line; }
string msg::server() {
        if (buf.chr(' ') == -1) return string();
        return buf.munch(':').burn(' ');
}
string msg::nick() {
        if (buf.chr('!') == -1 || buf.chr(' ') == -1)
                return string();
        if (buf.chr('!') > buf.chr(' '))
                return string();
        return buf.munch(':').burn('!');
}
string msg::user() {
        if (nick().empty()) return string();
        return buf.slurp('!').burn('@');
}
string msg::host() {
        if (nick().empty()) return string();
        return buf.slurp('@').burn(' ');
}
string msg::cmd() {
        if (buf.chr(' ') == -1) return string();
        return buf.tok(1, ' ');
}
string msg::param(int index) {
        if (buf.nchr(' ') < 2) return string();
        return buf.shl(buf.itok(2, ' ')).tok(index, ' ');
}
string msg::data() {
        if (buf.munch(':').chr(':') == -1 || buf.chr(' ') == -1) return string();
        return buf.munch(':').slurp(':');
}/*
:nick!user@host cmd param1 param2 :data
:server cmd param param :data
msg::msg(const char* line) {
        if (line) this->operator=(line);
        else this->operator=("Expecto_patronum");
}

msg& msg::operator= (const msg& s) {
        memcpy(buf, s.buf, 536);
        server = 0;
        nick = 0;
        user = 0;
        host = 0;
        cmd = 0;
        data = 0;
        if (s.server) {
                server = buf;
                cmd = s.cmd - s.server + buf;
                data = s.data - s.server + buf;
        } else if (s.nick) {
                nick = buf;
                user = s.user - s.nick + buf;
                host = s.host - s.nick + buf;
                cmd = s.cmd - s.nick + buf;
                data = s.data - s.nick + buf;
        }
        return *this;
}

bool msg::operator== (const char* line) {
        msg im(line);
        return *this == im;
}
bool msg::operator!= (const char* line) {
        msg im(line);
        return !(*this == im);
}
bool msg::operator== (msg im) {
        if (server == NULL) { if (im.server != NULL) return false; }
        else if (strcmp(server, im.server)) return false;
        if (nick == NULL) { if (im.nick != NULL) return false; }
        else if (strcmp(nick, im.nick)) return false;
        if (user == NULL) { if (im.user != NULL) return false; }
        else if (strcmp(user, im.user)) return false;
        if (host == NULL) { if (im.host != NULL) return false; }
        else if (strcmp(host, im.host)) return false;
        if (cmd == NULL) { if (im.cmd != NULL) return false; }
        else if (strcmp(cmd, im.cmd)) return false;
        if (data == NULL) { if (im.data != NULL) return false; }
        else if (strcmp(data, im.data)) return false;
        int i;
        const char* c = (const char*)1;
        for (i = 0, c = param(0); c; c = param(++i))
                if (strcmp(c, im.param(i))) return false;
        return true;
}
bool msg::operator!= (msg im) { return !(this->operator==(im)); }

const char* msg::param(int index) {
        const char* a = cmd + strlen(cmd) + 1;
        for (; index > 0; index--) {
                a += strlen(a) + 1;
                if (a[0] == 0) return 0;
        }
        return a;
}

msg& msg::operator= (const char* line) {
        int i = 0;
        const char *a, *b;
        server = 0;
        nick = 0;
        user = 0;
        host = 0;
        cmd = 0;
        data = 0;
        if (line[0] == ':') line++;
        a = strchr(line, '!');
        b = strchr(line, ' ');
        if (b == NULL) return *this;
        if (a != NULL && a < b) {
                strncpy((char*)buf, line, a - line);
                buf[a - line] = 0;
                nick = buf;
                line += strlen(buf) + 1;
                
                a = strchr(line, '@');
                user = buf + strlen(buf) + 1;
                strncpy((char*)user, line, a - line);
                ((char*)user)[a - line] = 0;
                line += strlen(user) + 1;
                
                a = strchr(line, ' ');
                host = user + strlen(user) + 1;
                strncpy((char*)host, line, a - line);
                ((char*)host)[a - line] = 0;
                line += strlen(host) + 1;
                
                a = strchr(line, ' ');
                cmd = host + strlen(host) + 1;
                strncpy((char*)cmd, line, a - line);
                ((char*)cmd)[a - line] = 0;
                line += strlen(cmd) + 1;
                
        } else if (a == NULL || a > b) {
                strncpy(buf, line, b - line);
                buf[b - line] = 0;
                server = buf;
                line += strlen(server) + 1;
                
                a = strchr(line, ' ');
                cmd = server + strlen(server) + 1;
                strncpy((char*)cmd, line, a - line);
                ((char*)cmd)[a - line] = 0;
                line += strlen(cmd) + 1;
        }
        
        a = cmd + strlen(cmd) + 1;
        for (b = strchr(line, ' '); line[0] != ':' && (*line - 1 != '\r' && *line != '\n') && line[0]; b = strpbrk(line, " \r\n")) {
                if (b == NULL) b = line + strlen(line);
                strncpy((char*)a, line, b - line);
                ((char*)a)[b - line] = 0;
                line += strlen(a) + 1;
                a += strlen(a) + 1;
        }
        ((char*)a)[0] = 0;
        a++;
        data = a;
        if (*line == '\r' || !(*line))
                ((char*)data)[0] = 0;
        else strcpy((char*)data, ++line);
        ((char*)data)[strlen(data) + 1] = 0;
        char* x = strstr((char*)data, "\r\n");
        if (x) *x = 0;
        return *this;
}*/

};
};

#ifdef _WIN32

proc::mutex::mutex() { InitializeCriticalSection(&id); }
proc::mutex::~mutex() { DeleteCriticalSection(&id); }
void proc::mutex::lock() { EnterCriticalSection(&id); }
bool proc::mutex::trylock() { return TryEnterCriticalSection(&id); }
void proc::mutex::unlock() { LeaveCriticalSection(&id); }

#else
proc::mutex::mutex() { pthread_mutex_init(&id, NULL); }
proc::mutex::~mutex() { pthread_mutex_destroy(&id); }
void proc::mutex::lock() { pthread_mutex_lock(&id); }
bool proc::mutex::trylock() { return !pthread_mutex_trylock(&id); }
void proc::mutex::unlock() { pthread_mutex_unlock(&id); }

#endif

#ifdef _WIN32

proc::semaphore::semaphore(size_t count) { init(count); }
proc::semaphore::semaphore(const char* name) { open(name); }
proc::semaphore::~semaphore() { if (id) CloseHandle(id); }
bool proc::semaphore::init(size_t count) {
        named = false;
        if ((id = CreateSemaphore(NULL, count, UINT_MAX, NULL)) == NULL)
                return false;
        else return true;
}
bool proc::semaphore::die() { return !CloseHandle(id); }
bool proc::semaphore::close() { return !CloseHandle(id); }
bool proc::semaphore::open(const char* name) {
        named = true;
        string s = name;
        s -= "Global\\";
        if ((id = OpenSemaphore(SEMAPHORE_MODIFY_STATE, false, s)) == NULL)
                return false;
        else return true;
}
bool proc::semaphore::get(size_t ms) {
        if (WaitForSingleObject(id, (ms ? ms : INFINITE)) == WAIT_FAILED)
                return true;
        else return false;
}
bool proc::semaphore::tryget() { return !WaitForSingleObject(id, 0); }
bool proc::semaphore::ret() { return ReleaseSemaphore(id, 1, 0); }

HANDLE mksem(const char* name, size_t count) { string s = name; s -= "Global\\"; return CreateSemaphore(NULL, count, UINT_MAX, s); }

#else


proc::semaphore::semaphore(size_t count) { init(count); }
proc::semaphore::semaphore(const char* name) { open(name); }
proc::semaphore::~semaphore() { if (id) if (named) { sem_close(id); } else { sem_destroy(id); } }
bool proc::semaphore::init(size_t count) { named = false; id = &s; return !sem_init(id, 0, count); }
bool proc::semaphore::die() { return !sem_destroy(id); }
bool proc::semaphore::close() { return !sem_close(id); }
bool proc::semaphore::open(const char* name) {
        named = true;
        char* n = (char*)malloc(strlen(name) + 2);
        n[0] = '/';
        n[1] = 0;
        strcat(n, name);
        if ((id = sem_open(n, 0)) == SEM_FAILED) id = 0;
        free(n);
        if (!id) return false;
        else return true;
}
bool proc::semaphore::get(size_t ms) {
        struct timespec t;
        if (!ms) return !sem_wait(id);
        else {
                t.tv_sec = ms / 1000;
                t.tv_nsec = (ms % 1000) * (1000 * 1000);
                return !sem_timedwait(id, &t);
        }
}
bool proc::semaphore::tryget() { return !sem_trywait(id); }
bool proc::semaphore::ret() { return !sem_post(id); }

sem_t* proc::mksem(const char* name, size_t count) {
        sem_t* s;
        char* n = (char*)malloc(strlen(name) + 2);
        n[0] = '/';
        n[1] = 0;
        strcat(n, name);
        if ((s = sem_open(n, O_CREAT, O_EXCL, 0666, count)) == SEM_FAILED) {
                free(n);
                return NULL;
        } else { free(n); return s; }
}
bool proc::rmsem(const char* name) { return !sem_unlink(name); }
#endif

string io::input::drink(const char* eol) {
        string s;
        if (!eol) eol = "\0";
        if (!strlen(eol)) {
                register int i;
                for (i = getc(); ok(); i = getc()) { if (!i) break; s += (char)i; }
                return s;
        }
        until (s.ends(eol)) s += getc();
        return s;
}

data io::input::suck(const char* eol, size_t len) {
        if (!len) len = strlen(eol);
        data d;
        size_t i;
        for (i = 0; i < len; i++) d << getc();
        return d;
}

bool fs::file::operator! () {
        if (!fd) return true;
        if (eof() | dead()) return true;
        if (feof(fd)) { drain(); return true; }
        if (ferror(fd)) { kill(); return true; }
        return false;
}
data io::input::dump() {
        data d;
        int i;
        if (eof()) return d;
        size_t a;
        for (a = 0;; a++) {
                i = getc();
                if (!ok()) break;
                d.putc(i);
        }
        return d;
}

size_t io::output::write(data d) { return write(d.buf, 1, d.len()); }

//string proc::environment::type() { return string("proc::environ"); }

bool proc::pstream::open(const char* program, const char* argv, environment envp) {
        data d = envp.bake();
        return open(program, argv, (void*)d.buf);
}
bool proc::pstream::open(const char* program, const char* argv, data d) {
        return open(program, argv, (void*)d.buf);
}
#ifndef _WIN32
bool proc::pstream::open(const char* program, const char* argv, void* envp) {
        if (!fs::fexist(program)) { kill(); return false; }
        string gay = program;
        if (argv) gay = gay.cat(' ').cat(argv);
        wordexp_t we;
        char **w;
        wordexp(gay, &we, WRDE_NOCMD);
        w = we.we_wordv;
        char *const e[] = {NULL};
        pname = program;
        pipe(rpipe);
        pipe(wpipe);
        p = fork();
        if (!p) {
                ::close(rpipe[0]);
                ::close(wpipe[1]);
                dup2(wpipe[0], 0); ::close(wpipe[0]);
                dup2(rpipe[1], 1); ::close(rpipe[1]);
                if (!envp) execve(program, w, e);
                else execve(program, w, (char* *const)envp);
                wordfree(&we);
        } else {
                wordfree(&we);
                ::close(wpipe[0]);
                ::close(rpipe[1]);
                return true;
        }
}
#else
bool proc::pstream::open(const char* program, const char* argv, void* envp) {
        if (!fs::fexist(program)) { kill(); return false; }
        pname = program;
        string args = program;
        fs::file f;
        string s;
        f.open(program, "rb");
        if (f.getc() == '#')
                if (f.getc() == '!') {
                        s = f.gets().strip();
                        pname = s;
                        if (pname.chr(' ') != -1) {
                                pname = pname.burn(' ');
                                args = pname;
                                args += ' ';
                                args += s.slurp(' ');
                                args += ' ';
                                args += program;
                        }
                }
        f.close();
        if (argv) args = args.cat(' ').cat(argv);
        con << pname << ' ' << args << '\n';
        CreatePipe(&rin, &win, NULL, 0);
        CreatePipe(&rout, &wout, NULL, 0);
        CreatePipe(&rerr, &werr, NULL, 0);
        SetHandleInformation(rin, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT);
        SetHandleInformation(wout, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT);
        SetHandleInformation(werr, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT);
        STARTUPINFOA si;
        PROCESS_INFORMATION pi;
        memset(&si, 0, sizeof(STARTUPINFOA));
        si.cb = sizeof(STARTUPINFOA);
        si.dwFlags = STARTF_USESTDHANDLES;
        si.hStdInput = rin;
        si.hStdOutput = wout;
        si.hStdError = werr;
        if (!CreateProcessA(pname, args, NULL, NULL, true, NORMAL_PRIORITY_CLASS, envp, NULL, &si, &pi)) return false;
        p = pi.dwProcessId;
        ph = pi.hProcess;
        Sleep(200);
        return true;
}
#endif

string proc::pstream::name() { return pname; }

data io::input::read(size_t size, size_t nmemb) {
        data d;
        d.realloc(size * nmemb);
        read(d.buf, size, nmemb);
        return d;
}

data net::socket::tcp::dump() {
        data d;
        char c;
        if (eof()) return d;
        for (;;) {
                if (ready()) {
                        switch (::recv(fd, &c, 1, 0)) {
                        case 0: drain(); return d;
                        case -1: kill(); return d;
                        case 1: d << c;
                        }
                } else return d;
        }
}

void proc::pstream::close() {
        pname.clear();
#ifndef _WIN32
        ::close(wpipe[0]); ::close(wpipe[1]);
        ::close(rpipe[0]); ::close(rpipe[1]);
        ::waitpid(p, NULL, 0);
#else
        CloseHandle(rin); CloseHandle(rout);
        CloseHandle(win); CloseHandle(wout);
        DWORD d;
        GetExitCodeProcess(ph, &d);
#endif
}
size_t proc::pstream::pid() { return p; }
int proc::pstream::getc() {
        register int i;
        char c;
#ifndef _WIN32
        struct pollfd pf;
#else
        DWORD avail = 0, bleft, bread;
#endif
#ifndef _WIN32
        pf.fd = rpipe[0];
        pf.events = POLLIN;
        poll(&pf, 1, 0);
        if (pf.revents & POLLIN == 0) {
                if (lsproc().str(this->operator string()) == -1) { kill(); return EOF; }
                if (!blocking) { drain(); return EOF; }
        }
#else
        PeekNamedPipe(rout, &c, 1, &bread, &avail, &bleft);
        if (avail <= 0) { 
                if (lsproc().str(this->operator string()) == -1) { kill(); return EOF; }
                if (!blocking) { drain(); return EOF; }
        }
#endif
#ifndef _WIN32
        switch (::read(rpipe[0], &c, 1)) {
        case 0: drain(); return EOF;
        case -1: kill(); return EOF;
        default: heal(); i = c; return i;
        }
#else
        if (ReadFile(rout, &c, 1, &bread, 0) != 0) {
                if (bread == 0) { drain(); return EOF; } heal(); i = c; return i;
        } else { kill(); return EOF; }
#endif
}

proc::pstream::pstream() { blocking = true; }

int proc::pstream::putc(int c) {
        register char i = c;
#ifndef _WIN32
        switch (::write(wpipe[1], &i, 1)) {
        case 0: drain(); return EOF;
        case -1: kill(); return EOF;
        case 1: heal(); fsync(wpipe[1]); return i;
        }
#else
        DWORD bwrite;
        if (WriteFile(win, &i, 1, &bwrite, 0) != 0) {
                if (bwrite == 0) { drain(); return EOF; } heal(); FlushFileBuffers(win); return i;
        } else { kill(); return EOF; }
#endif
}

string proc::pstream::type() { return string("proc::pstream"); }
proc::pstream::operator string () { string s; s << p; s << ':'; s << pname; return s; }

namespace net {
namespace http {

field::field(const char* s) { this->operator=(s); }
string field::type() { return string("net::http::field"); }
field::operator string () {
        string s = name;
        s += ": ";
        std::deque<svarpair>::iterator it;
        for (it = svars.begin(); it < svars.end(); it++) {
                if (it->v.empty()) { svars.erase(it); it--; continue; }
                if (it->n.len()) {
                        s += it->n;
                        s += '=';
                }
                s += it->v;
                s += "; ";
        }
        s = s.chomp("; ");
        return s;
}

string& field::var(const char* s) {
        if (s == 0 && svars.size()) return svars[0].v;
        std::deque<svarpair>::iterator it;
        svarpair svp;
        for (it = svars.begin(); it < svars.end(); it++)
                if (it->n == s) return it->v;
        if (it == svars.end()) {
                if (s) svp.n = string(s);
                else svp.n = string();
                svp.v = string();
                svars.push_back(svp);
                return svars.back().v;
        }
}

string& field::operator[] (const char* v) {
        if (v == 0) return var();
        return var(v);
}

string field::vars() {
        string s;
        std::deque<svarpair>::iterator it;
        for (it = svars.begin() + 1; it < svars.end(); it++) {
                s += it->n;
                s += '\n';
        }
        return s;
}

field& field::operator= (const char* s) {
        if (strstr(s, ": ") != 0) {
                name = s;
                name = name.burn(": ");
                s = strstr(s, ": ") + 2;
        }
        svars.clear();
        svarpair svp;
        if (strstr(s, "; ") == 0) {
                svp.v = s;
                svars.push_back(svp);
                return *this;
        }
        std::deque<string> t = string(s).split(' ');
        std::deque<string>::iterator it;
        for (it = t.begin(); it < t.end(); it++)
                if (it->chr('=') == -1) {
                        svp.v = it->burn(';').rtrim();
                        svars.push_back(svp);
                 } else {
                        svp.n = it->burn('=');
                        svp.v = it->slurp('=').burn(';').rtrim();
                        svars.push_back(svp);
                 }
        return *this;
}

string query::type() { return string("net::http::query"); }
query::operator string() {
        string s;
        std::deque<svarpair>::iterator it;
        for (it = svars.begin(); it < svars.end(); it++) {
                if (it->v.empty()) { svars.erase(it); it--; continue; }
                s += it->n;
                s += '=';
                s += it->v;
                s += '&';
        }
        s = s.chomp('&');
        return s;
}
string query::vars() {
        string s;
        std::deque<svarpair>::iterator it;
        for (it = svars.begin(); it < svars.end(); it++) {
                s += it->n;
                s += '\n';
        }
        return s;
}
string& query::var(const char* v) {
        svarpair svp;
        std::deque<svarpair>::iterator it;
        for (it = svars.begin(); it < svars.end(); it++)
                if (it->n == v) return it->v;
        svp.n = v;
        svp.v = string();
        svars.push_back(svp);
        return svars.back().v;
}
string& query::operator[] (const char* s) { return var(s); }
query& query::operator= (const char* s) {
        svars.clear();
        svarpair svp;
        std::deque<string> t = string(s).split('&');
        std::deque<string>::iterator it;
        for (it = t.begin(); it < t.end(); it++) {
                svp.n = it->tok(0, '=');
                svp.v = it->tok(1, '=');
                svars.push_back(svp);
        }
        return *this;
}
query::query(const char* s) { this->operator=(s); }

request& request::operator= (const char* s) {
        string t = s;
        t = t.chomp();
        method = t.tok(0, ' ').uc();
        file = t.tok(1, ' ').burn('?');
        if (t.tok(1, ' ').chr('?') == -1) qstr.clear();
        else qstr = t.tok(1, ' ').slurp('?');
        ver = atof(t.tok(2, ' ').slurp('/'));   
        return *this;
}

string request::type() { return string("net::http::request"); }
request::operator string () {
        string s;
        s << method << ' ' << file;
        if (qstr.len()) s << '?' << qstr;
        s << " HTTP/" << ver;
        return s;
}

string response::type() { return string("net::http::response"); }
response::operator string () {
        string s;
        s << "HTTP/" << ver << ' ' << code << ' ' << status << "\r\n";
        return s;
}
response& response::operator= (const char* s) {
        string t = s;
        ver = atof(t.slurp('/'));
        code = atoi(t.tok(1, ' '));
        status = t.shl(t.itok(2, ' ')).rtrim();
        return *this;
}

string header::type() { return string("net::http::header"); }
field& header::at(size_t i) {
        return f[i];
}
header::operator string () {
        string s;
        std::deque<field>::iterator it;
        for (it = f.begin(); it < f.end(); it++) {
                if (it->var().empty()) { f.erase(it); it--; continue; }
                if (it->name.empty()) { f.erase(it); it--; continue; }
                s = s.cat(it->operator string()).cat("\r\n");
        }
        s += "\r\n";
        return s;
}
string field::data() { return (this->operator string()).slurp(": ").rtrim(); }
field& header::var(const char* s) {
        std::deque<field>::iterator it;
        for (it = f.begin(); it < f.end(); it++)
                if (it->name == s) return *it;
        field t;
        t.name = s;
        f.push_back(t);
        return f.back();
}
size_t header::len() { return f.size(); }
string header::vars() {
        string s;
        std::deque<field>::iterator it;
        for (it = f.begin(); it < f.end(); it++) {
                if (it->name.empty()) { f.erase(it); it--; continue; }
                s += it->name;
                s += '\n';
        }
        return s;
}
field& header::operator[] (const char* s) { return var(s); }
header::header(const char* s) { this->operator=(s); }
header& header::clear() {
        f.clear();
        return *this;
}
header& header::operator= (const char* s) {
        f.clear();
        std::deque<string> t = string(s).rtrim().split('\n');
        std::deque<string>::iterator it;
        for (it = t.begin(); it < t.end(); it++) {
                if (it->chr(':') != -1)
                        f.push_back(field(it->rtrim().buf));
        }
        return *this;
}
//header::operator const char* () { i = this->operator string (); return i.buf; }
bool header::operator== (const char* s) { return this->operator string().operator==(s); }
bool header::operator== (header h) { return this->operator string().operator==(h.operator string ()); }
bool header::operator!= (const char* s) { return !this->operator==(s); }
bool header::operator!= (header h) { return !this->operator==(h); }
bool response::operator== (const char* s) { return this->operator string().operator==(s); }
bool response::operator== (response h) { return this->operator string().operator==(h.operator string ()); }
bool response::operator!= (const char* s) { return !this->operator==(s); }
bool response::operator!= (response h) { return !this->operator==(h); }
bool request::operator== (const char* s) { return this->operator string().operator==(s); }
bool request::operator== (request h) { return this->operator string().operator==(h.operator string ()); }
bool request::operator!= (const char* s) { return !this->operator==(s); }
bool request::operator!= (request h) { return !this->operator==(h); }
bool field::operator== (const char* s) { return this->operator string().operator==(s); }
bool field::operator== (field h) { return this->operator string().operator==(h.operator string ()); }
bool field::operator!= (const char* s) { return !this->operator==(s); }
bool field::operator!= (field h) { return !this->operator==(h); }
bool query::operator== (const char* s) { return this->operator string().operator==(s); }
bool query::operator== (query h) { return this->operator string().operator==(h.operator string ()); }
bool query::operator!= (const char* s) { return !this->operator==(s); }
bool query::operator!= (query h) { return !this->operator==(h); }

};
};

#ifdef _WIN32
int net::socket::tcp::wsatoerr(int i) {
        switch (i) {
        case WSA_INVALID_HANDLE: return EINVAL;
        case WSA_NOT_ENOUGH_MEMORY: return ENOMEM;
        case WSA_INVALID_PARAMETER: return EINVAL;
        case WSA_OPERATION_ABORTED: return EINTR;
        case WSA_IO_INCOMPLETE: return EBUSY;
        case WSA_IO_PENDING: return EBUSY;
        case WSAEINTR: return EINTR;
        case WSAEBADF: return EBADF;
        case WSAEACCES: return EACCES;
        case WSAEFAULT: return EFAULT;
        case WSAEINVAL: return EINVAL;
        case WSAEMFILE: return EMFILE;
        case WSAEWOULDBLOCK: return EAGAIN;
        case WSAEINPROGRESS: return EINPROGRESS;
        case WSAEALREADY: return EALREADY;
        case WSAENOTSOCK: return ENOTSOCK;
        case WSAEDESTADDRREQ: return EDESTADDRREQ;
        case WSAEMSGSIZE: return EMSGSIZE;
        case WSAEPROTOTYPE: return EPROTOTYPE;
        case WSAENOPROTOOPT: return ENOPROTOOPT;
        case WSAEPROTONOSUPPORT: return EPROTONOSUPPORT;
        case WSAESOCKTNOSUPPORT: return ENOTSUP;
        case WSAEOPNOTSUPP: return ENOTSUP;
        case WSAEPFNOSUPPORT: return EAFNOSUPPORT;
        case WSAEAFNOSUPPORT: return EAFNOSUPPORT;
        case WSAEADDRINUSE: return EADDRINUSE;
        case WSAEADDRNOTAVAIL: return EADDRNOTAVAIL;
        case WSAENETDOWN: return ENETDOWN;
        case WSAENETUNREACH: return ENETUNREACH;
        case WSAENETRESET: return ENETRESET;
        case WSAECONNABORTED: return ECONNABORTED;
        case WSAECONNREFUSED: return ECONNREFUSED;
        case WSAENOBUFS: return ENOBUFS;
        case WSAENOTCONN: return ENOTCONN;
        case WSAESHUTDOWN: return EIO;
        case WSAETOOMANYREFS: return EMLINK;
        case WSAETIMEDOUT: return ETIMEDOUT;
        case WSAELOOP: return ELOOP;
        case WSAENAMETOOLONG: return ENAMETOOLONG;
        case WSAEHOSTUNREACH: return EHOSTUNREACH;
        case WSAENOTEMPTY: return ENOTEMPTY;
        case WSAEPROCLIM: return EMFILE;
        case WSAEUSERS: return ENOMEM;
        case WSAEDQUOT: return ENOMEM;
        case WSAESTALE: return EBADF;
        case WSAEREMOTE: return ENOENT;
        case WSASYSNOTREADY: return EBUSY;
        case WSAVERNOTSUPPORTED: return ENOTSUP;
        case WSANOTINITIALISED: return EPERM;
        case WSAEDISCON: return ECANCELED;
        case WSAENOMORE: return ENOENT;
        case WSAECANCELLED: return ECANCELED;
        case WSAEINVALIDPROCTABLE: return EINVAL;
        case WSAEINVALIDPROVIDER: return EINVAL;
        case WSAEPROVIDERFAILEDINIT: return EINTR;
        case WSASYSCALLFAILURE: return EINTR;
        case WSASERVICE_NOT_FOUND: return ENOENT;
        case WSATYPE_NOT_FOUND: return ENOENT;
        case WSA_E_NO_MORE: return ENOENT;
        case WSA_E_CANCELLED: return ECANCELED;
        case WSAEREFUSED: return ECONNREFUSED;
        case WSAHOST_NOT_FOUND: return EHOSTUNREACH;
        case WSATRY_AGAIN: return EAGAIN;
        case WSANO_RECOVERY: return ENOTRECOVERABLE;
        case WSANO_DATA: return ENODATA;
        default: return 0;
        }
}
#endif

string object::tostr() { return this->operator string(); }

};