int f(unsigned char a, unsigned char b, unsigned char c)
{
	return ((a*b)/c) == (a*(b/c));
}

function f(a, b, c : byte) : boolean;
var
	a0, b0, c0 : word;
begin
	a0 := a; b0 := b; c0 := c;
	f := ( ((a0*b0) div c0) = (a0*(b0 div c0)) );
end;

א <- 1000000000
כל-עוד (אמת) בצע:
	אם ק, אזי:
		א <- 1000000000
		בצע פ
	אם א שווה ל - 0, אזי:
		בצע ס
	א <- 1-א

int get_index(int x, int A[], int N)
{
	int L = 0, H = N-1;
	while (L != H) {
		int M = (L+H)/2;
		if (x >= A[M])
			L = M;
		else
			H = M-1;
	}
	return L;
}

function get_index(x : integer; A : array of integer; N : integer) : integer;
var
	L, H, M : integer;
begin
	L := 0; H := N-1;
	while L <> H do
	begin
		M := (L+H) div 2;
		if x >= A[M] then
			L := M
		else
			H := M-1;
	end;
	get_index := L;
end;

	mov bx, offset var_ptr
	xor ax, ax
l:
	xchg [bx], ax
	or ax, ax
	jz l

	xor ebx, ebx
start:
	test eax, eax
	jz end
	xchg ebx, [eax]
	xchg ebx, eax
	jmp start
end:

unsigned int div_by_17(unsigned int a)
{
	return (MUL*a)>>SHIFT;
}

הגדרה:
	מילון0 הוא מילון היודע לקחת מחרוזת ולמצוא מספר שהותאם לה קודם לכן
	(או להגיד שעדיין לא הותאם לה מספר)
עבור כל אות מה - ABC, בצע:
	התאם למחרוזת המכילה את האות הזו בלבד את האינדקס שלה ב - ABC
	(כלומר, ל - "A" יותאם 1 ול - "Z" יותאם 26)
הכנס למשתנה קוד0 את המספר 26
קרא את התו הראשון מהמסר ושמור אותו ב - מחרוזת0
כל עוד ישנם עדיין תווים במסר שלא נקראו, בצע:
	קרא את התו הבא מהמסר ושמור אותו ב - תו0
	הכנס ל - מחרוזת1 את מחרוזת0 עם תו0 משורשר בסופה
	אם כבר הותאם מספר ל - מחרוזת1 ב - מילון0 אזי:
		החלף את הערך של מחרוזת0 בערך של מחרוזת1
	אחרת:
		פלוט את המספר שהותאם ל - מחרוזת0 לפי מילון0
		הוסף אחד לערך של קוד0
		התאם במילון0 את המספר קוד0 למחרוזת מחרוזת1
		החלף את הערך של מחרוזת0 בערך של תו0
פלוט את המספר שהותאם למחרוזת0 לפי מילון0 

3, 7, 27, 24, 29, 31, 7

unsigned int f1(unsigned int n)
{
	unsigned int x = 1;
	for (unsigned int i = 1; i <= n; i++) {
		x *= i;
	}
	return x;
}
unsigned int f2(unsigned int n)
{
	if (n == 0) return 1;
	return n*f2(n-1);
}

function f1(n : word) : word;
var
   x, i : word;
begin
     x := 1;
     for i := 1 to n do x := x*i;
     f1 := x;
end;
function f2(n : word) : word;
begin
     if n = 0 then f2 := 1
     else f2 := n*f2(n-1);
end;

start:
         time = 0
loop:
         if (time == 0 and program_time) time = user_input
         if (time > 0) {heat; time--; wait_a_second; if (time == 0) beep_end}
         goto loop
 
On cancel_pressed Interrupt:
         if (time>0) beep_abort; time=0
         goto loop

(x0*y1-x1*y0)/sqrt((x0*x0+y0*y0)*(x1*x1+y1*y1))

