// Объявление входных и выходных переменных
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)

// Библиотека функций 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 A916 = CBW(A9);
    i16 B716 = CBW(B7);
    i32 A932 = CWD(A916);
    i32 B732 = CWD(B716);

    // Первая ветка: ((A9 + X * B7) - Y) / X
    i32 XB7_mul = IMUL(X, B716);         // X * B7
    i16 XB7_mul_16 = x32Tox16(XB7_mul); // Приведение к i16
    i16 sum1 = SUM(A916, XB7_mul_16);   // A9 + X * B7
    i16 diff1 = ISUB(sum1, Y);          // (A9 + X * B7) - Y
    i32 diff1_32 = CWD(diff1);          // Приведение к i32
    i16 res1 = IDIV(diff1_32, X32);     // ((A9 + X * B7) - Y) / X

    // Вторая ветка: (B7 - Y * X) / A9 + Y
    i32 YX_mul = IMUL(Y, X);            // Y * X
    i16 YX_mul_16 = x32Tox16(YX_mul);  // Приведение к i16
    i16 diff2 = ISUB(B716, YX_mul_16); // B7 - Y * X
    i32 diff2_32 = CWD(diff2);          // Приведение к i32
    i16 div2 = IDIV(diff2_32, A932);    // (B7 - Y * X) / A9
    i16 res2 = SUM(div2, Y);            // (B7 - Y * X) / A9 + Y

    // Проверка условия X * Y >= 0
    i32 XY_mul = IMUL(X, Y);            // X * Y
    i16 zero = CONST(0);
    i32 zero_32 = CWD(zero);

    ICMPResult(XY_mul, zero_32);
    u1 cond = OR2(IEQ, IGT);            // X * Y >= 0

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

int __in __bits(16) x;
int __in __bits(16) y;
int __in __bits(8) a;
int __in __bits(8) b;
int __out __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)

i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }
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; }

u16 CBW      (u8  A) {return A;}
u32 CWD      (u16 A) {return A;}
i16 CONST    (i16 A) {return A;}
i16 x32Tox16 (i32 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 a16 = CBW(a);
    i16 b16 = CBW(b);
    i32 x32 = CWD(x);
    i32 y32 = CWD(y);
    i16 x16 = x32Tox16(x32);
    i16 y16 = x32Tox16(y32);

    // Промежуточные вычисления для res1
    i16 a_minus_b = ISUB(a16, b16);               // a - b
    i32 a_minus_b_32 = CWD(a_minus_b);
    i32 a_minus_b_x32 = IMUL(a_minus_b, x16);    // (a - b) * x
    i16 a_minus_b_x16 = x32Tox16(a_minus_b_x32);

    i16 a_plus_b = SUM(a16, b16);                // a + b
    i32 a_plus_b_32 = CWD(a_plus_b);
    i16 a_plus_b_div_y = IDIV(a_plus_b_32, y32); // (a + b) / y

    i16 res1 = SUM(a_minus_b_x16, a_plus_b_div_y); // res1 = (a - b) * x + (a + b) / y

    // Промежуточные вычисления для res2
    i16 x_minus_y = ISUB(x16, y16);               // x - y
    i32 x_minus_y_32 = CWD(x_minus_y);
    i32 x_minus_y_a32 = IMUL(x_minus_y, a16);    // (x - y) * a
    i16 x_minus_y_a16 = x32Tox16(x_minus_y_a32);

    i16 x_plus_y = SUM(x16, y16);                // x + y
    i32 x_plus_y_32 = CWD(x_plus_y);
    i16 x_plus_y_div_b = IDIV(x_plus_y_32, b16); // (x + y) / b

    i16 res2 = SUM(x_minus_y_a16, x_plus_y_div_b); // res2 = (x - y) * a + (x + y) / b

    // Условие для выбора результата
    i32 a_mul_b32 = IMUL(a16, b16);              // a * b
    i16 zero16 = CONST(0);
    i32 zero32 = CWD(zero16);
    ICMPResult(a_mul_b32, zero32);
    u1 cond = IEQ;                               // cond = (a * b == 0)

    // Выбор результата
    R = MSb16x2(res2, res1, cond);
}

#include <hlccad.mpc>

// Объявление глобальных переменных
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;

