Subversion Repositories Kolibri OS

; mov [pointer_to_screen],eax

; mov [output_array],ebx

; mov [screen_size_x],ecx

;setpixel (pixel_x,pixel_y)

setpixel:

  mov ecx,[output_array]

  mov eax,[pixel_y]

  mov ebx,[screen_size_x]

  imul eax,ebx

  add eax,[pixel_x]

  lea eax,[eax+eax*2]

  add eax,[pointer_to_screen]

  mov [ecx],eax

  add [output_array],4

  ret

; procedure <<<<<>>>>>

; IN

; eax - pointer to picture

; ebx - picture size x

; ecx - color of pixel

; esi - x coordinat of pixel

; edi - y coordinat of pixel

; OUT

; not returned value

PutPixel:

  imul ebx,edi

  add ebx,esi

  lea ebx,[ebx+ebx*2]

  add eax,ebx

  mov ebx,ecx

  shr ebx,16

  mov [eax],cx

  mov [eax+2],bl

  ret

; function <<<<<>>>>>

; IN

; eax - pointer to picture

; ebx - picture size x

; esi - x coordinat of pixel

; edi - y coordinat of pixel

; OUT

; eax - color of pixel in coordinats (x,y)

GetColorOfPixel:

  imul ebx,edi

  add ebx,esi

  lea ebx,[ebx+ebx*2]

  add eax,ebx

  mov ebx,[eax]

  and ebx,0xffffff

  mov eax,ebx

  ret

;procedure <<<>>>

; IN

;eax - pointer to screen

;ebx - output array

;ecx - (screen size x)*bytes per pixel

;edx - x1*65536+y1

;esi   x2

;edi - y2

; OUT

;eax - number of pixels

calculate_line:

  mov [pointer_to_screen],eax

  mov [output_array],ebx

  mov [screen_size_x],ecx

  mov eax,edx

  and eax,0xffff

  shr edx,16

  mov [x_l],edx     ;x=x1

  mov [y_l],eax     ;y=y1

  mov [sx],1

  mov [sy],1

  mov edx,[output_array]

  sub esi,[x_l]     ;esi=x2-x1

  jnz no_0_x

  and esi,0

  jmp x_no_minus

  no_0_x:

  jns x_no_minus

  neg esi

  mov [sx],-1	  ;sx=-sx

  x_no_minus:

  sub edi,[y_l]     ;edi=y2-y1

  jnz no_0_y

  and edi,0

  jmp y_no_minus

  no_0_y:

  jns y_no_minus

  neg edi

  mov [sy],-1	  ;sy=-sy

  y_no_minus:

  mov [_dx],esi

  mov [_dy],edi

  cmp [_dx],0	   ;if (dx=0 & dy=0) {  }

  jnz no_null_d

  cmp [_dy],0

  jnz no_null_d

  mov eax,[x_l]

  mov ebx,[y_l]

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel    ;setpixel(x1,y1)

  mov eax,1

  ret

  no_null_d:

  cmp edi,esi	   ;if (dy>dx) {  }

  jle no_bigger

  mov eax,[_dx]

  mov [z],eax	   ;z=dx

  mov eax,[_dy]

  mov [_dx],eax    ;dx=dy

  mov eax,[z]

  mov [_dy],eax    ;dy=z

  mov [_ch],dword 1 ;ch=true

  jmp exit_if2

  no_bigger:	   ;else {}

  and [_ch],0

  exit_if2:

  mov eax,[_dy]

  shl eax,1

  sub eax,[_dx]

  mov [e],eax	 ;e=2*dy-dx

  mov esi,1	 ;counter

  mov edi,[sx]

  mov ebp,[sy]

  do:

     mov eax,[x_l]

     mov ebx,[y_l]

     mov [pixel_x],eax

     mov [pixel_y],ebx

     call setpixel

     cmp [e],0

     js while_e

       mov eax,[_ch]

       test eax,eax

       jz ch_else

       add [x_l],edi

       jmp exit_if3

       ch_else:

       add [y_l],ebp

       exit_if3:

       mov eax,[_dx]

       shl eax,1

       sub [e],eax    ;e=e-2*dx

     while_e:

     mov eax,[_ch]

     test eax,eax

     jz ch_else2

     add [y_l],ebp

     jmp exit_if4

     ch_else2:

     add [x_l],edi

     exit_if4:

     mov eax,[_dy]

     shl eax,1

     add [e],eax ;e=e+2*dy

     inc esi

     mov ecx,[_dx]

     cmp esi,ecx

     jle do	     ;while (i<=dx)

     mov eax,[x_l]

     mov ebx,[y_l]

     mov [pixel_x],eax

     mov [pixel_y],ebx

     call setpixel

     mov eax,[output_array]

     sub eax,edx

     shr eax,2

  ret

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

