diff --git a/.gitignore b/.gitignore
index 2f97780ab..0d0846e31 100644
--- a/.gitignore
+++ b/.gitignore
@@ -142,3 +142,5 @@ src/rogue.530623577502174316.player
 src/checkfile
 
 src/log
+
+src/foo.zip
diff --git a/src/cc/rogue/main.c b/src/cc/rogue/main.c
index c0fa36752..1131e3429 100644
--- a/src/cc/rogue/main.c
+++ b/src/cc/rogue/main.c
@@ -20,10 +20,17 @@
 #include <memory.h>
 #include <string.h>
 #include <unistd.h>
+#include <curl/curl.h>
+#include <curl/easy.h>
+
+char USERPASS[8192];
+char Gametxidstr[67];
 
 #define SMALLVAL 0.000000000000001
 #define SATOSHIDEN ((uint64_t)100000000L)
 #define dstr(x) ((double)(x) / SATOSHIDEN)
+#define KOMODO_ASSETCHAIN_MAXLEN 65
+#define ASSETCHAINS_SYMBOL "ROGUE"
 
 #ifndef _BITS256
 #define _BITS256
@@ -31,6 +38,15 @@ union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uin
 typedef union _bits256 bits256;
 #endif
 
+double OS_milliseconds()
+{
+    struct timeval tv; double millis;
+    gettimeofday(&tv,NULL);
+    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' )
@@ -167,6 +183,23 @@ char *clonestr(char *str)
     strcpy(clone,str);
     return(clone);
 }
+
+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;
@@ -246,6 +279,487 @@ uint8_t *OS_fileptr(long *allocsizep,char *fname)
     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
+
+/************************************************************************
+ *
+ * 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);
+}
+
+#ifdef autoextract
+uint16_t _komodo_userpass(char *username,char *password,FILE *fp)
+{
+    char *rpcuser,*rpcpassword,*str,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);
+        }
+    }
+    if ( rpcuser != 0 && rpcpassword != 0 )
+    {
+        strcpy(username,rpcuser);
+        strcpy(password,rpcpassword);
+    }
+    //printf("rpcuser.(%s) rpcpassword.(%s) KMDUSERPASS.(%s) %u\n",rpcuser,rpcpassword,KMDUSERPASS,port);
+    if ( rpcuser != 0 )
+        free(rpcuser);
+    if ( rpcpassword != 0 )
+        free(rpcpassword);
+    return(port);
+}
+
+void komodo_statefname(char *fname,char *symbol,char *str)
+{
+    int32_t n,len;
+    sprintf(fname,"%s",getDataDir());
+    if ( (n= (int32_t)strlen(ASSETCHAINS_SYMBOL)) != 0 )
+    {
+        len = (int32_t)strlen(fname);
+        if ( strcmp(ASSETCHAINS_SYMBOL,&fname[len - n]) == 0 )
+            fname[len - n] = 0;
+        else
+        {
+            printf("unexpected fname.(%s) vs %s [%s] n.%d len.%d (%s)\n",fname,symbol,ASSETCHAINS_SYMBOL,n,len,&fname[len - n]);
+            return;
+        }
+    }
+    else
+    {
+#ifdef _WIN32
+        strcat(fname,"\\");
+#else
+        strcat(fname,"/");
+#endif
+    }
+    if ( symbol != 0 && symbol[0] != 0 && strcmp("KMD",symbol) != 0 )
+    {
+        strcat(fname,symbol);
+        //printf("statefname.(%s) -> (%s)\n",symbol,fname);
+#ifdef _WIN32
+        strcat(fname,"\\");
+#else
+        strcat(fname,"/");
+#endif
+    }
+    strcat(fname,str);
+    //printf("test.(%s) -> [%s] statename.(%s) %s\n",test,ASSETCHAINS_SYMBOL,symbol,fname);
+}
+
+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(fname,"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);
+}
+#endif
+
+#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://127.0.0.1:%u",port);
+        sprintf(postdata,"{\"method\":\"%s\",\"params\":%s}",method,params);
+        //printf("[%s] (%s) postdata.(%s) params.(%s) USERPASS.(%s)\n",ASSETCHAINS_SYMBOL,url,postdata,params,KMDUSERPASS);
+        retstr2 = bitcoind_RPC(&retstr,(char *)"debug",url,userpass,method,params);
+        //retstr = curl_post(&cHandle,url,USERPASS,postdata,0,0,0,0);
+    }
+    return(retstr2);
+}
+
+#include "rogue.h"
+
+void rogue_progress(struct rogue_state *rs,uint64_t seed,char *keystrokes,int32_t num)
+{
+    char cmd[16384],hexstr[16384]; int32_t i;
+    if ( rs->guiflag != 0 && Gametxidstr[0] != 0 )
+    {
+        for (i=0; i<num; i++)
+            sprintf(&hexstr[i<<1],"%02x",keystrokes[i]);
+        hexstr[i<<1] = 0;
+        sprintf(cmd,"./komodo-cli -ac_name=ROGUE cclib keystrokes 17 \\\"[%%22%s%%22,%%22%s%%22]\\\" >> keystrokes.log",Gametxidstr,hexstr);
+        if ( system(cmd) != 0 )
+            fprintf(stderr,"error issuing (%s)\n",cmd);
+    }
+}
+
+int32_t rogue_setplayerdata(struct rogue_state *rs,char *gametxidstr)
+{
+    char cmd[32768]; int32_t i,n,retval=-1; char *filestr,*pname,*statusstr,*datastr,fname[128]; long allocsize; cJSON *retjson,*array,*item;
+    if ( rs->guiflag == 0 )
+        return(-1);
+    if ( gametxidstr == 0 || *gametxidstr == 0 )
+        return(retval);
+    sprintf(fname,"%s.gameinfo",gametxidstr);
+    sprintf(cmd,"./komodo-cli -ac_name=ROGUE cclib gameinfo 17 \\\"[%%22%s%%22]\\\" > %s",gametxidstr,fname);
+    if ( system(cmd) != 0 )
+        fprintf(stderr,"error issuing (%s)\n",cmd);
+    else
+    {
+        filestr = (char *)OS_fileptr(&allocsize,fname);
+        if ( (retjson= cJSON_Parse(filestr)) != 0 )
+        {
+            if ( (array= jarray(&n,retjson,"players")) != 0 )
+            {
+                for (i=0; i<n; i++)
+                {
+                    item = jitem(array,i);
+                    if ( is_cJSON_True(jobj(item,"ismine")) != 0 && (statusstr= jstr(item,"status")) != 0 )
+                    {
+                        if ( strcmp(statusstr,"registered") == 0 )
+                        {
+                            retval = 0;
+                            if ( (item= jobj(item,"player")) != 0 && (datastr= jstr(item,"data")) != 0 )
+                            {
+                                if ( (pname= jstr(item,"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);
+}
+
 int main(int argc, char **argv, char **envp)
 {
     uint64_t seed; FILE *fp = 0;
diff --git a/src/cc/rogue/rogue.c b/src/cc/rogue/rogue.c
index 2f4545585..7e5a53fe5 100644
--- a/src/cc/rogue/rogue.c
+++ b/src/cc/rogue/rogue.c
@@ -26,7 +26,6 @@
  */
 struct rogue_state globalR;
 void garbage_collect();