// Главная функция
void main() {
    // Приведение переменных
    i32 X32 = CWD(X);
    i32 Y32 = CWD(Y);
    i16 A916 = CBW(A9);
    i16 B716 = CBW(B7);

    // Константы
    i16 zero16 = CONST(0);
    i32 zero32 = CWD(zero16);

    // Вычисления для первой ветки
    i32 A9_Y = IMUL(A916, Y);
    i32 B7_X = IMUL(B716, X);
    i16 A9_Y_16 = x32Tox16(A9_Y);
    i16 B7_X_16 = x32Tox16(B7_X);
    i16 sum1 = SUM(A9_Y_16, B7_X_16);
    i16 sub1 = ISUB(sum1, X);
    i32 sub1_32 = CWD(sub1);
    i16 res1 = IDIV(sub1_32, Y32);

    // Вычисления для второй ветки
    i32 A9_B7 = IMUL(A916, B716);
    i16 X_div_Y = IDIV(X32, Y32);
    i16 sub2 = ISUB(X_div_Y, Y);
    i16 res2 = SUM(A9_B7, sub2);

    // Условие X * Y < 0
    i32 XY_mul = IMUL(X, Y);
    ICMPResult(XY_mul, zero32);
    u1 cond = ILT;

    // Выбор результата
    RES = MSb16x2(res1, res2, cond);
}

// Объявление входных и выходных переменных
int __in __bits(16) x;
int __in __bits(16) y;
int __in __bits(8) a;
int __in __bits(8) b;
int __out __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)

// Библиотека функций 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 b16 = CBW(b);
    i32 a32 = CWD(a16);
    i32 b32 = CWD(b16);

    // Первая ветка: (x - y) * (a + b) + (b / a)
    i16 diff_xy = ISUB(x, y);            // x - y
    i16 sum_ab = SUM(a16, b16);          // a + b
    i32 mul_xy_ab = IMUL(diff_xy, sum_ab); // (x - y) * (a + b)
	i16	mul_xy_ab_16 = x32Tox16(mul_xy_ab);
    i16 div_b_a = IDIV(b32, a32);        // b / a
    i16 res1 = SUM(mul_xy_ab_16, div_b_a);  // (x - y) * (a + b) + (b / a)

    // Вторая ветка: (x / y) * ((a + b) / (a - b))
    i16 div_x_y = IDIV(x32, y32);        // x / y
    i16 diff_ab = ISUB(a16, b16);        // a - b
	i32 sum_ab_32 = CWD(sum_ab);
	i32 diff_ab_32 = CWD(diff_ab);
    i32 div_ab_ab = IDIV(sum_ab_32, diff_ab_32); // (a + b) / (a - b)
    i32 mul_xy_ab2 = IMUL(div_x_y, div_ab_ab); // (x / y) * ((a + b) / (a - b))
    i16 res2 = x32Tox16(mul_xy_ab2);

    // Проверка условия a == b
    ICMPResult(a32, b32);
    u1 cond = IEQ; // Условие a == b

    // Выбор результата на основе условия
    R = MSb16x2(res2, res1, cond);
}

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)); }
u1  NOT  (u1  A) { return ~A; }
u1  OR2  (u1  A, u1  B) { return A | B; }
u1  AND2 (u1  A, u1  B) { return A & B; }
i16 CONST (i16 A) { return A; }
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;}

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; }
i16 x32Tox16 (i32 A) { return A; }
u16 CBW (u8  A) { return A; }
u32 CWD (u16 A) { return A; }