;procedure calculate <<<<>>>>>>

; IN

;eax - pointer to screen

;ebx - output array

;ecx - (screen size x)

;edx - x1*65536+y1

;esi   x2

;edi - y2

; OUT

;eax - number of pixels

calculate_rectangle:

  mov [pointer_to_screen],eax

  mov [output_array],ebx

  mov [screen_size_x],ecx

  mov eax,edx

  and eax,0xffff

  shr edx,16

  mov [x_l],edx     ;x=x1

  mov [y_l],eax     ;y=y1

  mov [x2],esi	    ;x2

  mov [y2],edi	    ;y2

  mov [sx],1

  mov [sy],1

  mov edx,[output_array]

  sub esi,[x_l]     ;esi=x2-x1

  jnz no_0_x_r

  and esi,0

  jmp x_no_minus_r

  no_0_x_r:

  jns x_no_minus_r

  neg esi

  mov [sx],-1	  ;sx=-sx

  x_no_minus_r:

  sub edi,[y_l]     ;edi=y2-y1

  jnz no_0_y_r

  and edi,0

  jmp y_no_minus_r

  no_0_y_r:

  jns y_no_minus_r

  neg edi

  mov [sy],-1	  ;sy=-sy

  y_no_minus_r:

  mov [_dx],esi

  mov [_dy],edi

  cmp [_dx],0	   ;if (dx=0 & dy=0) {  }

  jnz no_null_r

  cmp [_dy],0

  jnz no_null_r

  mov eax,[x_l]

  mov ebx,[y_l]

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel    ;setpixel(x1,y1)

  mov eax,1

  ret

  no_null_r:

  mov edi,[_dx]

  mov esi,[x_l]       ;x1

  horizontal_lines:

  mov eax,esi	      ;x

  mov ebx,[y_l]       ;y1

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,esi	      ;x

  mov ebx,[y2]	      ;y2

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  add esi,[sx]

  dec edi

  jns horizontal_lines

  mov edi,[_dy]

  mov esi,[y_l]       ;y1

  vertical_lines:

  mov eax,[x_l]       ;x1

  mov ebx,esi	      ;y

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,[x2]	       ;x2

  mov ebx,esi	       ;y

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  add esi,[sy]

  dec edi

  jns vertical_lines

  mov eax,[output_array]

  sub eax,edx

  shr eax,2

  ret

;procedure <<<<<>>>>>

; IN

;eax - pointer to screen

;ebx - output array

;ecx - (screen size x)*bytes per pixel

;edx - x_c*65536+y_c

;esi   r

; OUT

;eax - number of pixels

