JIT

// Выделяем память из которой можно выполнять программы. Это основной момент
auto code = (unsigned char*)VirtualAlloc(0, 256, MEM_RESERVE|MEM_COMMIT, PAGE_EXECUTE_READWRITE);
VirtualLock(code, 256);
// Записываем программу
code[0] = 0xC3; // код команды RET 
// Выполняем
((void(*)())code)();

// Все условия перехода
enum Cc {
  JA=7, JAE=3, JB=2, JBE=6, JC=2, JE=4, JG=0xF, JGE=0xD, JL=0xC, JLE=0xE, JNA=6, 
  JNAE=2, JNB=3, JNBE=7, JNC=3, JNE=5, JNG=0xE, JNGE=0xC, JNL=0xD, JNLE=0xF, JNO=1,
  JNP=0xB, JNS=9, JNZ=5, JO=0, JP=0xA, JPE=0xA, JPO=0xB, JS=8, JZ=4 
};

// Используемые регистры
enum Reg { EAX=0, ECX=1, EDX=2, EBX=3 };

// Команды ALU
enum Alu { ADD=0, OR=1, ADC=2, SBB=3, AND=4, SUB=5, XOR=6, CMP=7 };

class Compiler {
protected:
  unsigned char *codeStart; // Начало кода
  unsigned char *code; // Конец кода

  unsigned char *prev; int cmd, cmdA, cmdB; // Для оптимизации
  enum { CMD_mov_reg_imm=1, CMD_mov_reg_EBX_rel, CMD_mov_reg_reg, CMD_SET_A, CMD_set };// Для оптимизации