void main() {
    // Приведение входных данных к типу i16
    i16 a16 = a;                          // Приведение a к i16
    i16 b16 = b;                          // Приведение b к i16
    i16 c16 = CBW(c);                     // Приведение c к i16
    i16 d16 = CBW(d);                     // Приведение d к i16

    i32 a32 = CWD(a16);                   // Приведение a16 к i32
    i32 b32 = CWD(b16);                   // Приведение b16 к i32
    i32 c32 = CWD(c16);                   // Приведение c16 к i32
    i32 d32 = CWD(d16);                   // Приведение d16 к i32

    i16 zero16 = CONST(0);                // Константа 0
    i16 neg_c16 = ISUB(zero16, c16);      // -c (в i16)
    i32 neg_c32 = CWD(neg_c16);           // -c (в i32)

    // Проверка условия cond1: b == -c
    ICMPResult(b32, neg_c32);
    u1 cond1 = IEQ;

    // Вычисление res1: -a * b - c * d + a / c + b / d
    i32 ab_mul32 = IMUL(a16, b16);        // a * b (в i32)
    i16 ab_mul16 = x32Tox16(ab_mul32);    // Приведение результата к i16
    i16 neg_ab16 = ISUB(zero16, ab_mul16); // -a * b (в i16)

    i32 cd_mul32 = IMUL(c16, d16);        // c * d (в i32)
    i16 cd16 = x32Tox16(cd_mul32);        // Приведение результата к i16

    i16 first_part = ISUB(neg_ab16, cd16); // -a * b - c * d

    i16 a_div_c = IDIV(a32, c32);         // a / c (в i16)
    i16 b_div_d = IDIV(b32, d32);         // b / d (в i16)
    i16 second_part = SUM(a_div_c, b_div_d); // a / c + b / d

    i16 res1 = SUM(first_part, second_part); // -a * b - c * d + a / c + b / d

    // Вычисление res2: ((a + b) * a * b * c * d) / (c - d)
    i16 ab_sum = SUM(a16, b16);           // a + b (в i16)
    i32 ab_sum32 = CWD(ab_sum);           // Приведение ab_sum к i32

    i32 ab_a_mul32 = IMUL(ab_sum, a16);   // (a + b) * a (в i32)
    i16 ab_a_mul16 = x32Tox16(ab_a_mul32); // Приведение результата к i16

    i32 ab_ab_mul32 = IMUL(ab_a_mul16, b16); // (a + b) * a * b (в i32)
    i16 ab_ab_mul16 = x32Tox16(ab_ab_mul32); // Приведение результата к i16

    i32 abc_mul32 = IMUL(ab_ab_mul16, c16); // (a + b) * a * b * c (в i32)
    i16 abc_mul16 = x32Tox16(abc_mul32);    // Приведение результата к i16

    i32 abcd_mul32 = IMUL(abc_mul16, d16);  // (a + b) * a * b * c * d (в i32)

    i16 cd_diff = ISUB(c16, d16);         // c - d (в i16)
    i32 cd_diff_32 = CWD(cd_diff);        // c - d (в i32)

    i16 res2 = IDIV(abcd_mul32, cd_diff_32); // ((a + b) * a * b * c * d) / (c - d)

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

#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() {
    i16 a9_16 = CBW(A9);
    i16 b7_16 = CBW(B7);
    i32 x32 = CWD(X);
    i32 y32 = CWD(Y);
    i32 a9_32 = CWD(a9_16);
    i32 b7_32 = CWD(b7_16);

    i32 xy_mul = IMUL(x32, y32);
    i32 zero_32 = CWD(CONST(0));

    ICMPResult(xy_mul, zero_32);
    u1 cond = ILT;

    i16 y_x_sum = ISUB(Y, X);
    i32 y_x_sum_32 = CWD(y_x_sum);
    i32 b7_y_mul = IMUL(b7_16, y32);
    i32 temp1 = ISUB(y_x_sum_32, b7_y_mul);
    i16 temp2 = IDIV

       i16 temp2 = IDIV(temp1, x32);
    i16 res1 = SUM(temp2, a9_16);

    i32 y_x_sum_32_2 = IMUL(SUM(Y, X), a9_32);
    i16 res2 = ISUB(IDIV(y_x_sum_32_2, b7_32), Y);

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

#include <hlccad.mpc>

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;

void main() {
    // Приведение типов
    i32 x32 = CWD(X);
    i32 y32 = CWD(Y);
    i16 a9_16 = CBW(A9);
    i16 b7_16 = CBW(B7);

    // Константа 0
    i16 zero = CONST(0);
    i32 zero_32 = CWD(zero);

    // Первая ветка: (A9 - B7 + X * Y) / X
    i16 a9_b7_diff = ISUB(a9_16, b7_16);
    i32 xy_mul_32 = IMUL(X, Y);
    i16 xy_mul_16 = x32Tox16(xy_mul_32);
    i16 branch1_sum = SUM(a9_b7_diff, xy_mul_16);
    i32 branch1_sum_32 = CWD(branch1_sum);
    i16 res1 = IDIV(branch1_sum_32, x32);

    // Вторая ветка: (B7 + A9) * X / Y - X
    i16 b7_a9_sum = SUM(b7_16, a9_16);
    i32 b7_a9_x_mul = IMUL(b7_a9_sum, X);
    i16 b7_a9_x_div_y = IDIV(b7_a9_x_mul, y32);
    i16 res2 = ISUB(b7_a9_x_div_y, X);

    // Условие X * Y >= 0
    i32 xy_mul = IMUL(X, Y);
    ICMPResult(xy_mul, zero_32);
    u1 cond = OR2(IEQ, IGT);

    // Выбор результата
    RES = MSb16x2(res2, res1, cond);
}

28.11 15:13 С. Задача №9 0 / 100 [1]: Ошибка компиляции (mpc): Ошибка синтаксиса (строка 66): i16 temp2 = IDIV.

#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() {
    i16 a9_16 = CBW(A9);
    i16 b7_16 = CBW(B7);
    i32 x32 = CWD(X);
    i32 y32 = CWD(Y);
    i32 a9_32 = CWD(a9_16);
    i32 b7_32 = CWD(b7_16);

    i32 xy_mul = IMUL(x32, y32);
    i32 zero_32 = CWD(CONST(0));

    ICMPResult(xy_mul, zero_32);
    u1 cond = ILT;

    i16 y_x_sum = ISUB(Y, X);
    i32 y_x_sum_32 = CWD(y_x_sum);
    i32 b7_y_mul = IMUL(b7_16, y32);
    i32 temp1 = ISUB(y_x_sum_32, b7_y_mul);
    i16 temp2 = IDIV

       i16 temp2 = IDIV(temp1, x32);
    i16 res1 = SUM(temp2, a9_16);

    i32 y_x_sum_32_2 = IMUL(SUM(Y, X), a9_32);
    i16 res2 = ISUB(IDIV(y_x_sum_32_2, b7_32), Y);

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

 

 i16 temp2 = IDIV

       i16 temp2 = IDIV(temp1, x32);

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)