calculate_circle:

  mov [pointer_to_screen],eax

  mov [output_array],ebx

  mov [screen_size_x],ecx

  mov eax,edx

  and eax,0xffff

  shr edx,16

  mov [x2],edx	   ;circle centr x

  mov [y2],eax	   ;circle centr y

  mov [r],esi	   ;radius of cicrle

  mov edx,[output_array]

  mov [x_l],0	   ;x=0

  mov [y_l],esi    ;y=r

  mov [d],3

  mov eax,[r]

  shl eax,1

  sub [d],eax	   ;d=3-2*r

  while_circle:

  mov esi,[y_l]

  mov edi,[x_l]

  sub esi,edi	   ;while y>=x

  js exit_while_circle

  mov eax,[x_l] ;x

  mov ebx,[y_l] ;y

  add eax,[x2]	;x+xc

  add ebx,[y2]	;y+yc

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,[x_l] ;x

  mov ebx,[y2]	;yc

  add eax,[x2]	;x+xc

  sub ebx,[y_l] ;yc-y

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,[x2]	;xc

  mov ebx,[y2]	;yc

  sub eax,[x_l] ;xc-x

  add ebx,[y_l] ;yc+y

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,[x2]	;xc

  mov ebx,[y2]	;yc

  sub eax,[x_l] ;xc-x

  sub ebx,[y_l] ;yc-y

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,[x2]	;xc

  mov ebx,[y2]	;yc

  add eax,[y_l] ;xc+y

  add ebx,[x_l] ;yc+x

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,[x2]	;xc

  mov ebx,[y2]	;yc

  add eax,[y_l] ;xc+y

  sub ebx,[x_l] ;yc-x

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,[x2]	;xc

  mov ebx,[y2]	;yc

  sub eax,[y_l] ;xc-y

  add ebx,[x_l] ;x+yc

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,[x2]	;xc

  mov ebx,[y2]	;yc

  sub eax,[y_l] ;xc-y

  sub ebx,[x_l] ;yc-x

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  cmp [d],0

  jns if1_d

  mov eax,[x_l]

  shl eax,2

  add eax,6

  add [d],eax  ;d=d+4*x+6

  jmp exit_if1_d

  if1_d:

  mov eax,[x_l]

  sub eax,[y_l]

  shl eax,2

  add eax,10

  add [d],eax	 ;d=d+4*(x-y)+10

  dec [y_l]

  exit_if1_d:

  inc [x_l]

  jmp while_circle

  exit_while_circle:

  mov eax,[output_array]

  sub eax,edx

  shr eax,2

  ret

;procedure <<<<<>>>>

;IN

;eax - pointer to screen

;ebx - pointer to output array

;ecx - picture size x

;edx - x0*65536+y0

;esi - x_max*65536+y_max

;edi - color of flood fill arrea

