Вы регистрируетесь на нашем сервисе в 2 клика.
Идет прямое подключение к нейросети Openai без ограничений из России.
Вы получаете 1000 токенов бесплатно при регистрации. 

У тебя есть API?
 

Как виртуальный помощник я не предоставляю API сам по себе. Однако могу помочь объяснить, как использовать API, которые предоставляет компания OpenAI. Если у вас есть конкретные вопросы об использовании API OpenAI или другой информации, буду рад помочь! 

Консультации
Пообщаться с «Искусственным интеллектом» можете ЗДЕСЬ.
Ответы на часто задаваемые вопросы (FAQ) вы можете найти здесь )
 

We query proprietary models using the OpenAI Python library,
and open-source ones with the EasyLLM Python library
to simplify querying them through the HuggingFace Inference API. 

Мне нужна твоя помощь в решению задач на C-MPA это язык основанный на языке C, но в нем есть некоторые отличия.
Ввод глобальных переменных происходит подобным образом: 
“unsigned __out __bits(16) R;” или “unsigned __in __bits(16) x;” и т.д.
локальные переменные задаются : 
“unsigned __bits(16) R;”

По вычислению выражения я приведу примеры, как выполнять задания:

Вычислить выражение:
     / a/b+c-d*a  , если   a*d<0
RES=< 
     \ b-(c+a/d)*b, если   a*d>=0
   
   где a,b,RES размером два байта,
       c,d - байт

Примеры:

  a= 8        a=10        
  b= 3        b= 7       
  c= 5        c=-9       
  d=-2        d= 3        

  RES=23      RES=49


Вот код полностью работающей программы для решения этой задачи:

int __in __bits(16) a;
int __in __bits(16) b;
int __in __bits(8) c;
int __in __bits(8) d;

int __out __bits(16) RES;

//	{ a/b + c - d*a, a*d < 0
//RES = { b - (c + a/d) * b	, a*d >= 0

#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)

u16 CBW      (u8  A) {return A;}
u32 CWD      (u16 A) {return A;}
i16 x32Tox16 (i32 A) {return A;}
i8  x16Tox8  (i16 A) {return A;}
i16 CONST    (i16 A) {return A;}

i16 SUM      (i16 A, i16 B) {i16 C; C = A + B; return C;}
i16 ISUB     (i16 A, i16 B) {i16 C; C = A - B; return C;}
i32 IMUL     (i16 A, i16 B) {i32 C; C = A * B; return C;}
i16 IDIV     (i32 A, i32 B) {i16 C; C = A / B; return C;}

u16 MSb16x2(u16 Zero, u16 One, u1 A) {return (A) ? One : Zero;}
u3 ICMP(i32 A, i32 B) {return (A > B) ? 4 : (A == B) ? 2 : 1;}
u1 IGT;
u1 IEQ;
u1 ILT;
void ICMPResult(i32 A, i32 B) {u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1;}

void main(){
	 i16 c16		= CBW(c);
	 i16 d16		= CBW(d);
	 i32 c32		= CWD(c16);
	 i32 d32		= CWD(d16);
	 i32 a32		= CWD(a);
	 i32 b32		= CWD(b);

	 i16 div1		= IDIV(a32, b);
	 i32 mult1		= IMUL(d16, a);
	 i16 mult1x16		= x32Tox16(mult1);
	 i16 sum1		= SUM(div1, c16);
	 i16 sub1		= ISUB(sum1, mult1x16);
	 i16 res1		= sub1;

	 i16 div2		= IDIV(a32, d16);
	 i16 sum2		= SUM(c16, div2);
	 i32 mult2		= IMUL(sum2, b);
	 i16 mult2x16		= x32Tox16(mult2);
	 i16 sub2		= ISUB(b, mult2x16);
	 i16 res2		= sub2;

	 i32 pr			= IMUL(a, d16);
	 u32 zero		= CONST(0);
	 ICMPResult(pr, zero);
	 RES 			= MSb16x2(res2, res1, ILT);
}

В самом начале программы в обязательном порядке необходимо записывать все глобальные переменные, 
причём использовать типы без сокращений, т.е. #define необходимо использовать только после объявления глобальных переменных.