  void s(char opcode) { cmd = 0; prev = code; *code++ = opcode; }
  void s(char opcode1, char opcode2) { s(opcode1); *code++ = opcode2; }
  void i(int imm) { *(int*)code = imm; code+=4; }

public:
  Compiler() {
    prev = code = codeStart = (unsigned char*)VirtualAlloc(0, 256, MEM_RESERVE|MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    VirtualLock(code, 256);
  }

  void execute() {
    ((void(*)())codeStart)();
  }

  // Команды без оптимизации

  void mov_reg_reg(Reg reg1, Reg reg2)   { s(0x8B, 0xC0|(reg1<<3)|reg2); cmd=CMD_mov_reg_reg; cmdA=reg1; cmdB=reg2; }
  void mov_reg_imm(Reg reg, int imm)     { s(0xB8|reg); i(imm); cmd=CMD_mov_reg_imm; cmdA=reg; cmdB=imm; }
  void mov_reg_EBX_rel(int reg, int rel) { s(0x8B, 0x83|(reg<<3)); i(rel); cmd=CMD_mov_reg_EBX_rel; cmdA=reg; cmdB=rel; }
  void mov_EBX_rel_reg(int rel, Reg reg) { s(0x89, 0x83|(reg<<3)); i(rel); }
  void push_reg(Reg reg)                 { s(0x50|reg); }
  void pop_reg(Reg reg)                  { s(0x58|reg); }
  void jcc(Cc cc, int label)             { s(0x0F, 0x80|cc); fixup(code, label); i(-4); }
  void jmp(int label)                    { s(0xE9); fixup(code, label); i(-4); }
  void ret()                             { s(0xC3); }
  void set(Cc cc, Reg reg)               { auto p=code; mov_reg_imm(reg,0); s(0x0F, 0x90|cc); *code++ = 0xC0|reg; prev=p; cmd=CMD_set; cmdA=cc; } 

  // Команды с оптимизацией

  void needFlags_jcc(Cc cc, int label)   {
    if(cc==JZ && cmd==CMD_set) { code = prev; jcc((Cc)cmdA, label); return; }
    alu_reg_reg(OR, EAX, EAX); 
    jcc(cc, label);
  }
  
  void alu_reg_imm(Alu alu, Reg reg, int imm) { 
    if(reg==EAX) { /* alu eax, imm */  s(0x05+(alu<<3)); i(imm); return; }
    /* alu reg1, imm */ s(0x81, 0xC0+(alu<<3)+reg); i(imm);
  }

  void alu_reg_reg(Alu alu, Reg reg1, Reg reg2) { 
    /* alu reg1, imm */      if(cmd==CMD_mov_reg_imm     && cmdA==reg2 ) { code=prev; alu_reg_imm(alu, reg1, cmdB); return; }
    /* alu reg1, [ebx+rel] */if(cmd==CMD_mov_reg_EBX_rel && cmdA==reg2 ) { code=prev; s(0x03+(alu<<3),  0x83+(reg1<<3)); i(cmdB); return; }
    s(0x03|(alu<<3)); *code++ = 0xC0|(reg1<<3)|reg2;
  } 

  void idiv_reg(Reg reg) { 
    /* idiv [ebx+rel] */ if(cmd == CMD_mov_reg_EBX_rel) { code = prev; s(0xF7, 0xBB); i(cmdA); return; }
    /* idiv reg */ s(0xF7, 0xF8|reg); 
  }

  void imul_reg(Reg reg) {
    /* imul [ebx+rel] */ if(cmd==CMD_mov_reg_EBX_rel && cmdA==reg) { code = prev; s(0xF7); *code++ = 0xAB; i(cmdB); return; }
    /* imul reg */ s(0xF7); *code++ = 0xE8|reg;
  }

  // Метки

  struct Fixup {
    unsigned char* code;
    int label;
    Fixup() {};
    Fixup(unsigned char* _code, int _label) { code=_code; label=_label; }
  };
  std::vector<Fixup> fixups;
  std::vector<unsigned char*> labels;

  void fixup(unsigned char* code, int label) { fixups.push_back(Fixup(code, label)); }
  void label(int label) { labels[label] = code; }
  int allocLabel() { labels.push_back(code); return labels.size()-1; }  
  void prepare() { for(auto f=fixups.begin(), fe=fixups.end(); f!=fe; f++) *(int*)f->code += labels[f->label] - f->code; }
};

struct Item {
  int a, b;
};

std::vector<Item> data;

#define OFFSET(X) ((char*)&Item.X-(char*)&Item.a)

void do() {
  Compiler c;
  c.mov_reg_imm(EBX, (int)data.begin()._Ptr);
  int l0 = c.allocLabel();
  c.mov_reg_EBX_rel(EAX, OFFSET(a));
  c.alu_reg_imm(CMP, EAX, 16);
  int l = c.allocLabel();
  c.jcc(JA, l);
  c.mov_EBX_rel_imm(OFFSET(b), 1);
  c.label(l);
  c.alu_reg_imm(ADD, EBX, sizeof(item));
  c.alu_reg_imm(CMP, EBX, (int)data.end()._Ptr);
  c.jcc(JNZ, l0);
  c.ret();

  c.prepare();
  c.execute();
}

enum Type { tAcc, tVar, tImm, tStack };

struct Var {
  Type type;
  int n;

  void set(Type _type, int _n) { type=_type; n=_n; }
  ~Var();
};

class Node {
public:
  Var v; // Переменная или константа
  Operator o; // Оператор
  Cc cc; // Условие перехода
  Node *a, *b; // Аргументы оператора. Надо заменить на list args

