code 31203;
procedure LNG INT DIVIDE(U,V,QUOTIENT,REMAINDER); value U;
integer array U,V,QUOTIENT,REMAINDER;
begin integer LU,LV,V1,DIFF,I,T,SCALE,D,Q1,J,CARRY;
   LU:=U[0]; LV:=V[0]; V1:=V[1]; DIFF:=LU - LV;

   if LV=1 then 
   begin CARRY:=0;
      for I:=1 step 1 until LU do 
      begin T:=CARRY * 10 000 000 + U[I]; QUOTIENT[I]:=T//V1;
         CARRY:=T - QUOTIENT[I] * V1
      end; REMAINDER[0]:=1; REMAINDER[1]:=CARRY;
      if QUOTIENT[1]=0 then 
      begin for I:=2 step 1 until LU do 
         QUOTIENT[I-1]:=QUOTIENT[I];
         QUOTIENT[0]:=LU - (if LU=1 then 0 else 1)
      end else QUOTIENT[0]:=LU
   end LV=1
   else 

   if LU<LV then 
   begin QUOTIENT[0]:=1; QUOTIENT[1]:=0;
      for I:=0 step 1 until LU do REMAINDER[I]:=U[I]
   end LU<LV
   else 

   begin integer array A[0:LV];
      SCALE:=10 000 000//(V1+1);
      if SCALE>1 then 
      begin comment NORMALIZE U; CARRY:=0;
         for I:=LU step -1 until 1 do 
         begin T:=SCALE * U[I] + CARRY; CARRY:=T//10 000 000;
            U[I]:=T - CARRY * 10 000 000
         end; U[0]:=CARRY;
         comment NORMALIZE V; CARRY:=0;
         for I:=LV step -1 until 1 do 
         begin T:=SCALE * V[I] + CARRY; CARRY:=T//10 000 000;
            V[I]:=T - CARRY * 10 000 000
         end; V1:=V[1]
      end NORMALIZATION
      comment COMPUTE QUOTIENT AND REMAINDER;
      for I:=0 step 1 until DIFF do 
      begin D:=U[I] * 10 000 000 + U[I+1];
         Q1:=if U[I]=V1 then 9 999 999 else D//V1;
         if V[2] * Q1 > (D-Q1*V1) * 10 000 000 + U[I+2] then 
         begin Q1:=Q1 - 1;
            if V[2]*Q1>(D-Q1*V1)*10 000 000+U[I+2] then Q1:=Q1-1
         end;

         comment U[I:I+LV]:=U[I:I+LV] - Q1 * V[1:LV];
         CARRY:=0;
         for J:=LV step -1 until 1 do 
         begin T:=Q1 * V[J] + CARRY; CARRY:=T//10 000 000;
            A[J]:=T - CARRY * 10 000 000
         end; A[0]:=CARRY;
         CARRY:=0;
         for J:=LV step -1 until 0 do 
         begin T:=U[I+J] - A[J] + CARRY; CARRY:=if T<0 then -1
            else 0; U[I+J]:=T - CARRY * 10 000 000
         end;

         comment IF CARRY=-1 THEN Q1 IS ONE TOO LARGE,
         AND V MUST BE ADDED BACK TO U[I:I+LV];
         if CARRY=-1 then 
         begin Q1:=Q1 - 1; CARRY:=0;
            for J:=LV step -1 until 1 do 
            begin T:=U[I+J] + V[J] + CARRY; CARRY:=if T<10 000 000
               then 0 else 1; U[I+J]:=T - CARRY * 10 000 000
            end 
         end; QUOTIENT[I]:=Q1
      end I;

      comment CORRECT STORAGE OF QUOTIENT;
      if QUOTIENT[0] ^= 0 then 
      begin for I:=DIFF step -1 until 0 do 
         QUOTIENT[I+1]:=QUOTIENT[I]; QUOTIENT[0]:=DIFF + 1
      end else 
      if DIFF < 2 then 
      begin QUOTIENT[0]:= 1; if DIFF = 0 then QUOTIENT[1]:= 0
      end else 
      if QUOTIENT[1] ^= 0 then QUOTIENT[0]:=DIFF else 
      begin for I:=1 step 1 until DIFF - 1 do 
         QUOTIENT[I]:=QUOTIENT[I+1]; QUOTIENT[0]:=DIFF - 1
      comment REMAINDER := U[DIFF+1:LU]//SCALE;
      if SCALE>1 then 
      begin CARRY:=0;
         for I:=1 step 1 until LV do 
         begin T:=CARRY * 10 000 000 + U[DIFF+I];
            REMAINDER[I]:=T//SCALE; CARRY:=T - REMAINDER[I] * SCALE
         end 
      end else 
      for I:=1 step 1 until LV do REMAINDER[I]:=U[DIFF+I];

      comment CORRECT STORAGE OF REMAINDER;
      I:=0; J:=LV;
      for I:=I+1 while REMAINDER[I]=0 and J>1 do J:=J-1;
      REMAINDER[0]:=J;
      if J<LV then 
      for I:=1 step 1 until J do 
      REMAINDER[I]:=REMAINDER[LV + I - J];

      comment UNNORMALIZE THE DIVISOR V;
      if SCALE>1 then 
      begin CARRY:=0;
         for I:=1 step 1 until LV do 
         begin T:=CARRY * 10 000 000 + V[I];
            V[I]:=T//SCALE; CARRY:=T - V[I] * SCALE
         end 
      end 
   end 
end LNG INT DIVIDE;
        eop