diff --git a/src/cc/gamescc.cpp b/src/cc/gamescc.cpp
index c6206b2ee..38e28a416 100644
--- a/src/cc/gamescc.cpp
+++ b/src/cc/gamescc.cpp
@@ -15,6 +15,10 @@
 
 #include "gamescc.h"
 
+
+#ifndef STANDALONE
+
+
 /*
 ./c cclib rng 17 \"[%229433dc3749aece1bd568f374a45da3b0bc6856990d7da3cd175399577940a775%22,250]\"
 {
@@ -47,6 +51,24 @@
  ./c cclib events 17 \"[%226d%22,%229433dc3749aece1bd568f374a45da3b0bc6856990d7da3cd175399577940a775%22,1]\"
 */
 
+int32_t games_payloadrecv(CPubKey pk,uint32_t timestamp,std::vector<uint8_t> payload)
+{
+    uint256 gametxid; int32_t i,len; char str[67]; uint32_t eventid = 0;
+    if ( (len= payload.size()) > 36 )
+    {
+        len -= 36;
+        for (i=0; i<32; i++)
+            ((uint8_t *)&gametxid)[i] = payload[len+i];
+        eventid = (uint32_t)payload[len+32];
+        eventid |= (uint32_t)payload[len+33] << 8;
+        eventid |= (uint32_t)payload[len+34] << 16;
+        eventid |= (uint32_t)payload[len+35] << 24;
+        for (i=0; i<len; i++)
+            fprintf(stderr,"%02x",payload[i]);
+        fprintf(stderr," got payload, from %s %s/e%d\n",pubkey33_str(str,(uint8_t *)&pk),gametxid.GetHex().c_str(),eventid);
+        return(0);
+    } else return(-1);
+}
 
 CScript games_newgameopret(int64_t buyin,int32_t maxplayers)
 {
@@ -315,21 +337,23 @@ int32_t games_eventsign(uint32_t &timestamp,std::vector<uint8_t> &sig,std::vecto
     } else return(-1);
 }
 
-int32_t games_payloadrecv(CPubKey pk,uint32_t timestamp,std::vector<uint8_t> payload)
+int32_t games_event(uint32_t timestamp,uint256 gametxid,int32_t eventid,std::vector<uint8_t> payload)
 {
-    uint256 gametxid; int32_t i,len; char str[67]; uint32_t eventid = 0;
-    if ( (len= payload.size()) > 36 )
+    std::vector<uint8_t> sig,vopret; CPubKey mypk; uint32_t x; int32_t i,len = payload.size();
+    payload.resize(len + 4 + 32);
+    for (i=0; i<32; i++)
+        payload[len++] = ((uint8_t *)&gametxid)[i];
+    x = eventid;
+    payload[len++] = x, x >>= 8;
+    payload[len++] = x, x >>= 8;
+    payload[len++] = x, x >>= 8;
+    payload[len++] = x;
+    mypk = pubkey2pk(Mypubkey());
+    if ( games_eventsign(timestamp,sig,payload,mypk) == 0 )
     {
-        len -= 36;
-        for (i=0; i<32; i++)
-            ((uint8_t *)&gametxid)[i] = payload[len+i];
-        eventid = (uint32_t)payload[len+32];
-        eventid |= (uint32_t)payload[len+33] << 8;
-        eventid |= (uint32_t)payload[len+34] << 16;
-        eventid |= (uint32_t)payload[len+35] << 24;
-        for (i=0; i<len; i++)
-            fprintf(stderr,"%02x",payload[i]);
-        fprintf(stderr," got payload, from %s %s/e%d\n",pubkey33_str(str,(uint8_t *)&pk),gametxid.GetHex().c_str(),eventid);
+        GetOpReturnData(games_eventopret(timestamp,mypk,sig,payload),vopret);
+        games_payloadrecv(mypk,timestamp,payload);
+        komodo_sendmessage(4,8,"events",vopret);
         return(0);
     } else return(-1);
 }