-char Gametxidstr[67];
 
 void purge_obj_guess(struct obj_info *array,int32_t n)
 {
@@ -152,71 +151,11 @@ int32_t flushkeystrokes(struct rogue_state *rs)
 }
 #else
 
-uint8_t *OS_fileptr(long *allocsizep,char *fname);
-#define is_cJSON_True(json) ((json) != 0 && ((json)->type & 0xff) == cJSON_True)
-
-int32_t rogue_setplayerdata(struct rogue_state *rs,char *gametxidstr)
-{
-    char cmd[32768]; int32_t i,n,retval=-1; char *filestr,*pname,*statusstr,*datastr,fname[128]; long allocsize; cJSON *retjson,*array,*item;
-    if ( gametxidstr == 0 || *gametxidstr == 0 )
-        return(retval);
-    sprintf(fname,"%s.gameinfo",gametxidstr);
-    sprintf(cmd,"./komodo-cli -ac_name=ROGUE cclib gameinfo 17 \\\"[%%22%s%%22]\\\" > %s",gametxidstr,fname);
-    if ( system(cmd) != 0 )
-        fprintf(stderr,"error issuing (%s)\n",cmd);
-    else
-    {
-        filestr = (char *)OS_fileptr(&allocsize,fname);
-        if ( (retjson= cJSON_Parse(filestr)) != 0 )
-        {
-            if ( (array= jarray(&n,retjson,"players")) != 0 )
-            {
-                for (i=0; i<n; i++)
-                {
-                    item = jitem(array,i);
-                    if ( is_cJSON_True(jobj(item,"ismine")) != 0 && (statusstr= jstr(item,"status")) != 0 )
-                    {
-                        if ( strcmp(statusstr,"registered") == 0 )
-                        {
-                            retval = 0;
-                            if ( (item= jobj(item,"player")) != 0 && (datastr= jstr(item,"data")) != 0 )
-                            {
-                                if ( (pname= jstr(item,"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);
-}
-
-void rogue_progress(uint64_t seed,char *keystrokes,int32_t num)
-{
-    char cmd[16384],hexstr[16384]; int32_t i;
-    if ( Gametxidstr[0] != 0 )
-    {
-        for (i=0; i<num; i++)
-            sprintf(&hexstr[i<<1],"%02x",keystrokes[i]);
-        hexstr[i<<1] = 0;
-        sprintf(cmd,"./komodo-cli -ac_name=ROGUE cclib keystrokes 17 \\\"[%%22%s%%22,%%22%s%%22]\\\" >> keystrokes.log",Gametxidstr,hexstr);
-        if ( system(cmd) != 0 )
-            fprintf(stderr,"error issuing (%s)\n",cmd);
-    }
-}
-
 int32_t flushkeystrokes(struct rogue_state *rs)
 {
     if ( rs->num > 0 )
     {
-        rogue_progress(rs->seed,rs->buffered,rs->num);
+        rogue_progress(rs,rs->seed,rs->buffered,rs->num);
         memset(rs->buffered,0,sizeof(rs->buffered));
         rs->counter++;
         rs->num = 0;
@@ -230,10 +169,10 @@ void rogue_bailout(struct rogue_state *rs)
     flushkeystrokes(rs);
     //sleep(5);
     return;
-    fprintf(stderr,"bailing out\n");
+    /*fprintf(stderr,"bailing out\n");
     sprintf(cmd,"./komodo-cli -ac_name=ROGUE cclib bailout 17 \\\"[%%22%s%%22]\\\" >> bailout.log",Gametxidstr);
     if ( system(cmd) != 0 )
-        fprintf(stderr,"error issuing (%s)\n",cmd);
+        fprintf(stderr,"error issuing (%s)\n",cmd);*/
 }
 
 int32_t rogue_replay2(uint8_t *newdata,uint64_t seed,char *keystrokes,int32_t num,struct rogue_player *player,int32_t sleepmillis)
@@ -356,6 +295,8 @@ int rogue(int argc, char **argv, char **envp)
 {
     char *env; int lowtime; struct rogue_state *rs = &globalR;
     memset(rs,0,sizeof(*rs));
+    rs->guiflag = 1;
+    rs->sleeptime = 1; // non-zero to allow refresh()
     if ( argc == 3 && strlen(argv[2]) == 64 )
     {
         rs->seed = atol(argv[1]);
@@ -366,8 +307,6 @@ int rogue(int argc, char **argv, char **envp)
             return(-1);
         }
     } else rs->seed = 777;
-    rs->guiflag = 1;
-    rs->sleeptime = 1; // non-zero to allow refresh()
     md_init();
 
 #ifdef MASTER
diff --git a/src/cc/rogue/rogue.h b/src/cc/rogue/rogue.h
index f687b170c..802dd5f64 100644
--- a/src/cc/rogue/rogue.h
+++ b/src/cc/rogue/rogue.h
@@ -370,7 +370,7 @@ struct rogue_state
     uint8_t playerdata[10000];
 };
 extern struct rogue_state globalR;
-
+extern char Gametxidstr[67];
 
 int rogue(int argc, char **argv, char **envp);
 void rogueiterate(struct rogue_state *rs);
@@ -380,6 +380,8 @@ int32_t rogue_restorepack(struct rogue_state *rs);
 void restore_player(struct rogue_state *rs);
 int32_t rogue_replay2(uint8_t *newdata,uint64_t seed,char *keystrokes,int32_t num,struct rogue_player *player,int32_t sleepmillis);
 void rogue_bailout(struct rogue_state *rs);
+void rogue_progress(struct rogue_state *rs,uint64_t seed,char *keystrokes,int32_t num);
+int32_t rogue_setplayerdata(struct rogue_state *rs,char *gametxidstr);
 
 #define ROGUE_MAXTOTAL (pstats.s_str*2)
 
diff --git a/src/cc/rogue/state.c b/src/cc/rogue/state.c
index 589f77422..7a0e2e4c6 100644
--- a/src/cc/rogue/state.c
+++ b/src/cc/rogue/state.c
@@ -1432,7 +1432,7 @@ rs_write_object(struct rogue_state *rs,FILE *savef, THING *o)
     if ( o->_o._o_packch != 0 )
     {
         item = &rs->P.roguepack[rs->P.packsize];
-        if ( pstats.s_hpt <= 0 )
+        if ( 0 && pstats.s_hpt <= 0 )
         {
             //fprintf(stderr,"KILLED\n");
             rs->P.gold = -1;
diff --git a/src/cc/rogue_rpc.cpp b/src/cc/rogue_rpc.cpp
index 8ca239c7b..2d34d27c8 100644
--- a/src/cc/rogue_rpc.cpp
+++ b/src/cc/rogue_rpc.cpp
@@ -1005,7 +1005,7 @@ UniValue rogue_finishgame(uint64_t txfee,struct CCcontract_info *cp,cJSON *param
                             newdata[i] = player[i];
                             ((uint8_t *)&P)[i] = player[i];
                         }
-                        if ( P.gold <= 0 || P.hitpoints <= 0 || (P.strength&0xffff) <= 0 || P.level <= 0 || P.experience <= 0 || P.dungeonlevel <= 0 )
+                        if ( 0 && (P.gold <= 0 || P.hitpoints <= 0 || (P.strength&0xffff) <= 0 || P.level <= 0 || P.experience <= 0 || P.dungeonlevel <= 0) )
                         {
                             fprintf(stderr,"zero value character was killed -> no playerdata\n");
                             newdata.resize(0);