Заметь, что для сокращения записи типа данных в объявлении переменной я использую #define, 
в самом конце указываю число в скобках __bits(n), где n - количество выделенных бит, запомни следующее объявление типов переменных: 
#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(16)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)

При решении задач обязательно используй данные сокращения, только ты можешь либо расширять, 
либо сужать данный перечень всех типов, т.е. ты можешь убирать некоторые типы, которые не используются в алгоритме решения задачи, 
добавлять их, изменять, если решение задачи требует другого количества бит в переменных.


Далее в программе используется библиотека с ограниченным количеством функции, при решении задачи можно использовать только их, 
использование встроенных в C функций, операторов и др. запрещено, разрешен вызов функции типа void, либо объявление локальных переменных с присваиванием значения,
которое было получено при выполнении какой-либо из вышеперечисленных функций, в решении данной задачи используется лишь часть из библиотеки, 
поэтому запомни пока что их и используй при решении задач.

Объяснение работы некоторых функций из данной библиотеки:

u16 MSb16x2(u16 Zero, u16 One, u1 A) {return (A) ? One : Zero;}
u3 ICMP(i32 A, i32 B) {return (A > B) ? 4 : (A == B) ? 2 : 1;}
u1 IGT;
u1 IEQ;
u1 ILT;
void ICMPResult(i32 A, i32 B) {u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1;}
- Данные функции используются вместо if else, пример её использования выше в решении моей задачи, 
если кратко, то мы сравниваем 2 числа, для определения в какую из 2-ух возможных веток зайдет функция (например a * d < 0 или a * d >= 0),
где первое число A - это левое значение неравенства, а B - это правое значение неравенства. 
После, заносим в глобальные переменные-флаги итог вычисления ICMP.
До этого мы вычисляем две ветки функции, чтобы подставить в глобальную переменную для вывода результата работы необходимое значение,
исходя из некоторой булевой переменной-флага. В решении моей задачи я использовал флаг ILT, который позволил мне определить, 
результат какой из двух веток(res1 или res2) функции мне необходимо вернуть в глобальную переменную __out типа.

Реши задачу:
{условие задачи}

Мне нужна твоя помощь в решению задач на C-MPA это язык основанный на языке C, но в нем есть некоторые отличия.
Ввод глобальных переменных происходит подобным образом: 
“unsigned __out __bits(16) R;” или “unsigned __in __bits(16) x;” и т.д.
локальные переменные задаются : 
“unsigned __bits(16) R;”

библиотека всех функций С-МПА, разрешено использовать только их, нельзя удалять их из программы, даже если некоторые из них не используются в решении задачи:

#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)
#define u64 unsigned __bits(64)
#define u4  unsigned __bits(4)

i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }
u64 FACT     (u4 A)              { u64 RES = 1; while (A > 1) RES *= A--; return RES; }

u1  NOT      (u1  A)             { return ~A; }
u1  OR2      (u1  A, u1  B)      { return A | B; }
u1  XOR2     (u1  A, u1  B)      { return A ^ B; }
u1  AND2     (u1  A, u1  B)      { return A & B; }

u8  DC       (u1  CS, u3  X)     { u8 d = 1; return (CS == 0) ? 0 : d << X; }
u4  CD       (u8  X)             { if (X == 0) return 0; u4 i = 0; while (!(X & 1)) { i++; X = X >> 1; } return (i << 1) + 1; }
u1  MS       (u8  X, u3  A)      { return ((X >> A) & 1); }

u16 CBW      (u8  A) {return A;}
u32 CWD      (u16 A) {return A;}
i16 CONST    (i16 A) {return A;}

i16 x32Tox16 (i32 A) {return A;}
i8  x16Tox8  (i16 A) {return A;}


i16 SUM      (i16 A, i16 B) {i16 C; C = A + B; return C;}
i16 ISUB     (i16 A, i16 B) {i16 C; C = A - B; return C;}
i32 IMUL     (i16 A, i16 B) {i32 C; C = A * B; return C;}
i16 IDIV     (i32 A, i32 B) {i16 C; C = A / B; return C;}

u16 MSb16x2(u16 Zero, u16 One, u1 A) {return (A) ? One : Zero;}
u3 ICMP(i32 A, i32 B) {return (A > B) ? 4 : (A == B) ? 2 : 1;}
u1 IGT;
u1 IEQ;
u1 ILT;
void ICMPResult(i32 A, i32 B) {u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1;}