@@ -337,9 +361,10 @@ int32_t games_payloadrecv(CPubKey pk,uint32_t timestamp,std::vector<uint8_t> pay
 UniValue games_events(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 {
     static uint256 lastgametxid; static uint32_t numevents;
-    UniValue result(UniValue::VOBJ); std::vector<uint8_t> sig,payload,vopret; int32_t len,i,n; uint32_t x; CPubKey mypk; char str[67]; uint32_t eventid,timestamp = 0; uint256 gametxid;
+    UniValue result(UniValue::VOBJ); std::vector<uint8_t> payload; int32_t len,i,n; uint32_t x; CPubKey mypk; char str[67]; uint32_t eventid,timestamp = 0; uint256 gametxid;
     if ( params != 0 && (n= cJSON_GetArraySize(params)) >= 1 && n <= 3 )
     {
+        mypk = pubkey2pk(Mypubkey());
         if ( payments_parsehexdata(payload,jitem(params,0),0) == 0 )
         {
             if ( n >= 2 )
@@ -357,23 +382,11 @@ UniValue games_events(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
                 if ( numevents <= eventid )
                     numevents = eventid+1;
             } else eventid = numevents++;
-            len = payload.size();
-            payload.resize(len + 4 + 32);
-            for (i=0; i<32; i++)
-                payload[len++] = ((uint8_t *)&gametxid)[i];
-            x = eventid;
-            payload[len++] = x, x >>= 8;
-            payload[len++] = x, x >>= 8;
-            payload[len++] = x, x >>= 8;
-            payload[len++] = x;
-            mypk = pubkey2pk(Mypubkey());
-            if ( games_eventsign(timestamp,sig,payload,mypk) == 0 )
+            if ( games_event(timestamp,gametxid,eventid,payload) == 0 )
             {
-                GetOpReturnData(games_eventopret(timestamp,mypk,sig,payload),vopret);
-                games_payloadrecv(mypk,timestamp,payload);
-                komodo_sendmessage(4,8,"events",vopret);
                 result.push_back(Pair("gametxid",gametxid.GetHex()));
                 result.push_back(Pair("eventid",(int64_t)eventid));
+                result.push_back(Pair("payload",jstr(jitem(params,0),0)));
                 result.push_back(Pair("timestamp",(int64_t)timestamp));
                 result.push_back(Pair("result","success"));
                 result.push_back(Pair("pubkey33",pubkey33_str(str,(uint8_t *)&mypk)));
@@ -423,9 +436,9 @@ void komodo_netevent(std::vector<uint8_t> message)
                 }
             }
         }
-        for (i=0; i<payload.size(); i++)
-            fprintf(stderr,"%02x",payload[i]);
-        fprintf(stderr," payload, got pk.%s siglen.%d lag.[%d]\n",pubkey33_str(str,(uint8_t *)&pk),(int32_t)sig.size(),lag);
+        //for (i=0; i<payload.size(); i++)
+        //    fprintf(stderr,"%02x",payload[i]);
+        //fprintf(stderr," payload, got pk.%s siglen.%d lag.[%d]\n",pubkey33_str(str,(uint8_t *)&pk),(int32_t)sig.size(),lag);
     }
     else
     {
@@ -951,7 +964,7 @@ void games_gameplayerinfo(struct CCcontract_info *cp,UniValue &obj,uint256 gamet
     } else fprintf(stderr,"findbaton err.%d\n",retval);
 }
 
-UniValue games_create(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
+UniValue games_newgame(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
     UniValue result(UniValue::VOBJ); std::string rawtx; CPubKey gamespk,mypk; char *jsonstr; uint64_t inputsum,change,required,buyin=0; int32_t i,n,maxplayers = 1;
@@ -1017,7 +1030,7 @@ UniValue games_pending(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
     return(result);
 }
 
-UniValue games_info(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
+UniValue games_gameinfo(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 {
     UniValue result(UniValue::VOBJ),a(UniValue::VARR); int32_t i,n,gameheight,maxplayers,numvouts; uint256 txid; CTransaction tx; int64_t buyin; uint64_t seed; bits256 t; char myaddr[64],str[64]; CPubKey mypk,gamespk;
     result.push_back(Pair("name","games"));
@@ -1586,7 +1599,7 @@ UniValue games_players(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
     return(result);
 }
 
-UniValue games_list(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
+UniValue games_games(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 {
     UniValue result(UniValue::VOBJ),a(UniValue::VARR),b(UniValue::VARR); uint256 txid,hashBlock,gametxid,tokenid,playertxid; int32_t vout,maxplayers,gameheight,numvouts; CPubKey gamespk,mypk; char coinaddr[64]; CTransaction tx,gametx; int64_t buyin;
     std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
@@ -1658,8 +1671,1011 @@ void games_packitemstr(char *packitemstr,struct games_packitem *item)
 {
     sprintf(packitemstr,"not yet");
 }
+#else
 
-#ifdef includgame
+
+#include <stdio.h>
+#include <stdint.h>
+#include <memory.h>
+#include <string.h>
+#include <unistd.h>
+#include <curl/curl.h>
+#include <curl/easy.h>
+
+char USERPASS[8192]; uint16_t GAMES_PORT;
+char Gametxidstr[67];
+char *clonestr(char *str);
+
+#define MAXSTR 1024
+char whoami[MAXSTR];
+
+#define SMALLVAL 0.000000000000001
+#define SATOSHIDEN ((uint64_t)100000000L)
+#define dstr(x) ((double)(x) / SATOSHIDEN)
+#define KOMODO_ASSETCHAIN_MAXLEN 65
+char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN],IPADDRESS[100];
+
+#ifndef _BITS256
+#define _BITS256
+union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uint64_t ulongs[4]; uint64_t txid; };
+typedef union _bits256 bits256;
+#endif
+
+#ifdef _WIN32
+#ifdef _MSC_VER
+int gettimeofday(struct timeval * tp, struct timezone * tzp)
+{
+    // Note: some broken versions only have 8 trailing zero's, the correct epoch has 9 trailing zero's
+    static const uint64_t EPOCH = ((uint64_t)116444736000000000ULL);
+    
+    SYSTEMTIME  system_time;
+    FILETIME    file_time;
+    uint64_t    time;
+    
+    GetSystemTime(&system_time);
+    SystemTimeToFileTime(&system_time, &file_time);
+    time = ((uint64_t)file_time.dwLowDateTime);
+    time += ((uint64_t)file_time.dwHighDateTime) << 32;
+    
+    tp->tv_sec = (long)((time - EPOCH) / 10000000L);
+    tp->tv_usec = (long)(system_time.wMilliseconds * 1000);
+    return 0;
+}
+#endif // _MSC_VER
+#endif
+
+
+
+double OS_milliseconds()
+{
+    struct timeval tv; double millis;
+#ifdef __MINGW32__
+    mingw_gettimeofday(&tv,NULL);
+#else
+    gettimeofday(&tv,NULL);
+#endif
+    millis = ((double)tv.tv_sec * 1000. + (double)tv.tv_usec / 1000.);
+    //printf("tv_sec.%ld usec.%d %f\n",tv.tv_sec,tv.tv_usec,millis);
+    return(millis);
+}
+
+int32_t _unhex(char c)
+{
+    if ( c >= '0' && c <= '9' )
+        return(c - '0');
+    else if ( c >= 'a' && c <= 'f' )
+        return(c - 'a' + 10);
+    else if ( c >= 'A' && c <= 'F' )
+        return(c - 'A' + 10);
+    return(-1);
+}
+
+int32_t is_hexstr(char *str,int32_t n)
+{
+    int32_t i;
+    if ( str == 0 || str[0] == 0 )
+        return(0);
+    for (i=0; str[i]!=0; i++)
+    {
+        if ( n > 0 && i >= n )
+            break;
+        if ( _unhex(str[i]) < 0 )
+            break;
+    }
+    if ( n == 0 )
+        return(i);
+    return(i == n);
+}
+
+int32_t unhex(char c)
+{
+    int32_t hex;
+    if ( (hex= _unhex(c)) < 0 )
+    {
+        //printf("unhex: illegal hexchar.(%c)\n",c);
+    }
+    return(hex);
+}
+
+unsigned char _decode_hex(char *hex) { return((unhex(hex[0])<<4) | unhex(hex[1])); }
+
+int32_t decode_hex(uint8_t *bytes,int32_t n,char *hex)
+{
+    int32_t adjust,i = 0;
+    //printf("decode.(%s)\n",hex);
+    if ( is_hexstr(hex,n) <= 0 )
+    {
+        memset(bytes,0,n);
+        return(n);
+    }
+    if ( hex[n-1] == '\n' || hex[n-1] == '\r' )
+        hex[--n] = 0;
+    if ( n == 0 || (hex[n*2+1] == 0 && hex[n*2] != 0) )
+    {
+        if ( n > 0 )
+        {
+            bytes[0] = unhex(hex[0]);
+            printf("decode_hex n.%d hex[0] (%c) -> %d hex.(%s) [n*2+1: %d] [n*2: %d %c] len.%ld\n",n,hex[0],bytes[0],hex,hex[n*2+1],hex[n*2],hex[n*2],(long)strlen(hex));
+        }
+        bytes++;
+        hex++;
+        adjust = 1;
+    } else adjust = 0;
+    if ( n > 0 )
+    {
+        for (i=0; i<n; i++)
+            bytes[i] = _decode_hex(&hex[i*2]);
+    }
+    //bytes[i] = 0;
+    return(n + adjust);
+}
+
+char hexbyte(int32_t c)
+{
+    c &= 0xf;
+    if ( c < 10 )
+        return('0'+c);
+    else if ( c < 16 )
+        return('a'+c-10);
+    else return(0);
+}
+
+int32_t init_hexbytes_noT(char *hexbytes,unsigned char *message,long len)
+{
+    int32_t i;
+    if ( len <= 0 )
+    {
+        hexbytes[0] = 0;
+        return(1);
+    }
+    for (i=0; i<len; i++)
+    {
+        hexbytes[i*2] = hexbyte((message[i]>>4) & 0xf);
+        hexbytes[i*2 + 1] = hexbyte(message[i] & 0xf);
+        //printf("i.%d (%02x) [%c%c]\n",i,message[i],hexbytes[i*2],hexbytes[i*2+1]);
+    }
+    hexbytes[len*2] = 0;
+    //printf("len.%ld\n",len*2+1);
+    return((int32_t)len*2+1);
+}
+
+char *bits256_str(char hexstr[65],bits256 x)
+{
+    init_hexbytes_noT(hexstr,x.bytes,sizeof(x));
+    return(hexstr);
+}
+
+long _stripwhite(char *buf,int accept)
+{
+    int32_t i,j,c;
+    if ( buf == 0 || buf[0] == 0 )
+        return(0);
+    for (i=j=0; buf[i]!=0; i++)
+    {
+        buf[j] = c = buf[i];
+        if ( c == accept || (c != ' ' && c != '\n' && c != '\r' && c != '\t' && c != '\b') )
+            j++;
+    }
+    buf[j] = 0;
+    return(j);
+}
+
+char *parse_conf_line(char *line,char *field)
+{
+    line += strlen(field);
+    for (; *line!='='&&*line!=0; line++)
+        break;
+    if ( *line == 0 )
+        return(0);
+    if ( *line == '=' )
+        line++;
+    while ( line[strlen(line)-1] == '\r' || line[strlen(line)-1] == '\n' || line[strlen(line)-1] == ' ' )
+        line[strlen(line)-1] = 0;
+    //printf("LINE.(%s)\n",line);
+    _stripwhite(line,0);
+    return(clonestr(line));
+}
+
+int32_t safecopy(char *dest,char *src,long len)
+{
+    int32_t i = -1;
+    if ( src != 0 && dest != 0 && src != dest )
+    {
+        if ( dest != 0 )
+            memset(dest,0,len);
+        for (i=0; i<len&&src[i]!=0; i++)
+            dest[i] = src[i];
+        if ( i == len )
+        {
+            printf("safecopy: %s too long %ld\n",src,len);
+#ifdef __APPLE__
+            //getchar();
+#endif
+            return(-1);
+        }
+        dest[i] = 0;
+    }
+    return(i);
+}
+
+#define true 1
+#define false 0
+//#ifdef STANDALONE
+//#include "../komodo/src/komodo_cJSON.c"
+//#else
+#include "../komodo_cJSON.c"
+//#endif
+
+int32_t games_replay(uint64_t seed,int32_t sleeptime);
+char *games_keystrokesload(int32_t *numkeysp,uint64_t seed,int32_t counter);
+
+int tetris(int argc, char **argv);
+
+void *OS_loadfile(char *fname,uint8_t **bufp,long *lenp,long *allocsizep)
+{
+    FILE *fp;
+    long  filesize,buflen = *allocsizep;
+    uint8_t *buf = *bufp;
+    *lenp = 0;
+    if ( (fp= fopen(fname,"rb")) != 0 )
+    {
+        fseek(fp,0,SEEK_END);
+        filesize = ftell(fp);
+        if ( filesize == 0 )
+        {
+            fclose(fp);
+            *lenp = 0;
+            printf("OS_loadfile null size.(%s)\n",fname);
+            return(0);
+        }
+        if ( filesize > buflen )
+        {
+            *allocsizep = filesize;
+            *bufp = buf = (uint8_t *)realloc(buf,(long)*allocsizep+64);
+        }
+        rewind(fp);
+        if ( buf == 0 )
+            printf("Null buf ???\n");
+        else
+        {
+            if ( fread(buf,1,(long)filesize,fp) != (unsigned long)filesize )
+                printf("error reading filesize.%ld\n",(long)filesize);
+            buf[filesize] = 0;
+        }
+        fclose(fp);
+        *lenp = filesize;
+        //printf("loaded.(%s)\n",buf);
+    } //else printf("OS_loadfile couldnt load.(%s)\n",fname);
+    return(buf);
+}
+
+uint8_t *OS_fileptr(long *allocsizep,char *fname)
+{
+    long filesize = 0; uint8_t *buf = 0; void *retptr;
+    *allocsizep = 0;
+    retptr = OS_loadfile(fname,&buf,&filesize,allocsizep);
+    return((uint8_t *)retptr);
+}
+
+struct MemoryStruct { char *memory; size_t size; };
+struct return_string { char *ptr; size_t len; };
+
+// return data from the server
+#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32)
+#define CURL_GLOBAL_SSL (1<<0)
+#define CURL_GLOBAL_WIN32 (1<<1)
+
+
+/************************************************************************
+ *
+ * Initialize the string handler so that it is thread safe
+ *
+ ************************************************************************/
+
+void init_string(struct return_string *s)
+{
+    s->len = 0;
+    s->ptr = (char *)calloc(1,s->len+1);
+    if ( s->ptr == NULL )
+    {
+        fprintf(stderr,"init_string malloc() failed\n");
+        exit(-1);
+    }
+    s->ptr[0] = '\0';
+}
+
+/************************************************************************
+ *
+ * Use the "writer" to accumulate text until done
+ *
+ ************************************************************************/
+
+size_t accumulatebytes(void *ptr,size_t size,size_t nmemb,struct return_string *s)
+{
+    size_t new_len = s->len + size*nmemb;
+    s->ptr = (char *)realloc(s->ptr,new_len+1);
+    if ( s->ptr == NULL )
+    {
+        fprintf(stderr, "accumulate realloc() failed\n");
+        exit(-1);
+    }
+    memcpy(s->ptr+s->len,ptr,size*nmemb);
+    s->ptr[new_len] = '\0';
+    s->len = new_len;
+    return(size * nmemb);
+}
+
+/************************************************************************
+ *
+ * return the current system time in milliseconds
+ *
+ ************************************************************************/
+
+#define EXTRACT_BITCOIND_RESULT  // if defined, ensures error is null and returns the "result" field
+#ifdef EXTRACT_BITCOIND_RESULT
+
+/************************************************************************
+ *
+ * perform post processing of the results
+ *
+ ************************************************************************/
+
+char *post_process_bitcoind_RPC(char *debugstr,char *command,char *rpcstr,char *params)
+{
+    long i,j,len; char *retstr = 0; cJSON *json,*result,*error;
+    //printf("<<<<<<<<<<< bitcoind_RPC: %s post_process_bitcoind_RPC.%s.[%s]\n",debugstr,command,rpcstr);
+    if ( command == 0 || rpcstr == 0 || rpcstr[0] == 0 )
+    {
+        if ( strcmp(command,"signrawtransaction") != 0 )
+            printf("<<<<<<<<<<< bitcoind_RPC: %s post_process_bitcoind_RPC.%s.[%s]\n",debugstr,command,rpcstr);
+        return(rpcstr);
+    }
+    json = cJSON_Parse(rpcstr);
+    if ( json == 0 )
+    {
+        printf("<<<<<<<<<<< bitcoind_RPC: %s post_process_bitcoind_RPC.%s can't parse.(%s) params.(%s)\n",debugstr,command,rpcstr,params);
+        free(rpcstr);
+        return(0);
+    }
+    result = cJSON_GetObjectItem(json,"result");
+    error = cJSON_GetObjectItem(json,"error");
+    if ( error != 0 && result != 0 )
+    {
+        if ( (error->type&0xff) == cJSON_NULL && (result->type&0xff) != cJSON_NULL )
+        {
+            retstr = cJSON_Print(result);
+            len = strlen(retstr);
+            if ( retstr[0] == '"' && retstr[len-1] == '"' )
+            {
+                for (i=1,j=0; i<len-1; i++,j++)
+                    retstr[j] = retstr[i];
+                retstr[j] = 0;
+            }
+        }
+        else if ( (error->type&0xff) != cJSON_NULL || (result->type&0xff) != cJSON_NULL )
+        {
+            if ( strcmp(command,"signrawtransaction") != 0 )
+                printf("<<<<<<<<<<< bitcoind_RPC: %s post_process_bitcoind_RPC (%s) error.%s\n",debugstr,command,rpcstr);
+        }
+        free(rpcstr);
+    } else retstr = rpcstr;
+    free_json(json);
+    //fprintf(stderr,"<<<<<<<<<<< bitcoind_RPC: postprocess returns.(%s)\n",retstr);
+    return(retstr);
+}
+#endif
+
+#ifdef _WIN32
+#ifdef _MSC_VER
+#define sleep(x) Sleep(1000*(x))
+#endif
+#endif
+
+/************************************************************************
+ *
+ * perform the query
+ *
+ ************************************************************************/
+
+char *bitcoind_RPC(char **retstrp,char *debugstr,char *url,char *userpass,char *command,char *params)
+{
+    static int didinit,count,count2; static double elapsedsum,elapsedsum2;
+    struct curl_slist *headers = NULL; struct return_string s; CURLcode res; CURL *curl_handle;
+    char *bracket0,*bracket1,*databuf = 0; long len; int32_t specialcase,numretries; double starttime;
+    if ( didinit == 0 )
+    {
+        didinit = 1;
+        curl_global_init(CURL_GLOBAL_ALL); //init the curl session
+    }
+    numretries = 0;
+    if ( debugstr != 0 && strcmp(debugstr,"BTCD") == 0 && command != 0 && strcmp(command,"SuperNET") ==  0 )
+        specialcase = 1;
+    else specialcase = 0;
+    if ( url[0] == 0 )
+        strcpy(url,"http://127.0.0.1:7876/nxt");
+    if ( specialcase != 0 && 0 )
+        printf("<<<<<<<<<<< bitcoind_RPC: debug.(%s) url.(%s) command.(%s) params.(%s)\n",debugstr,url,command,params);
+try_again:
+    if ( retstrp != 0 )
+        *retstrp = 0;
+    starttime = OS_milliseconds();
+    curl_handle = curl_easy_init();
+    init_string(&s);
+    headers = curl_slist_append(0,"Expect:");
+    
+    curl_easy_setopt(curl_handle,CURLOPT_USERAGENT,"mozilla/4.0");//"Mozilla/4.0 (compatible; )");
+    curl_easy_setopt(curl_handle,CURLOPT_HTTPHEADER,	headers);
+    curl_easy_setopt(curl_handle,CURLOPT_URL,		url);
+    curl_easy_setopt(curl_handle,CURLOPT_WRITEFUNCTION,	(void *)accumulatebytes); 		// send all data to this function
+    curl_easy_setopt(curl_handle,CURLOPT_WRITEDATA,		&s); 			// we pass our 's' struct to the callback
+    curl_easy_setopt(curl_handle,CURLOPT_NOSIGNAL,		1L);   			// supposed to fix "Alarm clock" and long jump crash
+    curl_easy_setopt(curl_handle,CURLOPT_NOPROGRESS,	1L);			// no progress callback
+    if ( strncmp(url,"https",5) == 0 )
+    {
+        curl_easy_setopt(curl_handle,CURLOPT_SSL_VERIFYPEER,0);
+        curl_easy_setopt(curl_handle,CURLOPT_SSL_VERIFYHOST,0);
+    }
+    if ( userpass != 0 )
+        curl_easy_setopt(curl_handle,CURLOPT_USERPWD,	userpass);
+    databuf = 0;
+    if ( params != 0 )
+    {
+        if ( command != 0 && specialcase == 0 )
+        {
+            len = strlen(params);
+            if ( len > 0 && params[0] == '[' && params[len-1] == ']' ) {
+                bracket0 = bracket1 = (char *)"";
+            }
+            else
+            {
+                bracket0 = (char *)"[";
+                bracket1 = (char *)"]";
+            }
+            
+            databuf = (char *)malloc(256 + strlen(command) + strlen(params));
+            sprintf(databuf,"{\"id\":\"jl777\",\"method\":\"%s\",\"params\":%s%s%s}",command,bracket0,params,bracket1);
+            //printf("url.(%s) userpass.(%s) databuf.(%s)\n",url,userpass,databuf);
+            //
+        } //else if ( specialcase != 0 ) fprintf(stderr,"databuf.(%s)\n",params);
+        curl_easy_setopt(curl_handle,CURLOPT_POST,1L);
+        if ( databuf != 0 )
+            curl_easy_setopt(curl_handle,CURLOPT_POSTFIELDS,databuf);
+        else curl_easy_setopt(curl_handle,CURLOPT_POSTFIELDS,params);
+    }
+    //laststart = milliseconds();
+    res = curl_easy_perform(curl_handle);
+    curl_slist_free_all(headers);
+    curl_easy_cleanup(curl_handle);
+    if ( databuf != 0 ) // clean up temporary buffer
+    {
+        free(databuf);
+        databuf = 0;
+    }
+    if ( res != CURLE_OK )
+    {
+        numretries++;
+        if ( specialcase != 0 )
+        {
+            printf("<<<<<<<<<<< bitcoind_RPC.(%s): BTCD.%s timeout params.(%s) s.ptr.(%s) err.%d\n",url,command,params,s.ptr,res);
+            free(s.ptr);
+            return(0);
+        }
+        else if ( numretries >= 1 )
+        {
+            //printf("Maximum number of retries exceeded!\n");
+            free(s.ptr);
+            return(0);
+        }
+        if ( (rand() % 1000) == 0 )
+            printf( "curl_easy_perform() failed: %s %s.(%s %s), retries: %d\n",curl_easy_strerror(res),debugstr,url,command,numretries);
+        free(s.ptr);
+        sleep((1<<numretries));
+        goto try_again;
+        
+    }
+    else
+    {
+        if ( command != 0 && specialcase == 0 )
+        {
+            count++;
+            elapsedsum += (OS_milliseconds() - starttime);
+            if ( (count % 1000000) == 0)
+                printf("%d: ave %9.6f | elapsed %.3f millis | bitcoind_RPC.(%s) url.(%s)\n",count,elapsedsum/count,(OS_milliseconds() - starttime),command,url);
+            if ( retstrp != 0 )
+            {
+                *retstrp = s.ptr;
+                return(s.ptr);
+            }
+            return(post_process_bitcoind_RPC(debugstr,command,s.ptr,params));
+        }
+        else
+        {
+            if ( 0 && specialcase != 0 )
+                fprintf(stderr,"<<<<<<<<<<< bitcoind_RPC: BTCD.(%s) -> (%s)\n",params,s.ptr);
+            count2++;
+            elapsedsum2 += (OS_milliseconds() - starttime);
+            if ( (count2 % 10000) == 0)
+                printf("%d: ave %9.6f | elapsed %.3f millis | NXT calls.(%s) cmd.(%s)\n",count2,elapsedsum2/count2,(double)(OS_milliseconds() - starttime),url,command);
+            return(s.ptr);
+        }
+    }
+    printf("bitcoind_RPC: impossible case\n");
+    free(s.ptr);
+    return(0);
+}
+
+static size_t WriteMemoryCallback(void *ptr,size_t size,size_t nmemb,void *data)
+{
+    size_t realsize = (size * nmemb);
+    struct MemoryStruct *mem = (struct MemoryStruct *)data;
+    mem->memory = (char *)((ptr != 0) ? realloc(mem->memory,mem->size + realsize + 1) : malloc(mem->size + realsize + 1));
+    if ( mem->memory != 0 )
+    {
+        if ( ptr != 0 )
+            memcpy(&(mem->memory[mem->size]),ptr,realsize);
+        mem->size += realsize;
+        mem->memory[mem->size] = 0;
+    }
+    //printf("got %d bytes\n",(int32_t)(size*nmemb));
+    return(realsize);
+}
+
+char *curl_post(CURL **cHandlep,char *url,char *userpass,char *postfields,char *hdr0,char *hdr1,char *hdr2,char *hdr3)
+{
+    struct MemoryStruct chunk; CURL *cHandle; long code; struct curl_slist *headers = 0;
+    if ( (cHandle= *cHandlep) == NULL )
+        *cHandlep = cHandle = curl_easy_init();
+    else curl_easy_reset(cHandle);
+    //#ifdef DEBUG
+    //curl_easy_setopt(cHandle,CURLOPT_VERBOSE, 1);
+    //#endif
+    curl_easy_setopt(cHandle,CURLOPT_USERAGENT,"mozilla/4.0");//"Mozilla/4.0 (compatible; )");
+    curl_easy_setopt(cHandle,CURLOPT_SSL_VERIFYPEER,0);
+    //curl_easy_setopt(cHandle,CURLOPT_SSLVERSION,1);
+    curl_easy_setopt(cHandle,CURLOPT_URL,url);
+    curl_easy_setopt(cHandle,CURLOPT_CONNECTTIMEOUT,10);
+    if ( userpass != 0 && userpass[0] != 0 )
+        curl_easy_setopt(cHandle,CURLOPT_USERPWD,userpass);
+    if ( postfields != 0 && postfields[0] != 0 )
+    {
+        curl_easy_setopt(cHandle,CURLOPT_POST,1);
+        curl_easy_setopt(cHandle,CURLOPT_POSTFIELDS,postfields);
+    }
+    if ( hdr0 != NULL && hdr0[0] != 0 )
+    {
+        //printf("HDR0.(%s) HDR1.(%s) HDR2.(%s) HDR3.(%s)\n",hdr0!=0?hdr0:"",hdr1!=0?hdr1:"",hdr2!=0?hdr2:"",hdr3!=0?hdr3:"");
+        headers = curl_slist_append(headers,hdr0);
+        if ( hdr1 != 0 && hdr1[0] != 0 )
+            headers = curl_slist_append(headers,hdr1);
+        if ( hdr2 != 0 && hdr2[0] != 0 )
+            headers = curl_slist_append(headers,hdr2);
+        if ( hdr3 != 0 && hdr3[0] != 0 )
+            headers = curl_slist_append(headers,hdr3);
+    } //headers = curl_slist_append(0,"Expect:");
+    if ( headers != 0 )
+        curl_easy_setopt(cHandle,CURLOPT_HTTPHEADER,headers);
+    //res = curl_easy_perform(cHandle);
+    memset(&chunk,0,sizeof(chunk));
+    curl_easy_setopt(cHandle,CURLOPT_WRITEFUNCTION,WriteMemoryCallback);
+    curl_easy_setopt(cHandle,CURLOPT_WRITEDATA,(void *)&chunk);
+    curl_easy_perform(cHandle);
+    curl_easy_getinfo(cHandle,CURLINFO_RESPONSE_CODE,&code);
+    if ( headers != 0 )
+        curl_slist_free_all(headers);
+    if ( code != 200 )
+        printf("(%s) server responded with code %ld (%s)\n",url,code,chunk.memory);
+    return(chunk.memory);
+}
+
+uint16_t _komodo_userpass(char *username, char *password, FILE *fp)
+{
+    char *rpcuser,*rpcpassword,*str,*ipaddress,line[8192]; uint16_t port = 0;
+    rpcuser = rpcpassword = 0;
+    username[0] = password[0] = 0;
+    while ( fgets(line,sizeof(line),fp) != 0 )
+    {
+        if ( line[0] == '#' )
+            continue;
+        //printf("line.(%s) %p %p\n",line,strstr(line,(char *)"rpcuser"),strstr(line,(char *)"rpcpassword"));
+        if ( (str= strstr(line,(char *)"rpcuser")) != 0 )
+            rpcuser = parse_conf_line(str,(char *)"rpcuser");
+        else if ( (str= strstr(line,(char *)"rpcpassword")) != 0 )
+            rpcpassword = parse_conf_line(str,(char *)"rpcpassword");
+        else if ( (str= strstr(line,(char *)"rpcport")) != 0 )
+        {
+            port = atoi(parse_conf_line(str,(char *)"rpcport"));
+            //fprintf(stderr,"rpcport.%u in file\n",port);
+        }
+        else if ( (str= strstr(line,(char *)"ipaddress")) != 0 )
+        {
+            ipaddress = parse_conf_line(str,(char *)"ipaddress");
+            strcpy(IPADDRESS,ipaddress);
+        }
+    }
+    if ( rpcuser != 0 && rpcpassword != 0 )
+    {
+        strcpy(username,rpcuser);
+        strcpy(password,rpcpassword);
+    }
+    //printf("rpcuser.(%s) rpcpassword.(%s) %u ipaddress.%s\n",rpcuser,rpcpassword,port,ipaddress);
+    if ( rpcuser != 0 )
+        free(rpcuser);
+    if ( rpcpassword != 0 )
+        free(rpcpassword);
+    return(port);
+}
+
+uint16_t komodo_userpass(char *userpass,char *symbol)
+{
+    FILE *fp; uint16_t port = 0; char fname[512],username[512],password[512],confname[KOMODO_ASSETCHAIN_MAXLEN];
+    userpass[0] = 0;
+    if ( strcmp("KMD",symbol) == 0 )
+    {
+#ifdef __APPLE__
+        sprintf(confname,"Komodo.conf");
+#else
+        sprintf(confname,"komodo.conf");
+#endif
+    }
+    else sprintf(confname,"%s.conf",symbol);
+    //komodo_statefname(fname,symbol,confname);
+    if ( (fp= fopen(confname,"rb")) != 0 )
+    {
+        port = _komodo_userpass(username,password,fp);
+        sprintf(userpass,"%s:%s",username,password);
+        if ( strcmp(symbol,ASSETCHAINS_SYMBOL) == 0 )
+            strcpy(USERPASS,userpass);
+        fclose(fp);
+    }
+    return(port);
+}
+
+#define is_cJSON_True(json) ((json) != 0 && ((json)->type & 0xff) == cJSON_True)
+
+char *komodo_issuemethod(char *userpass,char *method,char *params,uint16_t port)
+{
+    //static void *cHandle;
+    char url[512],*retstr=0,*retstr2=0,postdata[8192];
+    if ( params == 0 || params[0] == 0 )
+        params = (char *)"[]";
+    if ( strlen(params) < sizeof(postdata)-128 )
+    {
+        sprintf(url,(char *)"http://%s:%u",IPADDRESS,port);
+        sprintf(postdata,"{\"method\":\"%s\",\"params\":%s}",method,params);
+        //printf("[%s] (%s) postdata.(%s) params.(%s) USERPASS.(%s)\n",ASSETCHAINS_SYMBOL,url,postdata,params,USERPASS);
+        retstr2 = bitcoind_RPC(&retstr,(char *)"debug",url,userpass,method,params);
+        //retstr = curl_post(&cHandle,url,USERPASS,postdata,0,0,0,0);
+    }
+    return(retstr2);
+}
+
+int32_t issue_games_events(bits256 gametxid,uint32_t eventid,int32_t c)
+{
+    static FILE *fp;
+    char params[512],*retstr,str[65]; cJSON *retjson,*resobj; int32_t retval = -1;
+    if ( fp == 0 )
+        fp = fopen("events.log","wb");
+    sprintf(params,"[\"events\",\"17\",\"[%%22%08x%%22,%%22%s%%22,%u]\"]",c,bits256_str(str,gametxid),eventid);
+    if ( (retstr= komodo_issuemethod(USERPASS,(char *)"cclib",params,GAMES_PORT)) != 0 )
+    {
+        if ( (retjson= cJSON_Parse(retstr)) != 0 )
+        {
+            if ( (resobj= jobj(retjson,(char *)"result")) != 0 )
+            {
+                retval = 0;
+                if ( fp != 0 )
+                {
+                    fprintf(fp,"%s\n",jprint(resobj,0));
+                    fflush(fp);
+                }
+            }
+            free_json(retjson);
+        } else fprintf(fp,"error parsing %s\n",retstr);
+        free(retstr);
+    } else fprintf(fp,"error issuing method %s\n",params);
+    return(retval);
+}
+
+int32_t games_sendrawtransaction(char *rawtx)
+{
+    char *params,*retstr,*hexstr; cJSON *retjson,*resobj; int32_t retval = -1;
+    params = (char *)malloc(strlen(rawtx) + 16);
+    sprintf(params,"[\"%s\"]",rawtx);
+    if ( (retstr= komodo_issuemethod(USERPASS,(char *)"sendrawtransaction",params,GAMES_PORT)) != 0 )
+    {
+        if ( 0 ) // causes 4th level crash
+        {
+            static FILE *fp;
+            if ( fp == 0 )
+                fp = fopen("games.sendlog","wb");
+            if ( fp != 0 )
+            {
+                fprintf(fp,"%s\n",retstr);
+                fflush(fp);
+            }
+        }
+        if ( (retjson= cJSON_Parse(retstr)) != 0 )
+        {
+            if ( (resobj= jobj(retjson,(char *)"result")) != 0 )
+            {
+                if ( (hexstr= jstr(resobj,0)) != 0 && is_hexstr(hexstr,64) == 64 )
+                    retval = 0;
+            }
+            free_json(retjson);
+        }
+        
+        /* log sendrawtx result in file */
+        
+        /*
+         FILE *debug_file;
+         debug_file = fopen("tx_debug.log", "a");
+         fprintf(debug_file, "%s\n", retstr);
+         fflush(debug_file);
+         fclose(debug_file);
+         */
+        
+        free(retstr);
+    }
+    free(params);
+    return(retval);
+}
+
+int32_t games_progress(struct games_state *rs,int32_t waitflag,uint64_t seed,char *keystrokes,int32_t num)
+{
+    char cmd[16384],hexstr[16384],params[32768],*retstr,*errstr,*rawtx,*pastkeys,*keys; int32_t i,len,numpastkeys,retflag = -1; cJSON *retjson,*resobj; uint8_t *pastcmp;
+    if ( rs->guiflag != 0 && Gametxidstr[0] != 0 )
+    {
+        if ( rs->keystrokeshex != 0 )
+        {
+            if ( games_sendrawtransaction(rs->keystrokeshex) == 0 )
+            {
+                if ( waitflag == 0 )
+                    return(0);
+                else if ( 0 )
+                {
+                    while ( games_sendrawtransaction(rs->keystrokeshex) == 0 )
+                    {
+                        //fprintf(stderr,"pre-rebroadcast\n");
+                        sleep(10);
+                    }
+                }
+            }
+            free(rs->keystrokeshex), rs->keystrokeshex = 0;
+        }
+        if ( 0 && (pastkeys= games_keystrokesload(&numpastkeys,seed,1)) != 0 )
+        {
+            sprintf(params,"[\"extract\",\"17\",\"[%%22%s%%22]\"]",Gametxidstr);
+            if ( (retstr= komodo_issuemethod(USERPASS,(char *)"cclib",params,GAMES_PORT)) != 0 )
+            {
+                if ( (retjson= cJSON_Parse(retstr)) != 0 )
+                {
+                    if ( (resobj= jobj(retjson,(char *)"result")) != 0 && (keys= jstr(resobj,(char *)"keystrokes")) != 0 )
+                    {
+                        len = strlen(keys) / 2;
+                        pastcmp = (uint8_t *)malloc(len + 1);
+                        decode_hex(pastcmp,len,keys);
+                        fprintf(stderr,"keystrokes.(%s) vs pastkeys\n",keys);
+                        for (i=0; i<numpastkeys; i++)
+                            fprintf(stderr,"%02x",pastkeys[i]);
+                        fprintf(stderr,"\n");
+                        if ( len != numpastkeys || memcmp(pastcmp,pastkeys,len) != 0 )
+                        {
+                            fprintf(stderr,"pastcmp[%d] != pastkeys[%d]?\n",len,numpastkeys);
+                        }
+                        free(pastcmp);
+                    } else fprintf(stderr,"no keystrokes in (%s)\n",retstr);
+                    free_json(retjson);
+                } else fprintf(stderr,"error parsing.(%s)\n",retstr);
+                fprintf(stderr,"extracted.(%s)\n",retstr);
+                free(retstr);
+            } else fprintf(stderr,"error extracting game\n");
+            free(pastkeys);
+        } // else fprintf(stderr,"no pastkeys\n");
+        
+        for (i=0; i<num; i++)
+            sprintf(&hexstr[i<<1],"%02x",keystrokes[i]&0xff);
+        hexstr[i<<1] = 0;
+        if ( 0 )
+        {
+            sprintf(cmd,"./komodo-cli -ac_name=%s cclib keystrokes 17 \\\"[%%22%s%%22,%%22%s%%22]\\\" >> keystrokes.log",ASSETCHAINS_SYMBOL,Gametxidstr,hexstr);
+            if ( system(cmd) != 0 )
+                fprintf(stderr,"error issuing (%s)\n",cmd);
+        }
+        else
+        {
+            static FILE *fp;
+            if ( fp == 0 )
+                fp = fopen("keystrokes.log","a");
+            sprintf(params,"[\"keystrokes\",\"17\",\"[%%22%s%%22,%%22%s%%22]\"]",Gametxidstr,hexstr);
+            if ( (retstr= komodo_issuemethod(USERPASS,(char *)"cclib",params,GAMES_PORT)) != 0 )
+            {
+                if ( fp != 0 )
+                {
+                    fprintf(fp,"%s\n",params);
+                    fprintf(fp,"%s\n",retstr);
+                    fflush(fp);
+                }
+                if ( (retjson= cJSON_Parse(retstr)) != 0 )
+                {
+                    if ( (resobj= jobj(retjson,(char *)"result")) != 0 && (rawtx= jstr(resobj,(char *)"hex")) != 0 )
+                    {
+                        if ( rs->keystrokeshex != 0 )
+                            free(rs->keystrokeshex);
+                        if ( (errstr= jstr(resobj,(char *)"error")) == 0 )
+                        {
+                            rs->keystrokeshex = (char *)malloc(strlen(rawtx)+1);
+                            strcpy(rs->keystrokeshex,rawtx);
+                            retflag = 1;
+                        } else fprintf(stderr,"error sending keystrokes tx\n"), sleep(1);
+                        //fprintf(stderr,"set keystrokestx <- %s\n",rs->keystrokeshex);
+                    }
+                    free_json(retjson);
+                }
+                free(retstr);
+            }
+            if ( 0 && waitflag != 0 && rs->keystrokeshex != 0 )
+            {
+                while ( games_sendrawtransaction(rs->keystrokeshex) == 0 )
+                {
+                    //fprintf(stderr,"post-rebroadcast\n");
+                    sleep(3);
+                }
+                free(rs->keystrokeshex), rs->keystrokeshex = 0;
+            }
+        }
+    }
+    return(retflag);
+}
+
+int32_t games_setplayerdata(struct games_state *rs,char *gametxidstr)
+{
+    char cmd[32768]; int32_t i,n,retval=-1; char params[1024],*filestr=0,*pname,*statusstr,*datastr,fname[128]; long allocsize; cJSON *retjson,*array,*item,*resultjson;
+    if ( rs->guiflag == 0 )
+        return(-1);
+    if ( gametxidstr == 0 || *gametxidstr == 0 )
+        return(retval);
+    if ( 0 )
+    {
+        sprintf(fname,"%s.gameinfo",gametxidstr);
+        sprintf(cmd,"./komodo-cli -ac_name=%s cclib gameinfo 17 \\\"[%%22%s%%22]\\\" > %s",ASSETCHAINS_SYMBOL,gametxidstr,fname);
+        if ( system(cmd) != 0 )
+            fprintf(stderr,"error issuing (%s)\n",cmd);
+        else filestr = (char *)OS_fileptr(&allocsize,fname);
+    }
+    else
+    {
+        sprintf(params,"[\"gameinfo\",\"17\",\"[%%22%s%%22]\"]",gametxidstr);
+        filestr = komodo_issuemethod(USERPASS,(char *)"cclib",params,GAMES_PORT);
+    }
+    if ( filestr != 0 )
+    {
+        if ( (retjson= cJSON_Parse(filestr)) != 0 && (resultjson= jobj(retjson,(char *)"result")) != 0 )
+        {
+            //fprintf(stderr,"gameinfo.(%s)\n",jprint(resultjson,0));
+            if ( (array= jarray(&n,resultjson,(char *)"players")) != 0 )
+            {
+                for (i=0; i<n; i++)
+                {
+                    item = jitem(array,i);
+                    if ( is_cJSON_True(jobj(item,(char *)"ismine")) != 0 && (statusstr= jstr(item,(char *)"status")) != 0 )
+                    {
+                        if ( strcmp(statusstr,(char *)"registered") == 0 )
+                        {
+                            retval = 0;
+                            if ( (item= jobj(item,(char *)"player")) != 0 && (datastr= jstr(item,(char *)"data")) != 0 )
+                            {
+                                if ( (pname= jstr(item,(char *)"pname")) != 0 && strlen(pname) < MAXSTR-1 )
+                                    strcpy(whoami,pname);
+                                decode_hex((uint8_t *)&rs->P,(int32_t)strlen(datastr)/2,datastr);
+                                fprintf(stderr,"set pname[%s] %s\n",pname==0?"":pname,jprint(item,0));
+                                rs->restoring = 1;
+                            }
+                        }
+                    }
+                }
+            }
+            free_json(retjson);
+        }
+        free(filestr);
+    }
+    return(retval);
+}
+
+#ifdef _WIN32
+#ifdef _MSC_VER
+__inline int msver(void) {
+    switch (_MSC_VER) {
+        case 1500: return 2008;
+        case 1600: return 2010;
+        case 1700: return 2012;
+        case 1800: return 2013;
+        case 1900: return 2015;
+            //case 1910: return 2017;
+        default: return (_MSC_VER / 100);
+    }
+}
+
+static inline bool is_x64(void) {
+#if defined(__x86_64__) || defined(_WIN64) || defined(__aarch64__)
+    return 1;
+#elif defined(__amd64__) || defined(__amd64) || defined(_M_X64) || defined(_M_IA64)
+    return 1;
+#else
+    return 0;
+#endif
+}
+
+#define BUILD_DATE __DATE__ " " __TIME__
+#endif // _WIN32
+#endif // _MSC_VER
+
+int main(int argc, char **argv)
+{
+    uint64_t seed; FILE *fp = 0; int32_t i,j,c; char userpass[8192];
+#ifdef _WIN32
+#ifdef _MSC_VER
+    printf("*** games for Windows [ Build %s ] ***\n", BUILD_DATE);
+    const char* arch = is_x64() ? "64-bits" : "32-bits";
+    printf("    Built with VC++ %d (%ld) %s\n\n", msver(), _MSC_FULL_VER, arch);
+#endif
+#endif
+    
+    for (i=j=0; argv[0][i]!=0&&j<sizeof(ASSETCHAINS_SYMBOL); i++)
+    {
+        c = argv[0][i];
+        if ( c == '\\' || c == '/' )
+        {
+            j = 0;
+            continue;
+        }
+        ASSETCHAINS_SYMBOL[j++] = toupper(c);
+    }
+    ASSETCHAINS_SYMBOL[j++] = 0;
+    
+#ifdef _WIN32
+#ifdef _MSC_VER
+    if (strncmp(ASSETCHAINS_SYMBOL, "GTEST.EXE", sizeof(ASSETCHAINS_SYMBOL)) == 0 || strncmp(ASSETCHAINS_SYMBOL, "GTEST54.EXE", sizeof(ASSETCHAINS_SYMBOL)) == 0) {
+        strcpy(ASSETCHAINS_SYMBOL, "GTEST"); // accept TETRIS.conf, instead of TETRIS.EXE.conf or TETRIS54.EXE.conf if build with MSVC
+    }
+#endif
+#endif
+    strcpy(ASSETCHAINS_SYMBOL,"GTEST");
+
+    GAMES_PORT = komodo_userpass(userpass,ASSETCHAINS_SYMBOL);
+    if ( IPADDRESS[0] == 0 )
+        strcpy(IPADDRESS,"127.0.0.1");
+    printf("ASSETCHAINS_SYMBOL.(%s) port.%u (%s) IPADDRESS.%s \n",ASSETCHAINS_SYMBOL,GAMES_PORT,USERPASS,IPADDRESS); sleep(1);
+    if ( argc == 2 && (fp=fopen(argv[1],"rb")) == 0 )
+    {
+        
+#ifdef _WIN32
+#ifdef _MSC_VER
+        seed = _strtoui64(argv[1], NULL, 10);
+        fprintf(stderr, "replay seed.str(%s) seed.uint64_t(%I64u)", argv[1], seed);
+#else
+        fprintf(stderr, "replay seed.str(%s) seed.uint64_t(%llu)", argv[1], (long long)seed);
+        seed = atol(argv[1]); // windows, but not MSVC
+#endif // _MSC_VER
+#else
+        seed = atol(argv[1]); // non-windows
+#endif // _WIN32
+        
+        //fprintf(stderr,"replay %llu\n",(long long)seed);
+        return(games_replay(seed,10));
+    }
+    else
+    {
+        if ( fp != 0 )
+            fclose(fp);
+        if ( GAMES_PORT == 0 )
+        {
+            printf("you must copy %s.conf from ~/.komodo/%s/%s.conf (or equivalent location) to current dir\n",ASSETCHAINS_SYMBOL,ASSETCHAINS_SYMBOL,ASSETCHAINS_SYMBOL);
+            return(-1);
+        }
+        return(tetris(argc,argv));
+    }
+}
+#endif
 
 /***************************************************************************/
 /** https://github.com/brenns10/tetris
@@ -1690,7 +2706,6 @@ void games_packitemstr(char *packitemstr,struct games_packitem *item)
 #include <curses.h>
 #endif
 
-
 /*
  Convert a tetromino type to its corresponding cell.
  */
@@ -2381,9 +3396,9 @@ void display_score(WINDOW *w, tetris_game *tg)
 {
     wclear(w);
     box(w, 0, 0);
-    wprintw(w, "Score\n%d\n", tg->points);
-    wprintw(w, "Level\n%d\n", tg->level);
-    wprintw(w, "Lines\n%d\n", tg->lines_remaining);
+    wprintw(w, (char *)"Score\n%d\n", tg->points);
+    wprintw(w, (char *)"Level\n%d\n", tg->level);
+    wprintw(w, (char *)"Lines\n%d\n", tg->lines_remaining);
     wnoutrefresh(w);
 }
 
@@ -2397,7 +3412,7 @@ void save(tetris_game *game, WINDOW *w)
     wclear(w);
     box(w, 0, 0); // return the border
     wmove(w, 1, 1);
-    wprintw(w, "Save and exit? [Y/n] ");
+    wprintw(w, (char *)"Save and exit? [Y/n] ");
     wrefresh(w);
     timeout(-1);
     if (getch() == 'n') {
@@ -2409,8 +3424,8 @@ void save(tetris_game *game, WINDOW *w)
     fclose(f);
     tg_delete(game);
     endwin();
-    printf("Game saved to \"tetris.save\".\n");
-    printf("Resume by passing the filename as an argument to this program.\n");
+    fprintf(stderr,"Game saved to \"tetris.save\".\n");
+    fprintf(stderr,"Resume by passing the filename as an argument to this program.\n");
     exit(EXIT_SUCCESS);
 }
 
@@ -2434,15 +3449,31 @@ void init_colors(void)
  Main tetris game!
  */
 #ifdef STANDALONE
+char *clonestr(char *str)
+{
+    char *clone; int32_t len;
+    if ( str == 0 || str[0] == 0 )
+    {
+        printf("warning cloning nullstr.%p\n",str);
+#ifdef __APPLE__
+        while ( 1 ) sleep(1);
+#endif
+        str = (char *)"<nullstr>";
+    }
+    len = strlen(str);
+    clone = (char *)calloc(1,len+16);
+    strcpy(clone,str);
+    return(clone);
+}
 
-int main(int argc, char **argv)
+int tetris(int argc, char **argv)
 {
     tetris_game *tg;
     tetris_move move = TM_NONE;
     bool running = true;
     WINDOW *board, *next, *hold, *score;
-    //Mix_Music *music;
-    
+    int32_t c,skipcount=0; bits256 gametxid; uint32_t eventid = 0;
+    memset(&gametxid,0,sizeof(gametxid));
     // Load file if given a filename.
     if (argc >= 2) {
         FILE *f = fopen(argv[1], "r");
@@ -2481,8 +3512,18 @@ int main(int argc, char **argv)
         if ( (counter++ % 5) == 0 )
             doupdate();
         sleep_milli(10);
-        
-        switch (getch()) {
+        c = getch();
+        if ( c != -1 || skipcount == 0x3fff )
+        {
+            if ( skipcount > 0 )
+                issue_games_events(gametxid,eventid-skipcount,skipcount | 0x4000);
+            if ( c != -1 )
+                issue_games_events(gametxid,eventid,c);
+            skipcount = 0;
+        } else skipcount++;
+        eventid++;
+        switch ( c )
+        {
             case KEY_LEFT:
                 move = TM_LEFT;
                 break;
@@ -2533,6 +3574,11 @@ int main(int argc, char **argv)
     tg_delete(tg);
     return 0;
 }
-#endif
+
+int32_t games_replay(uint64_t seed,int32_t sleeptime)
+{
+    return(-1);
+}
+
 #endif
 
diff --git a/src/cc/gamescc.h b/src/cc/gamescc.h
index 8a6a3b656..19e5f8d26 100644
--- a/src/cc/gamescc.h
+++ b/src/cc/gamescc.h
@@ -1,6 +1,11 @@
 #ifndef H_GAMESCC_H
 #define H_GAMESCC_H
 
+#include <stdint.h>
+#include <stdio.h>
+
+#ifndef STANDALONE
+
 #define ENABLE_WALLET
 extern CWallet* pwalletMain;
 
@@ -30,29 +35,28 @@ std::string Games_pname;
     { (char *)MYCCNAME, (char *)"rng", (char *)"hash,playerid", 1, 2, ' ', EVAL_GAMES }, \
     { (char *)MYCCNAME, (char *)"rngnext", (char *)"seed", 1, 1, ' ', EVAL_GAMES }, \
     { (char *)MYCCNAME, (char *)"players", (char *)"no params", 0, 0, ' ', EVAL_GAMES }, \
-    { (char *)MYCCNAME, (char *)"list", (char *)"no params", 0, 0, ' ', EVAL_GAMES }, \
+    { (char *)MYCCNAME, (char *)"games", (char *)"no params", 0, 0, ' ', EVAL_GAMES }, \
     { (char *)MYCCNAME, (char *)"pending", (char *)"no params", 0, 0, ' ', EVAL_GAMES }, \
     { (char *)MYCCNAME, (char *)"setname", (char *)"pname", 1, 1, ' ', EVAL_GAMES }, \
-    { (char *)MYCCNAME, (char *)"create", (char *)"maxplayers,buyin", 2, 2, 'C', EVAL_GAMES }, \
+    { (char *)MYCCNAME, (char *)"newgame", (char *)"maxplayers,buyin", 2, 2, 'C', EVAL_GAMES }, \
     { (char *)MYCCNAME, (char *)"playerinfo", (char *)"playertxid", 1, 1, ' ', EVAL_GAMES }, \
-    { (char *)MYCCNAME, (char *)"info", (char *)"gametxid", 1, 1, ' ', EVAL_GAMES }, \
+    { (char *)MYCCNAME, (char *)"gameinfo", (char *)"gametxid", 1, 1, ' ', EVAL_GAMES }, \
     { (char *)MYCCNAME, (char *)"keystrokes", (char *)"txid,hexstr", 2, 2, 'K', EVAL_GAMES }, \
     { (char *)MYCCNAME, (char *)"finish", (char *)"gametxid", 1, 1, 'Q', EVAL_GAMES }, \
     { (char *)MYCCNAME, (char *)"events", (char *)"eventshex [gametxid [eventid]]", 1, 3, ' ', EVAL_GAMES }, \
     { (char *)MYCCNAME, (char *)"extract", (char *)"gametxid [pubkey]", 1, 2, ' ', EVAL_GAMES }, \
     { (char *)MYCCNAME, (char *)"register", (char *)"gametxid [playertxid]", 1, 2, 'R', EVAL_GAMES },
 
-
 bool games_validate(struct CCcontract_info *cp,int32_t height,Eval *eval,const CTransaction tx);
 UniValue games_rng(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
 UniValue games_rngnext(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
 UniValue games_players(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
-UniValue games_list(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
+UniValue games_games(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
 UniValue games_pending(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
 UniValue games_setname(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
-UniValue games_create(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
+UniValue games_newgame(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
 UniValue games_playerinfo(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
-UniValue games_info(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
+UniValue games_gameinfo(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
 UniValue games_keystrokes(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
 UniValue games_finish(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
 UniValue games_events(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
@@ -66,14 +70,30 @@ if ( cp->evalcode == EVAL_GAMES ) \
         return(games_rng(txfee,cp,params)); \
     else if ( strcmp(method,"rngnext") == 0 ) \
         return(games_rngnext(txfee,cp,params)); \
-    else if ( strcmp(method,"create") == 0 ) \
-        return(games_create(txfee,cp,params)); \
-    else if ( strcmp(method,"info") == 0 ) \
-        return(games_info(txfee,cp,params)); \
+    else if ( strcmp(method,"newgame") == 0 ) \
+        return(games_newgame(txfee,cp,params)); \
+    else if ( strcmp(method,"gameinfo") == 0 ) \
+        return(games_gameinfo(txfee,cp,params)); \
     else if ( strcmp(method,"register") == 0 ) \
         return(games_register(txfee,cp,params)); \
     else if ( strcmp(method,"events") == 0 ) \
         return(games_events(txfee,cp,params)); \
+    else if ( strcmp(method,"players") == 0 ) \
+        return(games_players(txfee,cp,params)); \
+    else if ( strcmp(method,"games") == 0 ) \
+        return(games_games(txfee,cp,params)); \
+    else if ( strcmp(method,"pending") == 0 ) \
+        return(games_pending(txfee,cp,params)); \
+    else if ( strcmp(method,"setname") == 0 ) \
+        return(games_setname(txfee,cp,params)); \
+    else if ( strcmp(method,"playerinfo") == 0 ) \
+        return(games_playerinfo(txfee,cp,params)); \
+    else if ( strcmp(method,"keystrokes") == 0 ) \
+        return(games_keystrokes(txfee,cp,params)); \
+    else if ( strcmp(method,"extract") == 0 ) \
+        return(games_extract(txfee,cp,params)); \
+    else if ( strcmp(method,"finish") == 0 ) \
+        return(games_finish(txfee,cp,params)); \
     else \
     { \
         result.push_back(Pair("result","error")); \
@@ -82,6 +102,7 @@ if ( cp->evalcode == EVAL_GAMES ) \
         return(result); \
     } \
 }
+#endif
 
 #define MAXPACK 23
 struct games_packitem
@@ -96,6 +117,18 @@ struct games_player
     struct games_packitem gamespack[MAXPACK];
 };
 
+struct games_state
+{
+    uint64_t seed;
+    char *keystrokes,*keystrokeshex;
+    uint32_t needflush,replaydone;
+    int32_t numkeys,ind,num,guiflag,counter,sleeptime,playersize,restoring,lastnum;
+    FILE *logfp;
+    struct games_player P;
+    char buffered[10000];
+    uint8_t playerdata[10000];
+};
+
 int32_t games_replay2(uint8_t *newdata,uint64_t seed,char *keystrokes,int32_t num,struct games_player *player,int32_t sleepmillis);
 void games_packitemstr(char *packitemstr,struct games_packitem *item);
 
diff --git a/src/cc/maketetris b/src/cc/maketetris
index 9c2a005a0..9f0af354e 100755
--- a/src/cc/maketetris
+++ b/src/cc/maketetris
@@ -1,2 +1,2 @@
-gcc -O3 -std=c++11 -I../secp256k1/include -I../univalue/include -I../cryptoconditions/include -I../cryptoconditions/src -I../cryptoconditions/src/asn -I.. -I. -DSTANDALONE tetris.cpp -lncurses -o tetris
+gcc -O3 -std=c++11 -I../secp256k1/include -I../univalue/include -I../cryptoconditions/include -I../cryptoconditions/src -I../cryptoconditions/src/asn -I.. -I. -DSTANDALONE gamescc.cpp -lncurses -lcurl -o tetris
 
diff --git a/src/cc/rewards.cpp b/src/cc/rewards.cpp
index 1351bbaeb..65e32ee27 100644
--- a/src/cc/rewards.cpp
+++ b/src/cc/rewards.cpp
@@ -197,6 +197,9 @@ bool RewardsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &t
     uint256 txid,fundingtxid,hashBlock,vinfundingtxid; uint64_t vinsbits,sbits,APR,minseconds,maxseconds,mindeposit,amount,reward,txfee=10000; int32_t numvins,numvouts,preventCCvins,preventCCvouts,i; uint8_t funcid; CScript scriptPubKey; CTransaction fundingTx,vinTx;
     numvins = tx.vin.size();
     numvouts = tx.vout.size();
+    int64_t interest; uint64_t valuein;
+    CCoinsViewCache &view = *pcoinsTip;
+    valuein = view.GetValueIn(chainActive.LastTip()->GetHeight(),&interest,tx,chainActive.LastTip()->nTime);
     preventCCvins = preventCCvouts = -1;
     if ( numvouts < 1 )
         return eval->Invalid("no vouts");
@@ -255,6 +258,11 @@ bool RewardsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &t
                         if ( (*cp->ismyvin)(tx.vin[i].scriptSig) == 0 )
                             return eval->Invalid("unexpected normal vin for unlock");
                     }
+                    if ( valuein-tx.GetValueOut() > txfee )
+                    {
+                        fprintf(stderr, "valueout.%li vs valuein.%li txfee.%li\n", tx.GetValueOut(), valuein, txfee);
+                        return eval->Invalid("alright is stealing your money");
+                    }
                     if ( numvouts == 2 && numvins == 1 )
                     {
                         if ( tx.vout[0].scriptPubKey.IsPayToCryptoCondition() != 0 )
@@ -707,4 +715,3 @@ std::string RewardsUnlock(uint64_t txfee,char *planstr,uint256 fundingtxid,uint2
     fprintf(stderr,"amount %.8f -> reward %.8f\n",(double)amount/COIN,(double)reward/COIN);
     return("");
 }
-
diff --git a/src/cc/rogue/cursesd.h b/src/cc/rogue/cursesd.h
index cb74941e5..e3eec5d41 100644
--- a/src/cc/rogue/cursesd.h
+++ b/src/cc/rogue/cursesd.h
@@ -16,6 +16,24 @@
 #ifndef H_CURSESD_H
 #define H_CURSESD_H
 
+#define COLOR_BLACK   0
+
+#ifdef PDC_RGB        /* RGB */
+# define COLOR_RED    1
+# define COLOR_GREEN  2
+# define COLOR_BLUE   4
+#else                 /* BGR */
+# define COLOR_BLUE   1
+# define COLOR_GREEN  2
+# define COLOR_RED    4
+#endif
+
+#define COLOR_CYAN    (COLOR_BLUE | COLOR_GREEN)
+#define COLOR_MAGENTA (COLOR_RED | COLOR_BLUE)
+#define COLOR_YELLOW  (COLOR_RED | COLOR_GREEN)
+
+#define COLOR_WHITE   7
+
 #define	LINES	24
 #define	COLS	80
 
@@ -151,6 +169,15 @@ char *unctrl(char c);
 #define halfdelay(x) 0
 #define nocbreak() 0
 
+// for tetris
+#define init_pair(a,b,c) 0
+#define start_color() 0
+#define box(a,b,c) 0
+#define A_REVERSE 0
+#define COLOR_PAIR(a) 0
+#define timeout(x) 0
+// end for tetris
+
 #ifndef TRUE
 #define TRUE 1
 #endif
diff --git a/src/cc/rogue_rpc.cpp b/src/cc/rogue_rpc.cpp
index fbb1a3d93..ee5f3d566 100644
--- a/src/cc/rogue_rpc.cpp
+++ b/src/cc/rogue_rpc.cpp
@@ -22,6 +22,7 @@
 #define ROGUE_MAXPLAYERS 64 // need to send unused fees back to globalCC address to prevent leeching
 #define ROGUE_MAXKEYSTROKESGAP 60
 #define ROGUE_MAXITERATIONS 777
+#define ROGUE_MAXCASHOUT (777 * COIN)
 
 #include "rogue/rogue_player.h"
 
@@ -1112,6 +1113,8 @@ int32_t rogue_playerdata_validate(int64_t *cashoutp,uint256 &playertxid,struct C
         dungeonlevel = P.dungeonlevel;
         if ( P.amulet != 0 && dungeonlevel < 26 )
             dungeonlevel = 26;
+        if ( dungeonlevel > 42 )
+            dungeonlevel = 42;
         *cashoutp = (uint64_t)P.gold * P.gold * mult * dungeonlevel;
         if ( newdata == playerdata )
         {
@@ -1281,6 +1284,8 @@ UniValue rogue_finishgame(uint64_t txfee,struct CCcontract_info *cp,cJSON *param
                             }
                             if ( cashout > 0 )
                             {
+                                if ( komodo_nextheight() > 77777 && cashout > ROGUE_MAXCASHOUT )
+                                    cashout = ROGUE_MAXCASHOUT;
                                 if ( (inputsum= AddCClibInputs(cp,mtx,roguepk,cashout,60,cp->unspendableCCaddr)) > cashout )
                                     CCchange = (inputsum - cashout);
                                 else fprintf(stderr,"couldnt find enough utxos\n");
@@ -1598,6 +1603,8 @@ bool rogue_validate(struct CCcontract_info *cp,int32_t height,Eval *eval,const C
                                     cashout *= 2;
                                     //cashout += numplayers * buyin;
                                 }
+                                if ( height > 777777 && cashout > ROGUE_MAXCASHOUT )
+                                    cashout = ROGUE_MAXCASHOUT;
                                 sprintf(cashstr,"tokentx.(%c) decoded.%d ht.%d txid.%s %.8f vs vout2 %.8f",tokentx,decoded,height,txid.GetHex().c_str(),(double)cashout/COIN,(double)tx.vout[2].nValue/COIN);
                                 if ( strcmp(laststr,cashstr) != 0 )
                                 {