flood_fill:

  mov [pointer_to_screen],eax

  mov [output_array],ebx

  mov [screen_size_x],ecx

  mov eax,edx

  and edx,0xffff

  shr eax,16

  mov [sx],eax	 ;x0

  mov [sy],edx	 ;y0

  mov eax,esi

  and esi,0xffff

  shr eax,16

  mov [m_x],eax  ;maximum x size of picture

  mov [m_y],esi  ;maximum y size of picture

  mov [c_f],edi    ;color of feel

  mov eax,[output_array] ; stek

  mov [eax],dword 1	 ; number of pointes in stek

  mov esi,[sx]

  mov edi,[sy]

  mov [eax+4],si	;x0

  mov [eax+4+2],di	  ;y0

  mov eax,[pointer_to_screen]

  mov ebx,[screen_size_x]

  call GetColorOfPixel

  mov [c],eax

  cmp eax,[c_f]

  jne can_flood_fill

  mov eax,[output_array]

  mov [eax],dword 0

  ret

  can_flood_fill:

  while_no_null:

  ;¨§¢«¥ª ¥¬ ª®®à¤¨­ âë ¨§ á⥪ 

  mov eax,[output_array]

  mov ebx,[eax]

  dec ebx

  shl ebx,2		  ;ebx=ebx*8

  add ebx,4		  ;ebx=ebx*8+4

  xor esi,esi

  xor edi,edi

  mov si,[eax+ebx]	 ;x

  mov di,[eax+ebx+2]	 ;y

  mov [x2],esi

  mov [y2],edi

  mov [sy],edi

  mov eax,[output_array]

  mov ebx,[eax]

  dec ebx

  mov [eax],ebx 	  ;

  ; go to right until color=c or until x

  mov edx,[x2]

  go_to_right:

  mov eax,[pointer_to_screen]

  mov ebx,[screen_size_x]

  mov esi,edx;

  mov edi,[sy]

  call GetColorOfPixel

  cmp eax,[c]

  jne not_color_of_feeling_arrea_right

  mov eax,[pointer_to_screen]

  mov ebx,[screen_size_x]

  mov ecx,[c_f]    ;color of filinf flood

  mov esi,edx

  mov edi,[sy]

  call PutPixel

  inc edx

  mov eax,edx

  cmp eax,[m_x]

  jle go_to_right

  not_color_of_feeling_arrea_right:

  mov eax,edx

  dec eax		 ;----------------------------------

  mov [x_r],eax      ; save right absciss

  ; go to left until color=c or until x>0

  mov esi,[x2]

  mov edi,[y2]

  dec esi

  mov edx,esi

  mov [sy],edi

  go_to_left:

  mov eax,[pointer_to_screen]

  mov ebx,[screen_size_x]

  mov esi,edx

  mov edi,[sy]

  call GetColorOfPixel

  cmp eax,[c]

  jne not_color_of_feeling_arrea_left

  mov eax,[pointer_to_screen]

  mov ebx,[screen_size_x]

  mov ecx,[c_f]    ;color of filing flood

  mov esi,edx

  mov edi,[sy]

  call PutPixel

  dec edx

  jns go_to_left

  not_color_of_feeling_arrea_left:

  mov eax,edx

  inc eax	    ;----------------------------------------

  mov [x_l],eax      ; save left absciss

  mov edi,[y2]

  dec edi

  jns no_null_1_floodfill

  mov edi,1

  no_null_1_floodfill:

  mov [sy],edi

  mov eax,[output_array]

  mov ebx,[eax]

  mov [l_s],ebx 	; save total number of points in stek

  mov [l_c],-1		; last color = -1

  mov edx,[x_l]

  analizing_from_left_to_right_upper:

  ; ­ «¨§¨à㥬 ¯¨ªá¥«¨ ­ ¤ «¨­¨¥© á «¥¢®£® ªà ï

  mov eax,[pointer_to_screen]

  mov ebx,[screen_size_x]

  mov esi,edx

  mov edi,[sy]

  call GetColorOfPixel

  push eax

  cmp eax,[c]	 ;¥á«¨ 梥⠯஢¥àאַ£® ¯¨ªá¥«ï ­¥ à ¢¥­ á,â® ­¥ § ­®á¨¬ ¥£® ¢ á⥪

  jne no_fill_1

  mov ebx,[l_c]

  cmp ebx,[c]

  jne no_fill_1

  mov edi,[sy]

  mov eax,[output_array]

  mov ebx,[eax]

  inc ebx

  mov [eax],ebx

  dec ebx

  shl ebx,2

  add ebx,4

  mov esi,edx

  dec esi

  mov [eax+ebx],si

  mov [eax+ebx+2],di

  no_fill_1:

  pop [l_c]

  inc edx

  cmp edx,[x_r]

  jle analizing_from_left_to_right_upper

  mov ebx,[l_c]

  cmp ebx,[c]	    ;last color is c(color of filing arrea) ?

  jne have_changes_in_stek_1

  ;save last color in stek

  mov edi,[sy]

  mov eax,[output_array]

  mov ebx,[eax]

  inc ebx

  mov [eax],ebx

  dec ebx

  shl ebx,2

  add ebx,4

  mov esi,edx

  dec esi

  mov [eax+ebx],si

  mov [eax+ebx+2],di

  have_changes_in_stek_1:

  mov edi,[y2]

  inc edi

  cmp edi,[m_y]

  jle no_max_1_floodfill

  mov edi,[m_y]

  no_max_1_floodfill:

  mov [sy],edi

  mov eax,[output_array]

  mov ebx,[eax]

  mov [l_s],ebx 	; save total number of points in stek

  mov [l_c],-1		; last color = -1

  mov edx,[x_l]

  analizing_from_left_to_right_down:

  ; ­ «¨§¨à㥬 ¯¨ªá¥«¨ ¯®¤ «¨­¨¥© á «¥¢®£® ªà ï

  mov eax,[pointer_to_screen]

  mov ebx,[screen_size_x]

  mov esi,edx

  mov edi,[sy]

  call GetColorOfPixel

  push eax

  cmp eax,[c]	 ;¥á«¨ 梥⠯஢¥àאַ£® ¯¨ªá¥«ï ­¥ à ¢¥­ á,â® ­¥ § ­®á¨¬ ¥£® ¢ á⥪

  je no_fill_3

  mov ebx,[l_c]

  cmp ebx,[c]

  jne no_fill_3

  mov edi,[sy]

  mov eax,[output_array]

  mov ebx,[eax]

  inc ebx

  mov [eax],ebx

  dec ebx

  shl ebx,2

  add ebx,4

  mov esi,edx

  dec esi

  mov [eax+ebx],si

  mov [eax+ebx+2],di

  no_fill_3:

  pop [l_c]

  inc edx

  cmp edx,[x_r]

  jle analizing_from_left_to_right_down

  mov ebx,[l_c]

  cmp ebx,[c]	    ;last color is c(color of filing arrea) ?

  jne have_changes_in_stek_2

  ;save last color in stek

  mov edi,[sy]

  mov eax,[output_array]

  mov ebx,[eax]

  inc ebx

  mov [eax],ebx

  dec ebx

  shl ebx,2

  add ebx,4

  mov esi,edx

  dec esi

  mov [eax+ebx],si

  mov [eax+ebx+2],di

  have_changes_in_stek_2:

  mov ebx,[output_array] ;while stek have points  ¯®ª  ¢ á⥪¥ ¥áâì â®çª¨(ª®®à¤¨­ âë)

  mov ecx,[ebx]

  test ecx,ecx

  jnz while_no_null

  ret