i16 SIGN(i16 A) { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS(i16 A) { return (A > 0) ? A : (A * (-1)); }

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; }
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() {
    // Приведение входных данных к нужным типам
    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);

    i16 zero16 = CONST(0);
    i16 one16 = CONST(1);

    // Вычисление res1
    i16 ac_sum = SUM(a16, c16);            // a + c
    i32 ac_d_mul = IMUL(ac_sum, d16);     // (a + c) * d
    i16 ac_d_div_b = IDIV(ac_d_mul, b32); // ((a + c) * d) / b

    i16 ad_sum = SUM(a16, d16);           // a + d
    i32 ad_c_mul = IMUL(ad_sum, c16);     // (a + d) * c
    i16 ad_c_div_b = IDIV(ad_c_mul, b32); // ((a + d) * c) / b

    i16 res1_temp = ISUB(ac_d_div_b, ad_c_div_b); // ((a + c) * d) / b - ((a + d) * c) / b
    i16 res1 = res1_temp;

    // Вычисление res2
    i16 b_d_sum = SUM(b16, d16);          // b + d
    i32 b_d_sum_32 = CWD(b_d_sum);        // Приведение b + d к i32
    i16 a_div_b_d = IDIV(a32, b_d_sum_32); // a / (b + d)

    i32 a_squared = IMUL(a16, a16);       // a^2
    i16 a_squared_16 = x32Tox16(a_squared); // Приведение a^2 к i16
    i16 c_b_sum = SUM(c16, b16);          // c + b
    i32 c_b_sum_32 = CWD(c_b_sum);        // Приведение c + b к i32
    i16 a2_div_c_b = IDIV(a_squared, c_b_sum_32); // a^2 / (c + b)

    i32 a_cubed = IMUL(a16, a_squared_16); // a^3
    i16 a_cubed_16 = x32Tox16(a_cubed);    // Приведение a^3 к i16
    i16 d_c_sum = SUM(d16, c16);           // d + c
    i16 d_c_sum_1 = SUM(d_c_sum, one16);   // d + c + 1
    i32 d_c_sum_1_32 = CWD(d_c_sum_1);     // Приведение d + c + 1 к i32
    i16 a3_div_d_c_1 = IDIV(a_cubed, d_c_sum_1_32); // a^3 / (d + c + 1)

    i16 res2_temp1 = SUM(a_div_b_d, a2_div_c_b); // a / (b + d) + a^2 / (c + b)
    i16 res2 = ISUB(res2_temp1, a3_div_d_c_1);   // a / (b + d) + a^2 / (c + b) - a^3 / (d + c + 1)

    // Условие для выбора результата
    ICMPResult(d32, b32);               // Сравнение d и b
    u1 cond1 = OR2(IEQ, IGT);           // d >= b
    ICMPResult(b32, zero16);            // Сравнение b и 0
    u1 cond2 = IGT;                     // b > 0
    u1 cond = AND2(cond1, cond2);       // Условие: d >= b и b > 0

    // Выбор результата
    RES = MSb16x2(res2, res1, cond);
}