По вычислению выражения я приведу примеры, как выполнять задания:
Вычислить выражение:
     / (a/b)/c+(d*c-d/b)*a,       если b>0 или c>0
RES=<
     \ ((a*b+c)*d-(a*d+b)*c)/b,   если b<0 и c<=0   

    где a,b,RES размером два байта
        c,d - байт 
Примеры:
  a=1        a=-1        
  b=1        b=-1       
  c=1        c=-1       
  d=1        d=-1        

  RES=1      RES=0

Вот код полностью работающей программы для решения этой задачи:

int __in __bits(16) a;
int __in __bits(16) b;
int __in __bits(8) c;
int __in __bits(8) d;

int __out __bits(16) RES;

//RES= (a/b)/c+(d*c-d/b)*a, b>0 || c>0
//RES= (a*b+c)*d-((a*d+b)*c)/b, b<0 && c<=0

#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)

u16 CBW      (u8  A) {return A;}
u32 CWD      (u16 A) {return A;}
i16 x32Tox16 (i32 A) {return A;}
i8  x16Tox8  (i16 A) {return A;}
i16 CONST    (i16 A) {return A;}

u1 IGT;
u1 IEQ;
u1 ILT;

i16 SUM      (i16 A, i16 B) {i16 C; C = A + B; return C;}
i16 ISUB     (i16 A, i16 B) {i16 C; C = A - B; return C;}
i32 IMUL     (i16 A, i16 B) {i32 C; C = A * B; return C;}
i16 IDIV     (i32 A, i32 B) {i16 C; C = A / B; return C;}
u16 MSb16x2   (u16 Zero, u16 One, u1 A) {return (A) ? One : Zero;}
u3 ICMP     (i32 A, i32 B) {return (A > B) ? 4 : (A == B) ? 2 : 1;}
void ICMPResult(i32 A, i32 B) {u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1;}
u1 AND2(u1 A, u1 B) {return A & B;}
u1 OR2(u1 A, u1 B) {return A | B;}

void main(){
  i32 a32    = CWD(a);
  i32 b32    = CWD(b);
  i16 c16    = CBW(c);
  i32 c32    = CWD(c16);
  i16 d16    = CBW(d);
  i32 d32    = CWD(d16);

  i16 adb    = IDIV(a32,b32);
  i32  adb32  = CWD(adb);
  i16  div1  = IDIV(adb32,c32);
  i32 dmc    = IMUL(d16,c16);
  i16 dmc16  = x32Tox16(dmc);
  i16 ddb    = IDIV(d32,b32);
  i16 sub1  = ISUB(dmc16,ddb);
  i32 mul2   = IMUL(sub1,a);
  i16  mul2_16  = x32Tox16(mul2);
  i16 res1  = SUM(div1,mul2_16);

  i32 amb    = IMUL(a,b);
  i16 amb16  = x32Tox16(amb);
  i16 sum1  = SUM(amb16,c16);
  i32  sub2  = IMUL(sum1,d16);
  i32 amd   = IMUL(a,d16);
  i16 amd16  = x32Tox16(amd);
  i16 sum3  = SUM(amd16,b);
  i32  mul3  = IMUL(sum3,c16);
  i32 isub32  = ISUB(sub2,mul3);
  i16 res2    = IDIV(isub32,b32);

  i16 zero16  = CONST(0);
  i32 zero32  = CWD(zero16);
  ICMPResult(b32,zero32);
  u1 cond1  = IGT;
  ICMPResult(c32,zero32);
  u1 cond2  = IGT;
  u1 cond   = OR2(cond1,cond2);
  RES      = MSb16x2(res2,res1,cond);
}

Таким образом ты можешь писать более сложные случаи "if" для захода в нужную ветку функции

//функции, которые меняют размерности, при умножении и делении они меняются, тебе нужно это учитывать поэтому используй после этих операций эти функции (обязательно!).
i16 x32Tox16 (i32 A) {return A;} 
i8  x16Tox8  (i16 A) {return A;}

Реши задачу:
{условие задачи}