  Node(Var& _v) { o=oNone; a=0; b=0; v=_v; }
  Node(int& n) { o=oNone; a=0; b=0; v.n=n; v.type=tImm; }
  Node(Operator _o, Cc _cc, Node* _a, Node* _b) { o=_o; cc=_cc; a=_a; b=_b; }
};

Node* parseVar(int level=0) {
  Node* a;
  if(p.ifToken("(")) { a = parseVar(0); p.needToken(")"); } else
  if(p.ifToken(ttInteger)) { a = new Node(p.i); } else
  if(p.ifToken(varNames)) { a = new Node(vars[p.i]); } else p.syntaxError();
  while(true) {
    Operator o; int l; Cc cc=JZ;
    if(level<1 && p.ifToken("Or")) l=1, o=oOr; else
    if(level<2 && p.ifToken("And")) l=2, o=oAnd; else
    if(level<3 && p.ifToken("<" )) l=3, o=oCmp, cc=JB;  else
    if(level<3 && p.ifToken("<=")) l=3, o=oCmp, cc=JBE; else
    if(level<3 && p.ifToken(">" )) l=3, o=oCmp, cc=JA;  else
    if(level<3 && p.ifToken(">=")) l=3, o=oCmp, cc=JAE; else
    if(level<3 && p.ifToken("==")) l=3, o=oCmp, cc=JE;  else
    if(level<3 && p.ifToken("!=")) l=3, o=oCmp, cc=JNE; else
    if(level<4 && p.ifToken("+" )) l=4, o=oAdd; else
    if(level<4 && p.ifToken("-" )) l=4, o=oSub; else
    if(p.ifToken("*")) l=5, o=oMul; else
    if(p.ifToken("/")) l=5, o=oDiv; else return a;
    Node* b = parseVar(l);
    a = new Node(o, cc, a, b);
  }
}

void compileVar(Var* x, Node* n, int jmpIfFalse=-1) {
  // Это переменная или константа
  if(n->o==oNone) {
    *x = n->v;
    return;
  }

  // AND и OR обрабатываем по особому.
  if(n->o==oAnd || n->o==oOr) {
    if(x) jmpIfFalse = c.allocLabel();
    if(n->o==oOr) {
      int jmpIfTrue = c.allocLabel();
      int elseLabel = c.allocLabel();
      compileVar(0, n->a, elseLabel);
      c.jmp(jmpIfTrue);
      c.label(elseLabel);
      compileVar(0, n->b, jmpIfFalse);
      c.label(jmpIfTrue);
    } else {
      compileVar(0, n->a, jmpIfFalse);
      compileVar(0, n->b, jmpIfFalse);
    }
    if(x) {
      c.mov_reg_imm(EAX, 1);
      int l = c.allocLabel();
      c.jmp(l);
      c.label(jmpIfFalse);
      c.mov_reg_imm(EAX, 0);
      c.label(l);
      accUsed = x;
      x->type = tAcc;
    }
    return;
  }

  // Получаем аргументы оператора
  Var a; compileVar(&a, n->a);
  Var b; compileVar(&b, n->b);

  // Помещаем арументы в EAX, EDX
  if(b.type==tAcc) push(EDX, b);
  push(EAX, a);
  if(b.type!=tAcc) push(EDX, b);

  // Выполняем оператор
  switch(n->o) {
    case oCmp: c.alu_reg_reg(CMP, EAX, EDX); /* Требуется значение */ if(x) c.set(n->cc, EAX); break;
    case oAdd: c.alu_reg_reg(ADD, EAX, EDX); break;
    case oSub: c.alu_reg_reg(SUB, EAX, EDX); break;
    case oDiv: c.idiv_reg(EDX); break;
    case oMul: c.imul_reg(EDX); break;
    default: FatalAppExitA(1, ":)");
  }

  if(x) {
    // Требуется значение
    accUsed = x;
    x->type = tAcc;
  } else {
    // Требуется условие
    c.jcc(n->cc, jmpIfFalse);
  }
}

// Поместить значение в регистр
void push(Reg reg, Var& x, bool freeAcc=false) {
  switch(x.type) {
    case tVar: c.mov_reg_EBX_rel(reg, x.n); break;
    case tImm: c.mov_reg_imm(reg, x.n); break;
    case tAcc: if(reg!=EAX) c.mov_reg_reg(reg, EAX); break;
    case tStack: c.pop_reg(reg); break;
  }
  x.type = tAcc;
  if(freeAcc) accUsed=0;
}

  // Начало цикла
  // for(EBX=data.begin(); EBX!=data.end(); EBX++) {

  c.mov_reg_imm(EBX, (int)data.begin()._Ptr);
  int l0 = c.allocLabel();

  // Компиляция выражения
  p.load("(a > b OR a > 18) AND b > c");
  Var out;
  compileVar(&out, parseVar());
  p.needToken(ttEof);

  // Сохраняем выражение в EBX->resut
  push(EAX, out, true);
  c.mov_EBX_rel_reg(OFFSET(result), EAX);

  // Конец цикла for(EBX=data.begin(); EBX!=data.end(); EBX++)
  c.alu_reg_imm(ADD, EBX, sizeof(item));
  c.alu_reg_imm(CMP, EBX, (int)data.end()._Ptr);
  c.jcc(JNZ, l0);
  c.ret();

