# HG changeset patch
# User jcdutton
# Date 1049384528 0
# Node ID 5ddb33e104a823f54d06bf7fb3d8d54682c20a2d
# Parent  26334f5fac2b1268a0db990ec9798798fb20f008
Fix getbits to be more sensible.
I.E. bit 63 of a number should correspond of start=63

diff -r 26334f5fac2b -r 5ddb33e104a8 decoder.c
--- a/decoder.c	Thu Apr 03 12:57:41 2003 +0000
+++ b/decoder.c	Thu Apr 03 15:42:08 2003 +0000
@@ -42,7 +42,7 @@
 
   if (count == 0) return 0;
 
-  if ( ((count+start) > 64) ||
+  if ( ((start - count) < -1) ||
        (count > 32) ||
        (start > 63) ||
        (count < 0) ||
@@ -50,8 +50,8 @@
     fprintf(MSG_OUT, "libdvdnav: Bad call to vm_getbits. Parameter out of range\n");
     assert(0);
   }
-  bit_mask >>= start;
-  bits = 64-count-start;
+  bit_mask >>= 63 - start;
+  bits = start + 1 - count;
   examining = ((bit_mask >> bits) << bits );
   command->examined |= examining;
   result = (command->instruction & bit_mask) >> bits;
@@ -112,9 +112,9 @@
    lower eight bits for the system or general purpose register. */
 static uint16_t eval_reg_or_data(command_t* command, int32_t imm, int32_t byte) {
   if(imm) { /*  immediate */
-    return vm_getbits(command, (byte*8), 16);
+    return vm_getbits(command, 63 - (byte*8), 16);
   } else {
-    return eval_reg(command, vm_getbits(command, ((byte + 1)*8), 8));
+    return eval_reg(command, vm_getbits(command, 63 - ((byte + 1)*8), 8));
   }
 }
 
@@ -124,9 +124,9 @@
 /* Evaluates gprm or data depending on bit, data is in byte n */
 uint16_t eval_reg_or_data_2(command_t* command, int32_t imm, int32_t byte) {
   if(imm) /* immediate */
-    return vm_getbits(command, ((byte*8)+1), 7);
+    return vm_getbits(command, 63 - ((byte*8)+1), 7);
   else
-    return get_GPRM(command->registers, (vm_getbits(command, ((byte*8)+4), 4)) );
+    return get_GPRM(command->registers, (vm_getbits(command, 63 - ((byte*8)+4), 4)) );
 }
 
 
@@ -157,10 +157,10 @@
 /* Evaluate if version 1.
    Has comparison data in byte 3 and 4-5 (immediate or register) */
 static int32_t eval_if_version_1(command_t* command) {
-  uint8_t op = vm_getbits(command, 9, 3);
+  uint8_t op = vm_getbits(command, 54, 3);
   if(op) {
-    return eval_compare(op, eval_reg(command, vm_getbits(command, 24, 8)), 
-                            eval_reg_or_data(command, vm_getbits(command, 8, 1), 4));
+    return eval_compare(op, eval_reg(command, vm_getbits(command, 39, 8)), 
+                            eval_reg_or_data(command, vm_getbits(command, 55, 1), 4));
   }
   return 1;
 }
@@ -168,10 +168,10 @@
 /* Evaluate if version 2.
    This version only compares register which are in byte 6 and 7 */
 static int32_t eval_if_version_2(command_t* command) {
-  uint8_t op = vm_getbits(command, 9, 3);
+  uint8_t op = vm_getbits(command, 54, 3);
   if(op) {
-    return eval_compare(op, eval_reg(command, vm_getbits(command, 48, 8)), 
-                            eval_reg(command, vm_getbits(command, 56, 8)));
+    return eval_compare(op, eval_reg(command, vm_getbits(command, 15, 8)), 
+                            eval_reg(command, vm_getbits(command, 7, 8)));
   }
   return 1;
 }
@@ -179,10 +179,10 @@
 /* Evaluate if version 3.
    Has comparison data in byte 2 and 6-7 (immediate or register) */
 static int32_t eval_if_version_3(command_t* command) {
-  uint8_t op = vm_getbits(command, 9, 3);
+  uint8_t op = vm_getbits(command, 54, 3);
   if(op) {
-    return eval_compare(op, eval_reg(command, vm_getbits(command, 16, 8)), 
-                            eval_reg_or_data(command, vm_getbits(command, 8, 1), 6));
+    return eval_compare(op, eval_reg(command, vm_getbits(command, 47, 8)), 
+                            eval_reg_or_data(command, vm_getbits(command, 55, 1), 6));
   }
   return 1;
 }
@@ -191,10 +191,10 @@
    Has comparison data in byte 1 and 4-5 (immediate or register) 
    The register in byte 1 is only the lowe nibble (4 bits) */
 static int32_t eval_if_version_4(command_t* command) {
-  uint8_t op = vm_getbits(command, 9, 3);
+  uint8_t op = vm_getbits(command, 54, 3);
   if(op) {
-    return eval_compare(op, eval_reg(command, vm_getbits(command, 12, 4)), 
-                            eval_reg_or_data(command, vm_getbits(command, 8, 1), 4));
+    return eval_compare(op, eval_reg(command, vm_getbits(command, 51, 4)), 
+                            eval_reg_or_data(command, vm_getbits(command, 55, 1), 4));
   }
   return 1;
 }
@@ -204,20 +204,20 @@
 static int32_t eval_special_instruction(command_t* command, int32_t cond) {
   int32_t line, level;
   
-  switch(vm_getbits(command, 12, 4)) {
+  switch(vm_getbits(command, 51, 4)) {
     case 0: /*  NOP */
       line = 0;
       return cond ? line : 0;
     case 1: /*  Goto line */
-      line = vm_getbits(command, 56, 8);
+      line = vm_getbits(command, 7, 8);
       return cond ? line : 0;
     case 2: /*  Break */
       /*  max number of rows < 256, so we will end this set */
       line = 256;
       return cond ? 256 : 0;
     case 3: /*  Set temporary parental level and goto */
-      line = vm_getbits(command, 56, 8); 
-      level = vm_getbits(command, 52, 4);
+      line = vm_getbits(command, 7, 8); 
+      level = vm_getbits(command, 11, 4);
       if(cond) {
 	/*  This always succeeds now, if we want real parental protection */
 	/*  we need to ask the user and have passwords and stuff. */
@@ -232,8 +232,8 @@
    Return 1 if link, or 0 if no link
    Actual link instruction is in return_values parameter */
 static int32_t eval_link_subins(command_t* command, int32_t cond, link_t *return_values) {
-  uint16_t button = vm_getbits(command, 48, 6);
-  uint8_t  linkop = vm_getbits(command, 59, 5);
+  uint16_t button = vm_getbits(command, 15, 6);
+  uint8_t  linkop = vm_getbits(command, 4, 5);
   
   if(linkop > 0x10)
     return 0;    /*  Unknown Link by Sub-Instruction command */
@@ -249,29 +249,29 @@
    Return 1 if link, or 0 if no link
    Actual link instruction is in return_values parameter */
 static int32_t eval_link_instruction(command_t* command, int32_t cond, link_t *return_values) {
-  uint8_t op = vm_getbits(command, 12, 4);
+  uint8_t op = vm_getbits(command, 51, 4);
   
   switch(op) {
     case 1:
 	return eval_link_subins(command, cond, return_values);
     case 4:
 	return_values->command = LinkPGCN;
-	return_values->data1   = vm_getbits(command, 49, 15);
+	return_values->data1   = vm_getbits(command, 14, 15);
 	return cond;
     case 5:
 	return_values->command = LinkPTTN;
-	return_values->data1 = vm_getbits(command, 54, 10);
-	return_values->data2 = vm_getbits(command, 48, 6);
+	return_values->data1 = vm_getbits(command, 9, 10);
+	return_values->data2 = vm_getbits(command, 15, 6);
 	return cond;
     case 6:
 	return_values->command = LinkPGN;
-	return_values->data1 = vm_getbits(command, 57, 7);
-	return_values->data2 = vm_getbits(command, 48, 6);
+	return_values->data1 = vm_getbits(command, 6, 7);
+	return_values->data2 = vm_getbits(command, 15, 6);
 	return cond;
     case 7:
 	return_values->command = LinkCN;
-	return_values->data1 = vm_getbits(command, 56, 8);
-	return_values->data2 = vm_getbits(command, 48, 6);
+	return_values->data1 = vm_getbits(command, 7, 8);
+	return_values->data2 = vm_getbits(command, 15, 6);
 	return cond;
   }
   return 0;
@@ -283,64 +283,64 @@
    actual jump instruction is in return_values parameter */
 static int32_t eval_jump_instruction(command_t* command, int32_t cond, link_t *return_values) {
   
-  switch(vm_getbits(command, 12, 4)) {
+  switch(vm_getbits(command, 51, 4)) {
     case 1:
       return_values->command = Exit;
       return cond;
     case 2:
       return_values->command = JumpTT;
-      return_values->data1 = vm_getbits(command, 41, 7);
+      return_values->data1 = vm_getbits(command, 22, 7);
       return cond;
     case 3:
       return_values->command = JumpVTS_TT;
-      return_values->data1 = vm_getbits(command, 41, 7);
+      return_values->data1 = vm_getbits(command, 22, 7);
       return cond;
     case 5:
       return_values->command = JumpVTS_PTT;
-      return_values->data1 = vm_getbits(command, 41, 7);
-      return_values->data2 = vm_getbits(command, 22, 10);
+      return_values->data1 = vm_getbits(command, 22, 7);
+      return_values->data2 = vm_getbits(command, 41, 10);
       return cond;
     case 6:
-      switch(vm_getbits(command, 40, 2)) {
+      switch(vm_getbits(command, 23, 2)) {
         case 0:
           return_values->command = JumpSS_FP;
           return cond;
         case 1:
           return_values->command = JumpSS_VMGM_MENU;
-          return_values->data1 =  vm_getbits(command, 44, 4);
+          return_values->data1 =  vm_getbits(command, 19, 4);
           return cond;
         case 2:
           return_values->command = JumpSS_VTSM;
-          return_values->data1 =  vm_getbits(command, 32, 8);
-          return_values->data2 =  vm_getbits(command, 24, 8);
-          return_values->data3 =  vm_getbits(command, 44, 4);
+          return_values->data1 =  vm_getbits(command, 31, 8);
+          return_values->data2 =  vm_getbits(command, 39, 8);
+          return_values->data3 =  vm_getbits(command, 19, 4);
           return cond;
         case 3:
           return_values->command = JumpSS_VMGM_PGC;
-          return_values->data1 =  vm_getbits(command, 17, 15);
+          return_values->data1 =  vm_getbits(command, 46, 15);
           return cond;
         }
       break;
     case 8:
-      switch(vm_getbits(command, 40, 2)) {
+      switch(vm_getbits(command, 23, 2)) {
         case 0:
           return_values->command = CallSS_FP;
-          return_values->data1 = vm_getbits(command, 32, 8);
+          return_values->data1 = vm_getbits(command, 31, 8);
           return cond;
         case 1:
           return_values->command = CallSS_VMGM_MENU;
-          return_values->data1 = vm_getbits(command, 44, 4);
-          return_values->data2 = vm_getbits(command, 32, 8);
+          return_values->data1 = vm_getbits(command, 19, 4);
+          return_values->data2 = vm_getbits(command, 31, 8);
           return cond;
         case 2:
           return_values->command = CallSS_VTSM;
-          return_values->data1 = vm_getbits(command, 44, 4);
-          return_values->data2 = vm_getbits(command, 32, 8);
+          return_values->data1 = vm_getbits(command, 19, 4);
+          return_values->data2 = vm_getbits(command, 31, 8);
           return cond;
         case 3:
           return_values->command = CallSS_VMGM_PGC;
-          return_values->data1 = vm_getbits(command, 17, 15);
-          return_values->data2 = vm_getbits(command, 32, 8);
+          return_values->data1 = vm_getbits(command, 46, 15);
+          return_values->data2 = vm_getbits(command, 31, 8);
           return cond;
       }
       break;
@@ -354,11 +354,11 @@
   int32_t i;
   uint16_t data, data2;
   
-  switch(vm_getbits(command, 4, 4)) {
+  switch(vm_getbits(command, 59, 4)) {
     case 1: /*  Set system reg 1 &| 2 &| 3 (Audio, Subp. Angle) */
       for(i = 1; i <= 3; i++) {
-        if(vm_getbits(command, ((2 + i)*8), 1)) {
-          data = eval_reg_or_data_2(command, vm_getbits(command, 3, 1), 2 + i);
+        if(vm_getbits(command, 63 - ((2 + i)*8), 1)) {
+          data = eval_reg_or_data_2(command, vm_getbits(command, 60, 1), 2 + i);
           if(cond) {
             command->registers->SPRM[i] = data;
           }
@@ -366,17 +366,17 @@
       }
       break;
     case 2: /*  Set system reg 9 & 10 (Navigation timer, Title PGC number) */
-      data = eval_reg_or_data(command, vm_getbits(command, 3, 1), 2);
-      data2 = vm_getbits(command, 40, 8); /*  ?? size */
+      data = eval_reg_or_data(command, vm_getbits(command, 60, 1), 2);
+      data2 = vm_getbits(command, 23, 8); /*  ?? size */
       if(cond) {
 	command->registers->SPRM[9] = data; /*  time */
 	command->registers->SPRM[10] = data2; /*  pgcN */
       }
       break;
     case 3: /*  Mode: Counter / Register + Set */
-      data = eval_reg_or_data(command, vm_getbits(command, 3, 1), 2);
-      data2 = vm_getbits(command, 44, 4);
-      if(vm_getbits(command, 40, 1)) {
+      data = eval_reg_or_data(command, vm_getbits(command, 60, 1), 2);
+      data2 = vm_getbits(command, 19, 4);
+      if(vm_getbits(command, 23, 1)) {
 	command->registers->GPRM_mode[data2] |= 1; /* Set bit 0 */
       } else {
 	command->registers->GPRM_mode[data2] &= ~ 0x01; /* Reset bit 0 */
@@ -386,13 +386,13 @@
       }
       break;
     case 6: /*  Set system reg 8 (Highlighted button) */
-      data = eval_reg_or_data(command, vm_getbits(command, 3, 1), 4); /*  Not system reg!! */
+      data = eval_reg_or_data(command, vm_getbits(command, 60, 1), 4); /*  Not system reg!! */
       if(cond) {
 	command->registers->SPRM[8] = data;
       }
       break;
   }
-  if(vm_getbits(command, 12, 4)) {
+  if(vm_getbits(command, 51, 4)) {
     return eval_link_instruction(command, cond, return_values);
   }
   return 0;
@@ -456,10 +456,10 @@
 
 /* Evaluate set instruction, combined with either Link or Compare. */
 static void eval_set_version_1(command_t* command, int32_t cond) {
-  uint8_t  op   = vm_getbits(command, 4, 4);
-  uint8_t  reg  = vm_getbits(command, 28, 4); /* FIXME: This is different from vmcmd.c!!! */
-  uint8_t  reg2 = vm_getbits(command, 44, 4);
-  uint16_t data = eval_reg_or_data(command, vm_getbits(command, 3, 1), 4);
+  uint8_t  op   = vm_getbits(command, 59, 4);
+  uint8_t  reg  = vm_getbits(command, 35, 4); /* FIXME: This is different from vmcmd.c!!! */
+  uint8_t  reg2 = vm_getbits(command, 19, 4);
+  uint16_t data = eval_reg_or_data(command, vm_getbits(command, 60, 1), 4);
 
   if(cond) {
     eval_set_op(command, op, reg, reg2, data);
@@ -469,10 +469,10 @@
 
 /* Evaluate set instruction, combined with both Link and Compare. */
 static void eval_set_version_2(command_t* command, int32_t cond) {
-  uint8_t  op   = vm_getbits(command, 4, 4);
-  uint8_t  reg  = vm_getbits(command, 12, 4);
-  uint8_t  reg2 = vm_getbits(command, 28, 4); /* FIXME: This is different from vmcmd.c!!! */
-  uint16_t data = eval_reg_or_data(command, vm_getbits(command, 3, 1), 2);
+  uint8_t  op   = vm_getbits(command, 59, 4);
+  uint8_t  reg  = vm_getbits(command, 51, 4);
+  uint8_t  reg2 = vm_getbits(command, 35, 4); /* FIXME: This is different from vmcmd.c!!! */
+  uint16_t data = eval_reg_or_data(command, vm_getbits(command, 60, 1), 2);
 
   if(cond) {
     eval_set_op(command, op, reg, reg2, data);
@@ -498,7 +498,7 @@
   command.registers = registers;
   memset(return_values, 0, sizeof(link_t));
 
-  switch(vm_getbits(&command, 0, 3)) { /* three first old_bits */
+  switch(vm_getbits(&command, 63, 3)) { /* three first old_bits */
     case 0: /*  Special instructions */
       cond = eval_if_version_1(&command);
       res = eval_special_instruction(&command, cond);
@@ -508,7 +508,7 @@
       }
       break;
     case 1: /*  Link/jump instructions */
-      if(vm_getbits(&command, 3, 1)) {
+      if(vm_getbits(&command, 60, 1)) {
         cond = eval_if_version_2(&command);
         res = eval_jump_instruction(&command, cond, return_values);
       } else {
@@ -527,7 +527,7 @@
     case 3: /*  Set instructions, either Compare or Link may be used */
       cond = eval_if_version_3(&command);
       eval_set_version_1(&command, cond);
-      if(vm_getbits(&command, 12, 4)) {
+      if(vm_getbits(&command, 51, 4)) {
 	res = eval_link_instruction(&command, cond, return_values);
       }
       if(res)
@@ -555,7 +555,7 @@
 	res = -1;
       break;
     default: /* Unknown command */
-      fprintf(MSG_OUT, "libdvdnav: WARNING: Unknown Command=%x\n", vm_getbits(&command, 0, 3));
+      fprintf(MSG_OUT, "libdvdnav: WARNING: Unknown Command=%x\n", vm_getbits(&command, 63, 3));
       assert(0);
   }
   /*  Check if there are bits not yet examined */
diff -r 26334f5fac2b -r 5ddb33e104a8 vmcmd.c
--- a/vmcmd.c	Thu Apr 03 12:57:41 2003 +0000
+++ b/vmcmd.c	Thu Apr 03 15:42:08 2003 +0000
@@ -114,22 +114,64 @@
   NULL,
   NULL,
 };
+
+typedef struct {
+  uint16_t SPRM[24];
+  uint16_t GPRM[16];
+  uint8_t  GPRM_mode[16];  /* Need to have some thing to indicate normal/counter mode for every
+GPRM */
+  struct timeval GPRM_time[16]; /* For counter mode */
+} registers_t;
+
+typedef struct
+{
+  uint64_t instruction;
+  uint64_t examined;
+  registers_t *registers;
+} command_t;
+
+uint32_t vm_getbits(command_t *command, int start, int count) {
+  uint64_t result = 0;
+  uint64_t bit_mask=0xffffffffffffffff;  /* I could put -1 instead */
+  uint64_t examining = 0;
+  int32_t  bits;
+  if (count == 0) return 0;
+
+  if ( ((start - count) < -1) ||
+       (count > 32) ||
+       (start > 63) ||
+       (count < 0) ||
+       (start < 0) ){
+    fprintf(stderr, "Bad call to vm_getbits. Parameter out of range\n");
+    assert(0);
+  }
+  bit_mask >>= 63 - start;
+  bits = start + 1 - count;
+  examining = ((bit_mask >> bits) << bits );
+  command->examined |= examining;
+  result = (command->instruction & bit_mask) >> bits;
+  return (uint32_t) result;
+}
     
 static void print_system_reg(uint16_t reg) {
   if(reg < sizeof(system_reg_abbr_table) / sizeof(char *))
-    fprintf(MSG_OUT, " %s (SRPM:%d)", system_reg_table[reg], reg);
+    fprintf(MSG_OUT, "%s (SRPM:%d)", system_reg_table[reg], reg);
   else
     fprintf(MSG_OUT, " WARNING: Unknown system register ( reg=%d ) ", reg);
 }
 
+static void print_g_reg(uint8_t reg) {
+    if(reg < 16)
+      fprintf(MSG_OUT, "g[%" PRIu8 "]", reg);
+    else
+      fprintf(MSG_OUT, " WARNING: Unknown general register ");
+}
+
 static void print_reg(uint8_t reg) {
   if(reg & 0x80)
     print_system_reg(reg & 0x7f);
   else
-    if(reg < 16)
-      fprintf(MSG_OUT, " g[%" PRIu8 "]", reg);
-    else
-      fprintf(MSG_OUT, " WARNING: Unknown general register ");
+    print_g_reg(reg & 0x7f);
 }
 
 static void print_cmp_op(uint8_t op) {
@@ -146,99 +188,133 @@
     fprintf(MSG_OUT, " WARNING: Unknown set op ");
 }
 
-static void print_reg_or_data(command_t* command, int immediate, int byte) {
+static void print_reg_or_data(command_t* command, int immediate, int start) {
   if(immediate) {
-    int i = vm_getbits(command, (byte*8), 16);
+    int i = vm_getbits(command, start, 16);
     
     fprintf(MSG_OUT, "0x%x", i);
     if(isprint(i & 0xff) && isprint((i>>8) & 0xff))
       fprintf(MSG_OUT, " (\"%c%c\")", (char)((i>>8) & 0xff), (char)(i & 0xff));
   } else {
-    print_reg(vm_getbits(command, ((byte + 1)*8), 8));
+    print_reg(vm_getbits(command, start - 8, 8));
   }
 }
 
-static void print_reg_or_data_2(command_t* command, int immediate, int byte) {
+static void print_reg_or_data_2(command_t* command, int immediate, int start) {
   if(immediate)
-    fprintf(MSG_OUT, "0x%x", vm_getbits(command, ((byte*8)+1), 7));
+    fprintf(MSG_OUT, "0x%x", vm_getbits(command, start - 9, 7));
   else
-    fprintf(MSG_OUT, "g[%" PRIu8 "]", vm_getbits(command, ((byte*8)+4), 4));
+    fprintf(MSG_OUT, "g[%" PRIu8 "]", vm_getbits(command, start - 4, 4));
 }
 
+static void print_reg_or_data_3(command_t* command, int immediate, int start) {
+  if(immediate) {
+    int i = vm_getbits(command, start, 16);
+    
+    fprintf(MSG_OUT, "0x%x", i);
+    if(isprint(i & 0xff) && isprint((i>>8) & 0xff))
+      fprintf(MSG_OUT, " (\"%c%c\")", (char)((i>>8) & 0xff), (char)(i & 0xff));
+  } else {
+    print_reg(vm_getbits(command, start, 8));
+  }
+}
+
+
 static void print_if_version_1(command_t* command) {
-  uint8_t op = vm_getbits(command, 9, 3);
+  uint8_t op = vm_getbits(command, 54, 3);
   
   if(op) {
     fprintf(MSG_OUT, "if (");
-    print_reg(vm_getbits(command,24,8));
+    print_reg(vm_getbits(command,39,8));
     print_cmp_op(op);
-    print_reg_or_data(command, vm_getbits(command, 8,1), 4);
+    print_reg_or_data(command, vm_getbits(command, 55,1), 31);
     fprintf(MSG_OUT, ") ");
   }
 }
 
 static void print_if_version_2(command_t* command) {
-  uint8_t op = vm_getbits(command, 9, 3);
+  uint8_t op = vm_getbits(command, 54, 3);
   
   if(op) {
     fprintf(MSG_OUT, "if (");
-    print_reg(vm_getbits(command, 48, 8));
+    print_reg(vm_getbits(command, 15, 8));
     print_cmp_op(op);
-    print_reg(vm_getbits(command, 56, 8));
+    print_reg(vm_getbits(command, 7, 8));
     fprintf(MSG_OUT, ") ");
   }
 }
 
 static void print_if_version_3(command_t* command) {
-  uint8_t op = vm_getbits(command, 9, 3);
+  uint8_t op = vm_getbits(command, 54, 3);
   
   if(op) {
     fprintf(MSG_OUT, "if (");
-    print_reg(vm_getbits(command, 20, 4));
+    print_reg(vm_getbits(command, 43, 4));
     print_cmp_op(op);
-    print_reg_or_data(command, vm_getbits(command, 8, 1), 6);
+    print_reg_or_data(command, vm_getbits(command, 55, 1), 15);
     fprintf(MSG_OUT, ") ");
   }
 }
 
 static void print_if_version_4(command_t* command) {
-  uint8_t op = vm_getbits(command, 9, 3);
-  
+  uint8_t op = vm_getbits(command, 54, 3);
+
   if(op) {
     fprintf(MSG_OUT, "if (");
-    print_reg(vm_getbits(command, 12, 4));
+    print_g_reg(vm_getbits(command, 51, 4));
     print_cmp_op(op);
-    print_reg_or_data(command, vm_getbits(command, 8, 1), 4);
+    print_reg_or_data(command, vm_getbits(command, 55, 1), 31);
     fprintf(MSG_OUT, ") ");
   }
 }
 
+static void print_if_version_5(command_t* command) {
+  uint8_t op = vm_getbits(command, 54, 3);
+  int set_immediate = vm_getbits(command, 60, 1);
+  
+  if(op) {
+    if (set_immediate) {
+      fprintf(MSG_OUT, "if (");
+      print_g_reg(vm_getbits(command, 31, 8));
+      print_cmp_op(op);
+      print_reg(vm_getbits(command, 23, 8));
+      fprintf(MSG_OUT, ") ");
+    } else {
+      fprintf(MSG_OUT, "if (");
+      print_g_reg(vm_getbits(command, 39, 8));
+      print_cmp_op(op);
+      print_reg_or_data(command, vm_getbits(command, 55, 1), 31);
+      fprintf(MSG_OUT, ") ");
+    }
+  }
+}
+
 static void print_special_instruction(command_t* command) {
-  uint8_t op = vm_getbits(command, 12, 4);
+  uint8_t op = vm_getbits(command, 51, 4);
   
   switch(op) {
     case 0: /*  NOP */
       fprintf(MSG_OUT, "Nop");
       break;
     case 1: /*  Goto line */
-      fprintf(MSG_OUT, "Goto %" PRIu8, vm_getbits(command, 56, 8));
+      fprintf(MSG_OUT, "Goto %" PRIu8, vm_getbits(command, 7, 8));
       break;
     case 2: /*  Break */
       fprintf(MSG_OUT, "Break");
       break;
     case 3: /*  Parental level */
       fprintf(MSG_OUT, "SetTmpPML %" PRIu8 ", Goto %" PRIu8, 
-	      vm_getbits(command, 52, 4), vm_getbits(command, 56, 8));
+	      vm_getbits(command, 11, 4), vm_getbits(command, 7, 8));
       break;
     default:
       fprintf(MSG_OUT, "WARNING: Unknown special instruction (%i)", 
-	      vm_getbits(command, 12, 4));
+	      vm_getbits(command, 51, 4));
   }
 }
 
 static void print_linksub_instruction(command_t* command) {
-  int linkop = vm_getbits(command, 59, 5);
-  int button = vm_getbits(command, 48, 6);
+  int linkop = vm_getbits(command, 4, 5);
+  int button = vm_getbits(command, 15, 6);
   
   if(linkop < sizeof(link_table)/sizeof(char *) && link_table[linkop] != NULL)
     fprintf(MSG_OUT, "%s (button %" PRIu8 ")", link_table[linkop], button);
@@ -247,7 +323,7 @@
 }
 
 static void print_link_instruction(command_t* command, int optional) {
-  uint8_t op = vm_getbits(command, 12, 4);
+  uint8_t op = vm_getbits(command, 51, 4);
   
   if(optional && op)
     fprintf(MSG_OUT, ", ");
@@ -261,19 +337,19 @@
       print_linksub_instruction(command);
       break;
     case 4:
-      fprintf(MSG_OUT, "LinkPGCN %" PRIu16, vm_getbits(command, 49, 15));
+      fprintf(MSG_OUT, "LinkPGCN %" PRIu16, vm_getbits(command, 14, 15));
       break;
     case 5:
       fprintf(MSG_OUT, "LinkPTT %" PRIu16 " (button %" PRIu8 ")", 
-	      vm_getbits(command, 54, 10), vm_getbits(command, 48, 6));
+	      vm_getbits(command, 9, 10), vm_getbits(command, 15, 6));
       break;
     case 6:
       fprintf(MSG_OUT, "LinkPGN %" PRIu8 " (button %" PRIu8 ")", 
-	      vm_getbits(command, 57, 7), vm_getbits(command, 48, 6));
+	      vm_getbits(command, 6, 7), vm_getbits(command, 15, 6));
       break;
     case 7:
       fprintf(MSG_OUT, "LinkCN %" PRIu8 " (button %" PRIu8 ")", 
-	      vm_getbits(command, 56, 8), vm_getbits(command, 48, 6));
+	      vm_getbits(command, 7, 8), vm_getbits(command, 15, 6));
       break;
     default:
       fprintf(MSG_OUT, "WARNING: Unknown link instruction");
@@ -281,54 +357,54 @@
 }
 
 static void print_jump_instruction(command_t* command) {
-  switch(vm_getbits(command, 12, 4)) {
+  switch(vm_getbits(command, 51, 4)) {
     case 1:
       fprintf(MSG_OUT, "Exit");
       break;
     case 2:
-      fprintf(MSG_OUT, "JumpTT %" PRIu8, vm_getbits(command, 41, 7));
+      fprintf(MSG_OUT, "JumpTT %" PRIu8, vm_getbits(command, 22, 7));
       break;
     case 3:
-      fprintf(MSG_OUT, "JumpVTS_TT %" PRIu8, vm_getbits(command, 41, 7));
+      fprintf(MSG_OUT, "JumpVTS_TT %" PRIu8, vm_getbits(command, 22, 7));
       break;
     case 5:
       fprintf(MSG_OUT, "JumpVTS_PTT %" PRIu8 ":%" PRIu16, 
-	      vm_getbits(command, 41, 7), vm_getbits(command, 22, 10));
+	      vm_getbits(command, 22, 7), vm_getbits(command, 41, 10));
       break;
     case 6:
-      switch(vm_getbits(command, 40, 2)) {
+      switch(vm_getbits(command, 23, 2)) {
         case 0:
           fprintf(MSG_OUT, "JumpSS FP");
           break;
         case 1:
-          fprintf(MSG_OUT, "JumpSS VMGM (menu %" PRIu8 ")", vm_getbits(command, 44, 4));
+          fprintf(MSG_OUT, "JumpSS VMGM (menu %" PRIu8 ")", vm_getbits(command, 19, 4));
           break;
         case 2:
           fprintf(MSG_OUT, "JumpSS VTSM (vts %" PRIu8 ", title %" PRIu8 
-		  ", menu %" PRIu8 ")", vm_getbits(command, 32, 8), vm_getbits(command, 24, 8), vm_getbits(command, 44, 4));
+		  ", menu %" PRIu8 ")", vm_getbits(command, 31, 8), vm_getbits(command, 39, 8), vm_getbits(command, 19, 4));
           break;
         case 3:
-          fprintf(MSG_OUT, "JumpSS VMGM (pgc %" PRIu8 ")", vm_getbits(command, 17, 15));
+          fprintf(MSG_OUT, "JumpSS VMGM (pgc %" PRIu8 ")", vm_getbits(command, 46, 15));
           break;
         }
       break;
     case 8:
-      switch(vm_getbits(command, 40, 2)) {
+      switch(vm_getbits(command, 23, 2)) {
         case 0:
           fprintf(MSG_OUT, "CallSS FP (rsm_cell %" PRIu8 ")",
-              vm_getbits(command, 32, 8));
+              vm_getbits(command, 31, 8));
           break;
         case 1:
           fprintf(MSG_OUT, "CallSS VMGM (menu %" PRIu8 
-		  ", rsm_cell %" PRIu8 ")", vm_getbits(command, 44, 4), vm_getbits(command, 32, 8));
+		  ", rsm_cell %" PRIu8 ")", vm_getbits(command, 19, 4), vm_getbits(command, 31, 8));
           break;
         case 2:
           fprintf(MSG_OUT, "CallSS VTSM (menu %" PRIu8 
-		  ", rsm_cell %" PRIu8 ")", vm_getbits(command, 44, 4), vm_getbits(command, 32, 8));
+		  ", rsm_cell %" PRIu8 ")", vm_getbits(command, 19, 4), vm_getbits(command, 31, 8));
           break;
         case 3:
           fprintf(MSG_OUT, "CallSS VMGM (pgc %" PRIu8 ", rsm_cell %" PRIu8 ")", 
-		  vm_getbits(command, 17, 15), vm_getbits(command, 32, 8));
+		  vm_getbits(command, 46, 15), vm_getbits(command, 31, 8));
           break;
       }
       break;
@@ -340,13 +416,13 @@
 static void print_system_set(command_t* command) {
   int i;
   
-  switch(vm_getbits(command, 4, 4)) {
+  switch(vm_getbits(command, 59, 4)) {
     case 1: /*  Set system reg 1 &| 2 &| 3 (Audio, Subp. Angle) */
       for(i = 1; i <= 3; i++) {
-        if(vm_getbits(command, ((2+i)*8), 1)) {
+        if(vm_getbits(command, 63 - ((2+i)*8), 1)) {
           print_system_reg(i);
           fprintf(MSG_OUT, " = ");
-          print_reg_or_data_2(command, vm_getbits(command, 3, 1), 2 + i);
+          print_reg_or_data_2(command, vm_getbits(command, 60, 1), 47 - (i*8) );
           fprintf(MSG_OUT, " ");
         }
       }
@@ -354,59 +430,72 @@
     case 2: /*  Set system reg 9 & 10 (Navigation timer, Title PGC number) */
       print_system_reg(9);
       fprintf(MSG_OUT, " = ");
-      print_reg_or_data(command, vm_getbits(command, 3, 1), 2);
+      print_reg_or_data(command, vm_getbits(command, 60, 1), 47);
       fprintf(MSG_OUT, " ");
       print_system_reg(10);
-      fprintf(MSG_OUT, " = %" PRIu8, vm_getbits(command, 40, 8)); /*  ?? */
+      fprintf(MSG_OUT, " = %" PRIu8, vm_getbits(command, 23, 8)); /*  ?? */
       break;
     case 3: /*  Mode: Counter / Register + Set */
       fprintf(MSG_OUT, "SetMode ");
-      if(vm_getbits(command, 40, 1))
+      if(vm_getbits(command, 23, 1))
 	fprintf(MSG_OUT, "Counter ");
       else
 	fprintf(MSG_OUT, "Register ");
-      print_reg(vm_getbits(command, 44, 4));
+      print_reg(vm_getbits(command, 19, 4));
       print_set_op(0x1); /*  '=' */
-      print_reg_or_data(command, vm_getbits(command, 3, 1), 2);
+      print_reg_or_data(command, vm_getbits(command, 60, 1), 47);
       break;
     case 6: /*  Set system reg 8 (Highlighted button) */
       print_system_reg(8);
-      if(vm_getbits(command, 3, 1)) /*  immediate */
-        fprintf(MSG_OUT, " = 0x%x (button no %d)", vm_getbits(command, 32, 16), vm_getbits(command, 32, 6));
+      if(vm_getbits(command, 60, 1)) /*  immediate */
+        fprintf(MSG_OUT, " = 0x%x (button no %d)", vm_getbits(command, 31, 16), vm_getbits(command, 31, 6));
       else
-        fprintf(MSG_OUT, " = g[%" PRIu8 "]", vm_getbits(command, 44, 4));
+        fprintf(MSG_OUT, " = g[%" PRIu8 "]", vm_getbits(command, 19, 4));
       break;
     default:
       fprintf(MSG_OUT, "WARNING: Unknown system set instruction (%i)", 
-	      vm_getbits(command, 4, 4));
+	      vm_getbits(command, 59, 4));
   }
 }
 
 static void print_set_version_1(command_t* command) {
-  uint8_t set_op = vm_getbits(command, 4, 4);
+  uint8_t set_op = vm_getbits(command, 59, 4);
   
   if(set_op) {
-    print_reg(vm_getbits(command, 24, 8));  /* FIXME: This is different from decoder.c!!!  */
+    print_reg(vm_getbits(command, 39, 8));  /* FIXME: This is different from decoder.c!!!  */
     print_set_op(set_op);
-    print_reg_or_data(command, vm_getbits(command, 3, 1), 4);
+    print_reg_or_data(command, vm_getbits(command, 60, 1), 31);
   } else {
     fprintf(MSG_OUT, "NOP");
   }
 }
 
 static void print_set_version_2(command_t* command) {
-  uint8_t set_op = vm_getbits(command, 4, 4);
+  uint8_t set_op = vm_getbits(command, 59, 4);
   
   if(set_op) {
-    print_reg(vm_getbits(command, 12, 4));
+    print_reg(vm_getbits(command, 51, 4));
     print_set_op(set_op);
-    print_reg_or_data(command, vm_getbits(command, 3, 1), 2);
+    print_reg_or_data(command, vm_getbits(command, 60, 1), 47);
   } else {
     fprintf(MSG_OUT, "NOP");
   }
 }
 
-void vmPrint_mnemonic(vm_cmd_t *vm_command)  {
+static void print_set_version_3(command_t* command) {
+  uint8_t set_op = vm_getbits(command, 59, 4);
+  
+  if(set_op) {
+    print_reg(vm_getbits(command, 51, 4));
+    print_set_op(set_op);
+    print_reg_or_data_3(command, vm_getbits(command, 60, 1), 47);
+  } else {
+    fprintf(MSG_OUT, "NOP");
+  }
+}
+
+
+void vm_print_mnemonic(vm_cmd_t *vm_command)  {
   command_t command;
   command.instruction =( (uint64_t) vm_command->bytes[0] << 56 ) |
         ( (uint64_t) vm_command->bytes[1] << 48 ) |
@@ -418,13 +507,13 @@
           (uint64_t) vm_command->bytes[7] ;
   command.examined = 0; 
 
-  switch(vm_getbits(&command,0,3)) { /* three first bits */
+  switch(vm_getbits(&command,63,3)) { /* three first bits */
     case 0: /*  Special instructions */
       print_if_version_1(&command);
       print_special_instruction(&command);
       break;
     case 1: /*  Jump/Call or Link instructions */
-      if(vm_getbits(&command,3,1)) {
+      if(vm_getbits(&command,60,1)) {
         print_if_version_2(&command);
         print_jump_instruction(&command);
       } else {
@@ -449,22 +538,22 @@
       print_linksub_instruction(&command);
       break;
     case 5: /*  Compare -> (Set and LinkSub) instructions */
-      print_if_version_4(&command);
+      print_if_version_5(&command);
       fprintf(MSG_OUT, "{ ");
-      print_set_version_2(&command);
+      print_set_version_3(&command);
       fprintf(MSG_OUT, ", ");
       print_linksub_instruction(&command);
       fprintf(MSG_OUT, " }");
       break;
     case 6: /*  Compare -> Set, always LinkSub instructions */
-      print_if_version_4(&command);
+      print_if_version_5(&command);
       fprintf(MSG_OUT, "{ ");
-      print_set_version_2(&command);
+      print_set_version_3(&command);
       fprintf(MSG_OUT, " } ");
       print_linksub_instruction(&command);
       break;
     default:
-      fprintf(MSG_OUT, "WARNING: Unknown instruction type (%i)", vm_getbits(&command, 0, 3));
+      fprintf(MSG_OUT, "WARNING: Unknown instruction type (%i)", vm_getbits(&command, 63, 3));
   }
   /*  Check if there still are bits set that were not examined */