// Объявление входных и выходных переменных
int __in __bits(16) x;
int __in __bits(16) y;
int __in __bits(8) a;
int __in __bits(8) c;
int __out __bits(16) RES;

// Определение типов с помощью макросов
#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)
#define u64 unsigned __bits(64)
#define u4  unsigned __bits(4)

// Библиотека функций C-MPA
i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }
u64 FACT     (u4 A)              { u64 RES = 1; while (A > 1) RES *= A--; return RES; }

u1  NOT      (u1  A)             { return ~A; }
u1  OR2      (u1  A, u1  B)      { return A | B; }
u1  XOR2     (u1  A, u1  B)      { return A ^ B; }
u1  AND2     (u1  A, u1  B)      { return A & B; }

u8  DC       (u1  CS, u3  X)     { u8 d = 1; return (CS == 0) ? 0 : d << X; }
u4  CD       (u8  X)             { if (X == 0) return 0; u4 i = 0; while (!(X & 1)) { i++; X = X >> 1; } return (i << 1) + 1; }
u1  MS       (u8  X, u3  A)      { return ((X >> A) & 1); }

u16 CBW      (u8  A) { return A; }
u32 CWD      (u16 A) { return A; }
i16 CONST    (i16 A) { return A; }

i16 x32Tox16 (i32 A) { return A; }
i8  x16Tox8  (i16 A) { return A; }

i16 SUM      (i16 A, i16 B) { i16 C; C = A + B; return C; }
i16 ISUB     (i16 A, i16 B) { i16 C; C = A - B; return C; }
i32 IMUL     (i16 A, i16 B) { i32 C; C = A * B; return C; }
i16 IDIV     (i32 A, i32 B) { i16 C; C = A / B; return C; }

u16 MSb16x2  (u16 Zero, u16 One, u1 A) { return (A) ? One : Zero; }
u3  ICMP     (i32 A, i32 B) { return (A > B) ? 4 : (A == B) ? 2 : 1; }
u1  IGT;
u1  IEQ;
u1  ILT;
void ICMPResult(i32 A, i32 B) { u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1; }

// Основной код программы
void main() {
    // Приведение переменных к необходимым типам
    i32 x32 = CWD(x);
    i32 y32 = CWD(y);
    i16 a16 = CBW(a);
    i16 c16 = CBW(c);
    i32 c16_32 = CWD(c16);
    i32 a16_32 = CWD(a16);

    // Ветка 1: ((x + y) / c - x) * a, если x * y < 0
    i16 sum_xy = SUM(x, y);                  // x + y
    i32 sum_xy_32 = CWD(sum_xy);             // Приведение к 32 битам
    i16 div_xy_c = IDIV(sum_xy_32, c16_32);  // (x + y) / c
    i16 term1 = ISUB(div_xy_c, x);           // (x + y) / c - x
    i32 term1_32 = CWD(term1);               // Приведение к 32 битам
    i32 term1_a = IMUL(term1_32, a16_32);    // ((x + y) / c - x) * a
    i16 res1 = x32Tox16(term1_a);            // Приведение результата

    // Ветка 2: ((a - x * y) * c) / y + x * y, если x * y >= 0
    i32 xy_mul = IMUL(x, y);                 // x * y
    i16 xy_mul_16 = x32Tox16(xy_mul);        // Приведение к 16 битам
    i16 diff_a_xy = ISUB(a16, xy_mul_16);    // a - x * y
    i32 diff_a_xy_32 = CWD(diff_a_xy);       // Приведение результата к 32 битам
    i32 diff_a_xy_c = IMUL(diff_a_xy_32, c16_32);  // (a - x * y) * c
    i16 diff_a_xy_c_div_y = IDIV(diff_a_xy_c, y32); // ((a - x * y) * c) / y
    i16 res2 = SUM(diff_a_xy_c_div_y, xy_mul_16);  // Вторая ветка

    // Условие: x * y < 0
    i16 zero = CONST(0);
    ICMPResult(xy_mul, zero);                // Сравнение x * y с нулем
    u1 isNegative = ILT;                     // Проверка условия x * y < 0

    // Выбор результата на основе условия
    RES = MSb16x2(res2, res1, isNegative);   // Если x * y < 0, выбираем res1, иначе res2
}

int __in __bits(16) a;
int __in __bits(16) b;
int __in __bits(8) c;
int __in __bits(8) d;
int __out __bits(16) RES;