xm=0
for x = 0 to 100 {
	xx = x*(y2-y1)/sqrt((x*x+y1*y1)*(x*x+y2*y2))
	if (xx > xm) xm = xx; a=x
}

class A { ... };
class B { ... };
class C { ... };
class Container {
	Container() : a(), c(), b() {
		c.start();
		b.start();
		a.start();
	}
	A a;
	B b;
	C c;
};

int f(int p, int p1)
{
	int i,j,i1,j1;
	i =p >>3; j =p &7;
	i1=p1>>3; j1=p1&7;
	return (i-i1)*(i-i1)+(j-j1)*(j-j1) == 5;
}

function f(p, p1 : integer) : boolean;
var
   i, j, i1, j1 : integer;
begin
     i  := p  shr 3; j  := p  and 7;
     i1 := p1 shr 3; j1 := p1 and 7;
     f := (i-i1)*(i-i1)+(j-j1)*(j-j1) = 5;
end;

int s(unsigned __int64 x){return (!x || x&(x-1));}
int r()
{
	unsigned __int64 i,m1,m2;
	int r = 0;
	int j;
	for (i=1; i; i++,r+=j==8)
		for (j=0,m1=0xff,m2=0x101010101010101; j<8; j++,m1<<=8, m2<<=1)
			if (s(i&m1) || s(i&m2)) break;
	return r;
}

void*x=(*((void*(*)())&(x=(void*)0xfdeb58)))();

FILE* fp = fopen("1.txt", "w");
char ch = 0xa;
fwrite(&ch, sizeof(ch), 1, fp);
fclose(fp);

int B[1<<7];
void f()
{
	int c, i, j;
	for (c = 0; c < (1<<7); c++) {
		if (B[c] == 0) {
			printf("%d\n", c);
			B[c] = 1;
			for (i = 1<<6; i != 0; i >>= 1) {
				for (j = 1<<6; j != 0; j >>= 1) {
					B[c^(i|j)] = 1;
				}
			}
		}
	}
}

var
	b : array[0..(1 shl 7)] of integer;
procedure f;
var
	i, j, c : integer;
begin
	for c := 0 to (1 shl 7)-1 do
	begin
		if B[c] = 0 then
		begin
			writeln(c);
			B[c] := 1;
			i := 1 shl 6;
			while i <> 0 do
			begin
				j := 1 shl 6;
				while j <> 0 do
				begin
					B[c xor (i or j)] := 1;
					j := j shr 1;
				end;
				i := i shr 1;
			end;
		end;
	end;
end;

int O[4] = {1, -1, 128, -128};
void f(unsigned char A[1<<14], int B[1<<14])
{
	int C[1<<8] = {0x3F7E};
	unsigned char X = 0, Y = 1;
	int j, m;
	for (j = 0; j < 1<<14; j++)
		B[j] = -1;
	while (X != Y) {
		int c = C[X++];
		for (j = 0; j < 4; j++) {
			m = c + O[j];
			if ((A[m] == 0) && (B[m] == -1) && (m != B[c]))
				{B[m] = c; C[Y++] = m; }
		}
	}
}

const
     O : array[0..3] of integer = (1, -1, 128, -128);
type
    typeA = array[0..(1 shl 14)-1] of byte;
    typeB = array[0..(1 shl 14)-1] of integer;
procedure f(var a : typeA; var b : typeB);
var
   C : array[0..(1 shl 8)-1] of integer;
   X, Y : byte;
   j, m, k: integer;
begin
     C[0] := $3F7E;
     X := 0; Y := 1;
     for j := 0 to (1 shl 14)-1 do
         B[j] := -1;
     while (X <> Y) do
     begin
          k := C[X]; X:=X+1;
          for j := 0 to 3 do
          begin
	       m := k + O[j];
	       if (A[m] = 0) and (B[m] = -1) and (m <> B[k]) then
               begin
		    B[m] := k; C[Y] := m; Y:=Y+1;
               end;
	 end;
    end;
end;