// One of the 16 threads:
/*
#ifdef Commence_OpenMP
    #pragma omp section
#endif
	{
	// x0y2
	// The cycle SF below is from 1+IndexOfX*DivideAndConquer .. (IndexOfX+1)*DivideAndConquer
	// The cycle QB below is from 1+IndexOfY*DivideAndConquer .. (IndexOfY+1)*DivideAndConquer
	// CAUTION: Do not forget that all x3 and/or y3 chunks have lengths different (>=) than DivideAndConquer.
	for (SF=1+0*DivideAndConquer; SF<=(0+1)*DivideAndConquer; SF++) {
	for (QB=1+2*DivideAndConquer; QB<=(2+1)*DivideAndConquer; QB++) {
		CarryFlag = 0;
		Cycle = QB - (1+2*DivideAndConquer) + SF - (1+0*DivideAndConquer) +1; // Here the subtractions are the initial values of SF&QB.
		TillerLeastSignificantDigit = LSDarray[ Multiplicand[(CandLength-SF+1)-1]-'0' ][ Multiplier[(ErLength-QB+1)-1]-'0' ];
		TillerMostSignificantDigit = MSDarray[ Multiplicand[(CandLength-SF+1)-1]-'0' ][ Multiplier[(ErLength-QB+1)-1]-'0' ];
		Result04[Cycle-1] = TillerLeastSignificantDigit + Result04[Cycle-1];
		if ( Result04[Cycle-1] >= 10 ) {
			Result04[Cycle-1] = Result04[Cycle-1] - 10;
			CarryFlag = 1;
		}
		NextNumPos = Cycle + 1;
		Result04[NextNumPos-1] = Result04[NextNumPos-1] + CarryFlag + TillerMostSignificantDigit;
		while (Result04[NextNumPos-1] >= 10) {
			Result04[NextNumPos-1] = Result04[NextNumPos-1] - 10;
			NextNumPos = NextNumPos + 1;
			Result04[NextNumPos-1] = Result04[NextNumPos-1] + 1;
		}
	}
	}
	//Here we have the result (REVERSED) in ASCII codes i.e. '0' stands for ASCII 000.
	ResLength=(DivideAndConquer+DivideAndConquer); // CAUTION: Do not forget that all x3 and/or y3 chunks have lengths different (>=) than DivideAndConquer.
	if (Result04[ResLength-1] == 0x00) ResLength--;

	//The last thing to be done: the in-place reversal:
	for (SF=1; SF<=ResLength/2; SF++) {
		CarryFlag = Result04[SF-1];
		Result04[SF-1] = Result04[(ResLength-SF+1)-1]+'0';
		Result04[(ResLength-SF+1)-1] = CarryFlag+'0';
	}
	if (ResLength%2 != 0)
		Result04[(ResLength/2+1)-1] = Result04[(ResLength/2+1)-1]+'0';
	//Terminate it:
	Result04[ResLength] = 0;
	}
*/