#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)
#define u64 unsigned __bits(64)
#define u4  unsigned __bits(4)

i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }
u64 FACT     (u4 A)              { u64 RES = 1; while (A > 1) RES *= A--; return RES; }

u1  NOT      (u1  A)             { return ~A; }
u1  OR2      (u1  A, u1  B)      { return A | B; }
u1  XOR2     (u1  A, u1  B)      { return A ^ B; }
u1  AND2     (u1  A, u1  B)      { return A & B; }

u8  DC       (u1  CS, u3  X)     { u8 d = 1; return (CS == 0) ? 0 : d << X; }
u4  CD       (u8  X)             { if (X == 0) return 0; u4 i = 0; while (!(X & 1)) { i++; X = X >> 1; } return (i << 1) + 1; }
u1  MS       (u8  X, u3  A)      { return ((X >> A) & 1); }

i16 CBW      (i8  A) {return A;}
i32 CWD      (i16 A) {return A;}
i16 x32Tox16 (i32 A) {return A;}
i8  x16Tox8  (i16 A) {return A;}
i16 CONST    (i16 A) {return A;}
u4 CONST4    (u4 A) {return A;}

i16 SUM      (i16 A, i16 B) {i16 C; C = A + B; return C;}
i16 ISUB     (i16 A, i16 B) {i16 C; C = A - B; return C;}
i32 IMUL     (i16 A, i16 B) {i32 C; C = A * B; return C;}
i16 IDIV     (i32 A, i32 B) {i16 C; C = A / B; return C;}

u16 MSb16x2(u16 Zero, u16 One, u1 A) {return (A) ? One : Zero;}
u3 ICMP(i32 A, i32 B) {return (A > B) ? 4 : (A == B) ? 2 : 1;}
u1 IGT;
u1 IEQ;
u1 ILT;
void ICMPResult(i32 A, i32 B) {u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1;}

void main() {
    // Преобразование и приведение переменных
    i32 a32 = CWD(a);
    i32 b32 = CWD(b);
    i16 c16 = CBW(c);
    i16 d16 = CBW(d);
    i32 c32 = CWD(c16);
    i32 d32 = CWD(d16);

    i16 zero = CONST(0);
    i32 zero_32 = CWD(zero);

    // Ветка 1: |(a - b) / c| + d * c, если d > 0
    i16 diff_ab = ISUB(a, b);                 // a - b
    i16 abs_diff_ab = ABS(diff_ab);           // |a - b|
    i32 abs_diff_ab_32 = CWD(abs_diff_ab);
    i16 abs_ab_div_c = IDIV(abs_diff_ab_32, c32); // |(a - b) / c|
    i32 d_c_mul_32 = IMUL(d16, c16);          // d * c
    i16 d_c_mul_16 = x32Tox16(d_c_mul_32);
    i16 res1 = SUM(abs_ab_div_c, d_c_mul_16); // res1 = |(a - b) / c| + d * c

    // Ветка 2: |(|a| - |b|)| * d / c + sign(a * b * c * d), если d <= 0
    i16 abs_a = ABS(a);                       // |a|
    i16 abs_b = ABS(b);                       // |b|
    i16 abs_diff_ab2 = ISUB(abs_a, abs_b);    // |a| - |b|
    i16 abs_abs_diff_ab2 = ABS(abs_diff_ab2); // |(|a| - |b|)|
    i32 abs_abs_diff_ab2_32 = CWD(abs_abs_diff_ab2);
    i32 d_abs_diff_ab2_32 = IMUL(abs_abs_diff_ab2, d16); // |(|a| - |b|)| * d
    i16 term2 = IDIV(d_abs_diff_ab2_32, c32); // (|(|a| - |b|)| * d) / c

    // Вычисление знака произведения a * b * c * d
    i32 ab_mul_32 = IMUL(a, b);               // a * b
    i16 ab_mul_16 = x32Tox16(ab_mul_32);
    i32 abc_mul_32 = IMUL(ab_mul_16, c16);    // a * b * c
    i16 abc_mul_16 = x32Tox16(abc_mul_32);
    i32 abcd_mul_32 = IMUL(abc_mul_16, d16);  // a * b * c * d
    i16 abcd_mul_16 = x32Tox16(abcd_mul_32);  // Приведение abcd к 16 бит
    i16 sign_term = SIGN(abcd_mul_16);        // sign(a * b * c * d)
    i16 res2 = SUM(term2, sign_term);         // res2 = |(|a| - |b|)| * d / c + sign(a * b * c * d)

    // Проверка условия d > 0
    ICMPResult(d32, zero_32);
    u1 isPositive = IGT;

    // Выбор значения для RES в зависимости от условия
    RES = MSb16x2(res2, res1, isPositive);
}

