diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c
index 018235a..1c5d7f6 100644
--- a/programs/winedbg/gdbproxy.c
+++ b/programs/winedbg/gdbproxy.c
@@ -123,6 +123,15 @@
     return "0123456789abcdef"[x];
 }
 
+static int hex_to_int(const char* src, size_t len){
+    unsigned int returnval = 0;
+    while (len--){
+        returnval=hex_from0(src[0]);
+        if(len) returnval<<=4;
+    }
+    return returnval;
+}
+
 static void hex_from(void* dst, const char* src, size_t len)
 {
     unsigned char *p = dst;
@@ -572,7 +581,28 @@
                         dbg_curr_thread->tid, cont);
     }
     else if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
-        fprintf(stderr, "Cannot find last thread (%lu)\n", dbg_curr_thread->tid);
+        fprintf(stderr, "Cannot find last thread\n");
+}
+
+
+static void    resume_debuggee_thread(struct gdb_context* gdbctx, unsigned long cont, unsigned int threadid)
+{
+
+    if (dbg_curr_thread)
+    {
+        if(dbg_curr_thread->tid  == threadid){
+            /* Windows debug and GDB don't seem to work well here, windows only likes ContinueDebugEvent being used on the reporter of the event */
+            if (!SetThreadContext(dbg_curr_thread->handle, &gdbctx->context))
+                if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
+                    fprintf(stderr, "Cannot set context on thread %lu\n", dbg_curr_thread->tid);
+            if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont))
+                if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
+                    fprintf(stderr, "Cannot continue on %lu (%lu)\n",
+                            dbg_curr_thread->tid, cont);
+        }
+    }
+    else if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
+        fprintf(stderr, "Cannot find last thread\n");
 }
 
 static void    wait_for_debuggee(struct gdb_context* gdbctx)
@@ -866,6 +896,185 @@
     return packet_reply_status(gdbctx);
 }
 