; procedure <<<<<>>>>>

; IN

; eax - pointer to picture

; ebx - output array

; ecx - picture size x

; edx - x0*65536+y0

; esi - a*65536+b

; edi - color

; OUT

; procedure not return value

calculate_ellips:

  mov [pointer_to_screen],eax

  mov [output_array],ebx

  mov [screen_size_x],ecx

  mov [e],ebx

  mov eax,edx

  and eax,0xffff

  shr edx,16

  mov [x2],edx	   ; centr x

  mov [y2],eax	   ; centr y

  mov eax,esi

  and eax,0xffff   ;eax=b

  shr esi,16	   ;esi=a

  mov [a],esi

  mov [b],eax

  mov [c],edi	   ;color

  mov [row],eax ;b

  imul esi,esi ;a*a

  imul eax,eax ;b*b

  mov [a_square],esi

  mov [b_square],eax

  and [col],0

  shl esi,1

  shl eax,1

  mov [two_a_square],esi

  mov [two_b_square],eax

  shl esi,1

  shl eax,1

  mov [four_a_square],esi

  mov [four_b_square],eax

  mov eax,[row] 	     ;eax=row

  mov ebx,eax

  dec ebx		     ;ebx=(row-1)

  imul ebx,eax		     ;ebx=(row-1)*row

  imul ebx,[two_a_square]    ;ebx=two_a_square*((row-1)*row)

  mov ecx,[a_square]	     ;ecx=a_square

  mov eax,1

  sub eax,ecx		     ;eax=(1-a_square)

  imul eax,[two_b_square]    ;eax=two_b_square*(1-a_square)

  add ebx,[a_square]	     ;ebx=two_a_square*((row-1)*row)+a_square

  add eax,ebx		     ;eax=two_a_square*((row-1)*row)+a_square+two_b_square*(1-a_square)

  mov [d],eax

  mov edx,[x2]		     ;x

  mov ebp,[y2]		     ;y

  while_ellips_1:

  mov esi,[a_square]

  mov edi,[b_square]

  imul esi,[row]

  imul edi,[col]

  cmp esi,edi

  jle no_while_ellips_1

  mov eax,edx	     ;x

  mov ebx,ebp	     ;y

  add eax,[col]      ;x+col

  add ebx,[row]      ;y+row

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,edx	     ;x

  mov ebx,ebp	     ;y

  add eax,[col]      ;x+col

  sub ebx,[row]      ;y-row

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,edx	     ;x

  mov ebx,ebp	     ;y

  sub eax,[col]      ;x-col

  add ebx,[row]      ;y+row

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,edx	     ;x

  mov ebx,ebp	     ;y

  sub eax,[col]      ;x-col

  sub ebx,[row]      ;y-row

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,[d]

  cmp eax,0

  js  lab33		 ;>=0

  dec [row]

  mov ebx,[four_a_square]

  mov ecx,[row]

  imul ebx,ecx		;ebx=four_a_square*(row)

  sub [d],ebx		;d=d-four_a_square*(row)

  lab33:

  mov eax,[col]

  shl eax,1

  add eax,3

  imul eax,[two_b_square]

  add [d],eax		;d=d+two_b_square*(3+(col*2))

  inc [col]

  jmp while_ellips_1

  no_while_ellips_1:

  mov eax,[col]

  inc eax

  imul eax,[col]

  imul eax,[two_b_square] ;eax=two_b_square*((col+1)*col)

  mov ebx,[row]

  sub ebx,2

  imul ebx,[row]

  inc ebx

  imul ebx,[two_a_square] ;ebx=two_a_square*((row-2)*row+1)

  mov ecx,1

  sub ecx,[two_a_square]

  imul ecx,[b_square]	  ;ecx=(1-two_a_square)*b_square

  add eax,ebx

  add eax,ecx

  mov [d],eax		  ;two_b_square*(col+1)*col+two_a_square*(row*(row-2)+1)+(1-two_a_square)*b_square

  mov edx,[x2]		     ;x

  mov ebp,[y2]		     ;y

  while_ellips_2:

  mov esi,[row]

  inc esi

  test esi,esi

  jz no_while_ellips_2

  mov eax,edx	     ;x

  mov ebx,ebp	     ;y

  add eax,[col]      ;x+col

  add ebx,[row]      ;y+row

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,edx	     ;x

  mov ebx,ebp	     ;y

  add eax,[col]      ;x+col

  sub ebx,[row]      ;y-row

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,edx	     ;x

  mov ebx,ebp	     ;y

  sub eax,[col]      ;x-col

  add ebx,[row]      ;y+row

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,edx	     ;x

  mov ebx,ebp	     ;y

  sub eax,[col]      ;x-col

  sub ebx,[row]      ;y-row

  mov [pixel_x],eax

  mov [pixel_y],ebx

  call setpixel

  mov eax,[d]

  cmp eax,0

  jns lab34

  inc [col]

  mov ebx,[col]

  imul ebx,[four_b_square]

  add [d],ebx		 ;d=d+four_b_square*col

  lab34:

  dec [row]

  mov ebx,[row]

  shl ebx,1

  mov eax,3

  sub eax,ebx

  imul eax,[two_a_square]

  add [d],eax		;d=d+two_b_square*(3-(row*2))

  jmp while_ellips_2

  no_while_ellips_2:

  mov eax,[output_array]

  sub eax,[e]

  shr eax,2

  ret

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

  x_l dd ?

  y_l dd ?

  x_r dd ?

  y_r dd ?

  _dx dd ?

  _dy dd ?

  sx  dd ?

  sy  dd ?

  z   dd ?

  e   dd ?

  i   dd ?

  _ch dd ?

  x2  dd ?

  y2  dd ?

  d   dd ?

  r   dd ?

  m_x dd ?

  m_y dd ?

  c   dd ?

  c_f dd ?

  l_c dd ?

  l_s dd ?

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

pointer_to_screen      dd 0

screen_size_x	       dd 0

output_array	       dd 0

pixel_x 	       dd 0

pixel_y 	       dd 0

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

a		       dd 0

b		       dd 0

col		       dd 0

row		       dd 0

bnew		       dd 0

a_square	       dd 0

b_square	       dd 0

two_a_square	       dd 0

two_b_square	       dd 0

four_a_square	       dd 0

four_b_square	       dd 0

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