int __in __bits(16) X;
int __in __bits(16) Y;
int __in __bits(8) A9;
int __in __bits(8) B7;
int __out __bits(16) RES;

#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)
#define u64 unsigned __bits(64)
#define u4  unsigned __bits(4)

i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }
u64 FACT     (u4 A)              { u64 RES = 1; while (A > 1) RES *= A--; return RES; }

u1  NOT      (u1  A)             { return ~A; }
u1  OR2      (u1  A, u1  B)      { return A | B; }
u1  XOR2     (u1  A, u1  B)      { return A ^ B; }
u1  AND2     (u1  A, u1  B)      { return A & B; }

u8  DC       (u1  CS, u3  X)     { u8 d = 1; return (CS == 0) ? 0 : d << X; }
u4  CD       (u8  X)             { if (X == 0) return 0; u4 i = 0; while (!(X & 1)) { i++; X = X >> 1; } return (i << 1) + 1; }
u1  MS       (u8  X, u3  A)      { return ((X >> A) & 1); }

u16 CBW      (u8  A)             { return A; }
u32 CWD      (u16 A)             { return A; }
i16 x32Tox16 (i32 A)             { return A; }
i8  x16Tox8  (i16 A)             { return A; }
i16 CONST    (i16 A)             { return A; }

i16 SUM      (i16 A, i16 B)      { i16 C; C = A + B; return C; }
i16 ISUB     (i16 A, i16 B)      { i16 C; C = A - B; return C; }
i32 IMUL     (i16 A, i16 B)      { i32 C; C = A * B; return C; }
i16 IDIV     (i32 A, i32 B)      { i16 C; C = A / B; return C; }

u16 MSb16x2  (u16 Zero, u16 One, u1 A) { return (A) ? One : Zero; }
u3 ICMP      (i32 A, i32 B)      { return (A > B) ? 4 : (A == B) ? 2 : 1; }
u1 IGT;
u1 IEQ;
u1 ILT;
void ICMPResult(i32 A, i32 B) { u3 C = ICMP(A, B); IGT = C == 4; IEQ = C == 2; ILT = C == 1; }

void main() {
    i32 X32 = CWD(X);
    i32 Y32 = CWD(Y);
    i16 A9_16 = CBW(A9);
    i16 B7_16 = CBW(B7);
    i32 A9_32 = CWD(A9_16);
    i32 B7_32 = CWD(B7_16);

    i32 XY_mul = IMUL(X, Y);              // X * Y
    i16 Y_X_sub = ISUB(Y, X);             // Y - X
    i16 Y_X_A9_sum = SUM(Y_X_sub, A9_16); // Y - X + A9
    i32 Y_B7_mul = IMUL(Y, B7_16);        // B7 * Y
	i16	Y_B7_mul_16 = x32Tox16(Y_B7_mul);
    i16 Y_X_A9_B7_sub = ISUB(Y_X_A9_sum, Y_B7_mul_16); // (Y - X + A9) - B7 * Y
    i32 Y_X_A9_B7_sub_32 = CWD(Y_X_A9_B7_sub);
    i16 res1 = IDIV(Y_X_A9_B7_sub_32, X32); // res1 = (Y - X + A9 - B7 * Y) / X

    i16 Y_X_sum = SUM(Y, X);             // Y + X
    i32 Y_X_A9_mul = IMUL(Y_X_sum, A9_16); // (Y + X) * A9
    i16 Y_X_A9_div_B7 = IDIV(Y_X_A9_mul, B7_32); // (Y + X) * A9 / B7
    i16 res2 = ISUB(Y_X_A9_div_B7, Y);    // res2 = (Y + X) * A9 / B7 - Y

    i16 zero16 = CONST(0);
    i32 zero32 = CWD(zero16);
    ICMPResult(XY_mul, zero32);
    u1 isNonNegative = OR2(IGT, IEQ);      // X * Y >= 0

    RES = MSb16x2(res2, res1, isNonNegative);
}

