diff --git a/src/engine/fileOps.cpp b/src/engine/fileOps.cpp
index 63cc1536..eb5e31e4 100644
--- a/src/engine/fileOps.cpp
+++ b/src/engine/fileOps.cpp
@@ -307,12 +307,9 @@ bool DivEngine::loadDMF(unsigned char* file, size_t len) {
         if (!ins->mode) {
           ins->type=DIV_INS_AY;
         }
-        ins->std.dutyMacro.height=31;
-        ins->std.waveMacro.height=7;
       }
       if (ds.system[0]==DIV_SYSTEM_PCE) {
         ins->type=DIV_INS_PCE;
-        ins->std.volMacro.height=31;
       }
       if ((ds.system[0]==DIV_SYSTEM_SMS_OPLL || ds.system[0]==DIV_SYSTEM_NES_VRC7) && ins->type==DIV_INS_FM) {
         ins->type=DIV_INS_OPLL;
diff --git a/src/engine/instrument.cpp b/src/engine/instrument.cpp
index d39e9c69..8f87e460 100644
--- a/src/engine/instrument.cpp
+++ b/src/engine/instrument.cpp
@@ -23,37 +23,13 @@
 #include "../ta-log.h"
 #include "../fileutils.h"
 
-void DivInstrument::putMacroData(DivInstrumentMacro m, SafeWriter* w) {
-  w->write("MACR",4);
-  w->writeI(0);
-
-  w->writeS(DIV_ENGINE_VERSION);
-
-  w->writeS(type);
-  w->writeC(0);
-
-  w->writeString(m.name,false);
-
-  w->writeI(m.len);
-  w->writeI(m.loop);
-  w->writeI(m.rel);
-  w->writeI(m.mode);
-  w->writeC(m.open);
-  for (int v=0; v<m.len; v++) {
-    w->writeI(m.val[v]);
-    w->writeI(0); // reserved
-    w->writeI(0); // reserved
-  }
-}
-
 void DivInstrument::putInsData(SafeWriter* w) {
   w->write("INST",4);
   w->writeI(0);
 
   w->writeS(DIV_ENGINE_VERSION);
 
-  w->writeS(type);
-  //w->writeC(type);
+  w->writeC(type);
   w->writeC(0);
 
   w->writeString(name,false);
@@ -125,7 +101,7 @@ void DivInstrument::putInsData(SafeWriter* w) {
   w->writeC(c64.hp);
   w->writeC(c64.ch3off);
   w->writeS(c64.cut);
-  //w->writeC(std.dutyMacro.mode);
+  w->writeC(c64.dutyIsAbs);
   w->writeC(c64.filterIsAbs);
   
   // Amiga
@@ -135,66 +111,6 @@ void DivInstrument::putInsData(SafeWriter* w) {
   }
 
   // standard
-  putMacroData(std.volMacro,w);
-  putMacroData(std.arpMacro,w);
-  putMacroData(std.dutyMacro,w);
-  putMacroData(std.waveMacro,w);
-  putMacroData(std.pitchMacro,w);
-  putMacroData(std.ex1Macro,w);
-  putMacroData(std.ex2Macro,w);
-  putMacroData(std.ex3Macro,w);
-  putMacroData(std.algMacro,w);
-  putMacroData(std.fbMacro,w);
-  putMacroData(std.fmsMacro,w);
-  putMacroData(std.fms2Macro,w);
-  putMacroData(std.amsMacro,w);
-  putMacroData(std.ams2Macro,w);
-  putMacroData(std.panLMacro,w);
-  putMacroData(std.panRMacro,w);
-  putMacroData(std.phaseResetMacro,w);
-  putMacroData(std.ex4Macro,w);
-  putMacroData(std.ex5Macro,w);
-  putMacroData(std.ex6Macro,w);
-  putMacroData(std.ex7Macro,w);
-  putMacroData(std.ex8Macro,w);
-  // FM macros
-  for (int i=0; i<4; i++) {
-    DivInstrumentSTD::OpMacro& op=std.opMacros[i];
-    putMacroData(op.amMacro,w);
-    putMacroData(op.arMacro,w);
-    putMacroData(op.drMacro,w);
-    putMacroData(op.multMacro,w);
-    putMacroData(op.rrMacro,w);
-    putMacroData(op.slMacro,w);
-    putMacroData(op.tlMacro,w);
-    putMacroData(op.dt2Macro,w);
-    putMacroData(op.rsMacro,w);
-    putMacroData(op.dtMacro,w);
-    putMacroData(op.d2rMacro,w);
-    putMacroData(op.ssgMacro,w);
-    putMacroData(op.damMacro,w);
-    putMacroData(op.dvbMacro,w);
-    putMacroData(op.egtMacro,w);
-    putMacroData(op.kslMacro,w);
-    putMacroData(op.susMacro,w);
-    putMacroData(op.vibMacro,w);
-    putMacroData(op.wsMacro,w);
-    putMacroData(op.ksrMacro,w);
-  }
-  // wavesynth macros
-  putMacroData(std.ws.wave1Macro,w);
-  putMacroData(std.ws.wave2Macro,w);
-  putMacroData(std.ws.rateDividerMacro,w);
-  putMacroData(std.ws.effectMacro,w);
-  putMacroData(std.ws.oneShotMacro,w);
-  putMacroData(std.ws.enabledMacro,w);
-  putMacroData(std.ws.globalMacro,w);
-  putMacroData(std.ws.speedMacro,w);
-  putMacroData(std.ws.param1Macro,w);
-  putMacroData(std.ws.param2Macro,w);
-  putMacroData(std.ws.param3Macro,w);
-  putMacroData(std.ws.param4Macro,w);
-  /*
   w->writeI(std.volMacro.len);
   w->writeI(std.arpMacro.len);
   w->writeI(std.dutyMacro.len);
@@ -454,7 +370,7 @@ void DivInstrument::putInsData(SafeWriter* w) {
     for (int j=0; j<op.ksrMacro.len; j++) {
       w->writeC(op.ksrMacro.val[j]);
     }
-  }*/
+  }
 
   // OPL drum data
   w->writeC(fm.fixedDrums);
@@ -478,7 +394,6 @@ void DivInstrument::putInsData(SafeWriter* w) {
   w->writeC(0); // reserved
 
   // more macros
-  /*
   w->writeI(std.panLMacro.len);
   w->writeI(std.panRMacro.len);
   w->writeI(std.phaseResetMacro.len);
@@ -538,7 +453,7 @@ void DivInstrument::putInsData(SafeWriter* w) {
   }
   for (int j=0; j<std.ex8Macro.len; j++) {
     w->writeI(std.ex8Macro.val[j]);
-  }*/
+  }
 
   // FDS
   w->writeI(fds.modSpeed);
@@ -565,43 +480,9 @@ void DivInstrument::putInsData(SafeWriter* w) {
   w->writeC(ws.param2);
   w->writeC(ws.param3);
   w->writeC(ws.param4);
-
-  // FM per-operator enable
-  for (int j=0; j<4; j++) {
-    DivInstrumentFM::Operator& op=fm.op[j];
-    w->writeC(op.enable?1:0);
-  }
-}
-
-DivDataErrors DivInstrument::readMacroData(DivInstrumentMacro& m, SafeReader& reader, short version) {
-  char magic[4];
-  reader.read(magic,4);
-  if (memcmp(magic,"MACR",4)!=0) {
-    logE("invalid macro header!\n");
-    return DIV_DATA_INVALID_HEADER;
-  }
-  reader.readI();
-
-  reader.readS(); // format version. ignored.
-  /*type=(DivInstrumentType)*/reader.readS(); // instrument type
-  reader.readC();
-  m.name=reader.readString();
-
-  m.len=reader.readI();
-  m.loop=reader.readI();
-  m.rel=reader.readI();
-  m.mode=reader.readI();
-  m.open=reader.readC();
-  for (int v=0; v<m.len; v++) {
-    m.val[v]=reader.readI();
-    reader.readI(); // reserved
-    reader.readI(); // reserved
-  }
-  return DIV_DATA_SUCCESS;
 }
 
 DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
-  bool istest=version&0x80;
   char magic[4];
   reader.read(magic,4);
   if (memcmp(magic,"INST",4)!=0) {
@@ -611,12 +492,7 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
   reader.readI();
 
   reader.readS(); // format version. ignored.
-  if (istest) {
-    type=(DivInstrumentType)reader.readS();
-  }
-  if (!istest) {
-    type=(DivInstrumentType)((unsigned char)reader.readC());
-  }
+  type=(DivInstrumentType)reader.readC();
   mode=(type==DIV_INS_FM);
   reader.readC();
   name=reader.readString();
@@ -690,9 +566,7 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
   c64.hp=reader.readC();
   c64.ch3off=reader.readC();
   c64.cut=reader.readS();
-  if (!istest) {
-    std.dutyMacro.mode=reader.readC();
-  }
+  c64.dutyIsAbs=reader.readC();
   c64.filterIsAbs=reader.readC();
 
   // Amiga
@@ -700,443 +574,230 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
   // reserved
   for (int k=0; k<14; k++) reader.readC();
 
-  if (istest) {
-    if (readMacroData(std.volMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.arpMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.dutyMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.waveMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.pitchMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ex1Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ex2Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ex3Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.algMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.fbMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.fmsMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.fms2Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.amsMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ams2Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.panLMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.panRMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.phaseResetMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ex4Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ex5Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ex6Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ex7Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ex8Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    // FM macros
-    for (int i=0; i<4; i++) {
-      DivInstrumentSTD::OpMacro& op=std.opMacros[i];
-      if (readMacroData(op.amMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.arMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.drMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.multMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.rrMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.slMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.tlMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.dt2Macro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.rsMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.dtMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.d2rMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.ssgMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.damMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.dvbMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.egtMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.kslMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.susMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.vibMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.wsMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-      if (readMacroData(op.ksrMacro,reader,version)!=DIV_DATA_SUCCESS) {
-        return DIV_DATA_INVALID_HEADER;
-      }
-    }
-    // wavesynth macros
-    if (readMacroData(std.ws.wave1Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ws.wave2Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ws.rateDividerMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ws.effectMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ws.oneShotMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ws.enabledMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ws.globalMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ws.speedMacro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ws.param1Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ws.param2Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ws.param3Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
-    }
-    if (readMacroData(std.ws.param4Macro,reader,version)!=DIV_DATA_SUCCESS) {
-      return DIV_DATA_INVALID_HEADER;
+  // standard
+  std.volMacro.len=reader.readI();
+  std.arpMacro.len=reader.readI();
+  std.dutyMacro.len=reader.readI();
+  std.waveMacro.len=reader.readI();
+  if (version>=17) {
+    std.pitchMacro.len=reader.readI();
+    std.ex1Macro.len=reader.readI();
+    std.ex2Macro.len=reader.readI();
+    std.ex3Macro.len=reader.readI();
+  }
+  std.volMacro.loop=reader.readI();
+  std.arpMacro.loop=reader.readI();
+  std.dutyMacro.loop=reader.readI();
+  std.waveMacro.loop=reader.readI();
+  if (version>=17) {
+    std.pitchMacro.loop=reader.readI();
+    std.ex1Macro.loop=reader.readI();
+    std.ex2Macro.loop=reader.readI();
+    std.ex3Macro.loop=reader.readI();
+  }
+  std.arpMacro.mode=reader.readC();
+  // these 3 were macro heights before but they are not used anymore
+  int oldVolHeight=reader.readC();
+  int oldDutyHeight=reader.readC();
+  reader.readC(); // oldWaveHeight
+  reader.read(std.volMacro.val,4*std.volMacro.len);
+  reader.read(std.arpMacro.val,4*std.arpMacro.len);
+  reader.read(std.dutyMacro.val,4*std.dutyMacro.len);
+  reader.read(std.waveMacro.val,4*std.waveMacro.len);
+  if (version<31) {
+    if (!std.arpMacro.mode) for (int j=0; j<std.arpMacro.len; j++) {
+      std.arpMacro.val[j]-=12;
     }
   }
-  if (!istest) {
-    // standard
-    std.volMacro.len=reader.readI();
-    std.arpMacro.len=reader.readI();
-    std.dutyMacro.len=reader.readI();
-    std.waveMacro.len=reader.readI();
-    if (version>=17) {
-      std.pitchMacro.len=reader.readI();
-      std.ex1Macro.len=reader.readI();
-      std.ex2Macro.len=reader.readI();
-      std.ex3Macro.len=reader.readI();
-    }
-    std.volMacro.loop=reader.readI();
-    std.arpMacro.loop=reader.readI();
-    std.dutyMacro.loop=reader.readI();
-    std.waveMacro.loop=reader.readI();
-    if (version>=17) {
-      std.pitchMacro.loop=reader.readI();
-      std.ex1Macro.loop=reader.readI();
-      std.ex2Macro.loop=reader.readI();
-      std.ex3Macro.loop=reader.readI();
-    }
-    std.arpMacro.mode=reader.readC();
-    std.volMacro.height=reader.readC();
-    std.dutyMacro.height=reader.readC();
-    std.waveMacro.height=reader.readC();
-    if (std.volMacro.height==0) std.volMacro.height=15;
-    if (std.dutyMacro.height==0) std.dutyMacro.height=3;
-    if (std.waveMacro.height==0) std.waveMacro.height=63;
-    reader.read(std.volMacro.val,4*std.volMacro.len);
-    reader.read(std.arpMacro.val,4*std.arpMacro.len);
-    reader.read(std.dutyMacro.val,4*std.dutyMacro.len);
-    reader.read(std.waveMacro.val,4*std.waveMacro.len);
-    if (version<31) {
-      if (!std.arpMacro.mode) for (int j=0; j<std.arpMacro.len; j++) {
-        std.arpMacro.val[j]-=12;
+  if (version>=17) {
+    reader.read(std.pitchMacro.val,4*std.pitchMacro.len);
+    reader.read(std.ex1Macro.val,4*std.ex1Macro.len);
+    reader.read(std.ex2Macro.val,4*std.ex2Macro.len);
+    reader.read(std.ex3Macro.val,4*std.ex3Macro.len);
+  } else {
+    if (type==DIV_INS_STD) {
+      if (oldVolHeight==31) {
+        type=DIV_INS_PCE;
+      }
+      if (oldDutyHeight==31) {
+        type=DIV_INS_AY;
       }
     }
-    if (version>=17) {
-      reader.read(std.pitchMacro.val,4*std.pitchMacro.len);
-      reader.read(std.ex1Macro.val,4*std.ex1Macro.len);
-      reader.read(std.ex2Macro.val,4*std.ex2Macro.len);
-      reader.read(std.ex3Macro.val,4*std.ex3Macro.len);
-    } else {
-      if (type==DIV_INS_STD) {
-        if (std.volMacro.height==31) {
-          type=DIV_INS_PCE;
-        }
-        if (std.dutyMacro.height==31) {
-          type=DIV_INS_AY;
-        }
-      }
+  }
+
+  // FM macros
+  if (version>=29) {
+    std.algMacro.len=reader.readI();
+    std.fbMacro.len=reader.readI();
+    std.fmsMacro.len=reader.readI();
+    std.amsMacro.len=reader.readI();
+    std.algMacro.loop=reader.readI();
+    std.fbMacro.loop=reader.readI();
+    std.fmsMacro.loop=reader.readI();
+    std.amsMacro.loop=reader.readI();
+    std.volMacro.open=reader.readC();
+    std.arpMacro.open=reader.readC();
+    std.dutyMacro.open=reader.readC();
+    std.waveMacro.open=reader.readC();
+    std.pitchMacro.open=reader.readC();
+    std.ex1Macro.open=reader.readC();
+    std.ex2Macro.open=reader.readC();
+    std.ex3Macro.open=reader.readC();
+    std.algMacro.open=reader.readC();
+    std.fbMacro.open=reader.readC();
+    std.fmsMacro.open=reader.readC();
+    std.amsMacro.open=reader.readC();
+
+    reader.read(std.algMacro.val,4*std.algMacro.len);
+    reader.read(std.fbMacro.val,4*std.fbMacro.len);
+    reader.read(std.fmsMacro.val,4*std.fmsMacro.len);
+    reader.read(std.amsMacro.val,4*std.amsMacro.len);
+
+    for (int i=0; i<4; i++) {
+      DivInstrumentSTD::OpMacro& op=std.opMacros[i];
+
+      op.amMacro.len=reader.readI();
+      op.arMacro.len=reader.readI();
+      op.drMacro.len=reader.readI();
+      op.multMacro.len=reader.readI();
+      op.rrMacro.len=reader.readI();
+      op.slMacro.len=reader.readI();
+      op.tlMacro.len=reader.readI();
+      op.dt2Macro.len=reader.readI();
+      op.rsMacro.len=reader.readI();
+      op.dtMacro.len=reader.readI();
+      op.d2rMacro.len=reader.readI();
+      op.ssgMacro.len=reader.readI();
+
+      op.amMacro.loop=reader.readI();
+      op.arMacro.loop=reader.readI();
+      op.drMacro.loop=reader.readI();
+      op.multMacro.loop=reader.readI();
+      op.rrMacro.loop=reader.readI();
+      op.slMacro.loop=reader.readI();
+      op.tlMacro.loop=reader.readI();
+      op.dt2Macro.loop=reader.readI();
+      op.rsMacro.loop=reader.readI();
+      op.dtMacro.loop=reader.readI();
+      op.d2rMacro.loop=reader.readI();
+      op.ssgMacro.loop=reader.readI();
+
+      op.amMacro.open=reader.readC();
+      op.arMacro.open=reader.readC();
+      op.drMacro.open=reader.readC();
+      op.multMacro.open=reader.readC();
+      op.rrMacro.open=reader.readC();
+      op.slMacro.open=reader.readC();
+      op.tlMacro.open=reader.readC();
+      op.dt2Macro.open=reader.readC();
+      op.rsMacro.open=reader.readC();
+      op.dtMacro.open=reader.readC();
+      op.d2rMacro.open=reader.readC();
+      op.ssgMacro.open=reader.readC();
     }
 
-    // FM macros
-    if (version>=29) {
-      std.algMacro.len=reader.readI();
-      std.fbMacro.len=reader.readI();
-      std.fmsMacro.len=reader.readI();
-      std.amsMacro.len=reader.readI();
-      std.algMacro.loop=reader.readI();
-      std.fbMacro.loop=reader.readI();
-      std.fmsMacro.loop=reader.readI();
-      std.amsMacro.loop=reader.readI();
-      std.volMacro.open=reader.readC();
-      std.arpMacro.open=reader.readC();
-      std.dutyMacro.open=reader.readC();
-      std.waveMacro.open=reader.readC();
-      std.pitchMacro.open=reader.readC();
-      std.ex1Macro.open=reader.readC();
-      std.ex2Macro.open=reader.readC();
-      std.ex3Macro.open=reader.readC();
-      std.algMacro.open=reader.readC();
-      std.fbMacro.open=reader.readC();
-      std.fmsMacro.open=reader.readC();
-      std.amsMacro.open=reader.readC();
+    for (int i=0; i<4; i++) {
+      DivInstrumentSTD::OpMacro& op=std.opMacros[i];
+      reader.read(op.amMacro.val,op.amMacro.len);
+      reader.read(op.arMacro.val,op.arMacro.len);
+      reader.read(op.drMacro.val,op.drMacro.len);
+      reader.read(op.multMacro.val,op.multMacro.len);
+      reader.read(op.rrMacro.val,op.rrMacro.len);
+      reader.read(op.slMacro.val,op.slMacro.len);
+      reader.read(op.tlMacro.val,op.tlMacro.len);
+      reader.read(op.dt2Macro.val,op.dt2Macro.len);
+      reader.read(op.rsMacro.val,op.rsMacro.len);
+      reader.read(op.dtMacro.val,op.dtMacro.len);
+      reader.read(op.d2rMacro.val,op.d2rMacro.len);
+      reader.read(op.ssgMacro.val,op.ssgMacro.len);
+    }
+  }
 
-      reader.read(std.algMacro.val,4*std.algMacro.len);
-      reader.read(std.fbMacro.val,4*std.fbMacro.len);
-      reader.read(std.fmsMacro.val,4*std.fmsMacro.len);
-      reader.read(std.amsMacro.val,4*std.amsMacro.len);
+  // release points
+  if (version>=44) {
+    std.volMacro.rel=reader.readI();
+    std.arpMacro.rel=reader.readI();
+    std.dutyMacro.rel=reader.readI();
+    std.waveMacro.rel=reader.readI();
+    std.pitchMacro.rel=reader.readI();
+    std.ex1Macro.rel=reader.readI();
+    std.ex2Macro.rel=reader.readI();
+    std.ex3Macro.rel=reader.readI();
+    std.algMacro.rel=reader.readI();
+    std.fbMacro.rel=reader.readI();
+    std.fmsMacro.rel=reader.readI();
+    std.amsMacro.rel=reader.readI();
 
-      for (int i=0; i<4; i++) {
-        DivInstrumentSTD::OpMacro& op=std.opMacros[i];
+    for (int i=0; i<4; i++) {
+      DivInstrumentSTD::OpMacro& op=std.opMacros[i];
 
-        op.amMacro.len=reader.readI();
-        op.arMacro.len=reader.readI();
-        op.drMacro.len=reader.readI();
-        op.multMacro.len=reader.readI();
-        op.rrMacro.len=reader.readI();
-        op.slMacro.len=reader.readI();
-        op.tlMacro.len=reader.readI();
-        op.dt2Macro.len=reader.readI();
-        op.rsMacro.len=reader.readI();
-        op.dtMacro.len=reader.readI();
-        op.d2rMacro.len=reader.readI();
-        op.ssgMacro.len=reader.readI();
+      op.amMacro.rel=reader.readI();
+      op.arMacro.rel=reader.readI();
+      op.drMacro.rel=reader.readI();
+      op.multMacro.rel=reader.readI();
+      op.rrMacro.rel=reader.readI();
+      op.slMacro.rel=reader.readI();
+      op.tlMacro.rel=reader.readI();
+      op.dt2Macro.rel=reader.readI();
+      op.rsMacro.rel=reader.readI();
+      op.dtMacro.rel=reader.readI();
+      op.d2rMacro.rel=reader.readI();
+      op.ssgMacro.rel=reader.readI();
+    }
+  }
 
-        op.amMacro.loop=reader.readI();
-        op.arMacro.loop=reader.readI();
-        op.drMacro.loop=reader.readI();
-        op.multMacro.loop=reader.readI();
-        op.rrMacro.loop=reader.readI();
-        op.slMacro.loop=reader.readI();
-        op.tlMacro.loop=reader.readI();
-        op.dt2Macro.loop=reader.readI();
-        op.rsMacro.loop=reader.readI();
-        op.dtMacro.loop=reader.readI();
-        op.d2rMacro.loop=reader.readI();
-        op.ssgMacro.loop=reader.readI();
+  // extended op macros
+  if (version>=61) {
+    for (int i=0; i<4; i++) {
+      DivInstrumentSTD::OpMacro& op=std.opMacros[i];
 
-        op.amMacro.open=reader.readC();
-        op.arMacro.open=reader.readC();
-        op.drMacro.open=reader.readC();
-        op.multMacro.open=reader.readC();
-        op.rrMacro.open=reader.readC();
-        op.slMacro.open=reader.readC();
-        op.tlMacro.open=reader.readC();
-        op.dt2Macro.open=reader.readC();
-        op.rsMacro.open=reader.readC();
-        op.dtMacro.open=reader.readC();
-        op.d2rMacro.open=reader.readC();
-        op.ssgMacro.open=reader.readC();
-      }
+      op.damMacro.len=reader.readI();
+      op.dvbMacro.len=reader.readI();
+      op.egtMacro.len=reader.readI();
+      op.kslMacro.len=reader.readI();
+      op.susMacro.len=reader.readI();
+      op.vibMacro.len=reader.readI();
+      op.wsMacro.len=reader.readI();
+      op.ksrMacro.len=reader.readI();
 
-      for (int i=0; i<4; i++) {
-        DivInstrumentSTD::OpMacro& op=std.opMacros[i];
-        for (int l=0; l<op.amMacro.len; l++) {
-          op.amMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.arMacro.len; l++) {
-          op.arMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.drMacro.len; l++) {
-          op.drMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.multMacro.len; l++) {
-          op.multMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.rrMacro.len; l++) {
-          op.rrMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.slMacro.len; l++) {
-          op.slMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.tlMacro.len; l++) {
-          op.tlMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.dt2Macro.len; l++) {
-          op.dt2Macro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.rsMacro.len; l++) {
-          op.rsMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.dtMacro.len; l++) {
-          op.dtMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.d2rMacro.len; l++) {
-          op.d2rMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.ssgMacro.len; l++) {
-          op.ssgMacro.val[l]=(unsigned char)reader.readC();
-        }
-      }
+      op.damMacro.loop=reader.readI();
+      op.dvbMacro.loop=reader.readI();
+      op.egtMacro.loop=reader.readI();
+      op.kslMacro.loop=reader.readI();
+      op.susMacro.loop=reader.readI();
+      op.vibMacro.loop=reader.readI();
+      op.wsMacro.loop=reader.readI();
+      op.ksrMacro.loop=reader.readI();
+
+      op.damMacro.rel=reader.readI();
+      op.dvbMacro.rel=reader.readI();
+      op.egtMacro.rel=reader.readI();
+      op.kslMacro.rel=reader.readI();
+      op.susMacro.rel=reader.readI();
+      op.vibMacro.rel=reader.readI();
+      op.wsMacro.rel=reader.readI();
+      op.ksrMacro.rel=reader.readI();
+
+      op.damMacro.open=reader.readC();
+      op.dvbMacro.open=reader.readC();
+      op.egtMacro.open=reader.readC();
+      op.kslMacro.open=reader.readC();
+      op.susMacro.open=reader.readC();
+      op.vibMacro.open=reader.readC();
+      op.wsMacro.open=reader.readC();
+      op.ksrMacro.open=reader.readC();
     }
 
-    // release points
-    if (version>=44) {
-      std.volMacro.rel=reader.readI();
-      std.arpMacro.rel=reader.readI();
-      std.dutyMacro.rel=reader.readI();
-      std.waveMacro.rel=reader.readI();
-      std.pitchMacro.rel=reader.readI();
-      std.ex1Macro.rel=reader.readI();
-      std.ex2Macro.rel=reader.readI();
-      std.ex3Macro.rel=reader.readI();
-      std.algMacro.rel=reader.readI();
-      std.fbMacro.rel=reader.readI();
-      std.fmsMacro.rel=reader.readI();
-      std.amsMacro.rel=reader.readI();
-
-      for (int i=0; i<4; i++) {
-        DivInstrumentSTD::OpMacro& op=std.opMacros[i];
-
-        op.amMacro.rel=reader.readI();
-        op.arMacro.rel=reader.readI();
-        op.drMacro.rel=reader.readI();
-        op.multMacro.rel=reader.readI();
-        op.rrMacro.rel=reader.readI();
-        op.slMacro.rel=reader.readI();
-        op.tlMacro.rel=reader.readI();
-        op.dt2Macro.rel=reader.readI();
-        op.rsMacro.rel=reader.readI();
-        op.dtMacro.rel=reader.readI();
-        op.d2rMacro.rel=reader.readI();
-        op.ssgMacro.rel=reader.readI();
-      }
-    }
-
-    // extended op macros
-    if (version>=61) {
-      for (int i=0; i<4; i++) {
-        DivInstrumentSTD::OpMacro& op=std.opMacros[i];
-
-        op.damMacro.len=reader.readI();
-        op.dvbMacro.len=reader.readI();
-        op.egtMacro.len=reader.readI();
-        op.kslMacro.len=reader.readI();
-        op.susMacro.len=reader.readI();
-        op.vibMacro.len=reader.readI();
-        op.wsMacro.len=reader.readI();
-        op.ksrMacro.len=reader.readI();
-
-        op.damMacro.loop=reader.readI();
-        op.dvbMacro.loop=reader.readI();
-        op.egtMacro.loop=reader.readI();
-        op.kslMacro.loop=reader.readI();
-        op.susMacro.loop=reader.readI();
-        op.vibMacro.loop=reader.readI();
-        op.wsMacro.loop=reader.readI();
-        op.ksrMacro.loop=reader.readI();
-
-        op.damMacro.rel=reader.readI();
-        op.dvbMacro.rel=reader.readI();
-        op.egtMacro.rel=reader.readI();
-        op.kslMacro.rel=reader.readI();
-        op.susMacro.rel=reader.readI();
-        op.vibMacro.rel=reader.readI();
-        op.wsMacro.rel=reader.readI();
-        op.ksrMacro.rel=reader.readI();
-
-        op.damMacro.open=reader.readC();
-        op.dvbMacro.open=reader.readC();
-        op.egtMacro.open=reader.readC();
-        op.kslMacro.open=reader.readC();
-        op.susMacro.open=reader.readC();
-        op.vibMacro.open=reader.readC();
-        op.wsMacro.open=reader.readC();
-        op.ksrMacro.open=reader.readC();
-      }
-
-      for (int i=0; i<4; i++) {
-        DivInstrumentSTD::OpMacro& op=std.opMacros[i];
-        for (int l=0; l<op.damMacro.len; l++) {
-          op.damMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.dvbMacro.len; l++) {
-          op.dvbMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.egtMacro.len; l++) {
-          op.egtMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.kslMacro.len; l++) {
-          op.kslMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.susMacro.len; l++) {
-          op.susMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.vibMacro.len; l++) {
-          op.vibMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.wsMacro.len; l++) {
-          op.wsMacro.val[l]=(unsigned char)reader.readC();
-        }
-        for (int l=0; l<op.ksrMacro.len; l++) {
-          op.ksrMacro.val[l]=(unsigned char)reader.readC();
-        }
-      }
+    for (int i=0; i<4; i++) {
+      DivInstrumentSTD::OpMacro& op=std.opMacros[i];
+      reader.read(op.damMacro.val,op.damMacro.len);
+      reader.read(op.dvbMacro.val,op.dvbMacro.len);
+      reader.read(op.egtMacro.val,op.egtMacro.len);
+      reader.read(op.kslMacro.val,op.kslMacro.len);
+      reader.read(op.susMacro.val,op.susMacro.len);
+      reader.read(op.vibMacro.val,op.vibMacro.len);
+      reader.read(op.wsMacro.val,op.wsMacro.len);
+      reader.read(op.ksrMacro.val,op.ksrMacro.len);
     }
   }
 
@@ -1182,53 +843,51 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
   }
 
   // more macros
-  if (!istest) {
-    if (version>=76) {
-      std.panLMacro.len=reader.readI();
-      std.panRMacro.len=reader.readI();
-      std.phaseResetMacro.len=reader.readI();
-      std.ex4Macro.len=reader.readI();
-      std.ex5Macro.len=reader.readI();
-      std.ex6Macro.len=reader.readI();
-      std.ex7Macro.len=reader.readI();
-      std.ex8Macro.len=reader.readI();
+  if (version>=76) {
+    std.panLMacro.len=reader.readI();
+    std.panRMacro.len=reader.readI();
+    std.phaseResetMacro.len=reader.readI();
+    std.ex4Macro.len=reader.readI();
+    std.ex5Macro.len=reader.readI();
+    std.ex6Macro.len=reader.readI();
+    std.ex7Macro.len=reader.readI();
+    std.ex8Macro.len=reader.readI();
 
-      std.panLMacro.loop=reader.readI();
-      std.panRMacro.loop=reader.readI();
-      std.phaseResetMacro.loop=reader.readI();
-      std.ex4Macro.loop=reader.readI();
-      std.ex5Macro.loop=reader.readI();
-      std.ex6Macro.loop=reader.readI();
-      std.ex7Macro.loop=reader.readI();
-      std.ex8Macro.loop=reader.readI();
+    std.panLMacro.loop=reader.readI();
+    std.panRMacro.loop=reader.readI();
+    std.phaseResetMacro.loop=reader.readI();
+    std.ex4Macro.loop=reader.readI();
+    std.ex5Macro.loop=reader.readI();
+    std.ex6Macro.loop=reader.readI();
+    std.ex7Macro.loop=reader.readI();
+    std.ex8Macro.loop=reader.readI();
 
-      std.panLMacro.rel=reader.readI();
-      std.panRMacro.rel=reader.readI();
-      std.phaseResetMacro.rel=reader.readI();
-      std.ex4Macro.rel=reader.readI();
-      std.ex5Macro.rel=reader.readI();
-      std.ex6Macro.rel=reader.readI();
-      std.ex7Macro.rel=reader.readI();
-      std.ex8Macro.rel=reader.readI();
+    std.panLMacro.rel=reader.readI();
+    std.panRMacro.rel=reader.readI();
+    std.phaseResetMacro.rel=reader.readI();
+    std.ex4Macro.rel=reader.readI();
+    std.ex5Macro.rel=reader.readI();
+    std.ex6Macro.rel=reader.readI();
+    std.ex7Macro.rel=reader.readI();
+    std.ex8Macro.rel=reader.readI();
 
-      std.panLMacro.open=reader.readC();
-      std.panRMacro.open=reader.readC();
-      std.phaseResetMacro.open=reader.readC();
-      std.ex4Macro.open=reader.readC();
-      std.ex5Macro.open=reader.readC();
-      std.ex6Macro.open=reader.readC();
-      std.ex7Macro.open=reader.readC();
-      std.ex8Macro.open=reader.readC();
+    std.panLMacro.open=reader.readC();
+    std.panRMacro.open=reader.readC();
+    std.phaseResetMacro.open=reader.readC();
+    std.ex4Macro.open=reader.readC();
+    std.ex5Macro.open=reader.readC();
+    std.ex6Macro.open=reader.readC();
+    std.ex7Macro.open=reader.readC();
+    std.ex8Macro.open=reader.readC();
 
-      reader.read(std.panLMacro.val,4*std.panLMacro.len);
-      reader.read(std.panRMacro.val,4*std.panRMacro.len);
-      reader.read(std.phaseResetMacro.val,4*std.phaseResetMacro.len);
-      reader.read(std.ex4Macro.val,4*std.ex4Macro.len);
-      reader.read(std.ex5Macro.val,4*std.ex5Macro.len);
-      reader.read(std.ex6Macro.val,4*std.ex6Macro.len);
-      reader.read(std.ex7Macro.val,4*std.ex7Macro.len);
-      reader.read(std.ex8Macro.val,4*std.ex8Macro.len);
-    }
+    reader.read(std.panLMacro.val,4*std.panLMacro.len);
+    reader.read(std.panRMacro.val,4*std.panRMacro.len);
+    reader.read(std.phaseResetMacro.val,4*std.phaseResetMacro.len);
+    reader.read(std.ex4Macro.val,4*std.ex4Macro.len);
+    reader.read(std.ex5Macro.val,4*std.ex5Macro.len);
+    reader.read(std.ex6Macro.val,4*std.ex6Macro.len);
+    reader.read(std.ex7Macro.val,4*std.ex7Macro.len);
+    reader.read(std.ex8Macro.val,4*std.ex8Macro.len);
   }
 
   // FDS
@@ -1262,14 +921,6 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
     ws.param3=reader.readC();
     ws.param4=reader.readC();
   }
-
-  // FM per-operator enable
-  if (istest) {
-    for (int j=0; j<4; j++) {
-      DivInstrumentFM::Operator& op=fm.op[j];
-      op.enable=reader.readC();
-    }
-  }
   return DIV_DATA_SUCCESS;
 }
 
diff --git a/src/engine/instrument.h b/src/engine/instrument.h
index e12da09d..605241c7 100644
--- a/src/engine/instrument.h
+++ b/src/engine/instrument.h
@@ -26,7 +26,7 @@
 // NOTICE!
 // before adding new instrument types to this struct, please ask me first.
 // absolutely zero support granted to conflicting formats.
-enum DivInstrumentType : unsigned short {
+enum DivInstrumentType: unsigned short {
   DIV_INS_STD=0,
   DIV_INS_FM=1,
   DIV_INS_GB=2,
@@ -81,7 +81,7 @@ struct DivInstrumentFM {
     unsigned char am, ar, dr, mult, rr, sl, tl, dt2, rs, dt, d2r, ssgEnv;
     unsigned char dam, dvb, egt, ksl, sus, vib, ws, ksr; // YMU759/OPL/OPZ
     Operator():
-      enable(false),
+      enable(true),
       am(0),
       ar(0),
       dr(0),
@@ -156,22 +156,20 @@ struct DivInstrumentFM {
 struct DivInstrumentMacro {
   String name;
   int val[256];
-  int height;
   unsigned int mode;
   bool open;
   unsigned char len;
   signed char loop;
   signed char rel;
-  DivInstrumentMacro(String n, int h=~0, bool initOpen=false):
+  DivInstrumentMacro(String n, bool initOpen=false):
     name(n),
-    height(h),
     mode(0),
     open(initOpen),
     len(0),
     loop(-1),
     rel(-1) {
     memset(val,0,256*sizeof(int));
-    }
+  }
 };
 
 struct DivInstrumentSTD {
@@ -186,9 +184,7 @@ struct DivInstrumentSTD {
   DivInstrumentMacro algMacro;
   DivInstrumentMacro fbMacro;
   DivInstrumentMacro fmsMacro;
-  DivInstrumentMacro fms2Macro;
   DivInstrumentMacro amsMacro;
-  DivInstrumentMacro ams2Macro;
   DivInstrumentMacro panLMacro;
   DivInstrumentMacro panRMacro;
   DivInstrumentMacro phaseResetMacro;
@@ -222,36 +218,16 @@ struct DivInstrumentSTD {
     DivInstrumentMacro ksrMacro;
     OpMacro():
       amMacro("am"), arMacro("ar"), drMacro("dr"), multMacro("mult"),
-      rrMacro("rr"), slMacro("sl"), tlMacro("tl",~0,true), dt2Macro("dt2"),
+      rrMacro("rr"), slMacro("sl"), tlMacro("tl",true), dt2Macro("dt2"),
       rsMacro("rs"), dtMacro("dt"), d2rMacro("d2r"), ssgMacro("ssg"),
       damMacro("dam"), dvbMacro("dvb"), egtMacro("egt"), kslMacro("ksl"),
       susMacro("sus"), vibMacro("vib"), wsMacro("ws"), ksrMacro("ksr") {}
   } opMacros[4];
-  struct WaveSynthMacro {
-    DivInstrumentMacro wave1Macro, wave2Macro;
-    DivInstrumentMacro rateDividerMacro;
-    DivInstrumentMacro effectMacro;
-    DivInstrumentMacro oneShotMacro, enabledMacro, globalMacro;
-    DivInstrumentMacro speedMacro, param1Macro, param2Macro, param3Macro, param4Macro;
-    WaveSynthMacro():
-      wave1Macro("wave1"),
-      wave2Macro("wave2"),
-      rateDividerMacro("rateDivider"),
-      effectMacro("effect"),
-      oneShotMacro("oneShot"),
-      enabledMacro("enabled"),
-      globalMacro("global"),
-      speedMacro("speed"),
-      param1Macro("param1"),
-      param2Macro("param2"),
-      param3Macro("param3"),
-      param4Macro("param4") {}
-  } ws;
   DivInstrumentSTD():
-    volMacro("vol",15,true),
+    volMacro("vol",true),
     arpMacro("arp"),
-    dutyMacro("duty",3),
-    waveMacro("wave",63),
+    dutyMacro("duty"),
+    waveMacro("wave"),
     pitchMacro("pitch"),
     ex1Macro("ex1"),
     ex2Macro("ex2"),
@@ -259,9 +235,7 @@ struct DivInstrumentSTD {
     algMacro("alg"),
     fbMacro("fb"),
     fmsMacro("fms"),
-    fms2Macro("fms2"),
     amsMacro("ams"),
-    ams2Macro("ams2"),
     panLMacro("panL"),
     panRMacro("panR"),
     phaseResetMacro("phaseReset"),
@@ -425,15 +399,6 @@ struct DivInstrument {
    */
   DivDataErrors readInsData(SafeReader& reader, short version);
 
-  /**
-   * read macro data in .fui format.
-   * @param m the macro.
-   * @param reader the reader.
-   * @param version the format version.
-   * @return a DivDataErrors.
-   */
-  DivDataErrors readMacroData(DivInstrumentMacro& m, SafeReader& reader, short version);
-
   /**
    * save this instrument to a file.
    * @param path file path.
diff --git a/src/engine/macroInt.cpp b/src/engine/macroInt.cpp
index aafeedbc..489a6fab 100644
--- a/src/engine/macroInt.cpp
+++ b/src/engine/macroInt.cpp
@@ -45,10 +45,10 @@ void DivMacroStruct::doMacro(DivInstrumentMacro& source, bool released) {
   }
 }
 
-// CPU hell
 void DivMacroInt::next() {
   if (ins==NULL) return;
-  // Run macros
+  // run macros
+  // TODO: potentially get rid of list to avoid allocations
   if (!macroList.empty()) {
       for (std::list<DivMacroExecList>::iterator iter = macroList.begin(); iter!= macroList.end(); iter++) {
         iter->doMacro(released);
@@ -63,6 +63,7 @@ void DivMacroInt::release() {
 void DivMacroInt::init(DivInstrument* which) {
   ins=which;
   // initialize
+  // TODO: potentially get rid of list to avoid allocations
   while (!macroList.empty()) {
     macroList.front().init();
     macroList.pop_front();
@@ -106,17 +107,10 @@ void DivMacroInt::init(DivInstrument* which) {
   if (ins->std.fmsMacro.len>0) {
     macroList.push_back(DivMacroExecList(fms,ins->std.fmsMacro));
   }
-  if (ins->std.fms2Macro.len>0) {
-    macroList.push_back(DivMacroExecList(fms2,ins->std.fms2Macro));
-  }
   if (ins->std.amsMacro.len>0) {
     macroList.push_back(DivMacroExecList(ams,ins->std.amsMacro));
   }
-  if (ins->std.ams2Macro.len>0) {
-    macroList.push_back(DivMacroExecList(ams2,ins->std.ams2Macro));
-  }
 
-  // TODO: other macros
   if (ins->std.panLMacro.len>0) {
     macroList.push_back(DivMacroExecList(panL,ins->std.panLMacro));
   }
@@ -209,46 +203,9 @@ void DivMacroInt::init(DivInstrument* which) {
     }
   }
 
-  // prepare wavesynth macros
-  if (ins->std.ws.wave1Macro.len>0) {
-    macroList.push_back(DivMacroExecList(ws.wave1,ins->std.ws.wave1Macro));
-  }
-  if (ins->std.ws.wave2Macro.len>0) {
-    macroList.push_back(DivMacroExecList(ws.wave2,ins->std.ws.wave2Macro));
-  }
-  if (ins->std.ws.rateDividerMacro.len>0) {
-    macroList.push_back(DivMacroExecList(ws.rateDivider,ins->std.ws.rateDividerMacro));
-  }
-  if (ins->std.ws.effectMacro.len>0) {
-    macroList.push_back(DivMacroExecList(ws.effect,ins->std.ws.effectMacro));
-  }
-  if (ins->std.ws.oneShotMacro.len>0) {
-    macroList.push_back(DivMacroExecList(ws.oneShot,ins->std.ws.oneShotMacro));
-  }
-  if (ins->std.ws.enabledMacro.len>0) {
-    macroList.push_back(DivMacroExecList(ws.enabled,ins->std.ws.enabledMacro));
-  }
-  if (ins->std.ws.globalMacro.len>0) {
-    macroList.push_back(DivMacroExecList(ws.global,ins->std.ws.globalMacro));
-  }
-  if (ins->std.ws.speedMacro.len>0) {
-    macroList.push_back(DivMacroExecList(ws.speed,ins->std.ws.speedMacro));
-  }
-  if (ins->std.ws.param1Macro.len>0) {
-    macroList.push_back(DivMacroExecList(ws.param1,ins->std.ws.param1Macro));
-  }
-  if (ins->std.ws.param2Macro.len>0) {
-    macroList.push_back(DivMacroExecList(ws.param2,ins->std.ws.param2Macro));
-  }
-  if (ins->std.ws.param3Macro.len>0) {
-    macroList.push_back(DivMacroExecList(ws.param3,ins->std.ws.param3Macro));
-  }
-  if (ins->std.ws.param4Macro.len>0) {
-    macroList.push_back(DivMacroExecList(ws.param4,ins->std.ws.param4Macro));
-  }
   if (!macroList.empty()) {
-      for (std::list<DivMacroExecList>::iterator iter = macroList.begin(); iter!= macroList.end(); iter++) {
-        iter->prepare();
+    for (std::list<DivMacroExecList>::iterator iter = macroList.begin(); iter!= macroList.end(); iter++) {
+      iter->prepare();
     }
   }
 }
diff --git a/src/engine/macroInt.h b/src/engine/macroInt.h
index 3ce0c872..2480d743 100644
--- a/src/engine/macroInt.h
+++ b/src/engine/macroInt.h
@@ -73,7 +73,7 @@ class DivMacroInt {
     DivMacroStruct vol;
     DivMacroStruct arp;
     DivMacroStruct duty, wave, pitch, ex1, ex2, ex3;
-    DivMacroStruct alg, fb, fms, fms2, ams, ams2;
+    DivMacroStruct alg, fb, fms, ams;
     DivMacroStruct panL, panR, phaseReset, ex4, ex5, ex6, ex7, ex8;
   
     // FM operator macro
@@ -105,28 +105,6 @@ class DivMacroInt {
         ws(),
         ksr() {}
     } op[4];
-  
-    // wavesynth macro
-    struct IntWS {
-      DivMacroStruct wave1, wave2;
-      DivMacroStruct rateDivider;
-      DivMacroStruct effect;
-      DivMacroStruct oneShot, enabled, global;
-      DivMacroStruct speed, param1, param2, param3, param4;
-      IntWS():
-        wave1(),
-        wave2(),
-        rateDivider(),
-        effect(),
-        oneShot(),
-        enabled(),
-        global(),
-        speed(),
-        param1(),
-        param2(),
-        param3(),
-        param4() {}
-    } ws;
 
     /**
      * trigger macro release.
@@ -165,9 +143,7 @@ class DivMacroInt {
       alg(),
       fb(),
       fms(),
-      fms2(),
       ams(),
-      ams2(),
       panL(),
       panR(),
       phaseReset(),
diff --git a/src/engine/platform/tx81z.cpp b/src/engine/platform/tx81z.cpp
index 76c9d24b..7ea634b2 100644
--- a/src/engine/platform/tx81z.cpp
+++ b/src/engine/platform/tx81z.cpp
@@ -275,18 +275,10 @@ void DivPlatformTX81Z::tick() {
       chan[i].state.fms=chan[i].std.fms.val;
       rWrite(chanOffs[i]+ADDR_FMS_AMS,((chan[i].state.fms&7)<<4)|(chan[i].state.ams&3));
     }
-    if (chan[i].std.fms2.had) {
-      chan[i].state.fms2=chan[i].std.fms2.val;
-      //rWrite(chanOffs[i]+ADDR_FMS_AMS,0x84|((chan[i].state.fms2&7)<<4)|(chan[i].state.ams2&3));
-    }
     if (chan[i].std.ams.had) {
       chan[i].state.ams=chan[i].std.ams.val;
       rWrite(chanOffs[i]+ADDR_FMS_AMS,((chan[i].state.fms&7)<<4)|(chan[i].state.ams&3));
     }
-    if (chan[i].std.ams2.had) {
-      chan[i].state.ams2=chan[i].std.ams2.val;
-      //rWrite(chanOffs[i]+ADDR_FMS_AMS,0x84|((chan[i].state.fms2&7)<<4)|(chan[i].state.ams2&3));
-    }
     for (int j=0; j<4; j++) {
       unsigned short baseAddr=chanOffs[i]|opOffs[j];
       DivInstrumentFM::Operator& op=chan[i].state.op[j];
diff --git a/src/gui/insEdit.cpp b/src/gui/insEdit.cpp
index 685160b7..3e141612 100644
--- a/src/gui/insEdit.cpp
+++ b/src/gui/insEdit.cpp
@@ -110,7 +110,7 @@ enum FMParams {
 #define FM_SHORT_NAME(x) fmParamShortNames[settings.fmNames][x]
 
 const char* fmOperatorBits[5]={
-  "op1", "op3", "op2", "op4", NULL
+  "op1", "op2", "op3", "op4", NULL
 };
 
 const char* c64ShapeBits[5]={
@@ -182,11 +182,12 @@ const char* dualWSEffects[7]={
 
 const char* macroAbsoluteMode[2]={
   "Relative",
-  "Absolute",
+  "Absolute"
 };
 
 const char* macroDummyMode[2]={
-  "empty",
+  "Bug",
+  "Bug"
 };
 
 String macroHoverNote(int id, float val) {
@@ -996,7 +997,7 @@ void FurnaceGUI::drawFMEnv(unsigned char tl, unsigned char ar, unsigned char dr,
       } else { \
         modeName=displayModeName[macro.mode]; \
       } \
-      if (ImGui::BeginCombo("Macro Mode##IMacroMode_" macroName,modeName.c_str())) { \
+      if (ImGui::BeginCombo("TODO: Improve##IMacroMode_" macroName,modeName.c_str())) { \
         String id; \
         for (unsigned int i=0; i<=macroModeMax; i++) { \
           id=fmt::sprintf("%d: %s",i,displayModeName[i]); \
@@ -1100,7 +1101,7 @@ void FurnaceGUI::drawFMEnv(unsigned char tl, unsigned char ar, unsigned char dr,
       } else { \
         modeName=displayModeName[macro.mode]; \
       } \
-      if (ImGui::BeginCombo("Macro Mode##IOPMacroMode_" macroName,modeName.c_str())) { \
+      if (ImGui::BeginCombo("TODO: Improve##IOPMacroMode_" macroName,modeName.c_str())) { \
         String id; \
         for (unsigned int i=0; i<=macroModeMax; i++) { \
           id=fmt::sprintf("%d: %s",i,displayModeName[i]); \
@@ -2056,10 +2057,9 @@ void FurnaceGUI::drawInsEdit() {
               NORMAL_MACRO(ins->std.fbMacro,0,7,"fb",FM_NAME(FM_FB),96,ins->std.fbMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[1],0,7,NULL,false);
               if (ins->type!=DIV_INS_OPL) {
                 if (ins->type==DIV_INS_OPZ) {
+                  // TODO: FMS2/AMS2 macros
                   NORMAL_MACRO(ins->std.fmsMacro,0,7,"fms",FM_NAME(FM_FMS),96,ins->std.fmsMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[2],0,7,NULL,false);
-                  NORMAL_MACRO(ins->std.fms2Macro,0,7,"fms2",FM_NAME(FM_FMS2),96,ins->std.fms2Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[3],0,7,NULL,false);
                   NORMAL_MACRO(ins->std.amsMacro,0,3,"ams",FM_NAME(FM_AMS),48,ins->std.amsMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[4],0,3,NULL,false);
-                  NORMAL_MACRO(ins->std.ams2Macro,0,3,"ams2",FM_NAME(FM_AMS2),48,ins->std.ams2Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[5],0,3,NULL,false);
                 } else {
                   NORMAL_MACRO(ins->std.fmsMacro,0,7,"fms",FM_NAME(FM_FMS),96,ins->std.fmsMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[2],0,7,NULL,false);
                   NORMAL_MACRO(ins->std.amsMacro,0,3,"ams",FM_NAME(FM_AMS),48,ins->std.amsMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[3],0,3,NULL,false);
@@ -2072,7 +2072,7 @@ void FurnaceGUI::drawInsEdit() {
               NORMAL_MACRO(ins->std.ex2Macro,0,127,"ex2","PM Depth",128,ins->std.ex2Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[7],0,127,NULL,false);
               NORMAL_MACRO(ins->std.ex3Macro,0,255,"ex3","LFO Speed",128,ins->std.ex3Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[8],0,255,NULL,false);
               NORMAL_MACRO(ins->std.waveMacro,0,3,"wave","LFO Shape",48,ins->std.waveMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_WAVE],mmlString[9],0,3,&macroLFOWaves,false);
-              NORMAL_MACRO(ins->std.ex4Macro,0,4,"ex4","Operator On/Off",128,ins->std.ex4Macro.open,true,fmOperatorBits,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[10],0,4,NULL,false);
+              NORMAL_MACRO(ins->std.ex4Macro,0,4,"ex4","OpMask",128,ins->std.ex4Macro.open,true,fmOperatorBits,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[10],0,4,NULL,false);
             }
             MACRO_END;
             ImGui::EndTabItem();
@@ -2238,10 +2238,7 @@ void FurnaceGUI::drawInsEdit() {
 
           P(ImGui::Checkbox("Volume Macro is Cutoff Macro",&ins->c64.volIsCutoff));
           P(ImGui::Checkbox("Absolute Cutoff Macro",&ins->c64.filterIsAbs));
-          bool dutyAbs=ins->std.dutyMacro.mode&1;
-          if (ImGui::Checkbox("Absolute Duty Macro",&dutyAbs)) { PARAMETER
-            ins->std.dutyMacro.mode^=1;
-          }
+          P(ImGui::Checkbox("Absolute Duty Macro",&ins->c64.dutyIsAbs));
           ImGui::EndTabItem();
         }
         if (ins->type==DIV_INS_AMIGA) if (ImGui::BeginTabItem("Amiga/Sample")) {
@@ -2387,9 +2384,6 @@ void FurnaceGUI::drawInsEdit() {
             ins->type==DIV_INS_SWAN ||
             ins->type==DIV_INS_PCE ||
             ins->type==DIV_INS_SCC) {
-          float asFloat[256];
-          int asInt[256];
-          float loopIndicator[256];
           if (ImGui::BeginTabItem("Wavetable")) {
             ImGui::Checkbox("Enable synthesizer",&ins->ws.enabled);
             ImGui::SameLine();
@@ -2484,20 +2478,6 @@ void FurnaceGUI::drawInsEdit() {
 
             ImGui::EndTabItem();
           }
-          if (ImGui::BeginTabItem("Wavetable Macros")) {
-            MACRO_BEGIN(0);
-              NORMAL_MACRO(ins->std.ws.enabledMacro,0,1,"enabled","Enable",160,ins->std.ws.enabledMacro.open,true,oneBit,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[5],0,1,NULL,false);
-              NORMAL_MACRO(ins->std.ws.oneShotMacro,0,1,"oneShot","One Shot",160,ins->std.ws.oneShotMacro.open,true,oneBit,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[4],0,1,NULL,false);
-              NORMAL_MACRO(ins->std.ws.globalMacro,0,1,"global","Global",160,ins->std.ws.globalMacro.open,true,oneBit,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[6],0,1,NULL,false);
-              NORMAL_MACRO(ins->std.ws.effectMacro,0,255,"effect","Effect",160,ins->std.ws.effectMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[3],0,255,NULL,false);
-              NORMAL_MACRO(ins->std.ws.wave1Macro,0,255,"wave1","Wave 1",160,ins->std.ws.wave1Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[0],0,255,NULL,false);
-              NORMAL_MACRO(ins->std.ws.wave2Macro,0,255,"wave2","Wave 2",160,ins->std.ws.wave2Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[1],0,255,NULL,false);
-              NORMAL_MACRO(ins->std.ws.rateDividerMacro,1,7,"rateDivider","Rate",160,ins->std.ws.rateDividerMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[2],1,7,NULL,false);
-              NORMAL_MACRO(ins->std.ws.speedMacro,0,255,"speed","Speed",160,ins->std.ws.speedMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[6],0,255,NULL,false);
-              NORMAL_MACRO(ins->std.ws.param1Macro,1,7,"amount","Amount",160,ins->std.ws.param1Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[6],1,7,NULL,false);
-            MACRO_END;
-            ImGui::EndTabItem();
-          }
         }
         if (ImGui::BeginTabItem("Macros")) {
           float asFloat[256];
@@ -2546,7 +2526,7 @@ void FurnaceGUI::drawInsEdit() {
           int dutyMax=3;
           if (ins->type==DIV_INS_C64) {
             dutyLabel="Duty";
-            if (ins->std.dutyMacro.mode) {
+            if (ins->c64.dutyIsAbs) {
               dutyMax=4095;
             } else {
               dutyMax=24;
@@ -2593,7 +2573,7 @@ void FurnaceGUI::drawInsEdit() {
             dutyLabel="Duty";
             dutyMax=7;
           }
-          bool dutyIsRel=(ins->type==DIV_INS_C64 && !ins->std.dutyMacro.mode);
+          bool dutyIsRel=(ins->type==DIV_INS_C64 && !ins->c64.dutyIsAbs);
 
           const char* waveLabel="Waveform";
           int waveMax=(ins->type==DIV_INS_AY || ins->type==DIV_INS_AY8930 || ins->type==DIV_INS_VERA)?3:63;
@@ -2813,7 +2793,7 @@ void FurnaceGUI::drawInsEdit() {
             if (dutyMax>0) {
               ImGui::Separator();
               if (ins->type==DIV_INS_C64) {
-                if (ins->std.dutyMacro.mode) {
+                if (ins->c64.dutyIsAbs) {
                   ImGui::Text("Duty Macro");
                 } else {
                   ImGui::Text("Relative Duty Macro");