  // Запуск
  c.prepare();
  c.execute();

SIMD

Совершеннолетние_клиенты(Имя) :-
  Клиенты(Имя, Возраст),
  Возраст > 18;

% Верно, что НОД (A, 0) = A
gcd2(A, 0, A).
 
% Верно, что НОД(A, B) = G, когда A>0, B>0 и НОД(B, A % B) = G (% - остаток от деления)
gcd2(A, B, G) :- A>0, B>0, N is mod(A, B), gcd2(B, N, G).
 
gcdn(A, [], A).
gcdn(A, [B|Bs], G) :- gcd2(A, B, N), gcdn(N, Bs, G).
gcdn([A|As], G) :- gcdn(A, As, G).

void gcd2(int a, int b, std::function<void(int)> result) {
  // Верно, что НОД (A, 0) = A
  if(b==0) result(a);
  //Верно, что НОД(A, B) = G, когда A>0, B>0 и НОД(B, A % B) = G (% - остаток от деления)
  if(a>0 && b>0) gcd2(b, a % b, result);
}
 
void gcdn(int a, int* bb, int* be, std::function<void(int)> result) {
  if(bb==be) result(a);
        else gcd2(a, *bb, [&](int n) { gcdn(n, bb+1, be, result); });
}

void gcdn(int* xb, int* xe, std::function<void(int)> result) {
  gcdn(*xb, xb+1, xe, result);
}

void test() {
  vector<int> numbers;
  numbers.push_back(36);
  numbers.push_back(6);
  numbers.push_back(10);  
  gcdn(numbers.begin(), numbers.end(), [&](int n) { 
    cout << n;
  });
}

class LambdaToSlot : public QObject {
Q_OBJECT
public:
	std::function<void()> lambda;
	LambdaToSlot(QObject* owner, std::function<void()> _lambda) : QObject(owner), lambda(_lambda) {}
	~LambdaToSlot() {}
public slots:
	void slot() { lambda(); }
};

subMenu->addAction("Открыть "+tableName, new LambdaToSlot(subMenu, [tableName]{
	openList(tableName);
}), SLOT(slot()));

subMenu->addAction("Открыть "+tableName, [tableName]{
	openList(tableName);
});

      int mx,my;
      getCursorPos(mx,my);
      screenToClient(mx,my);
      unsigned char* a = (unsigned char*)dc.backBmp.ptr32;
      if(a==0) return;
      double cy = dc.backBmp.height;
      double cx = dc.backBmp.width;
      for(int y=dc.backBmp.height-1; y>=0; y--)
        for(int x=0; x<dc.backBmp.width; x++) {
          int xx = abs(cx-x-mx)*cy/cx + abs(cy-y-my);
          xx = 16-xx;
          if(xx<0) xx=0;
          for(int n=0; n<3; n++) {
            int v = int(*a) + xx;
            if(v > 255) v = 255;
            *a++ = v; 
          }
          a++;
        }