int __in __bits(16) a;
int __in __bits(16) b;
int __in __bits(8) c;
int __in __bits(8) d;
int __out __bits(16) RES;

#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)

u16 CBW      (u8  A) {return A;}
u32 CWD      (u16 A) {return A;}
i16 x32Tox16 (i32 A) {return A;}
i8  x16Tox8  (i16 A) {return A;}
i16 CONST    (i16 A) {return A;}

u1 IGT;
u1 IEQ;
u1 ILT;

i16 SUM      (i16 A, i16 B) {i16 C; C = A + B; return C;}
i16 ISUB     (i16 A, i16 B) {i16 C; C = A - B; return C;}
i32 IMUL     (i16 A, i16 B) {i32 C; C = A * B; return C;}
i16 IDIV     (i32 A, i32 B) {i16 C; C = A / B; return C;}
u16 MSb16x2  (u16 Zero, u16 One, u1 A) {return (A) ? One : Zero;}
u3 ICMP     (i32 A, i32 B) {return (A > B) ? 4 : (A == B) ? 2 : 1;}
void ICMPResult(i32 A, i32 B) {u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1;}
u1 AND2(u1 A, u1 B) {return A & B;}
u1 OR2(u1 A, u1 B) {return A | B;}

void main() {
    i16 a16 = a;
    i16 b16 = b;
    i16 c16 = CBW(c);
    i16 d16 = CBW(d);
	i32 a32 = CWD(a16);
    i32 b32 = CWD(b16);
    i32 c32 = CWD(c16);
    i32 d32 = CWD(d16);

    i32 a2_32 = IMUL(a16, a16);
    i16 a2_16 = x32Tox16(a2_32);
    i32 a3_32 = IMUL(a16, a2_16);
    i16 a3_16 = x32Tox16(a3_32);

    i32 b2_32 = IMUL(b16, b16);
    i16 b2_16 = x32Tox16(b2_32);

    i32 c2_32 = IMUL(c16, c16);
    i16 c2_16 = x32Tox16(c2_32);
    i32 c3_32 = IMUL(c16, c2_16);
    i16 c3_16 = x32Tox16(c3_32);

	i32 d2_32 = IMUL(d16, d16);
    i16 d2_16 = x32Tox16(d2_32);
	i32 d3_32 = IMUL(d2_16, d16);
    i16 d3_16 = x32Tox16(d3_32);

    i32 term1_32 = IMUL(a16, b2_16);
    i16 term1_16 = x32Tox16(term1_32);
    i32 term1_32_final = IMUL(term1_16, c3_16);
    i16 term1_final = x32Tox16(term1_32_final);

    i32 term2_32 = IMUL(b16, c2_16);
    i16 term2_16 = x32Tox16(term2_32);
    i32 term2_32_final = IMUL(term2_16, d3_16);
    i16 term2_final = x32Tox16(term2_32_final);

	i16 term12_final = SUM(term1_final, term2_final);

    i16 term3_16 = IDIV(a3_16, b2_16);
	i32 term3_32 = CWD(term3_16);
	i16 term3_final = IDIV(term3_32, c16);

	i16 res1 = ISUB(term12_final, term3_final);

	i16 sum1 = SUM(a16, b16);
	i32 mult1_32 = IMUL(c16, d16);
	i16 mult1_16 = x32Tox16(mult1_32);
	i16 sum2 = SUM(sum1, mult1_16);
	i32 sum2_32 = CWD(sum2);

    i16 sub1 = ISUB(a16, b16);
	i16 sub2 = ISUB(sub1, mult1_16);
	i16	res2 = IDIV(sum2_32, sub2);

    i16 two = CONST(-2);
	i16 five = CONST(5);

    ICMPResult(two, a16);
    u1 inRange1 = ILT;
	ICMPResult(a16, five);
	u1 inRange2 = ILT;
	u1 inRange = AND2(inRange1, inRange2);

    RES = MSb16x2(res2, res1, inRange);
}