+static enum packet_return packet_verbose(struct gdb_context* gdbctx)
+{
+    int i;
+    int defaultAction = -1; /* magic non action */
+    unsigned char sig;
+    int actions =0;
+    int actionIndex[20]; /* allow for upto 20 actions */
+    int threadIndex[20];
+    int threadCount = 0;
+    unsigned int threadIDs[100]; /* TODO: Should make this dynamic */
+    unsigned int threadID = 0;
+    struct dbg_thread*  thd;
+
+    /* basic check */
+    assert(gdbctx->in_packet_len >= 4);
+
+    /* OK we have vCont followed by..
+    * ? for query
+    * c for packet_continue
+    * Csig for packet_continue_signal
+    * s for step
+    * Ssig  for step signal
+    * and then an optional thread ID at the end..
+    * *******************************************/
+
+    fprintf(stderr, "trying to process a verbose packet\n");
+    /* now check that we've got Cont */
+    assert(strncmp(gdbctx->in_packet, "Cont", 4) == 0);
+
+    /* Query */
+    if(gdbctx->in_packet[4] == '?'){
+        /*
+          Reply:
+          `vCont[;action]...'
+          The vCont packet is supported. Each action is a supported command in the vCont packet.
+          `'
+          The vCont packet is not supported.  (this didn't seem to be obayed!)
+        */
+        packet_reply_open(gdbctx);
+        packet_reply_add(gdbctx, "vCont", 5);
+        /* add all the supported actions to the reply (all of them for now)*/
+        packet_reply_add(gdbctx, ";c", 2);
+        packet_reply_add(gdbctx, ";C", 2);
+        packet_reply_add(gdbctx, ";s", 2);
+        packet_reply_add(gdbctx, ";S", 2);
+        packet_reply_close(gdbctx);
+        return packet_done;
+    }
+
+    /* This may not be the 'fastest' code in the world. but it should be nice and easy to debug.
+    (as it's run when people are debugging break points I'm sure they won't notice the extra 100 cycles anyway)
+    now if only gdb talked XML.... */
+#if 0 /* handy for debugging */
+    fprintf(stderr, "no, but can we find a default packet %.*s %d\n", gdbctx->in_packet_len, gdbctx->in_packet,  gdbctx->in_packet_len);
+#endif
+
+    /* go through the packet and identify where all the actions start att */
+    for(i = 4; i < gdbctx->in_packet_len - 1; i++){
+        if(gdbctx->in_packet[i] == ';'){
+            threadIndex[actions] = 0;
+            actionIndex[actions++] = i;
+        }else if(gdbctx->in_packet[i] == ':'){
+            threadIndex[actions - 1] = i;
+        }
+    }
+
+    /* now look up the default action */
+    for(i = 0 ; i < actions; i++){
+        if(threadIndex[i] == 0){
+            if(defaultAction != -1){
+                    fprintf(stderr,"Too many default actions specified\n");
+                    return packet_error;
+            }
+            defaultAction = i;
+        }
+    }
+
+    /* Now, I have this default action thing that needs to be applied to all non counted threads */
+
+    /* go through all the threads and stick there id's in the to be done list. */
+    for (thd = gdbctx->process->threads; thd; thd = thd->next)
+    {
+        threadIDs[threadCount++] = thd->tid;
+        /* check to see if we have more threads than I counted on, and tell the user what to do
+         * (their running winedbg, so I'm sure they can fix the problem from the error message!) */
+        if(threadCount == 100){
+            fprintf(stderr, "Wow, that's a lot of threads, change threadIDs in wine/programms/winedgb/gdbproxy.c to be higher\n");
+            break;
+        }
+    }
+
+    /* Ok, now we have... actionIndex full of actions and we know what threads there are, so all
+     * that remains is to apply the actions to the threads and the default action to any threads
+     * left */
+    if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread)
+    if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME)
+        fprintf(stderr, "NIY: cont on %lu, while last thread is %lu\n",
+                gdbctx->exec_thread->tid, dbg_curr_thread->tid);
+
+    /* deal with the threaded stuff first */
+    for( i = 0; i < actions ; i++){
+
+        if(threadIndex[i] != 0){
+
+            int j, idLength = 0;
+            if(i < actions - 1){
+                idLength = (actionIndex[i+1] - threadIndex[i]) - 1;
+            } else{
+                idLength = (gdbctx->in_packet_len - threadIndex[i]) - 1;
+            }
+
+            threadID = hex_to_int( gdbctx->in_packet + threadIndex[i] + 1 , idLength);
+            /* process the action */
+            switch(gdbctx->in_packet[actionIndex[i] + 1]){
+            case 's': /* step */
+                be_cpu->single_step(&gdbctx->context, TRUE);
+                /* fall through*/
+            case 'c': /* continue */
+                resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID);
+                break;
+            case 'S': /* step Sig, */
+                be_cpu->single_step(&gdbctx->context, TRUE);
+                /* fall through */
+            case 'C': /* continue sig */
+                hex_from(&sig, gdbctx->in_packet + actionIndex[i] + 2, 1);
+                /* cannot change signals on the fly */
+                if (gdbctx->trace & GDBPXY_TRC_COMMAND)
+                    fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig);
+                if (sig != gdbctx->last_sig)
+                    return packet_error;
+                resume_debuggee_thread(gdbctx, DBG_EXCEPTION_NOT_HANDLED, threadID);
+                break;
+            }
+            for(j = 0 ; j< threadCount; j++){
+                if(threadIDs[j] == threadID){
+                    threadIDs[j] = 0;
+                    break;
+                }
+            }
+        }
+    } /* for i=0 ; i< actions */
+
+     /* now we have manage the default action */
+    if(defaultAction >=0){
+        for(i = 0 ; i< threadCount; i++){
+            /* check to see if we've already done something to the thread*/
+            if(threadIDs[i] != 0){
+                /* if not apply the default action*/
+                threadID = threadIDs[i];
+                /* process the action (yes this is almost identical to the one above!) */
+                switch(gdbctx->in_packet[actionIndex[defaultAction] + 1]){
+                case 's': /* step */
+                    be_cpu->single_step(&gdbctx->context, TRUE);
+                    /* fall through */
+                case 'c': /* continue */
+                    resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID);
+                    break;
+                case 'S':
+                     be_cpu->single_step(&gdbctx->context, TRUE);
+                     /* fall through */
+                case 'C': /* continue sig */
+                    hex_from(&sig, gdbctx->in_packet + actionIndex[defaultAction] + 2, 1);
+                    /* cannot change signals on the fly */
+                    if (gdbctx->trace & GDBPXY_TRC_COMMAND)
+                        fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig);
+                    if (sig != gdbctx->last_sig)
+                        return packet_error;
+                    resume_debuggee_thread(gdbctx, DBG_EXCEPTION_NOT_HANDLED, threadID);
+                    break;
+                }
+            }
+        }
+    } /* if(defaultAction >=0) */
+
+    wait_for_debuggee(gdbctx);
+    be_cpu->single_step(&gdbctx->context, FALSE);
+    return packet_reply_status(gdbctx);
+}
+
 static enum packet_return packet_continue_signal(struct gdb_context* gdbctx)
 {
     unsigned char sig;
@@ -1604,7 +1813,7 @@
 
 static struct packet_entry packet_entries[] =
 {
-/*        {'!', packet_extended}, */
+        /*{'!', packet_extended}, */
         {'?', packet_last_signal},
         {'c', packet_continue},
         {'C', packet_continue_signal},
@@ -1618,9 +1827,12 @@
         /* {'p', packet_read_register}, doesn't seem needed */
         {'P', packet_write_register},
         {'q', packet_query},
-        {'s', packet_step},
+        /* {'Q', packet_set}, */
+        /* {'R', packet,restart}, only in extended mode ! */
+        {'s', packet_step},        
         /*{'S', packet_step_signal}, hard(er) to implement */
         {'T', packet_thread_alive},
+        {'v', packet_verbose},
         {'z', packet_remove_breakpoint},
         {'Z', packet_set_breakpoint},
 };