      int mx,my;
      getCursorPos(mx,my);
      screenToClient(mx,my);
      unsigned char* a = (unsigned char*)dc.backBmp.ptr32;
      if(a==0) return;
      double cy = dc.backBmp.height;
      double cx = dc.backBmp.width;
      for(int y=dc.backBmp.height-1; y>=0; y--)
        for(int x=0; x<dc.backBmp.width; x++) {
          int xx = abs(cx-x-mx)*cy/cx + abs(cy-y-my);
          xx = 16-xx;
          if(xx<0) xx=0;
          for(int n=0; n<3; n++) {
            int v = int(*a) + xx;
            if(v > 255) v = 255;
            *a++ = v; 
          }
          a++;
        }

8AD1h SELF_NAME      Собственное имя файла 256 байт (этот адрес содержится в DE после запуска)
8BD1h CMD_LINE       Командная строка 256 байт (этот адрес содержится в HL после запуска)
8CD1h SD_BIOS_CODE   Код SD BIOS 559 байт (возможно будет расти в начало сдвигая SELF_NAME и CMD_LINE)
8F00h -              Не используется ~233 байта (возможно тут есть переменные монитора)
8FDFh MONITOR_VARS   Переменные монитора
9000h VIDEO_MEM      Видеопамять 

Reboot      Теплая перезагрузка (A=0, HL="", DE="" / A=код ошибки)
Exec        Запустить программу (A=0, HL=имя файла, DE=командная строка  / A=код ошибки)
FindFirst   Начать получение списка файлов (A=1, HL=путь, DE=максимум файлов для загрузки, 
                                                 BC=адрес / HL=сколько загрузили, A=код ошибки)
FindNext    Продолжить получение списка файлов (A=1, HL=":", DE=максимум файлов для загрузки, 
                                                 BC=адрес / HL=сколько загрузили, A=код ошибки)
Open        Открыть файл       (A=2, D=0,   HL=имя файла / A=код ошибки)
Create      Создать файл       (A=2, D=1,   HL=имя файла / A=код ошибки)
MkDir       Создать папку      (A=2, D=2,   HL=имя файла / A=код ошибки)
Delete      Удалить файл/папку (A=2, D=100, HL=имя файла / A=код ошибки)
Seek        Установить позицию чтения записи файла (A=3, B=режим, DE:HL=позиция / A=код ошибки, DE:HL=позиция)
               (С начала B=0, с текущего положения B=1, с конца B=2)
GetSize     Получить размер файла (A=3, B=100 / A=код ошибки, DE:HL= размер файла)
Swap        Работа с двумя открытыми файлами (A=3, B=200 / A=код ошибки)
Read        Прочитать из файла (A=4, HL=размер, DE=адрес / A=код ошибки, HL=сколько загрузили)
Write       Записать в файл (A=5, HL=размер, DE=адрес / A=код ошибки)
WriteEOF    Конец файла (A=5, HL=0 / A=код ошибки)
Move        Переместить файл/папку (A=6, HL=из, DE=в / A=код ошибки)
GetFree     Размер флешки и свободное место на флешке (A=7, HL=буфер / A=код ошибки) 

Код:	

     .org 0h

DATA_PORT       = 0EE00h
ADDR_PORT       = 0EE01h
CTL_PORT        = 0EE03h
SEND_MODE       = 10001011b ; Настройка: 1 0 0 A СH 0 B CL   1=ввод 0=вывод
RECV_MODE       = 10011011b

ERR_START         = 040h
ERR_WAIT          = 041h
ERR_OK_DISK     = 042h
ERR_OK          = 043h
ERR_OK_READ       = 044h
ERR_OK_ENTRY     = 045h
ERR_OK_WRITE     = 046h
ERR_OK_ADDR    = 047h

Entry:
     ; Первым этапом происходит синхронизация с контроллером
     ; 256 попыток. Для этого в регистр C заносится 0

     ; А в стек заносится адрес перезагрузки 0C000h

     LXI   B, 0F800h
     PUSH   B     

     JMP   Boot

     NOP

;----------------------------------------------------------------------------
; Отправка и прием байта

Rst1:
     INX   H      ; HL = ADDR_PORT
     MVI   M, 86
     MVI   M, 87
     DCX   H      ; HL = DATA_PORT
     MOV   A, M
     RET

;----------------------------------------------------------------------------
; Ожидание готовности МК

Rst2:
WaitForReady:
     Rst   1
     CPI   ERR_WAIT
     JZ      WaitForReady
     RET

;----------------------------------------------------------------------------

RetrySync:
     ; Попытки
     DCR C
     RZ            ; Ошибка синхронизации, перезагрузка

Boot:
     ; Режим передачи (освобождаем шину) и инициализируем HL
     MVI   A, RECV_MODE
     CALL SetMode

     ; Начало любой команды
     MVI   M, 19
     MVI   M, 23
     MVI   M, 87

     ; Если есть синхронизация, то контроллер ответит ERR_START
     Rst   1         
     CPI   ERR_START
     JNZ   RetrySync

     ; Дальше будет ERR_OK_WAIT, ERR_OK_NEXT
     ; Инициализация флешки
     Rst   2
     CPI   ERR_OK_ADDR
     JNZ   Rst1      ; Ошибка, освобождаем шину и перезагрузка

     ; ERR_OK_NEXT высталенный МК будет висеть на шине до следующего RST,
     ; только после него МК освободит шину и мы сможем включить режим передачи.
     Rst   1     

     ; Режим передачи     
     MVI   A, SEND_MODE
     CALL SetMode

