OSchip
/
OpenBLAS
Not watched
1
0
Fork 0
Code
Releases 66 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 056ba26755
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '056ba26755'
${ noResults }
OpenBLAS/kernel/generic/zlaswp_ncopy_4.c

712 lines
15 kB
Raw Blame History 

  1. /*********************************************************************/

  2. /* Copyright 2009, 2010 The University of Texas at Austin.           */

  3. /* All rights reserved.                                              */

  4. /*                                                                   */

  5. /* Redistribution and use in source and binary forms, with or        */

  6. /* without modification, are permitted provided that the following   */

  7. /* conditions are met:                                               */

  8. /*                                                                   */

  9. /*   1. Redistributions of source code must retain the above         */

  10. /*      copyright notice, this list of conditions and the following  */

  11. /*      disclaimer.                                                  */

  12. /*                                                                   */

  13. /*   2. Redistributions in binary form must reproduce the above      */

  14. /*      copyright notice, this list of conditions and the following  */

  15. /*      disclaimer in the documentation and/or other materials       */

  16. /*      provided with the distribution.                              */

  17. /*                                                                   */

  18. /*    THIS  SOFTWARE IS PROVIDED  BY THE  UNIVERSITY OF  TEXAS AT    */

  19. /*    AUSTIN  ``AS IS''  AND ANY  EXPRESS OR  IMPLIED WARRANTIES,    */

  20. /*    INCLUDING, BUT  NOT LIMITED  TO, THE IMPLIED  WARRANTIES OF    */

  21. /*    MERCHANTABILITY  AND FITNESS FOR  A PARTICULAR  PURPOSE ARE    */

  22. /*    DISCLAIMED.  IN  NO EVENT SHALL THE UNIVERSITY  OF TEXAS AT    */

  23. /*    AUSTIN OR CONTRIBUTORS BE  LIABLE FOR ANY DIRECT, INDIRECT,    */

  24. /*    INCIDENTAL,  SPECIAL, EXEMPLARY,  OR  CONSEQUENTIAL DAMAGES    */

  25. /*    (INCLUDING, BUT  NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE    */

  26. /*    GOODS  OR  SERVICES; LOSS  OF  USE,  DATA,  OR PROFITS;  OR    */

  27. /*    BUSINESS INTERRUPTION) HOWEVER CAUSED  AND ON ANY THEORY OF    */

  28. /*    LIABILITY, WHETHER  IN CONTRACT, STRICT  LIABILITY, OR TORT    */

  29. /*    (INCLUDING NEGLIGENCE OR OTHERWISE)  ARISING IN ANY WAY OUT    */

  30. /*    OF  THE  USE OF  THIS  SOFTWARE,  EVEN  IF ADVISED  OF  THE    */

  31. /*    POSSIBILITY OF SUCH DAMAGE.                                    */

  32. /*                                                                   */

  33. /* The views and conclusions contained in the software and           */

  34. /* documentation are those of the authors and should not be          */

  35. /* interpreted as representing official policies, either expressed   */

  36. /* or implied, of The University of Texas at Austin.                 */

  37. /*********************************************************************/

  38. 

  39. #include <stdio.h>

  40. #include "common.h"

  41. 

  42. #define a2	(a1 + 2)

  43. #define a4	(a3 + 2)

  44. #define a6	(a5 + 2)

  45. #define a8	(a7 + 2)

  46. 

  47. int CNAME(BLASLONG n, BLASLONG k1, BLASLONG k2, FLOAT *a, BLASLONG lda, blasint *ipiv, FLOAT *buffer){

  48. 

  49.   BLASLONG i, j, ip1, ip2;

  50.   blasint *piv;

  51.   FLOAT *a1, *a3, *a5, *a7;

  52.   FLOAT *b1, *b2, *b3, *b4;

  53.   FLOAT *b5, *b6, *b7, *b8;

  54.   FLOAT A1, A2, A3, A4, A5, A6, A7, A8;

  55.   FLOAT B1, B2, B3, B4, B5, B6, B7, B8;

  56. 

  57.   FLOAT A9, A10, A11, A12, A13, A14, A15, A16;

  58.   FLOAT B9, B10, B11, B12, B13, B14, B15, B16;

  59. 

  60.   a -= 2;

  61.   lda *= 2;

  62.   k1 --;

  63. 

  64.  ipiv += k1;

  65. 

  66.   if (n  <= 0) return 0;

  67. 

  68.   j = (n >> 2);

  69.   if (j > 0) {

  70.     do {

  71.       piv = ipiv;

  72. 

  73.       a1 = a + (k1 + 1) * 2;

  74. 

  75.       a3 = a1 + 1 * lda;

  76.       a5 = a1 + 2 * lda;

  77.       a7 = a1 + 3 * lda;

  78. 

  79.       ip1 = *(piv + 0) * 2;

  80.       ip2 = *(piv + 1) * 2;

  81.       piv += 2;

  82. 

  83.       b1 = a + ip1;

  84.       b2 = a + ip2;

  85. 

  86.       b3 = b1 + 1 * lda;

  87.       b4 = b2 + 1 * lda;

  88.       b5 = b1 + 2 * lda;

  89.       b6 = b2 + 2 * lda;

  90.       b7 = b1 + 3 * lda;

  91.       b8 = b2 + 3 * lda;

  92. 

  93.       i = ((k2 - k1) >> 1);

  94. 

  95.       if (i > 0) {

  96. 	do {

  97. 	  A1  = *(a1 + 0);

  98. 	  A9  = *(a1 + 1);

  99. 	  A2  = *(a2 + 0);

  100. 	  A10 = *(a2 + 1);

  101. 	  A3  = *(a3 + 0);

  102. 	  A11 = *(a3 + 1);

  103. 	  A4  = *(a4 + 0);

  104. 	  A12 = *(a4 + 1);

  105. 	  A5  = *(a5 + 0);

  106. 	  A13 = *(a5 + 1);

  107. 	  A6  = *(a6 + 0);

  108. 	  A14 = *(a6 + 1);

  109. 	  A7  = *(a7 + 0);

  110. 	  A15 = *(a7 + 1);

  111. 	  A8  = *(a8 + 0);

  112. 	  A16 = *(a8 + 1);

  113. 

  114. 	  B1  = *(b1 + 0);

  115. 	  B9  = *(b1 + 1);

  116. 	  B2  = *(b2 + 0);

  117. 	  B10 = *(b2 + 1);

  118. 	  B3  = *(b3 + 0);

  119. 	  B11 = *(b3 + 1);

  120. 	  B4  = *(b4 + 0);

  121. 	  B12 = *(b4 + 1);

  122. 	  B5  = *(b5 + 0);

  123. 	  B13 = *(b5 + 1);

  124. 	  B6  = *(b6 + 0);

  125. 	  B14 = *(b6 + 1);

  126. 	  B7  = *(b7 + 0);

  127. 	  B15 = *(b7 + 1);

  128. 	  B8  = *(b8 + 0);

  129. 	  B16 = *(b8 + 1);

  130. 

  131. 	  ip1 = *(piv + 0) * 2;

  132. 	  ip2 = *(piv + 1) * 2;

  133. 	  piv += 2;

  134. 

  135. 	if (b1 == a1) {

  136. 	    if (b2 == a2) {

  137. 	      *(buffer +  0) = A1;

  138. 	      *(buffer +  1) = A9;

  139. 	      *(buffer +  2) = A3;

  140. 	      *(buffer +  3) = A11;

  141. 	      *(buffer +  4) = A5;

  142. 	      *(buffer +  5) = A13;

  143. 	      *(buffer +  6) = A7;

  144. 	      *(buffer +  7) = A15;

  145. 

  146. 	      *(buffer +  8) = A2;

  147. 	      *(buffer +  9) = A10;

  148. 	      *(buffer + 10) = A4;

  149. 	      *(buffer + 11) = A12;

  150. 	      *(buffer + 12) = A6;

  151. 	      *(buffer + 13) = A14;

  152. 	      *(buffer + 14) = A8;

  153. 	      *(buffer + 15) = A16;

  154. 	    } else {

  155. 	      *(buffer +  0) = A1;

  156. 	      *(buffer +  1) = A9;

  157. 	      *(buffer +  2) = A3;

  158. 	      *(buffer +  3) = A11;

  159. 	      *(buffer +  4) = A5;

  160. 	      *(buffer +  5) = A13;

  161. 	      *(buffer +  6) = A7;

  162. 	      *(buffer +  7) = A15;

  163. 

  164. 	      *(buffer +  8) = B2;

  165. 	      *(buffer +  9) = B10;

  166. 	      *(buffer + 10) = B4;

  167. 	      *(buffer + 11) = B12;

  168. 	      *(buffer + 12) = B6;

  169. 	      *(buffer + 13) = B14;

  170. 	      *(buffer + 14) = B8;

  171. 	      *(buffer + 15) = B16;

  172. 

  173. 	      *(b2 + 0) = A2;

  174. 	      *(b2 + 1) = A10;

  175. 	      *(b4 + 0) = A4;

  176. 	      *(b4 + 1) = A12;

  177. 	      *(b6 + 0) = A6;

  178. 	      *(b6 + 1) = A14;

  179. 	      *(b8 + 0) = A8;

  180. 	      *(b8 + 1) = A16;

  181. 	    }

  182. 	} else

  183. 	  if (b1 == a2) {

  184. 	      if (b2 == a2) {

  185. 		*(buffer +  0) = A2;

  186. 		*(buffer +  1) = A10;

  187. 		*(buffer +  2) = A4;

  188. 		*(buffer +  3) = A12;

  189. 		*(buffer +  4) = A6;

  190. 		*(buffer +  5) = A14;

  191. 		*(buffer +  6) = A8;

  192. 		*(buffer +  7) = A16;

  193. 		*(buffer +  8) = A1;

  194. 		*(buffer +  9) = A9;

  195. 		*(buffer + 10) = A3;

  196. 		*(buffer + 11) = A11;

  197. 		*(buffer + 12) = A5;

  198. 		*(buffer + 13) = A13;

  199. 		*(buffer + 14) = A7;

  200. 		*(buffer + 15) = A15;

  201. 

  202. 	      } else {

  203. 		*(buffer +  0) = A2;

  204. 		*(buffer +  1) = A10;

  205. 		*(buffer +  2) = A4;

  206. 		*(buffer +  3) = A12;

  207. 		*(buffer +  4) = A6;

  208. 		*(buffer +  5) = A14;

  209. 		*(buffer +  6) = A8;

  210. 		*(buffer +  7) = A16;

  211. 		*(buffer +  8) = B2;

  212. 		*(buffer +  9) = B10;

  213. 		*(buffer + 10) = B4;

  214. 		*(buffer + 11) = B12;

  215. 		*(buffer + 12) = B6;

  216. 		*(buffer + 13) = B14;

  217. 		*(buffer + 14) = B8;

  218. 		*(buffer + 15) = B16;

  219. 

  220. 		*(b2 + 0) = A1;

  221. 		*(b2 + 1) = A9;

  222. 		*(b4 + 0) = A3;

  223. 		*(b4 + 1) = A11;

  224. 		*(b6 + 0) = A5;

  225. 		*(b6 + 1) = A13;

  226. 		*(b8 + 0) = A7;

  227. 		*(b8 + 1) = A15;

  228. 	      }

  229. 	  } else {

  230. 	      if (b2 == a2) {

  231. 		*(buffer +  0) = B1;

  232. 		*(buffer +  1) = B9;

  233. 		*(buffer +  2) = B3;

  234. 		*(buffer +  3) = B11;

  235. 		*(buffer +  4) = B5;

  236. 		*(buffer +  5) = B13;

  237. 		*(buffer +  6) = B7;

  238. 		*(buffer +  7) = B15;

  239. 		*(buffer +  8) = A2;

  240. 		*(buffer +  9) = A10;

  241. 		*(buffer + 10) = A4;

  242. 		*(buffer + 11) = A12;

  243. 		*(buffer + 12) = A6;

  244. 		*(buffer + 13) = A14;

  245. 		*(buffer + 14) = A8;

  246. 		*(buffer + 15) = A16;

  247. 

  248. 		*(b1 + 0) = A1;

  249. 		*(b1 + 1) = A9;

  250. 		*(b3 + 0) = A3;

  251. 		*(b3 + 1) = A11;

  252. 		*(b5 + 0) = A5;

  253. 		*(b5 + 1) = A13;

  254. 		*(b7 + 0) = A7;

  255. 		*(b7 + 1) = A15;

  256. 	      } else

  257. 		if (b2 == b1) {

  258. 		  *(buffer +  0) = B1;

  259. 		  *(buffer +  1) = B9;

  260. 		  *(buffer +  2) = B3;

  261. 		  *(buffer +  3) = B11;

  262. 		  *(buffer +  4) = B5;

  263. 		  *(buffer +  5) = B13;

  264. 		  *(buffer +  6) = B7;

  265. 		  *(buffer +  7) = B15;

  266. 		  *(buffer +  8) = A1;

  267. 		  *(buffer +  9) = A9;

  268. 		  *(buffer + 10) = A3;

  269. 		  *(buffer + 11) = A11;

  270. 		  *(buffer + 12) = A5;

  271. 		  *(buffer + 13) = A13;

  272. 		  *(buffer + 14) = A7;

  273. 		  *(buffer + 15) = A15;

  274. 

  275. 		  *(b1 + 0) = A2;

  276. 		  *(b1 + 1) = A10;

  277. 		  *(b3 + 0) = A4;

  278. 		  *(b3 + 1) = A12;

  279. 		  *(b5 + 0) = A6;

  280. 		  *(b5 + 1) = A14;

  281. 		  *(b7 + 0) = A8;

  282. 		  *(b7 + 1) = A16;

  283. 		} else {

  284. 		  *(buffer +  0) = B1;

  285. 		  *(buffer +  1) = B9;

  286. 		  *(buffer +  2) = B3;

  287. 		  *(buffer +  3) = B11;

  288. 		  *(buffer +  4) = B5;

  289. 		  *(buffer +  5) = B13;

  290. 		  *(buffer +  6) = B7;

  291. 		  *(buffer +  7) = B15;

  292. 		  *(buffer +  8) = B2;

  293. 		  *(buffer +  9) = B10;

  294. 		  *(buffer + 10) = B4;

  295. 		  *(buffer + 11) = B12;

  296. 		  *(buffer + 12) = B6;

  297. 		  *(buffer + 13) = B14;

  298. 		  *(buffer + 14) = B8;

  299. 		  *(buffer + 15) = B16;

  300. 

  301. 		  *(b1 + 0) = A1;

  302. 		  *(b1 + 1) = A9;

  303. 		  *(b2 + 0) = A2;

  304. 		  *(b2 + 1) = A10;

  305. 		  *(b3 + 0) = A3;

  306. 		  *(b3 + 1) = A11;

  307. 		  *(b4 + 0) = A4;

  308. 		  *(b4 + 1) = A12;

  309. 		  *(b5 + 0) = A5;

  310. 		  *(b5 + 1) = A13;

  311. 		  *(b6 + 0) = A6;

  312. 		  *(b6 + 1) = A14;

  313. 		  *(b7 + 0) = A7;

  314. 		  *(b7 + 1) = A15;

  315. 		  *(b8 + 0) = A8;

  316. 		  *(b8 + 1) = A16;

  317. 		}

  318. 	  }

  319. 

  320. 	 buffer += 16;

  321. 

  322. 	  b1 = a + ip1;

  323. 	  b2 = a + ip2;

  324. 

  325. 	  b3 = b1 + 1 * lda;

  326. 	  b4 = b2 + 1 * lda;

  327. 	  b5 = b1 + 2 * lda;

  328. 	  b6 = b2 + 2 * lda;

  329. 	  b7 = b1 + 3 * lda;

  330. 	  b8 = b2 + 3 * lda;

  331. 

  332. 	  a1 += 4;

  333. 	  a3 += 4;

  334. 	  a5 += 4;

  335. 	  a7 += 4;

  336. 

  337. 	i --;

  338. 	} while (i > 0);

  339.       }

  340. 

  341.       i = ((k2 - k1) & 1);

  342. 

  343.       if (i > 0) {

  344. 	A1  = *(a1 + 0);

  345. 	A9  = *(a1 + 1);

  346. 	B1  = *(b1 + 0);

  347. 	B9  = *(b1 + 1);

  348. 	A3  = *(a3 + 0);

  349. 	A11 = *(a3 + 1);

  350. 	B3  = *(b3 + 0);

  351. 	B11 = *(b3 + 1);

  352. 	A5  = *(a5 + 0);

  353. 	A13 = *(a5 + 1);

  354. 	B5  = *(b5 + 0);

  355. 	B13 = *(b5 + 1);

  356. 	A7  = *(a7 + 0);

  357. 	A15 = *(a7 + 1);

  358. 	B7  = *(b7 + 0);

  359. 	B15 = *(b7 + 1);

  360. 

  361. 	if (a1 == b1) {

  362. 	  *(buffer + 0) = A1;

  363. 	  *(buffer + 1) = A9;

  364. 	  *(buffer + 2) = A3;

  365. 	  *(buffer + 3) = A11;

  366. 	  *(buffer + 4) = A5;

  367. 	  *(buffer + 5) = A13;

  368. 	  *(buffer + 6) = A7;

  369. 	  *(buffer + 7) = A15;

  370. 	} else {

  371. 	  *(buffer + 0) = B1;

  372. 	  *(buffer + 1) = B9;

  373. 	  *(buffer + 2) = B3;

  374. 	  *(buffer + 3) = B11;

  375. 	  *(buffer + 4) = B5;

  376. 	  *(buffer + 5) = B13;

  377. 	  *(buffer + 6) = B7;

  378. 	  *(buffer + 7) = B15;

  379. 

  380. 	  *(b1 + 0) = A1;

  381. 	  *(b1 + 1) = A9;

  382. 	  *(b3 + 0) = A3;

  383. 	  *(b3 + 1) = A11;

  384. 	  *(b5 + 0) = A5;

  385. 	  *(b5 + 1) = A13;

  386. 	  *(b7 + 0) = A7;

  387. 	  *(b7 + 1) = A15;

  388. 	}

  389. 	buffer += 8;

  390.       }

  391. 

  392.       a += 4 * lda;

  393. 

  394.       j --;

  395.     } while (j > 0);

  396.   }

  397. 

  398.   if (n & 2) {

  399.     piv = ipiv;

  400. 

  401.     a1 = a + (k1 + 1) * 2;

  402.     a3 = a1 + lda;

  403. 

  404.     ip1 = *(piv + 0) * 2;

  405.     ip2 = *(piv + 1) * 2;

  406.     piv += 2;

  407. 

  408.     b1 = a + ip1;

  409.     b2 = a + ip2;

  410. 

  411.     b3 = b1 + lda;

  412.     b4 = b2 + lda;

  413. 

  414.     i = ((k2 - k1) >> 1);

  415. 

  416.     if (i > 0) {

  417.       do {

  418. 	A1 = *(a1 + 0);

  419. 	A2 = *(a1 + 1);

  420. 	A3 = *(a2 + 0);

  421. 	A4 = *(a2 + 1);

  422. 	A5 = *(a3 + 0);

  423. 	A6 = *(a3 + 1);

  424. 	A7 = *(a4 + 0);

  425. 	A8 = *(a4 + 1);

  426. 

  427. 	B1 = *(b1 + 0);

  428. 	B2 = *(b1 + 1);

  429. 	B3 = *(b2 + 0);

  430. 	B4 = *(b2 + 1);

  431. 	B5 = *(b3 + 0);

  432. 	B6 = *(b3 + 1);

  433. 	B7 = *(b4 + 0);

  434. 	B8 = *(b4 + 1);

  435. 

  436. 	ip1 = *(piv + 0) * 2;

  437. 	ip2 = *(piv + 1) * 2;

  438. 	piv += 2;

  439. 

  440. 	if (b1 == a1) {

  441. 	  if (b2 == a2) {

  442. 	    *(buffer + 0) = A1;

  443. 	    *(buffer + 1) = A2;

  444. 	    *(buffer + 2) = A5;

  445. 	    *(buffer + 3) = A6;

  446. 	    *(buffer + 4) = A3;

  447. 	    *(buffer + 5) = A4;

  448. 	    *(buffer + 6) = A7;

  449. 	    *(buffer + 7) = A8;

  450. 	  } else {

  451. 	    *(buffer + 0) = A1;

  452. 	    *(buffer + 1) = A2;

  453. 	    *(buffer + 2) = A5;

  454. 	    *(buffer + 3) = A6;

  455. 	    *(buffer + 4) = B3;

  456. 	    *(buffer + 5) = B4;

  457. 	    *(buffer + 6) = B7;

  458. 	    *(buffer + 7) = B8;

  459. 

  460. 	    *(b2 + 0) = A3;

  461. 	    *(b2 + 1) = A4;

  462. 	    *(b4 + 0) = A7;

  463. 	    *(b4 + 1) = A8;

  464. 	  }

  465. 	} else

  466. 	  if (b1 == a2) {

  467. 	    if (b2 == a2) {

  468. 	      *(buffer + 0) = A3;

  469. 	      *(buffer + 1) = A4;

  470. 	      *(buffer + 2) = A7;

  471. 	      *(buffer + 3) = A8;

  472. 	      *(buffer + 4) = A1;

  473. 	      *(buffer + 5) = A2;

  474. 	      *(buffer + 6) = A5;

  475. 	      *(buffer + 7) = A6;

  476. 	    } else {

  477. 	      *(buffer + 0) = A3;

  478. 	      *(buffer + 1) = A4;

  479. 	      *(buffer + 2) = A7;

  480. 	      *(buffer + 3) = A8;

  481. 	      *(buffer + 4) = B3;

  482. 	      *(buffer + 5) = B4;

  483. 	      *(buffer + 6) = B7;

  484. 	      *(buffer + 7) = B8;

  485. 

  486. 	      *(b2 + 0) = A1;

  487. 	      *(b2 + 1) = A2;

  488. 	      *(b4 + 0) = A5;

  489. 	      *(b4 + 1) = A6;

  490. 	    }

  491. 	  } else {

  492. 	    if (b2 == a2) {

  493. 	      *(buffer + 0) = B1;

  494. 	      *(buffer + 1) = B2;

  495. 	      *(buffer + 2) = B5;

  496. 	      *(buffer + 3) = B6;

  497. 	      *(buffer + 4) = A3;

  498. 	      *(buffer + 5) = A4;

  499. 	      *(buffer + 6) = A7;

  500. 	      *(buffer + 7) = A8;

  501. 

  502. 	      *(b1 + 0) = A1;

  503. 	      *(b1 + 1) = A2;

  504. 	      *(b3 + 0) = A5;

  505. 	      *(b3 + 1) = A6;

  506. 	    } else

  507. 	      if (b2 == b1) {

  508. 		*(buffer + 0) = B1;

  509. 		*(buffer + 1) = B2;

  510. 		*(buffer + 2) = B5;

  511. 		*(buffer + 3) = B6;

  512. 		*(buffer + 4) = A1;

  513. 		*(buffer + 5) = A2;

  514. 		*(buffer + 6) = A5;

  515. 		*(buffer + 7) = A6;

  516. 

  517. 		*(b1 + 0) = A3;

  518. 		*(b1 + 1) = A4;

  519. 		*(b3 + 0) = A7;

  520. 		*(b3 + 1) = A8;

  521. 	      } else {

  522. 		*(buffer + 0) = B1;

  523. 		*(buffer + 1) = B2;

  524. 		*(buffer + 2) = B5;

  525. 		*(buffer + 3) = B6;

  526. 		*(buffer + 4) = B3;

  527. 		*(buffer + 5) = B4;

  528. 		*(buffer + 6) = B7;

  529. 		*(buffer + 7) = B8;

  530. 		*(b1 + 0) = A1;

  531. 		*(b1 + 1) = A2;

  532. 		*(b2 + 0) = A3;

  533. 		*(b2 + 1) = A4;

  534. 		*(b3 + 0) = A5;

  535. 		*(b3 + 1) = A6;

  536. 		*(b4 + 0) = A7;

  537. 		*(b4 + 1) = A8;

  538. 	      }

  539. 	  }

  540. 

  541. 	  buffer += 8;

  542. 

  543. 	  b1 = a + ip1;

  544. 	  b2 = a + ip2;

  545. 

  546. 	  b3 = b1 + lda;

  547. 	  b4 = b2 + lda;

  548. 

  549. 	  a1 += 4;

  550. 	  a3 += 4;

  551. 

  552. 	  i --;

  553.       } while (i > 0);

  554.     }

  555. 

  556.     i = ((k2 - k1) & 1);

  557. 

  558.     if (i > 0) {

  559.       A1 = *(a1 + 0);

  560.       A2 = *(a1 + 1);

  561.       B1 = *(b1 + 0);

  562.       B2 = *(b1 + 1);

  563.       A3 = *(a3 + 0);

  564.       A4 = *(a3 + 1);

  565.       B3 = *(b3 + 0);

  566.       B4 = *(b3 + 1);

  567. 

  568.       if (a1 == b1) {

  569. 	*(buffer + 0) = A1;

  570. 	*(buffer + 1) = A2;

  571. 	*(buffer + 2) = A3;

  572. 	*(buffer + 3) = A4;

  573. 

  574.       } else {

  575. 	*(buffer + 0) = B1;

  576. 	*(buffer + 1) = B2;

  577. 	*(buffer + 2) = B3;

  578. 	*(buffer + 3) = B4;

  579. 	*(b1 + 0) = A1;

  580. 	*(b1 + 1) = A2;

  581. 	*(b3 + 0) = A3;

  582. 	*(b3 + 1) = A4;

  583.       }

  584.       buffer += 4;

  585.     }

  586. 

  587.     a += 2 * lda;

  588.   }

  589. 

  590.   if (n & 1) {

  591.     piv = ipiv;

  592. 

  593.     a1 = a + (k1 + 1) * 2;

  594. 

  595.     ip1 = *(piv + 0) * 2;

  596.     ip2 = *(piv + 1) * 2;

  597.     piv += 2;

  598. 

  599.     b1 = a + ip1;

  600.     b2 = a + ip2;

  601. 

  602.     i = ((k2 - k1) >> 1);

  603. 

  604.     if (i > 0) {

  605.       do {

  606. 	A1 = *(a1 + 0);

  607. 	A2 = *(a1 + 1);

  608. 	A3 = *(a2 + 0);

  609. 	A4 = *(a2 + 1);

  610. 	B1 = *(b1 + 0);

  611. 	B2 = *(b1 + 1);

  612. 	B3 = *(b2 + 0);

  613. 	B4 = *(b2 + 1);

  614. 

  615. 	ip1 = *(piv + 0) * 2;

  616. 	ip2 = *(piv + 1) * 2;

  617. 	piv += 2;

  618. 

  619. 	if (b1 == a1) {

  620. 	  if (b2 == a2) {

  621. 	    *(buffer + 0) = A1;

  622. 	    *(buffer + 1) = A2;

  623. 	    *(buffer + 2) = A3;

  624. 	    *(buffer + 3) = A4;

  625. 	  } else {

  626. 	    *(buffer + 0) = A1;

  627. 	    *(buffer + 1) = A2;

  628. 	    *(buffer + 2) = B3;

  629. 	    *(buffer + 3) = B4;

  630. 

  631. 	    *(b2 + 0) = A3;

  632. 	    *(b2 + 1) = A4;

  633. 	  }

  634. 	} else

  635. 	  if (b1 == a2) {

  636. 	    if (b2 == a2) {

  637. 	      *(buffer + 0) = A3;

  638. 	      *(buffer + 1) = A4;

  639. 	      *(buffer + 2) = A1;

  640. 	      *(buffer + 3) = A2;

  641. 	    } else {

  642. 	      *(buffer + 0) = A3;

  643. 	      *(buffer + 1) = A4;

  644. 	      *(buffer + 2) = B3;

  645. 	      *(buffer + 3) = B4;

  646. 	      *(b2 + 0) = A1;

  647. 	      *(b2 + 1) = A2;

  648. 	    }

  649. 	  } else {

  650. 	    if (b2 == a2) {

  651. 	      *(buffer + 0) = B1;

  652. 	      *(buffer + 1) = B2;

  653. 	      *(buffer + 2) = A3;

  654. 	      *(buffer + 3) = A4;

  655. 	      *(b1 + 0) = A1;

  656. 	      *(b1 + 1) = A2;

  657. 	    } else

  658. 	      if (b2 == b1) {

  659. 		*(buffer + 0) = B1;

  660. 		*(buffer + 1) = B2;

  661. 		*(buffer + 2) = A1;

  662. 		*(buffer + 3) = A2;

  663. 		*(b1 + 0) = A3;

  664. 		*(b1 + 1) = A4;

  665. 	      } else {

  666. 		*(buffer + 0) = B1;

  667. 		*(buffer + 1) = B2;

  668. 		*(buffer + 2) = B3;

  669. 		*(buffer + 3) = B4;

  670. 		*(b1 + 0) = A1;

  671. 		*(b1 + 1) = A2;

  672. 		*(b2 + 0) = A3;

  673. 		*(b2 + 1) = A4;

  674. 	      }

  675. 	  }

  676. 

  677. 	buffer += 4;

  678. 

  679. 	b1 = a + ip1;

  680. 	b2 = a + ip2;

  681. 

  682. 	a1 += 4;

  683. 

  684. 	i --;

  685.       } while (i > 0);

  686.     }

  687. 

  688.     i = ((k2 - k1) & 1);

  689. 

  690.     if (i > 0) {

  691.       A1 = *(a1 + 0);

  692.       A2 = *(a1 + 1);

  693.       B1 = *(b1 + 0);

  694.       B2 = *(b1 + 1);

  695. 

  696.       if (a1 == b1) {

  697. 	*(buffer + 0) = A1;

  698. 	*(buffer + 1) = A2;

  699.       } else {

  700. 	*(buffer + 0) = B1;

  701. 	*(buffer + 1) = B2;

  702. 	*(b1 + 0) = A1;

  703. 	*(b1 + 1) = A2;

  704.       }

  705.       buffer += 2;

  706.     }

  707.   }

  708. 

  709.   return 0;

  710. }