// The main loop of one of the 16 threads, the 64bit assembly, the three nested loops are 00f7c-00e2f+6 = 339 bytes long:
/*
;;; 	// x0y2
;;; 	// The cycle SF below is from 1+IndexOfX*DivideAndConquer .. (IndexOfX+1)*DivideAndConquer
;;; 	// The cycle QB below is from 1+IndexOfY*DivideAndConquer .. (IndexOfY+1)*DivideAndConquer
;;; 	// CAUTION: Do not forget that all x3 and/or y3 chunks have lengths different (>=) than DivideAndConquer.
;;; 	for (SF=1+0*DivideAndConquer; SF<=(0+1)*DivideAndConquer; SF++) {
;;; 	for (QB=1+2*DivideAndConquer; QB<=(2+1)*DivideAndConquer; QB++) {

.B2.133::                            					; !!! First loop [ !!!
  00e2f 45 89 fa         mov r10d, r15d                         
  00e32 41 8d 1c 07      lea ebx, DWORD PTR [r15+rax]           
  00e36 41 2b dd         sub ebx, r13d                          
  00e39 45 33 db         xor r11d, r11d                         
  00e3c 41 f7 da         neg r10d                               
  00e3f 89 dd            mov ebp, ebx                           
  00e41 44 3b ff         cmp r15d, edi                          
  00e44 0f 87 26 01 00 
        00               ja .B2.144 
.B2.134::                       
  00e4a 4c 89 b4 24 f8 
        02 00 00         mov QWORD PTR [760+rsp], r14           

;;; 		CarryFlag = 0;
;;; 		Cycle = QB - (1+2*DivideAndConquer) + SF - (1+0*DivideAndConquer) +1; // Here the subtractions are the initial values of SF&QB.
;;; 		TillerLeastSignificantDigit = LSDarray[ Multiplicand[(CandLength-SF+1)-1]-'0' ][ Multiplier[(ErLength-QB+1)-1]-'0' ];

  00e52 46 8d 64 06 ff   lea r12d, DWORD PTR [-1+rsi+r8]        
  00e57 89 bc 24 98 02 
        00 00            mov DWORD PTR [664+rsp], edi           
  00e5e 89 b4 24 90 02 
        00 00            mov DWORD PTR [656+rsp], esi           
  00e65 44 89 4c 24 50   mov DWORD PTR [80+rsp], r9d            
  00e6a 43 0f b6 14 34   movzx edx, BYTE PTR [r12+r14]          
  00e6f 44 89 44 24 48   mov DWORD PTR [72+rsp], r8d            
  00e74 89 44 24 38      mov DWORD PTR [56+rsp], eax            
  00e78 4c 8b bc 24 80 
        02 00 00         mov r15, QWORD PTR [640+rsp]           
  00e80 48 8d 0c 92      lea rcx, QWORD PTR [rdx+rdx*4]         
  00e84 44 8b ac 24 a8 
        02 00 00         mov r13d, DWORD PTR [680+rsp]          
  00e8c 4c 8d a4 4c 60 
        01 00 00         lea r12, QWORD PTR [352+rsp+rcx*2]     
  00e94 4c 8b b4 24 a0 
        02 00 00         mov r14, QWORD PTR [672+rsp]           
  00e9c 48 8d 8c 4c c4 
        01 00 00         lea rcx, QWORD PTR [452+rsp+rcx*2]     
  00ea4 41 8d 14 01      lea edx, DWORD PTR [r9+rax]            
.B2.135::                            					; !!! Second loop [ !!!
  00ea8 45 32 c9         xor r9b, r9b                           
  00eab 43 8d 7c 15 00   lea edi, DWORD PTR [r13+r10]           
  00eb0 42 0f b6 04 37   movzx eax, BYTE PTR [rdi+r14]          
  00eb5 44 0f b6 84 08 
        f0 fd ff ff      movzx r8d, BYTE PTR [-528+rax+rcx]     

;;; 		TillerMostSignificantDigit = MSDarray[ Multiplicand[(CandLength-SF+1)-1]-'0' ][ Multiplier[(ErLength-QB+1)-1]-'0' ];

  00ebe 42 8a bc 20 f0 
        fd ff ff         mov dil, BYTE PTR [-528+rax+r12]       

;;; 		Result04[Cycle-1] = TillerLeastSignificantDigit + Result04[Cycle-1];

  00ec6 8d 43 ff         lea eax, DWORD PTR [-1+rbx]            
  00ec9 42 0f b6 34 38   movzx esi, BYTE PTR [rax+r15]          
  00ece 41 03 f0         add esi, r8d                           

;;; 		if ( Result04[Cycle-1] >= 10 ) {

  00ed1 44 0f b6 c6      movzx r8d, sil                         
  00ed5 41 83 f8 0a      cmp r8d, 10                            
  00ed9 7c 0d            jl .B2.137 
.B2.136::                       

;;; 			Result04[Cycle-1] = Result04[Cycle-1] - 10;

  00edb 41 83 c0 f6      add r8d, -10                           

;;; 			CarryFlag = 1;

  00edf 41 b1 01         mov r9b, 1                             
  00ee2 46 88 04 38      mov BYTE PTR [rax+r15], r8b            
  00ee6 eb 04            jmp .B2.138 
.B2.137::                       
  00ee8 42 88 34 38      mov BYTE PTR [rax+r15], sil            
.B2.138::                       

;;; 		}
;;; 		NextNumPos = Cycle + 1;
;;; 		Result04[NextNumPos-1] = Result04[NextNumPos-1] + CarryFlag + TillerMostSignificantDigit;

  00eec 42 8a 04 3b      mov al, BYTE PTR [rbx+r15]             
  00ef0 40 02 c7         add al, dil                            
  00ef3 41 02 c1         add al, r9b                            
  00ef6 42 88 04 3b      mov BYTE PTR [rbx+r15], al             

;;; 		while (Result04[NextNumPos-1] >= 10) {

  00efa 42 0f b6 74 3d 
        00               movzx esi, BYTE PTR [rbp+r15]          
  00f00 83 fe 0a         cmp esi, 10                            
  00f03 7c 22            jl .B2.142 
.B2.139::                       
  00f05 42 8d 04 1a      lea eax, DWORD PTR [rdx+r11]           
.B2.140::                       					; !!! Third loop [ !!!
  00f09 ff c0            inc eax                                

;;; 			Result04[NextNumPos-1] = Result04[NextNumPos-1] - 10;

  00f0b 8d 70 ff         lea esi, DWORD PTR [-1+rax]            

;;; 			NextNumPos = NextNumPos + 1;
;;; 			Result04[NextNumPos-1] = Result04[NextNumPos-1] + 1;

  00f0e 42 80 04 3e f6   add BYTE PTR [rsi+r15], -10            
  00f13 42 0f b6 3c 38   movzx edi, BYTE PTR [rax+r15]          
  00f18 ff c7            inc edi                                
  00f1a 42 88 3c 38      mov BYTE PTR [rax+r15], dil            
  00f1e 40 0f b6 ff      movzx edi, dil                         
  00f22 83 ff 0a         cmp edi, 10                            
  00f25 7d e2            jge .B2.140 					; !!! Third loop ] !!!
.B2.142::                       
  00f27 41 ff c3         inc r11d                               
  00f2a 41 ff ca         dec r10d                               
  00f2d ff c5            inc ebp                                
  00f2f ff c3            inc ebx                                
  00f31 44 3b 5c 24 58   cmp r11d, DWORD PTR [88+rsp]           
  00f36 0f 82 6c ff ff 
        ff               jb .B2.135  					; !!! Second loop ] !!!
.B2.143::                       
  00f3c 8b bc 24 98 02 
        00 00            mov edi, DWORD PTR [664+rsp]           
  00f43 44 8b ac 24 d8 
        02 00 00         mov r13d, DWORD PTR [728+rsp]          
  00f4b 8b b4 24 90 02 
        00 00            mov esi, DWORD PTR [656+rsp]           
  00f52 44 8b 4c 24 50   mov r9d, DWORD PTR [80+rsp]            
  00f57 44 8b bc 24 e0 
        02 00 00         mov r15d, DWORD PTR [736+rsp]          
  00f5f 44 8b 44 24 48   mov r8d, DWORD PTR [72+rsp]            
  00f64 8b 44 24 38      mov eax, DWORD PTR [56+rsp]            
  00f68 4c 8b b4 24 f8 
        02 00 00         mov r14, QWORD PTR [760+rsp]           
.B2.144::                       
  00f70 ff c0            inc eax                                
  00f72 41 ff c8         dec r8d                                
  00f75 3b 84 24 d0 02 
        00 00            cmp eax, DWORD PTR [720+rsp]           
  00f7c 0f 82 ad fe ff 
        ff               jb .B2.133  					; !!! First loop ] !!!
*/
// Intel(R) C++ Intel(R) 64 Compiler XE for applications running on Intel(R) 64, Version 12.1.1.258 Build 20111011 was used.