     ; Код команды
       XRA   A
     Rst   1

     ; МК читает данные во время тактового импульса, т.е. он уже их прочитал.
     ; Включаем режим приема, т.е. освобождаем шину.

     ; Режим приема
     MVI   A, RECV_MODE
     CALL SetMode

     ; МК захватит шину во время тактового импульса (первого RST)

     ; Дальше будет ERR_OK_WAIT, ERR_OK_RKS
     Rst   2
     CPI   ERR_OK_RKS
     JNZ   Rst1      ; Ошибка, освобождаем шину и перезагрузка
     
     ; Удаляем из стека 0F800h
     POP   B

     ; Адрес загрузки в BC
     Rst   1
     MOV   C, A
     Rst   1
     MOV   B, A

     ; Сохраняем в стек адрес запуска
     PUSH   B

     ; Подождать, пока МК прочитает очередной блок денных
RecvLoop:
     Rst   2
     CPI   ERR_OK_READ
     JZ      Rst1      ; Всё загружено, освобождаем шину и запуск
     ORA   A
     JNZ   0F800h   ; Ошибка, перезагрузка (не отпускаем контроллер)

     ; Принять очередной блок
     Rst   1
     MOV   E, A
     Rst   1
     MOV   D, A
RecvBlock:
     Rst   1
     STAX   B
     INX   B
     DCX   D
     MOV   A, E
     ORA   D
     JNZ   RecvBlock
     JMP   RecvLoop

      ; Прием/передача
SetMode:
     LXI   H, CTL_PORT
     MOV   M, A
     DCX   H
     DCX   H      ; HL = ADDR_PORT
     RET
.End

О чем я вообще?

Раскрасил командер

Ядро (DOS.SYS)

Представляет собой набор подпрограмм по адресу C800h. Это подпрограммы обслуживания
экрана, принтера, клавиатуры и накопителя на магнитой ленте и файловой системы.

Зеленым отмечены функции соврапающие со стандратным Специалистом. Но галвная проблема
невосместимости - Аппаратная. Адрес порта клавиатуры у MX изменен.

Стандартные служебные ячейки

Карта памяти

Формат файловой системы FAT8

6 байт - имя файла
3 байта - расширение файла
1 байт - атрибуты файла
2 байт - адрес загрузки файла
2 байт - длина файла - 1
1 байт - ?
1 байт - первый кластер файла

И еще хвала TASM :)

#define G_WINDOW(X,Y,W,H) .db 2, Y, 90h+(X>>3), H-6, (W>>3)-2
#define G_HLINE(X,Y,W) .db 1, Y, 90h+(X>>3), (((X&7)+W+7)>>3)-2, 0FFh>>(X&7), (0FF00h>>((W+X)&7)) & 0FFh
#define G_VLINE(X,Y,H) .db 3, Y, 90h+(X>>3), H, 80h>>(X&7)

g_filePanel:	G_WINDOW(0, 0, 192, 230)	; было 2, 0, 90h, 0E0h, 16h
		G_HLINE(4, 208, 184)		; было 1, 0D0h, 90h, 16h, 0Fh, 0F0h
		G_VLINE(96, 3, 205)		; было 3, ?, 9Ch, 0CDh, 80h
		.db 0

g_infoPanel:	G_WINDOW(0, 0, 192, 230)	; было 2, 0, 90h, 0E0h, 16h
		G_HLINE(4, 31, 184)		; было 1, 1Fh, 90h, 16h, 0Fh, 0F0h

void bitBlt(uchar* d => de, uchar* s => hl, uint wh => bc) {
  asm {
bitBlt_l1:
    push d
    push b                        
bitBlt_l2:
    mov b, m   ; Читаем байт цвета
    inx h
    mvi a, 1   ; Дополнительное ОЗУ
    sta 0F900H
    mov a, b   ; Записываем байт цвета
    stax d
    xra a      ; Основное ОЗУ
    sta 0F900H
    mov a, m   ; Читаем байт пикселей
    inx h
    stax d     ; Записывает байт пикселей
    inx d      
    dcr c      ; Цикл по ширине
    jnz bitBlt_l2
    pop b
    pop d    
    inr d      ; Цикл по высоте
    dcr b
    jnz bitBlt_l1
  }
}