numeric-linalg

Educational material on the SciPy implementation of numerical linear algebra algorithms

NameSizeMode
..
lapack/LAPACKE/include/lapacke_64.h 816751B -rw-r--r--
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562
00563
00564
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579
00580
00581
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606
00607
00608
00609
00610
00611
00612
00613
00614
00615
00616
00617
00618
00619
00620
00621
00622
00623
00624
00625
00626
00627
00628
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793
00794
00795
00796
00797
00798
00799
00800
00801
00802
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829
00830
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856
00857
00858
00859
00860
00861
00862
00863
00864
00865
00866
00867
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905
00906
00907
00908
00909
00910
00911
00912
00913
00914
00915
00916
00917
00918
00919
00920
00921
00922
00923
00924
00925
00926
00927
00928
00929
00930
00931
00932
00933
00934
00935
00936
00937
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972
00973
00974
00975
00976
00977
00978
00979
00980
00981
00982
00983
00984
00985
00986
00987
00988
00989
00990
00991
00992
00993
00994
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028
01029
01030
01031
01032
01033
01034
01035
01036
01037
01038
01039
01040
01041
01042
01043
01044
01045
01046
01047
01048
01049
01050
01051
01052
01053
01054
01055
01056
01057
01058
01059
01060
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070
01071
01072
01073
01074
01075
01076
01077
01078
01079
01080
01081
01082
01083
01084
01085
01086
01087
01088
01089
01090
01091
01092
01093
01094
01095
01096
01097
01098
01099
01100
01101
01102
01103
01104
01105
01106
01107
01108
01109
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120
01121
01122
01123
01124
01125
01126
01127
01128
01129
01130
01131
01132
01133
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144
01145
01146
01147
01148
01149
01150
01151
01152
01153
01154
01155
01156
01157
01158
01159
01160
01161
01162
01163
01164
01165
01166
01167
01168
01169
01170
01171
01172
01173
01174
01175
01176
01177
01178
01179
01180
01181
01182
01183
01184
01185
01186
01187
01188
01189
01190
01191
01192
01193
01194
01195
01196
01197
01198
01199
01200
01201
01202
01203
01204
01205
01206
01207
01208
01209
01210
01211
01212
01213
01214
01215
01216
01217
01218
01219
01220
01221
01222
01223
01224
01225
01226
01227
01228
01229
01230
01231
01232
01233
01234
01235
01236
01237
01238
01239
01240
01241
01242
01243
01244
01245
01246
01247
01248
01249
01250
01251
01252
01253
01254
01255
01256
01257
01258
01259
01260
01261
01262
01263
01264
01265
01266
01267
01268
01269
01270
01271
01272
01273
01274
01275
01276
01277
01278
01279
01280
01281
01282
01283
01284
01285
01286
01287
01288
01289
01290
01291
01292
01293
01294
01295
01296
01297
01298
01299
01300
01301
01302
01303
01304
01305
01306
01307
01308
01309
01310
01311
01312
01313
01314
01315
01316
01317
01318
01319
01320
01321
01322
01323
01324
01325
01326
01327
01328
01329
01330
01331
01332
01333
01334
01335
01336
01337
01338
01339
01340
01341
01342
01343
01344
01345
01346
01347
01348
01349
01350
01351
01352
01353
01354
01355
01356
01357
01358
01359
01360
01361
01362
01363
01364
01365
01366
01367
01368
01369
01370
01371
01372
01373
01374
01375
01376
01377
01378
01379
01380
01381
01382
01383
01384
01385
01386
01387
01388
01389
01390
01391
01392
01393
01394
01395
01396
01397
01398
01399
01400
01401
01402
01403
01404
01405
01406
01407
01408
01409
01410
01411
01412
01413
01414
01415
01416
01417
01418
01419
01420
01421
01422
01423
01424
01425
01426
01427
01428
01429
01430
01431
01432
01433
01434
01435
01436
01437
01438
01439
01440
01441
01442
01443
01444
01445
01446
01447
01448
01449
01450
01451
01452
01453
01454
01455
01456
01457
01458
01459
01460
01461
01462
01463
01464
01465
01466
01467
01468
01469
01470
01471
01472
01473
01474
01475
01476
01477
01478
01479
01480
01481
01482
01483
01484
01485
01486
01487
01488
01489
01490
01491
01492
01493
01494
01495
01496
01497
01498
01499
01500
01501
01502
01503
01504
01505
01506
01507
01508
01509
01510
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521
01522
01523
01524
01525
01526
01527
01528
01529
01530
01531
01532
01533
01534
01535
01536
01537
01538
01539
01540
01541
01542
01543
01544
01545
01546
01547
01548
01549
01550
01551
01552
01553
01554
01555
01556
01557
01558
01559
01560
01561
01562
01563
01564
01565
01566
01567
01568
01569
01570
01571
01572
01573
01574
01575
01576
01577
01578
01579
01580
01581
01582
01583
01584
01585
01586
01587
01588
01589
01590
01591
01592
01593
01594
01595
01596
01597
01598
01599
01600
01601
01602
01603
01604
01605
01606
01607
01608
01609
01610
01611
01612
01613
01614
01615
01616
01617
01618
01619
01620
01621
01622
01623
01624
01625
01626
01627
01628
01629
01630
01631
01632
01633
01634
01635
01636
01637
01638
01639
01640
01641
01642
01643
01644
01645
01646
01647
01648
01649
01650
01651
01652
01653
01654
01655
01656
01657
01658
01659
01660
01661
01662
01663
01664
01665
01666
01667
01668
01669
01670
01671
01672
01673
01674
01675
01676
01677
01678
01679
01680
01681
01682
01683
01684
01685
01686
01687
01688
01689
01690
01691
01692
01693
01694
01695
01696
01697
01698
01699
01700
01701
01702
01703
01704
01705
01706
01707
01708
01709
01710
01711
01712
01713
01714
01715
01716
01717
01718
01719
01720
01721
01722
01723
01724
01725
01726
01727
01728
01729
01730
01731
01732
01733
01734
01735
01736
01737
01738
01739
01740
01741
01742
01743
01744
01745
01746
01747
01748
01749
01750
01751
01752
01753
01754
01755
01756
01757
01758
01759
01760
01761
01762
01763
01764
01765
01766
01767
01768
01769
01770
01771
01772
01773
01774
01775
01776
01777
01778
01779
01780
01781
01782
01783
01784
01785
01786
01787
01788
01789
01790
01791
01792
01793
01794
01795
01796
01797
01798
01799
01800
01801
01802
01803
01804
01805
01806
01807
01808
01809
01810
01811
01812
01813
01814
01815
01816
01817
01818
01819
01820
01821
01822
01823
01824
01825
01826
01827
01828
01829
01830
01831
01832
01833
01834
01835
01836
01837
01838
01839
01840
01841
01842
01843
01844
01845
01846
01847
01848
01849
01850
01851
01852
01853
01854
01855
01856
01857
01858
01859
01860
01861
01862
01863
01864
01865
01866
01867
01868
01869
01870
01871
01872
01873
01874
01875
01876
01877
01878
01879
01880
01881
01882
01883
01884
01885
01886
01887
01888
01889
01890
01891
01892
01893
01894
01895
01896
01897
01898
01899
01900
01901
01902
01903
01904
01905
01906
01907
01908
01909
01910
01911
01912
01913
01914
01915
01916
01917
01918
01919
01920
01921
01922
01923
01924
01925
01926
01927
01928
01929
01930
01931
01932
01933
01934
01935
01936
01937
01938
01939
01940
01941
01942
01943
01944
01945
01946
01947
01948
01949
01950
01951
01952
01953
01954
01955
01956
01957
01958
01959
01960
01961
01962
01963
01964
01965
01966
01967
01968
01969
01970
01971
01972
01973
01974
01975
01976
01977
01978
01979
01980
01981
01982
01983
01984
01985
01986
01987
01988
01989
01990
01991
01992
01993
01994
01995
01996
01997
01998
01999
02000
02001
02002
02003
02004
02005
02006
02007
02008
02009
02010
02011
02012
02013
02014
02015
02016
02017
02018
02019
02020
02021
02022
02023
02024
02025
02026
02027
02028
02029
02030
02031
02032
02033
02034
02035
02036
02037
02038
02039
02040
02041
02042
02043
02044
02045
02046
02047
02048
02049
02050
02051
02052
02053
02054
02055
02056
02057
02058
02059
02060
02061
02062
02063
02064
02065
02066
02067
02068
02069
02070
02071
02072
02073
02074
02075
02076
02077
02078
02079
02080
02081
02082
02083
02084
02085
02086
02087
02088
02089
02090
02091
02092
02093
02094
02095
02096
02097
02098
02099
02100
02101
02102
02103
02104
02105
02106
02107
02108
02109
02110
02111
02112
02113
02114
02115
02116
02117
02118
02119
02120
02121
02122
02123
02124
02125
02126
02127
02128
02129
02130
02131
02132
02133
02134
02135
02136
02137
02138
02139
02140
02141
02142
02143
02144
02145
02146
02147
02148
02149
02150
02151
02152
02153
02154
02155
02156
02157
02158
02159
02160
02161
02162
02163
02164
02165
02166
02167
02168
02169
02170
02171
02172
02173
02174
02175
02176
02177
02178
02179
02180
02181
02182
02183
02184
02185
02186
02187
02188
02189
02190
02191
02192
02193
02194
02195
02196
02197
02198
02199
02200
02201
02202
02203
02204
02205
02206
02207
02208
02209
02210
02211
02212
02213
02214
02215
02216
02217
02218
02219
02220
02221
02222
02223
02224
02225
02226
02227
02228
02229
02230
02231
02232
02233
02234
02235
02236
02237
02238
02239
02240
02241
02242
02243
02244
02245
02246
02247
02248
02249
02250
02251
02252
02253
02254
02255
02256
02257
02258
02259
02260
02261
02262
02263
02264
02265
02266
02267
02268
02269
02270
02271
02272
02273
02274
02275
02276
02277
02278
02279
02280
02281
02282
02283
02284
02285
02286
02287
02288
02289
02290
02291
02292
02293
02294
02295
02296
02297
02298
02299
02300
02301
02302
02303
02304
02305
02306
02307
02308
02309
02310
02311
02312
02313
02314
02315
02316
02317
02318
02319
02320
02321
02322
02323
02324
02325
02326
02327
02328
02329
02330
02331
02332
02333
02334
02335
02336
02337
02338
02339
02340
02341
02342
02343
02344
02345
02346
02347
02348
02349
02350
02351
02352
02353
02354
02355
02356
02357
02358
02359
02360
02361
02362
02363
02364
02365
02366
02367
02368
02369
02370
02371
02372
02373
02374
02375
02376
02377
02378
02379
02380
02381
02382
02383
02384
02385
02386
02387
02388
02389
02390
02391
02392
02393
02394
02395
02396
02397
02398
02399
02400
02401
02402
02403
02404
02405
02406
02407
02408
02409
02410
02411
02412
02413
02414
02415
02416
02417
02418
02419
02420
02421
02422
02423
02424
02425
02426
02427
02428
02429
02430
02431
02432
02433
02434
02435
02436
02437
02438
02439
02440
02441
02442
02443
02444
02445
02446
02447
02448
02449
02450
02451
02452
02453
02454
02455
02456
02457
02458
02459
02460
02461
02462
02463
02464
02465
02466
02467
02468
02469
02470
02471
02472
02473
02474
02475
02476
02477
02478
02479
02480
02481
02482
02483
02484
02485
02486
02487
02488
02489
02490
02491
02492
02493
02494
02495
02496
02497
02498
02499
02500
02501
02502
02503
02504
02505
02506
02507
02508
02509
02510
02511
02512
02513
02514
02515
02516
02517
02518
02519
02520
02521
02522
02523
02524
02525
02526
02527
02528
02529
02530
02531
02532
02533
02534
02535
02536
02537
02538
02539
02540
02541
02542
02543
02544
02545
02546
02547
02548
02549
02550
02551
02552
02553
02554
02555
02556
02557
02558
02559
02560
02561
02562
02563
02564
02565
02566
02567
02568
02569
02570
02571
02572
02573
02574
02575
02576
02577
02578
02579
02580
02581
02582
02583
02584
02585
02586
02587
02588
02589
02590
02591
02592
02593
02594
02595
02596
02597
02598
02599
02600
02601
02602
02603
02604
02605
02606
02607
02608
02609
02610
02611
02612
02613
02614
02615
02616
02617
02618
02619
02620
02621
02622
02623
02624
02625
02626
02627
02628
02629
02630
02631
02632
02633
02634
02635
02636
02637
02638
02639
02640
02641
02642
02643
02644
02645
02646
02647
02648
02649
02650
02651
02652
02653
02654
02655
02656
02657
02658
02659
02660
02661
02662
02663
02664
02665
02666
02667
02668
02669
02670
02671
02672
02673
02674
02675
02676
02677
02678
02679
02680
02681
02682
02683
02684
02685
02686
02687
02688
02689
02690
02691
02692
02693
02694
02695
02696
02697
02698
02699
02700
02701
02702
02703
02704
02705
02706
02707
02708
02709
02710
02711
02712
02713
02714
02715
02716
02717
02718
02719
02720
02721
02722
02723
02724
02725
02726
02727
02728
02729
02730
02731
02732
02733
02734
02735
02736
02737
02738
02739
02740
02741
02742
02743
02744
02745
02746
02747
02748
02749
02750
02751
02752
02753
02754
02755
02756
02757
02758
02759
02760
02761
02762
02763
02764
02765
02766
02767
02768
02769
02770
02771
02772
02773
02774
02775
02776
02777
02778
02779
02780
02781
02782
02783
02784
02785
02786
02787
02788
02789
02790
02791
02792
02793
02794
02795
02796
02797
02798
02799
02800
02801
02802
02803
02804
02805
02806
02807
02808
02809
02810
02811
02812
02813
02814
02815
02816
02817
02818
02819
02820
02821
02822
02823
02824
02825
02826
02827
02828
02829
02830
02831
02832
02833
02834
02835
02836
02837
02838
02839
02840
02841
02842
02843
02844
02845
02846
02847
02848
02849
02850
02851
02852
02853
02854
02855
02856
02857
02858
02859
02860
02861
02862
02863
02864
02865
02866
02867
02868
02869
02870
02871
02872
02873
02874
02875
02876
02877
02878
02879
02880
02881
02882
02883
02884
02885
02886
02887
02888
02889
02890
02891
02892
02893
02894
02895
02896
02897
02898
02899
02900
02901
02902
02903
02904
02905
02906
02907
02908
02909
02910
02911
02912
02913
02914
02915
02916
02917
02918
02919
02920
02921
02922
02923
02924
02925
02926
02927
02928
02929
02930
02931
02932
02933
02934
02935
02936
02937
02938
02939
02940
02941
02942
02943
02944
02945
02946
02947
02948
02949
02950
02951
02952
02953
02954
02955
02956
02957
02958
02959
02960
02961
02962
02963
02964
02965
02966
02967
02968
02969
02970
02971
02972
02973
02974
02975
02976
02977
02978
02979
02980
02981
02982
02983
02984
02985
02986
02987
02988
02989
02990
02991
02992
02993
02994
02995
02996
02997
02998
02999
03000
03001
03002
03003
03004
03005
03006
03007
03008
03009
03010
03011
03012
03013
03014
03015
03016
03017
03018
03019
03020
03021
03022
03023
03024
03025
03026
03027
03028
03029
03030
03031
03032
03033
03034
03035
03036
03037
03038
03039
03040
03041
03042
03043
03044
03045
03046
03047
03048
03049
03050
03051
03052
03053
03054
03055
03056
03057
03058
03059
03060
03061
03062
03063
03064
03065
03066
03067
03068
03069
03070
03071
03072
03073
03074
03075
03076
03077
03078
03079
03080
03081
03082
03083
03084
03085
03086
03087
03088
03089
03090
03091
03092
03093
03094
03095
03096
03097
03098
03099
03100
03101
03102
03103
03104
03105
03106
03107
03108
03109
03110
03111
03112
03113
03114
03115
03116
03117
03118
03119
03120
03121
03122
03123
03124
03125
03126
03127
03128
03129
03130
03131
03132
03133
03134
03135
03136
03137
03138
03139
03140
03141
03142
03143
03144
03145
03146
03147
03148
03149
03150
03151
03152
03153
03154
03155
03156
03157
03158
03159
03160
03161
03162
03163
03164
03165
03166
03167
03168
03169
03170
03171
03172
03173
03174
03175
03176
03177
03178
03179
03180
03181
03182
03183
03184
03185
03186
03187
03188
03189
03190
03191
03192
03193
03194
03195
03196
03197
03198
03199
03200
03201
03202
03203
03204
03205
03206
03207
03208
03209
03210
03211
03212
03213
03214
03215
03216
03217
03218
03219
03220
03221
03222
03223
03224
03225
03226
03227
03228
03229
03230
03231
03232
03233
03234
03235
03236
03237
03238
03239
03240
03241
03242
03243
03244
03245
03246
03247
03248
03249
03250
03251
03252
03253
03254
03255
03256
03257
03258
03259
03260
03261
03262
03263
03264
03265
03266
03267
03268
03269
03270
03271
03272
03273
03274
03275
03276
03277
03278
03279
03280
03281
03282
03283
03284
03285
03286
03287
03288
03289
03290
03291
03292
03293
03294
03295
03296
03297
03298
03299
03300
03301
03302
03303
03304
03305
03306
03307
03308
03309
03310
03311
03312
03313
03314
03315
03316
03317
03318
03319
03320
03321
03322
03323
03324
03325
03326
03327
03328
03329
03330
03331
03332
03333
03334
03335
03336
03337
03338
03339
03340
03341
03342
03343
03344
03345
03346
03347
03348
03349
03350
03351
03352
03353
03354
03355
03356
03357
03358
03359
03360
03361
03362
03363
03364
03365
03366
03367
03368
03369
03370
03371
03372
03373
03374
03375
03376
03377
03378
03379
03380
03381
03382
03383
03384
03385
03386
03387
03388
03389
03390
03391
03392
03393
03394
03395
03396
03397
03398
03399
03400
03401
03402
03403
03404
03405
03406
03407
03408
03409
03410
03411
03412
03413
03414
03415
03416
03417
03418
03419
03420
03421
03422
03423
03424
03425
03426
03427
03428
03429
03430
03431
03432
03433
03434
03435
03436
03437
03438
03439
03440
03441
03442
03443
03444
03445
03446
03447
03448
03449
03450
03451
03452
03453
03454
03455
03456
03457
03458
03459
03460
03461
03462
03463
03464
03465
03466
03467
03468
03469
03470
03471
03472
03473
03474
03475
03476
03477
03478
03479
03480
03481
03482
03483
03484
03485
03486
03487
03488
03489
03490
03491
03492
03493
03494
03495
03496
03497
03498
03499
03500
03501
03502
03503
03504
03505
03506
03507
03508
03509
03510
03511
03512
03513
03514
03515
03516
03517
03518
03519
03520
03521
03522
03523
03524
03525
03526
03527
03528
03529
03530
03531
03532
03533
03534
03535
03536
03537
03538
03539
03540
03541
03542
03543
03544
03545
03546
03547
03548
03549
03550
03551
03552
03553
03554
03555
03556
03557
03558
03559
03560
03561
03562
03563
03564
03565
03566
03567
03568
03569
03570
03571
03572
03573
03574
03575
03576
03577
03578
03579
03580
03581
03582
03583
03584
03585
03586
03587
03588
03589
03590
03591
03592
03593
03594
03595
03596
03597
03598
03599
03600
03601
03602
03603
03604
03605
03606
03607
03608
03609
03610
03611
03612
03613
03614
03615
03616
03617
03618
03619
03620
03621
03622
03623
03624
03625
03626
03627
03628
03629
03630
03631
03632
03633
03634
03635
03636
03637
03638
03639
03640
03641
03642
03643
03644
03645
03646
03647
03648
03649
03650
03651
03652
03653
03654
03655
03656
03657
03658
03659
03660
03661
03662
03663
03664
03665
03666
03667
03668
03669
03670
03671
03672
03673
03674
03675
03676
03677
03678
03679
03680
03681
03682
03683
03684
03685
03686
03687
03688
03689
03690
03691
03692
03693
03694
03695
03696
03697
03698
03699
03700
03701
03702
03703
03704
03705
03706
03707
03708
03709
03710
03711
03712
03713
03714
03715
03716
03717
03718
03719
03720
03721
03722
03723
03724
03725
03726
03727
03728
03729
03730
03731
03732
03733
03734
03735
03736
03737
03738
03739
03740
03741
03742
03743
03744
03745
03746
03747
03748
03749
03750
03751
03752
03753
03754
03755
03756
03757
03758
03759
03760
03761
03762
03763
03764
03765
03766
03767
03768
03769
03770
03771
03772
03773
03774
03775
03776
03777
03778
03779
03780
03781
03782
03783
03784
03785
03786
03787
03788
03789
03790
03791
03792
03793
03794
03795
03796
03797
03798
03799
03800
03801
03802
03803
03804
03805
03806
03807
03808
03809
03810
03811
03812
03813
03814
03815
03816
03817
03818
03819
03820
03821
03822
03823
03824
03825
03826
03827
03828
03829
03830
03831
03832
03833
03834
03835
03836
03837
03838
03839
03840
03841
03842
03843
03844
03845
03846
03847
03848
03849
03850
03851
03852
03853
03854
03855
03856
03857
03858
03859
03860
03861
03862
03863
03864
03865
03866
03867
03868
03869
03870
03871
03872
03873
03874
03875
03876
03877
03878
03879
03880
03881
03882
03883
03884
03885
03886
03887
03888
03889
03890
03891
03892
03893
03894
03895
03896
03897
03898
03899
03900
03901
03902
03903
03904
03905
03906
03907
03908
03909
03910
03911
03912
03913
03914
03915
03916
03917
03918
03919
03920
03921
03922
03923
03924
03925
03926
03927
03928
03929
03930
03931
03932
03933
03934
03935
03936
03937
03938
03939
03940
03941
03942
03943
03944
03945
03946
03947
03948
03949
03950
03951
03952
03953
03954
03955
03956
03957
03958
03959
03960
03961
03962
03963
03964
03965
03966
03967
03968
03969
03970
03971
03972
03973
03974
03975
03976
03977
03978
03979
03980
03981
03982
03983
03984
03985
03986
03987
03988
03989
03990
03991
03992
03993
03994
03995
03996
03997
03998
03999
04000
04001
04002
04003
04004
04005
04006
04007
04008
04009
04010
04011
04012
04013
04014
04015
04016
04017
04018
04019
04020
04021
04022
04023
04024
04025
04026
04027
04028
04029
04030
04031
04032
04033
04034
04035
04036
04037
04038
04039
04040
04041
04042
04043
04044
04045
04046
04047
04048
04049
04050
04051
04052
04053
04054
04055
04056
04057
04058
04059
04060
04061
04062
04063
04064
04065
04066
04067
04068
04069
04070
04071
04072
04073
04074
04075
04076
04077
04078
04079
04080
04081
04082
04083
04084
04085
04086
04087
04088
04089
04090
04091
04092
04093
04094
04095
04096
04097
04098
04099
04100
04101
04102
04103
04104
04105
04106
04107
04108
04109
04110
04111
04112
04113
04114
04115
04116
04117
04118
04119
04120
04121
04122
04123
04124
04125
04126
04127
04128
04129
04130
04131
04132
04133
04134
04135
04136
04137
04138
04139
04140
04141
04142
04143
04144
04145
04146
04147
04148
04149
04150
04151
04152
04153
04154
04155
04156
04157
04158
04159
04160
04161
04162
04163
04164
04165
04166
04167
04168
04169
04170
04171
04172
04173
04174
04175
04176
04177
04178
04179
04180
04181
04182
04183
04184
04185
04186
04187
04188
04189
04190
04191
04192
04193
04194
04195
04196
04197
04198
04199
04200
04201
04202
04203
04204
04205
04206
04207
04208
04209
04210
04211
04212
04213
04214
04215
04216
04217
04218
04219
04220
04221
04222
04223
04224
04225
04226
04227
04228
04229
04230
04231
04232
04233
04234
04235
04236
04237
04238
04239
04240
04241
04242
04243
04244
04245
04246
04247
04248
04249
04250
04251
04252
04253
04254
04255
04256
04257
04258
04259
04260
04261
04262
04263
04264
04265
04266
04267
04268
04269
04270
04271
04272
04273
04274
04275
04276
04277
04278
04279
04280
04281
04282
04283
04284
04285
04286
04287
04288
04289
04290
04291
04292
04293
04294
04295
04296
04297
04298
04299
04300
04301
04302
04303
04304
04305
04306
04307
04308
04309
04310
04311
04312
04313
04314
04315
04316
04317
04318
04319
04320
04321
04322
04323
04324
04325
04326
04327
04328
04329
04330
04331
04332
04333
04334
04335
04336
04337
04338
04339
04340
04341
04342
04343
04344
04345
04346
04347
04348
04349
04350
04351
04352
04353
04354
04355
04356
04357
04358
04359
04360
04361
04362
04363
04364
04365
04366
04367
04368
04369
04370
04371
04372
04373
04374
04375
04376
04377
04378
04379
04380
04381
04382
04383
04384
04385
04386
04387
04388
04389
04390
04391
04392
04393
04394
04395
04396
04397
04398
04399
04400
04401
04402
04403
04404
04405
04406
04407
04408
04409
04410
04411
04412
04413
04414
04415
04416
04417
04418
04419
04420
04421
04422
04423
04424
04425
04426
04427
04428
04429
04430
04431
04432
04433
04434
04435
04436
04437
04438
04439
04440
04441
04442
04443
04444
04445
04446
04447
04448
04449
04450
04451
04452
04453
04454
04455
04456
04457
04458
04459
04460
04461
04462
04463
04464
04465
04466
04467
04468
04469
04470
04471
04472
04473
04474
04475
04476
04477
04478
04479
04480
04481
04482
04483
04484
04485
04486
04487
04488
04489
04490
04491
04492
04493
04494
04495
04496
04497
04498
04499
04500
04501
04502
04503
04504
04505
04506
04507
04508
04509
04510
04511
04512
04513
04514
04515
04516
04517
04518
04519
04520
04521
04522
04523
04524
04525
04526
04527
04528
04529
04530
04531
04532
04533
04534
04535
04536
04537
04538
04539
04540
04541
04542
04543
04544
04545
04546
04547
04548
04549
04550
04551
04552
04553
04554
04555
04556
04557
04558
04559
04560
04561
04562
04563
04564
04565
04566
04567
04568
04569
04570
04571
04572
04573
04574
04575
04576
04577
04578
04579
04580
04581
04582
04583
04584
04585
04586
04587
04588
04589
04590
04591
04592
04593
04594
04595
04596
04597
04598
04599
04600
04601
04602
04603
04604
04605
04606
04607
04608
04609
04610
04611
04612
04613
04614
04615
04616
04617
04618
04619
04620
04621
04622
04623
04624
04625
04626
04627
04628
04629
04630
04631
04632
04633
04634
04635
04636
04637
04638
04639
04640
04641
04642
04643
04644
04645
04646
04647
04648
04649
04650
04651
04652
04653
04654
04655
04656
04657
04658
04659
04660
04661
04662
04663
04664
04665
04666
04667
04668
04669
04670
04671
04672
04673
04674
04675
04676
04677
04678
04679
04680
04681
04682
04683
04684
04685
04686
04687
04688
04689
04690
04691
04692
04693
04694
04695
04696
04697
04698
04699
04700
04701
04702
04703
04704
04705
04706
04707
04708
04709
04710
04711
04712
04713
04714
04715
04716
04717
04718
04719
04720
04721
04722
04723
04724
04725
04726
04727
04728
04729
04730
04731
04732
04733
04734
04735
04736
04737
04738
04739
04740
04741
04742
04743
04744
04745
04746
04747
04748
04749
04750
04751
04752
04753
04754
04755
04756
04757
04758
04759
04760
04761
04762
04763
04764
04765
04766
04767
04768
04769
04770
04771
04772
04773
04774
04775
04776
04777
04778
04779
04780
04781
04782
04783
04784
04785
04786
04787
04788
04789
04790
04791
04792
04793
04794
04795
04796
04797
04798
04799
04800
04801
04802
04803
04804
04805
04806
04807
04808
04809
04810
04811
04812
04813
04814
04815
04816
04817
04818
04819
04820
04821
04822
04823
04824
04825
04826
04827
04828
04829
04830
04831
04832
04833
04834
04835
04836
04837
04838
04839
04840
04841
04842
04843
04844
04845
04846
04847
04848
04849
04850
04851
04852
04853
04854
04855
04856
04857
04858
04859
04860
04861
04862
04863
04864
04865
04866
04867
04868
04869
04870
04871
04872
04873
04874
04875
04876
04877
04878
04879
04880
04881
04882
04883
04884
04885
04886
04887
04888
04889
04890
04891
04892
04893
04894
04895
04896
04897
04898
04899
04900
04901
04902
04903
04904
04905
04906
04907
04908
04909
04910
04911
04912
04913
04914
04915
04916
04917
04918
04919
04920
04921
04922
04923
04924
04925
04926
04927
04928
04929
04930
04931
04932
04933
04934
04935
04936
04937
04938
04939
04940
04941
04942
04943
04944
04945
04946
04947
04948
04949
04950
04951
04952
04953
04954
04955
04956
04957
04958
04959
04960
04961
04962
04963
04964
04965
04966
04967
04968
04969
04970
04971
04972
04973
04974
04975
04976
04977
04978
04979
04980
04981
04982
04983
04984
04985
04986
04987
04988
04989
04990
04991
04992
04993
04994
04995
04996
04997
04998
04999
05000
05001
05002
05003
05004
05005
05006
05007
05008
05009
05010
05011
05012
05013
05014
05015
05016
05017
05018
05019
05020
05021
05022
05023
05024
05025
05026
05027
05028
05029
05030
05031
05032
05033
05034
05035
05036
05037
05038
05039
05040
05041
05042
05043
05044
05045
05046
05047
05048
05049
05050
05051
05052
05053
05054
05055
05056
05057
05058
05059
05060
05061
05062
05063
05064
05065
05066
05067
05068
05069
05070
05071
05072
05073
05074
05075
05076
05077
05078
05079
05080
05081
05082
05083
05084
05085
05086
05087
05088
05089
05090
05091
05092
05093
05094
05095
05096
05097
05098
05099
05100
05101
05102
05103
05104
05105
05106
05107
05108
05109
05110
05111
05112
05113
05114
05115
05116
05117
05118
05119
05120
05121
05122
05123
05124
05125
05126
05127
05128
05129
05130
05131
05132
05133
05134
05135
05136
05137
05138
05139
05140
05141
05142
05143
05144
05145
05146
05147
05148
05149
05150
05151
05152
05153
05154
05155
05156
05157
05158
05159
05160
05161
05162
05163
05164
05165
05166
05167
05168
05169
05170
05171
05172
05173
05174
05175
05176
05177
05178
05179
05180
05181
05182
05183
05184
05185
05186
05187
05188
05189
05190
05191
05192
05193
05194
05195
05196
05197
05198
05199
05200
05201
05202
05203
05204
05205
05206
05207
05208
05209
05210
05211
05212
05213
05214
05215
05216
05217
05218
05219
05220
05221
05222
05223
05224
05225
05226
05227
05228
05229
05230
05231
05232
05233
05234
05235
05236
05237
05238
05239
05240
05241
05242
05243
05244
05245
05246
05247
05248
05249
05250
05251
05252
05253
05254
05255
05256
05257
05258
05259
05260
05261
05262
05263
05264
05265
05266
05267
05268
05269
05270
05271
05272
05273
05274
05275
05276
05277
05278
05279
05280
05281
05282
05283
05284
05285
05286
05287
05288
05289
05290
05291
05292
05293
05294
05295
05296
05297
05298
05299
05300
05301
05302
05303
05304
05305
05306
05307
05308
05309
05310
05311
05312
05313
05314
05315
05316
05317
05318
05319
05320
05321
05322
05323
05324
05325
05326
05327
05328
05329
05330
05331
05332
05333
05334
05335
05336
05337
05338
05339
05340
05341
05342
05343
05344
05345
05346
05347
05348
05349
05350
05351
05352
05353
05354
05355
05356
05357
05358
05359
05360
05361
05362
05363
05364
05365
05366
05367
05368
05369
05370
05371
05372
05373
05374
05375
05376
05377
05378
05379
05380
05381
05382
05383
05384
05385
05386
05387
05388
05389
05390
05391
05392
05393
05394
05395
05396
05397
05398
05399
05400
05401
05402
05403
05404
05405
05406
05407
05408
05409
05410
05411
05412
05413
05414
05415
05416
05417
05418
05419
05420
05421
05422
05423
05424
05425
05426
05427
05428
05429
05430
05431
05432
05433
05434
05435
05436
05437
05438
05439
05440
05441
05442
05443
05444
05445
05446
05447
05448
05449
05450
05451
05452
05453
05454
05455
05456
05457
05458
05459
05460
05461
05462
05463
05464
05465
05466
05467
05468
05469
05470
05471
05472
05473
05474
05475
05476
05477
05478
05479
05480
05481
05482
05483
05484
05485
05486
05487
05488
05489
05490
05491
05492
05493
05494
05495
05496
05497
05498
05499
05500
05501
05502
05503
05504
05505
05506
05507
05508
05509
05510
05511
05512
05513
05514
05515
05516
05517
05518
05519
05520
05521
05522
05523
05524
05525
05526
05527
05528
05529
05530
05531
05532
05533
05534
05535
05536
05537
05538
05539
05540
05541
05542
05543
05544
05545
05546
05547
05548
05549
05550
05551
05552
05553
05554
05555
05556
05557
05558
05559
05560
05561
05562
05563
05564
05565
05566
05567
05568
05569
05570
05571
05572
05573
05574
05575
05576
05577
05578
05579
05580
05581
05582
05583
05584
05585
05586
05587
05588
05589
05590
05591
05592
05593
05594
05595
05596
05597
05598
05599
05600
05601
05602
05603
05604
05605
05606
05607
05608
05609
05610
05611
05612
05613
05614
05615
05616
05617
05618
05619
05620
05621
05622
05623
05624
05625
05626
05627
05628
05629
05630
05631
05632
05633
05634
05635
05636
05637
05638
05639
05640
05641
05642
05643
05644
05645
05646
05647
05648
05649
05650
05651
05652
05653
05654
05655
05656
05657
05658
05659
05660
05661
05662
05663
05664
05665
05666
05667
05668
05669
05670
05671
05672
05673
05674
05675
05676
05677
05678
05679
05680
05681
05682
05683
05684
05685
05686
05687
05688
05689
05690
05691
05692
05693
05694
05695
05696
05697
05698
05699
05700
05701
05702
05703
05704
05705
05706
05707
05708
05709
05710
05711
05712
05713
05714
05715
05716
05717
05718
05719
05720
05721
05722
05723
05724
05725
05726
05727
05728
05729
05730
05731
05732
05733
05734
05735
05736
05737
05738
05739
05740
05741
05742
05743
05744
05745
05746
05747
05748
05749
05750
05751
05752
05753
05754
05755
05756
05757
05758
05759
05760
05761
05762
05763
05764
05765
05766
05767
05768
05769
05770
05771
05772
05773
05774
05775
05776
05777
05778
05779
05780
05781
05782
05783
05784
05785
05786
05787
05788
05789
05790
05791
05792
05793
05794
05795
05796
05797
05798
05799
05800
05801
05802
05803
05804
05805
05806
05807
05808
05809
05810
05811
05812
05813
05814
05815
05816
05817
05818
05819
05820
05821
05822
05823
05824
05825
05826
05827
05828
05829
05830
05831
05832
05833
05834
05835
05836
05837
05838
05839
05840
05841
05842
05843
05844
05845
05846
05847
05848
05849
05850
05851
05852
05853
05854
05855
05856
05857
05858
05859
05860
05861
05862
05863
05864
05865
05866
05867
05868
05869
05870
05871
05872
05873
05874
05875
05876
05877
05878
05879
05880
05881
05882
05883
05884
05885
05886
05887
05888
05889
05890
05891
05892
05893
05894
05895
05896
05897
05898
05899
05900
05901
05902
05903
05904
05905
05906
05907
05908
05909
05910
05911
05912
05913
05914
05915
05916
05917
05918
05919
05920
05921
05922
05923
05924
05925
05926
05927
05928
05929
05930
05931
05932
05933
05934
05935
05936
05937
05938
05939
05940
05941
05942
05943
05944
05945
05946
05947
05948
05949
05950
05951
05952
05953
05954
05955
05956
05957
05958
05959
05960
05961
05962
05963
05964
05965
05966
05967
05968
05969
05970
05971
05972
05973
05974
05975
05976
05977
05978
05979
05980
05981
05982
05983
05984
05985
05986
05987
05988
05989
05990
05991
05992
05993
05994
05995
05996
05997
05998
05999
06000
06001
06002
06003
06004
06005
06006
06007
06008
06009
06010
06011
06012
06013
06014
06015
06016
06017
06018
06019
06020
06021
06022
06023
06024
06025
06026
06027
06028
06029
06030
06031
06032
06033
06034
06035
06036
06037
06038
06039
06040
06041
06042
06043
06044
06045
06046
06047
06048
06049
06050
06051
06052
06053
06054
06055
06056
06057
06058
06059
06060
06061
06062
06063
06064
06065
06066
06067
06068
06069
06070
06071
06072
06073
06074
06075
06076
06077
06078
06079
06080
06081
06082
06083
06084
06085
06086
06087
06088
06089
06090
06091
06092
06093
06094
06095
06096
06097
06098
06099
06100
06101
06102
06103
06104
06105
06106
06107
06108
06109
06110
06111
06112
06113
06114
06115
06116
06117
06118
06119
06120
06121
06122
06123
06124
06125
06126
06127
06128
06129
06130
06131
06132
06133
06134
06135
06136
06137
06138
06139
06140
06141
06142
06143
06144
06145
06146
06147
06148
06149
06150
06151
06152
06153
06154
06155
06156
06157
06158
06159
06160
06161
06162
06163
06164
06165
06166
06167
06168
06169
06170
06171
06172
06173
06174
06175
06176
06177
06178
06179
06180
06181
06182
06183
06184
06185
06186
06187
06188
06189
06190
06191
06192
06193
06194
06195
06196
06197
06198
06199
06200
06201
06202
06203
06204
06205
06206
06207
06208
06209
06210
06211
06212
06213
06214
06215
06216
06217
06218
06219
06220
06221
06222
06223
06224
06225
06226
06227
06228
06229
06230
06231
06232
06233
06234
06235
06236
06237
06238
06239
06240
06241
06242
06243
06244
06245
06246
06247
06248
06249
06250
06251
06252
06253
06254
06255
06256
06257
06258
06259
06260
06261
06262
06263
06264
06265
06266
06267
06268
06269
06270
06271
06272
06273
06274
06275
06276
06277
06278
06279
06280
06281
06282
06283
06284
06285
06286
06287
06288
06289
06290
06291
06292
06293
06294
06295
06296
06297
06298
06299
06300
06301
06302
06303
06304
06305
06306
06307
06308
06309
06310
06311
06312
06313
06314
06315
06316
06317
06318
06319
06320
06321
06322
06323
06324
06325
06326
06327
06328
06329
06330
06331
06332
06333
06334
06335
06336
06337
06338
06339
06340
06341
06342
06343
06344
06345
06346
06347
06348
06349
06350
06351
06352
06353
06354
06355
06356
06357
06358
06359
06360
06361
06362
06363
06364
06365
06366
06367
06368
06369
06370
06371
06372
06373
06374
06375
06376
06377
06378
06379
06380
06381
06382
06383
06384
06385
06386
06387
06388
06389
06390
06391
06392
06393
06394
06395
06396
06397
06398
06399
06400
06401
06402
06403
06404
06405
06406
06407
06408
06409
06410
06411
06412
06413
06414
06415
06416
06417
06418
06419
06420
06421
06422
06423
06424
06425
06426
06427
06428
06429
06430
06431
06432
06433
06434
06435
06436
06437
06438
06439
06440
06441
06442
06443
06444
06445
06446
06447
06448
06449
06450
06451
06452
06453
06454
06455
06456
06457
06458
06459
06460
06461
06462
06463
06464
06465
06466
06467
06468
06469
06470
06471
06472
06473
06474
06475
06476
06477
06478
06479
06480
06481
06482
06483
06484
06485
06486
06487
06488
06489
06490
06491
06492
06493
06494
06495
06496
06497
06498
06499
06500
06501
06502
06503
06504
06505
06506
06507
06508
06509
06510
06511
06512
06513
06514
06515
06516
06517
06518
06519
06520
06521
06522
06523
06524
06525
06526
06527
06528
06529
06530
06531
06532
06533
06534
06535
06536
06537
06538
06539
06540
06541
06542
06543
06544
06545
06546
06547
06548
06549
06550
06551
06552
06553
06554
06555
06556
06557
06558
06559
06560
06561
06562
06563
06564
06565
06566
06567
06568
06569
06570
06571
06572
06573
06574
06575
06576
06577
06578
06579
06580
06581
06582
06583
06584
06585
06586
06587
06588
06589
06590
06591
06592
06593
06594
06595
06596
06597
06598
06599
06600
06601
06602
06603
06604
06605
06606
06607
06608
06609
06610
06611
06612
06613
06614
06615
06616
06617
06618
06619
06620
06621
06622
06623
06624
06625
06626
06627
06628
06629
06630
06631
06632
06633
06634
06635
06636
06637
06638
06639
06640
06641
06642
06643
06644
06645
06646
06647
06648
06649
06650
06651
06652
06653
06654
06655
06656
06657
06658
06659
06660
06661
06662
06663
06664
06665
06666
06667
06668
06669
06670
06671
06672
06673
06674
06675
06676
06677
06678
06679
06680
06681
06682
06683
06684
06685
06686
06687
06688
06689
06690
06691
06692
06693
06694
06695
06696
06697
06698
06699
06700
06701
06702
06703
06704
06705
06706
06707
06708
06709
06710
06711
06712
06713
06714
06715
06716
06717
06718
06719
06720
06721
06722
06723
06724
06725
06726
06727
06728
06729
06730
06731
06732
06733
06734
06735
06736
06737
06738
06739
06740
06741
06742
06743
06744
06745
06746
06747
06748
06749
06750
06751
06752
06753
06754
06755
06756
06757
06758
06759
06760
06761
06762
06763
06764
06765
06766
06767
06768
06769
06770
06771
06772
06773
06774
06775
06776
06777
06778
06779
06780
06781
06782
06783
06784
06785
06786
06787
06788
06789
06790
06791
06792
06793
06794
06795
06796
06797
06798
06799
06800
06801
06802
06803
06804
06805
06806
06807
06808
06809
06810
06811
06812
06813
06814
06815
06816
06817
06818
06819
06820
06821
06822
06823
06824
06825
06826
06827
06828
06829
06830
06831
06832
06833
06834
06835
06836
06837
06838
06839
06840
06841
06842
06843
06844
06845
06846
06847
06848
06849
06850
06851
06852
06853
06854
06855
06856
06857
06858
06859
06860
06861
06862
06863
06864
06865
06866
06867
06868
06869
06870
06871
06872
06873
06874
06875
06876
06877
06878
06879
06880
06881
06882
06883
06884
06885
06886
06887
06888
06889
06890
06891
06892
06893
06894
06895
06896
06897
06898
06899
06900
06901
06902
06903
06904
06905
06906
06907
06908
06909
06910
06911
06912
06913
06914
06915
06916
06917
06918
06919
06920
06921
06922
06923
06924
06925
06926
06927
06928
06929
06930
06931
06932
06933
06934
06935
06936
06937
06938
06939
06940
06941
06942
06943
06944
06945
06946
06947
06948
06949
06950
06951
06952
06953
06954
06955
06956
06957
06958
06959
06960
06961
06962
06963
06964
06965
06966
06967
06968
06969
06970
06971
06972
06973
06974
06975
06976
06977
06978
06979
06980
06981
06982
06983
06984
06985
06986
06987
06988
06989
06990
06991
06992
06993
06994
06995
06996
06997
06998
06999
07000
07001
07002
07003
07004
07005
07006
07007
07008
07009
07010
07011
07012
07013
07014
07015
07016
07017
07018
07019
07020
07021
07022
07023
07024
07025
07026
07027
07028
07029
07030
07031
07032
07033
07034
07035
07036
07037
07038
07039
07040
07041
07042
07043
07044
07045
07046
07047
07048
07049
07050
07051
07052
07053
07054
07055
07056
07057
07058
07059
07060
07061
07062
07063
07064
07065
07066
07067
07068
07069
07070
07071
07072
07073
07074
07075
07076
07077
07078
07079
07080
07081
07082
07083
07084
07085
07086
07087
07088
07089
07090
07091
07092
07093
07094
07095
07096
07097
07098
07099
07100
07101
07102
07103
07104
07105
07106
07107
07108
07109
07110
07111
07112
07113
07114
07115
07116
07117
07118
07119
07120
07121
07122
07123
07124
07125
07126
07127
07128
07129
07130
07131
07132
07133
07134
07135
07136
07137
07138
07139
07140
07141
07142
07143
07144
07145
07146
07147
07148
07149
07150
07151
07152
07153
07154
07155
07156
07157
07158
07159
07160
07161
07162
07163
07164
07165
07166
07167
07168
07169
07170
07171
07172
07173
07174
07175
07176
07177
07178
07179
07180
07181
07182
07183
07184
07185
07186
07187
07188
07189
07190
07191
07192
07193
07194
07195
07196
07197
07198
07199
07200
07201
07202
07203
07204
07205
07206
07207
07208
07209
07210
07211
07212
07213
07214
07215
07216
07217
07218
07219
07220
07221
07222
07223
07224
07225
07226
07227
07228
07229
07230
07231
07232
07233
07234
07235
07236
07237
07238
07239
07240
07241
07242
07243
07244
07245
07246
07247
07248
07249
07250
07251
07252
07253
07254
07255
07256
07257
07258
07259
07260
07261
07262
07263
07264
07265
07266
07267
07268
07269
07270
07271
07272
07273
07274
07275
07276
07277
07278
07279
07280
07281
07282
07283
07284
07285
07286
07287
07288
07289
07290
07291
07292
07293
07294
07295
07296
07297
07298
07299
07300
07301
07302
07303
07304
07305
07306
07307
07308
07309
07310
07311
07312
07313
07314
07315
07316
07317
07318
07319
07320
07321
07322
07323
07324
07325
07326
07327
07328
07329
07330
07331
07332
07333
07334
07335
07336
07337
07338
07339
07340
07341
07342
07343
07344
07345
07346
07347
07348
07349
07350
07351
07352
07353
07354
07355
07356
07357
07358
07359
07360
07361
07362
07363
07364
07365
07366
07367
07368
07369
07370
07371
07372
07373
07374
07375
07376
07377
07378
07379
07380
07381
07382
07383
07384
07385
07386
07387
07388
07389
07390
07391
07392
07393
07394
07395
07396
07397
07398
07399
07400
07401
07402
07403
07404
07405
07406
07407
07408
07409
07410
07411
07412
07413
07414
07415
07416
07417
07418
07419
07420
07421
07422
07423
07424
07425
07426
07427
07428
07429
07430
07431
07432
07433
07434
07435
07436
07437
07438
07439
07440
07441
07442
07443
07444
07445
07446
07447
07448
07449
07450
07451
07452
07453
07454
07455
07456
07457
07458
07459
07460
07461
07462
07463
07464
07465
07466
07467
07468
07469
07470
07471
07472
07473
07474
07475
07476
07477
07478
07479
07480
07481
07482
07483
07484
07485
07486
07487
07488
07489
07490
07491
07492
07493
07494
07495
07496
07497
07498
07499
07500
07501
07502
07503
07504
07505
07506
07507
07508
07509
07510
07511
07512
07513
07514
07515
07516
07517
07518
07519
07520
07521
07522
07523
07524
07525
07526
07527
07528
07529
07530
07531
07532
07533
07534
07535
07536
07537
07538
07539
07540
07541
07542
07543
07544
07545
07546
07547
07548
07549
07550
07551
07552
07553
07554
07555
07556
07557
07558
07559
07560
07561
07562
07563
07564
07565
07566
07567
07568
07569
07570
07571
07572
07573
07574
07575
07576
07577
07578
07579
07580
07581
07582
07583
07584
07585
07586
07587
07588
07589
07590
07591
07592
07593
07594
07595
07596
07597
07598
07599
07600
07601
07602
07603
07604
07605
07606
07607
07608
07609
07610
07611
07612
07613
07614
07615
07616
07617
07618
07619
07620
07621
07622
07623
07624
07625
07626
07627
07628
07629
07630
07631
07632
07633
07634
07635
07636
07637
07638
07639
07640
07641
07642
07643
07644
07645
07646
07647
07648
07649
07650
07651
07652
07653
07654
07655
07656
07657
07658
07659
07660
07661
07662
07663
07664
07665
07666
07667
07668
07669
07670
07671
07672
07673
07674
07675
07676
07677
07678
07679
07680
07681
07682
07683
07684
07685
07686
07687
07688
07689
07690
07691
07692
07693
07694
07695
07696
07697
07698
07699
07700
07701
07702
07703
07704
07705
07706
07707
07708
07709
07710
07711
07712
07713
07714
07715
07716
07717
07718
07719
07720
07721
07722
07723
07724
07725
07726
07727
07728
07729
07730
07731
07732
07733
07734
07735
07736
07737
07738
07739
07740
07741
07742
07743
07744
07745
07746
07747
07748
07749
07750
07751
07752
07753
07754
07755
07756
07757
07758
07759
07760
07761
07762
07763
07764
07765
07766
07767
07768
07769
07770
07771
07772
07773
07774
07775
07776
07777
07778
07779
07780
07781
07782
07783
07784
07785
07786
07787
07788
07789
07790
07791
07792
07793
07794
07795
07796
07797
07798
07799
07800
07801
07802
07803
07804
07805
07806
07807
07808
07809
07810
07811
07812
07813
07814
07815
07816
07817
07818
07819
07820
07821
07822
07823
07824
07825
07826
07827
07828
07829
07830
07831
07832
07833
07834
07835
07836
07837
07838
07839
07840
07841
07842
07843
07844
07845
07846
07847
07848
07849
07850
07851
07852
07853
07854
07855
07856
07857
07858
07859
07860
07861
07862
07863
07864
07865
07866
07867
07868
07869
07870
07871
07872
07873
07874
07875
07876
07877
07878
07879
07880
07881
07882
07883
07884
07885
07886
07887
07888
07889
07890
07891
07892
07893
07894
07895
07896
07897
07898
07899
07900
07901
07902
07903
07904
07905
07906
07907
07908
07909
07910
07911
07912
07913
07914
07915
07916
07917
07918
07919
07920
07921
07922
07923
07924
07925
07926
07927
07928
07929
07930
07931
07932
07933
07934
07935
07936
07937
07938
07939
07940
07941
07942
07943
07944
07945
07946
07947
07948
07949
07950
07951
07952
07953
07954
07955
07956
07957
07958
07959
07960
07961
07962
07963
07964
07965
07966
07967
07968
07969
07970
07971
07972
07973
07974
07975
07976
07977
07978
07979
07980
07981
07982
07983
07984
07985
07986
07987
07988
07989
07990
07991
07992
07993
07994
07995
07996
07997
07998
07999
08000
08001
08002
08003
08004
08005
08006
08007
08008
08009
08010
08011
08012
08013
08014
08015
08016
08017
08018
08019
08020
08021
08022
08023
08024
08025
08026
08027
08028
08029
08030
08031
08032
08033
08034
08035
08036
08037
08038
08039
08040
08041
08042
08043
08044
08045
08046
08047
08048
08049
08050
08051
08052
08053
08054
08055
08056
08057
08058
08059
08060
08061
08062
08063
08064
08065
08066
08067
08068
08069
08070
08071
08072
08073
08074
08075
08076
08077
08078
08079
08080
08081
08082
08083
08084
08085
08086
08087
08088
08089
08090
08091
08092
08093
08094
08095
08096
08097
08098
08099
08100
08101
08102
08103
08104
08105
08106
08107
08108
08109
08110
08111
08112
08113
08114
08115
08116
08117
08118
08119
08120
08121
08122
08123
08124
08125
08126
08127
08128
08129
08130
08131
08132
08133
08134
08135
08136
08137
08138
08139
08140
08141
08142
08143
08144
08145
08146
08147
08148
08149
08150
08151
08152
08153
08154
08155
08156
08157
08158
08159
08160
08161
08162
08163
08164
08165
08166
08167
08168
08169
08170
08171
08172
08173
08174
08175
08176
08177
08178
08179
08180
08181
08182
08183
08184
08185
08186
08187
08188
08189
08190
08191
08192
08193
08194
08195
08196
08197
08198
08199
08200
08201
08202
08203
08204
08205
08206
08207
08208
08209
08210
08211
08212
08213
08214
08215
08216
08217
08218
08219
08220
08221
08222
08223
08224
08225
08226
08227
08228
08229
08230
08231
08232
08233
08234
08235
08236
08237
08238
08239
08240
08241
08242
08243
08244
08245
08246
08247
08248
08249
08250
08251
08252
08253
08254
08255
08256
08257
08258
08259
08260
08261
08262
08263
08264
08265
08266
08267
08268
08269
08270
08271
08272
08273
08274
08275
08276
08277
08278
08279
08280
08281
08282
08283
08284
08285
08286
08287
08288
08289
08290
08291
08292
08293
08294
08295
08296
08297
08298
08299
08300
08301
08302
08303
08304
08305
08306
08307
08308
08309
08310
08311
08312
08313
08314
08315
08316
08317
08318
08319
08320
08321
08322
08323
08324
08325
08326
08327
08328
08329
08330
08331
08332
08333
08334
08335
08336
08337
08338
08339
08340
08341
08342
08343
08344
08345
08346
08347
08348
08349
08350
08351
08352
08353
08354
08355
08356
08357
08358
08359
08360
08361
08362
08363
08364
08365
08366
08367
08368
08369
08370
08371
08372
08373
08374
08375
08376
08377
08378
08379
08380
08381
08382
08383
08384
08385
08386
08387
08388
08389
08390
08391
08392
08393
08394
08395
08396
08397
08398
08399
08400
08401
08402
08403
08404
08405
08406
08407
08408
08409
08410
08411
08412
08413
08414
08415
08416
08417
08418
08419
08420
08421
08422
08423
08424
08425
08426
08427
08428
08429
08430
08431
08432
08433
08434
08435
08436
08437
08438
08439
08440
08441
08442
08443
08444
08445
08446
08447
08448
08449
08450
08451
08452
08453
08454
08455
08456
08457
08458
08459
08460
08461
08462
08463
08464
08465
08466
08467
08468
08469
08470
08471
08472
08473
08474
08475
08476
08477
08478
08479
08480
08481
08482
08483
08484
08485
08486
08487
08488
08489
08490
08491
08492
08493
08494
08495
08496
08497
08498
08499
08500
08501
08502
08503
08504
08505
08506
08507
08508
08509
08510
08511
08512
08513
08514
08515
08516
08517
08518
08519
08520
08521
08522
08523
08524
08525
08526
08527
08528
08529
08530
08531
08532
08533
08534
08535
08536
08537
08538
08539
08540
08541
08542
08543
08544
08545
08546
08547
08548
08549
08550
08551
08552
08553
08554
08555
08556
08557
08558
08559
08560
08561
08562
08563
08564
08565
08566
08567
08568
08569
08570
08571
08572
08573
08574
08575
08576
08577
08578
08579
08580
08581
08582
08583
08584
08585
08586
08587
08588
08589
08590
08591
08592
08593
08594
08595
08596
08597
08598
08599
08600
08601
08602
08603
08604
08605
08606
08607
08608
08609
08610
08611
08612
08613
08614
08615
08616
08617
08618
08619
08620
08621
08622
08623
08624
08625
08626
08627
08628
08629
08630
08631
08632
08633
08634
08635
08636
08637
08638
08639
08640
08641
08642
08643
08644
08645
08646
08647
08648
08649
08650
08651
08652
08653
08654
08655
08656
08657
08658
08659
08660
08661
08662
08663
08664
08665
08666
08667
08668
08669
08670
08671
08672
08673
08674
08675
08676
08677
08678
08679
08680
08681
08682
08683
08684
08685
08686
08687
08688
08689
08690
08691
08692
08693
08694
08695
08696
08697
08698
08699
08700
08701
08702
08703
08704
08705
08706
08707
08708
08709
08710
08711
08712
08713
08714
08715
08716
08717
08718
08719
08720
08721
08722
08723
08724
08725
08726
08727
08728
08729
08730
08731
08732
08733
08734
08735
08736
08737
08738
08739
08740
08741
08742
08743
08744
08745
08746
08747
08748
08749
08750
08751
08752
08753
08754
08755
08756
08757
08758
08759
08760
08761
08762
08763
08764
08765
08766
08767
08768
08769
08770
08771
08772
08773
08774
08775
08776
08777
08778
08779
08780
08781
08782
08783
08784
08785
08786
08787
08788
08789
08790
08791
08792
08793
08794
08795
08796
08797
08798
08799
08800
08801
08802
08803
08804
08805
08806
08807
08808
08809
08810
08811
08812
08813
08814
08815
08816
08817
08818
08819
08820
08821
08822
08823
08824
08825
08826
08827
08828
08829
08830
08831
08832
08833
08834
08835
08836
08837
08838
08839
08840
08841
08842
08843
08844
08845
08846
08847
08848
08849
08850
08851
08852
08853
08854
08855
08856
08857
08858
08859
08860
08861
08862
08863
08864
08865
08866
08867
08868
08869
08870
08871
08872
08873
08874
08875
08876
08877
08878
08879
08880
08881
08882
08883
08884
08885
08886
08887
08888
08889
08890
08891
08892
08893
08894
08895
08896
08897
08898
08899
08900
08901
08902
08903
08904
08905
08906
08907
08908
08909
08910
08911
08912
08913
08914
08915
08916
08917
08918
08919
08920
08921
08922
08923
08924
08925
08926
08927
08928
08929
08930
08931
08932
08933
08934
08935
08936
08937
08938
08939
08940
08941
08942
08943
08944
08945
08946
08947
08948
08949
08950
08951
08952
08953
08954
08955
08956
08957
08958
08959
08960
08961
08962
08963
08964
08965
08966
08967
08968
08969
08970
08971
08972
08973
08974
08975
08976
08977
08978
08979
08980
08981
08982
08983
08984
08985
08986
08987
08988
08989
08990
08991
08992
08993
08994
08995
08996
08997
08998
08999
09000
09001
09002
09003
09004
09005
09006
09007
09008
09009
09010
09011
09012
09013
09014
09015
09016
09017
09018
09019
09020
09021
09022
09023
09024
09025
09026
09027
09028
09029
09030
09031
09032
09033
09034
09035
09036
09037
09038
09039
09040
09041
09042
09043
09044
09045
09046
09047
09048
09049
09050
09051
09052
09053
09054
09055
09056
09057
09058
09059
09060
09061
09062
09063
09064
09065
09066
09067
09068
09069
09070
09071
09072
09073
09074
09075
09076
09077
09078
09079
09080
09081
09082
09083
09084
09085
09086
09087
09088
09089
09090
09091
09092
09093
09094
09095
09096
09097
09098
09099
09100
09101
09102
09103
09104
09105
09106
09107
09108
09109
09110
09111
09112
09113
09114
09115
09116
09117
09118
09119
09120
09121
09122
09123
09124
09125
09126
09127
09128
09129
09130
09131
09132
09133
09134
09135
09136
09137
09138
09139
09140
09141
09142
09143
09144
09145
09146
09147
09148
09149
09150
09151
09152
09153
09154
09155
09156
09157
09158
09159
09160
09161
09162
09163
09164
09165
09166
09167
09168
09169
09170
09171
09172
09173
09174
09175
09176
09177
09178
09179
09180
09181
09182
09183
09184
09185
09186
09187
09188
09189
09190
09191
09192
09193
09194
09195
09196
09197
09198
09199
09200
09201
09202
09203
09204
09205
09206
09207
09208
09209
09210
09211
09212
09213
09214
09215
09216
09217
09218
09219
09220
09221
09222
09223
09224
09225
09226
09227
09228
09229
09230
09231
09232
09233
09234
09235
09236
09237
09238
09239
09240
09241
09242
09243
09244
09245
09246
09247
09248
09249
09250
09251
09252
09253
09254
09255
09256
09257
09258
09259
09260
09261
09262
09263
09264
09265
09266
09267
09268
09269
09270
09271
09272
09273
09274
09275
09276
09277
09278
09279
09280
09281
09282
09283
09284
09285
09286
09287
09288
09289
09290
09291
09292
09293
09294
09295
09296
09297
09298
09299
09300
09301
09302
09303
09304
09305
09306
09307
09308
09309
09310
09311
09312
09313
09314
09315
09316
09317
09318
09319
09320
09321
09322
09323
09324
09325
09326
09327
09328
09329
09330
09331
09332
09333
09334
09335
09336
09337
09338
09339
09340
09341
09342
09343
09344
09345
09346
09347
09348
09349
09350
09351
09352
09353
09354
09355
09356
09357
09358
09359
09360
09361
09362
09363
09364
09365
09366
09367
09368
09369
09370
09371
09372
09373
09374
09375
09376
09377
09378
09379
09380
09381
09382
09383
09384
09385
09386
09387
09388
09389
09390
09391
09392
09393
09394
09395
09396
09397
09398
09399
09400
09401
09402
09403
09404
09405
09406
09407
09408
09409
09410
09411
09412
09413
09414
09415
09416
09417
09418
09419
09420
09421
09422
09423
09424
09425
09426
09427
09428
09429
09430
09431
09432
09433
09434
09435
09436
09437
09438
09439
09440
09441
09442
09443
09444
09445
09446
09447
09448
09449
09450
09451
09452
09453
09454
09455
09456
09457
09458
09459
09460
09461
09462
09463
09464
09465
09466
09467
09468
09469
09470
09471
09472
09473
09474
09475
09476
09477
09478
09479
09480
09481
09482
09483
09484
09485
09486
09487
09488
09489
09490
09491
09492
09493
09494
09495
09496
09497
09498
09499
09500
09501
09502
09503
09504
09505
09506
09507
09508
09509
09510
09511
09512
09513
09514
09515
09516
09517
09518
09519
09520
09521
09522
09523
09524
09525
09526
09527
09528
09529
09530
09531
09532
09533
09534
09535
09536
09537
09538
09539
09540
09541
09542
09543
09544
09545
09546
09547
09548
09549
09550
09551
09552
09553
09554
09555
09556
09557
09558
09559
09560
09561
09562
09563
09564
09565
09566
09567
09568
09569
09570
09571
09572
09573
09574
09575
09576
09577
09578
09579
09580
09581
09582
09583
09584
09585
09586
09587
09588
09589
09590
09591
09592
09593
09594
09595
09596
09597
09598
09599
09600
09601
09602
09603
09604
09605
09606
09607
09608
09609
09610
09611
09612
09613
09614
09615
09616
09617
09618
09619
09620
09621
09622
09623
09624
09625
09626
09627
09628
09629
09630
09631
09632
09633
09634
09635
09636
09637
09638
09639
09640
09641
09642
09643
09644
09645
09646
09647
09648
09649
09650
09651
09652
09653
09654
09655
09656
09657
09658
09659
09660
09661
09662
09663
09664
09665
09666
09667
09668
09669
09670
09671
09672
09673
09674
09675
09676
09677
09678
09679
09680
09681
09682
09683
09684
09685
09686
09687
09688
09689
09690
09691
09692
09693
09694
09695
09696
09697
09698
09699
09700
09701
09702
09703
09704
09705
09706
09707
09708
09709
09710
09711
09712
09713
09714
09715
09716
09717
09718
09719
09720
09721
09722
09723
09724
09725
09726
09727
09728
09729
09730
09731
09732
09733
09734
09735
09736
09737
09738
09739
09740
09741
09742
09743
09744
09745
09746
09747
09748
09749
09750
09751
09752
09753
09754
09755
09756
09757
09758
09759
09760
09761
09762
09763
09764
09765
09766
09767
09768
09769
09770
09771
09772
09773
09774
09775
09776
09777
09778
09779
09780
09781
09782
09783
09784
09785
09786
09787
09788
09789
09790
09791
09792
09793
09794
09795
09796
09797
09798
09799
09800
09801
09802
09803
09804
09805
09806
09807
09808
09809
09810
09811
09812
09813
09814
09815
09816
09817
09818
09819
09820
09821
09822
09823
09824
09825
09826
09827
09828
09829
09830
09831
09832
09833
09834
09835
09836
09837
09838
09839
09840
09841
09842
09843
09844
09845
09846
09847
09848
09849
09850
09851
09852
09853
09854
09855
09856
09857
09858
09859
09860
09861
09862
09863
09864
09865
09866
09867
09868
09869
09870
09871
09872
09873
09874
09875
09876
09877
09878
09879
09880
09881
09882
09883
09884
09885
09886
09887
09888
09889
09890
09891
09892
09893
09894
09895
09896
09897
09898
09899
09900
09901
09902
09903
09904
09905
09906
09907
09908
09909
09910
09911
09912
09913
09914
09915
09916
09917
09918
09919
09920
09921
09922
09923
09924
09925
09926
09927
09928
09929
09930
09931
09932
09933
09934
09935
09936
09937
09938
09939
09940
09941
09942
09943
09944
09945
09946
09947
09948
09949
09950
09951
09952
09953
09954
09955
09956
09957
09958
09959
09960
09961
09962
09963
09964
09965
09966
09967
09968
09969
09970
09971
09972
09973
09974
09975
09976
09977
09978
09979
09980
09981
09982
09983
09984
09985
09986
09987
09988
09989
09990
09991
09992
09993
09994
09995
09996
09997
09998
09999
10000
10001
10002
10003
10004
10005
10006
10007
10008
10009
10010
10011
10012
10013
10014
10015
10016
10017
10018
10019
10020
10021
10022
10023
10024
10025
10026
10027
10028
10029
10030
10031
10032
10033
10034
10035
10036
10037
10038
10039
10040
10041
10042
10043
10044
10045
10046
10047
10048
10049
10050
10051
10052
10053
10054
10055
10056
10057
10058
10059
10060
10061
10062
10063
10064
10065
10066
10067
10068
10069
10070
10071
10072
10073
10074
10075
10076
10077
10078
10079
10080
10081
10082
10083
10084
10085
10086
10087
10088
10089
10090
10091
10092
10093
10094
10095
10096
10097
10098
10099
10100
10101
10102
10103
10104
10105
10106
10107
10108
10109
10110
10111
10112
10113
10114
10115
10116
10117
10118
10119
10120
10121
10122
10123
10124
10125
10126
10127
10128
10129
10130
10131
10132
10133
10134
10135
10136
10137
10138
10139
10140
10141
10142
10143
10144
10145
10146
10147
10148
10149
10150
10151
10152
10153
10154
10155
10156
10157
10158
10159
10160
10161
10162
10163
10164
10165
10166
10167
10168
10169
10170
10171
10172
10173
10174
10175
10176
10177
10178
10179
10180
10181
10182
10183
10184
10185
10186
10187
10188
10189
10190
10191
10192
10193
10194
10195
10196
10197
10198
10199
10200
10201
10202
10203
10204
10205
10206
10207
10208
10209
10210
10211
10212
10213
10214
10215
10216
10217
10218
10219
10220
10221
10222
10223
10224
10225
10226
10227
10228
10229
10230
10231
10232
10233
10234
10235
10236
10237
10238
10239
10240
10241
10242
10243
10244
10245
10246
10247
10248
10249
10250
10251
10252
10253
10254
10255
10256
10257
10258
10259
10260
10261
10262
10263
10264
10265
10266
10267
10268
10269
10270
10271
10272
10273
10274
10275
10276
10277
10278
10279
10280
10281
10282
10283
10284
10285
10286
10287
10288
10289
10290
10291
10292
10293
10294
10295
10296
10297
10298
10299
10300
10301
10302
10303
10304
10305
10306
10307
10308
10309
10310
10311
10312
10313
10314
10315
10316
10317
10318
10319
10320
10321
10322
10323
10324
10325
10326
10327
10328
10329
10330
10331
10332
10333
10334
10335
10336
10337
10338
10339
10340
10341
10342
10343
10344
10345
10346
10347
10348
10349
10350
10351
10352
10353
10354
10355
10356
10357
10358
10359
10360
10361
10362
10363
10364
10365
10366
10367
10368
10369
10370
10371
10372
10373
10374
10375
10376
10377
10378
10379
10380
10381
10382
10383
10384
10385
10386
10387
10388
10389
10390
10391
10392
10393
10394
10395
10396
10397
10398
10399
10400
10401
10402
10403
10404
10405
10406
10407
10408
10409
10410
10411
10412
10413
10414
10415
10416
10417
10418
10419
10420
10421
10422
10423
10424
10425
10426
10427
10428
10429
10430
10431
10432
10433
10434
10435
10436
10437
10438
10439
10440
10441
10442
10443
10444
10445
10446
10447
10448
10449
10450
10451
10452
10453
10454
10455
10456
10457
10458
10459
10460
10461
10462
10463
10464
10465
10466
10467
10468
10469
10470
10471
10472
10473
10474
10475
10476
10477
10478
10479
10480
10481
10482
10483
10484
10485
10486
10487
10488
10489
10490
10491
10492
10493
10494
10495
10496
10497
10498
10499
10500
10501
10502
10503
10504
10505
10506
10507
10508
10509
10510
10511
10512
10513
10514
10515
10516
10517
10518
10519
10520
10521
10522
10523
10524
10525
10526
10527
10528
10529
10530
10531
10532
10533
10534
10535
10536
10537
10538
10539
10540
10541
10542
10543
10544
10545
10546
10547
10548
10549
10550
10551
10552
10553
10554
10555
10556
10557
10558
10559
10560
10561
10562
10563
10564
10565
10566
10567
10568
10569
10570
10571
10572
10573
10574
10575
10576
10577
10578
10579
10580
10581
10582
10583
10584
10585
10586
10587
10588
10589
10590
10591
10592
10593
10594
10595
10596
10597
10598
10599
10600
10601
10602
10603
10604
10605
10606
10607
10608
10609
10610
10611
10612
10613
10614
10615
10616
10617
10618
10619
10620
10621
10622
10623
10624
10625
10626
10627
10628
10629
10630
10631
10632
10633
10634
10635
10636
10637
10638
10639
10640
10641
10642
10643
10644
10645
10646
10647
10648
10649
10650
10651
10652
10653
10654
10655
10656
10657
10658
10659
10660
10661
10662
10663
10664
10665
10666
10667
10668
10669
10670
10671
10672
10673
10674
10675
10676
10677
10678
10679
10680
10681
10682
10683
10684
10685
10686
10687
10688
10689
10690
10691
10692
10693
10694
10695
10696
10697
10698
10699
10700
10701
10702
10703
10704
10705
10706
10707
10708
10709
10710
10711
10712
10713
10714
10715
10716
10717
10718
10719
10720
10721
10722
10723
10724
10725
10726
10727
10728
10729
10730
10731
10732
10733
10734
10735
10736
10737
10738
10739
10740
10741
10742
10743
10744
10745
10746
10747
10748
10749
10750
10751
10752
10753
10754
10755
10756
10757
10758
10759
10760
10761
10762
10763
10764
10765
10766
10767
10768
10769
10770
10771
10772
10773
10774
10775
10776
10777
10778
10779
10780
10781
10782
10783
10784
10785
10786
10787
10788
10789
10790
10791
10792
10793
10794
10795
10796
10797
10798
10799
10800
10801
10802
10803
10804
10805
10806
10807
10808
10809
10810
10811
10812
10813
10814
10815
10816
10817
10818
10819
10820
10821
10822
10823
10824
10825
10826
10827
10828
10829
10830
10831
10832
10833
10834
10835
10836
10837
10838
10839
10840
10841
10842
10843
10844
10845
10846
10847
10848
10849
10850
10851
10852
10853
10854
10855
10856
10857
10858
10859
10860
10861
10862
10863
10864
10865
10866
10867
10868
10869
10870
10871
10872
10873
10874
10875
10876
10877
10878
10879
10880
10881
10882
10883
10884
10885
10886
10887
10888
10889
10890
10891
10892
10893
10894
10895
10896
10897
10898
10899
10900
10901
10902
10903
10904
10905
10906
10907
10908
10909
10910
10911
10912
10913
10914
10915
10916
10917
10918
10919
10920
10921
10922
10923
10924
10925
10926
10927
10928
10929
10930
10931
10932
10933
10934
10935
10936
10937
10938
10939
10940
10941
10942
10943
10944
10945
10946
10947
10948
10949
10950
10951
10952
10953
10954
10955
10956
10957
10958
10959
10960
10961
10962
10963
10964
10965
10966
10967
10968
10969
10970
10971
10972
10973
10974
10975
10976
10977
10978
10979
10980
10981
10982
10983
10984
10985
10986
10987
10988
10989
10990
10991
10992
10993
10994
10995
10996
10997
10998
10999
11000
11001
11002
11003
11004
11005
11006
11007
11008
11009
11010
11011
11012
11013
11014
11015
11016
11017
11018
11019
11020
11021
11022
11023
11024
11025
11026
11027
11028
11029
11030
11031
11032
11033
11034
11035
11036
11037
11038
11039
11040
11041
11042
11043
11044
11045
11046
11047
11048
11049
11050
11051
11052
11053
11054
11055
11056
11057
11058
11059
11060
11061
11062
11063
11064
11065
11066
11067
11068
11069
11070
11071
11072
11073
11074
11075
11076
11077
11078
11079
11080
11081
11082
11083
11084
11085
11086
11087
11088
11089
11090
11091
11092
11093
11094
11095
11096
11097
11098
11099
11100
11101
11102
11103
11104
11105
11106
11107
11108
11109
11110
11111
11112
11113
11114
11115
11116
11117
11118
11119
11120
11121
11122
11123
11124
11125
11126
11127
11128
11129
11130
11131
11132
11133
11134
11135
11136
11137
11138
11139
11140
11141
11142
11143
11144
11145
11146
11147
11148
11149
11150
11151
11152
11153
11154
11155
11156
11157
11158
11159
11160
11161
11162
11163
11164
11165
11166
11167
11168
11169
11170
11171
11172
11173
11174
11175
11176
11177
11178
11179
11180
11181
11182
11183
11184
11185
11186
11187
11188
11189
11190
11191
11192
11193
11194
11195
11196
11197
11198
11199
11200
11201
11202
11203
11204
11205
11206
11207
11208
11209
11210
11211
11212
11213
11214
11215
11216
11217
11218
11219
11220
11221
11222
11223
11224
11225
11226
11227
11228
11229
11230
11231
11232
11233
11234
11235
11236
11237
11238
11239
11240
11241
11242
11243
11244
11245
11246
11247
11248
11249
11250
11251
11252
11253
11254
11255
11256
11257
11258
11259
11260
11261
11262
11263
11264
11265
11266
11267
11268
11269
11270
11271
11272
11273
11274
11275
11276
11277
11278
11279
11280
11281
11282
11283
11284
11285
11286
11287
11288
11289
11290
11291
11292
11293
11294
11295
11296
11297
11298
11299
11300
11301
11302
11303
11304
11305
11306
11307
11308
11309
11310
11311
11312
11313
11314
11315
11316
11317
11318
11319
11320
11321
11322
11323
11324
11325
11326
11327
11328
11329
11330
11331
11332
11333
11334
11335
11336
11337
11338
11339
11340
11341
11342
11343
11344
11345
11346
11347
11348
11349
11350
11351
11352
11353
11354
11355
11356
11357
11358
11359
11360
11361
11362
11363
11364
11365
11366
11367
11368
11369
11370
11371
11372
11373
11374
11375
11376
11377
11378
11379
11380
11381
11382
11383
11384
11385
11386
11387
11388
11389
11390
11391
11392
11393
11394
11395
11396
11397
11398
11399
11400
11401
11402
11403
11404
11405
11406
11407
11408
11409
11410
11411
11412
11413
11414
11415
11416
11417
11418
11419
11420
11421
11422
11423
11424
11425
11426
11427
11428
11429
11430
11431
11432
11433
11434
11435
11436
11437
11438
11439
11440
11441
11442
11443
11444
11445
11446
11447
11448
11449
11450
11451
11452
11453
11454
11455
11456
11457
11458
11459
11460
11461
11462
11463
11464
11465
11466
11467
11468
11469
11470
11471
11472
11473
11474
11475
11476
11477
11478
11479
11480
11481
11482
11483
11484
11485
11486
11487
11488
11489
11490
11491
11492
11493
11494
11495
11496
11497
11498
11499
11500
11501
11502
11503
11504
11505
11506
11507
11508
11509
11510
11511
11512
11513
11514
11515
11516
11517
11518
11519
11520
11521
11522
11523
11524
11525
11526
11527
11528
11529
11530
11531
11532
11533
11534
11535
11536
11537
11538
11539
11540
11541
11542
11543
11544
11545
11546
11547
11548
11549
11550
11551
11552
11553
11554
11555
11556
11557
11558
11559
11560
11561
11562
11563
11564
11565
11566
11567
11568
11569
11570
11571
11572
11573
11574
11575
11576
11577
11578
11579
11580
11581
11582
11583
11584
11585
11586
11587
11588
11589
11590
11591
11592
11593
11594
11595
11596
11597
11598
11599
11600
11601
11602
11603
11604
11605
11606
11607
11608
11609
11610
11611
11612
11613
11614
11615
11616
11617
11618
11619
11620
11621
11622
11623
11624
11625
11626
11627
11628
11629
11630
11631
11632
11633
11634
11635
11636
11637
11638
11639
11640
11641
11642
11643
11644
11645
11646
11647
11648
11649
11650
11651
11652
11653
11654
11655
11656
11657
11658
11659
11660
11661
11662
11663
11664
11665
11666
11667
11668
11669
11670
11671
11672
11673
11674
11675
11676
11677
11678
11679
11680
11681
11682
11683
11684
11685
11686
11687
11688
11689
11690
11691
11692
11693
11694
11695
11696
11697
11698
11699
11700
11701
11702
11703
11704
11705
11706
11707
11708
11709
11710
11711
11712
11713
11714
11715
11716
11717
11718
11719
11720
11721
11722
11723
11724
11725
11726
11727
11728
11729
11730
11731
11732
11733
11734
11735
11736
11737
11738
11739
11740
11741
11742
11743
11744
11745
11746
11747
11748
11749
11750
11751
11752
11753
11754
11755
11756
11757
11758
11759
11760
11761
11762
11763
11764
11765
11766
11767
11768
11769
11770
11771
11772
11773
11774
11775
11776
11777
11778
11779
11780
11781
11782
11783
11784
11785
11786
11787
11788
11789
11790
11791
11792
11793
11794
11795
11796
11797
11798
11799
11800
11801
11802
11803
11804
11805
11806
11807
11808
11809
11810
11811
11812
11813
11814
11815
11816
11817
11818
11819
11820
11821
11822
11823
11824
11825
11826
11827
11828
11829
11830
11831
11832
11833
11834
11835
11836
11837
11838
11839
11840
11841
11842
11843
11844
11845
11846
11847
11848
11849
11850
11851
11852
11853
11854
11855
11856
11857
11858
11859
11860
11861
11862
11863
11864
11865
11866
11867
11868
11869
11870
11871
11872
11873
11874
11875
11876
11877
11878
11879
11880
11881
11882
11883
11884
11885
11886
11887
11888
11889
11890
11891
11892
11893
11894
11895
11896
11897
11898
11899
11900
11901
11902
11903
11904
11905
11906
11907
11908
11909
11910
11911
11912
11913
11914
11915
11916
11917
11918
11919
11920
11921
11922
11923
11924
11925
11926
11927
11928
11929
11930
11931
11932
11933
11934
11935
11936
11937
11938
11939
11940
11941
11942
11943
11944
11945
11946
11947
11948
11949
11950
11951
11952
11953
11954
11955
11956
11957
11958
11959
11960
11961
11962
11963
11964
11965
11966
11967
11968
11969
11970
11971
11972
11973
11974
11975
11976
11977
11978
11979
11980
11981
11982
11983
11984
11985
11986
11987
11988
11989
11990
11991
11992
11993
11994
11995
11996
11997
11998
11999
12000
12001
12002
12003
12004
12005
12006
12007
12008
12009
12010
12011
12012
12013
12014
12015
12016
12017
12018
12019
12020
12021
12022
12023
12024
12025
12026
12027
12028
12029
12030
12031
12032
12033
12034
12035
12036
12037
12038
12039
12040
12041
12042
12043
12044
12045
12046
12047
12048
12049
12050
12051
12052
12053
12054
12055
12056
12057
12058
12059
12060
12061
12062
12063
12064
12065
12066
12067
12068
12069
12070
12071
12072
12073
12074
12075
12076
12077
12078
12079
12080
12081
12082
12083
12084
12085
12086
12087
12088
12089
12090
12091
12092
12093
12094
12095
12096
12097
12098
12099
12100
12101
12102
12103
12104
12105
12106
12107
12108
12109
12110
12111
12112
12113
12114
12115
12116
12117
12118
12119
12120
12121
12122
12123
12124
12125
12126
12127
12128
12129
12130
12131
12132
12133
12134
12135
12136
12137
12138
12139
12140
12141
12142
12143
12144
12145
12146
12147
12148
12149
12150
12151
12152
12153
12154
12155
12156
12157
12158
12159
12160
12161
12162
12163
12164
12165
12166
12167
12168
12169
12170
12171
12172
12173
12174
12175
12176
12177
12178
12179
12180
12181
12182
12183
12184
12185
12186
12187
12188
12189
12190
12191
12192
12193
12194
12195
12196
12197
12198
12199
12200
12201
12202
12203
12204
12205
12206
12207
12208
12209
12210
12211
12212
12213
12214
12215
12216
12217
12218
12219
12220
12221
12222
12223
12224
12225
12226
12227
12228
12229
12230
12231
12232
12233
12234
12235
12236
12237
12238
12239
12240
12241
12242
12243
12244
12245
12246
12247
12248
12249
12250
12251
12252
12253
12254
12255
12256
12257
12258
12259
12260
12261
12262
12263
12264
12265
12266
12267
12268
12269
12270
12271
12272
12273
12274
12275
12276
12277
12278
12279
12280
12281
12282
12283
12284
12285
12286
12287
12288
12289
12290
12291
12292
12293
12294
12295
12296
12297
12298
12299
12300
12301
12302
12303
12304
12305
12306
12307
12308
12309
12310
12311
12312
12313
12314
12315
12316
12317
12318
12319
12320
12321
12322
12323
12324
12325
12326
12327
12328
12329
12330
12331
12332
12333
12334
12335
12336
12337
12338
12339
12340
12341
12342
12343
12344
12345
12346
12347
12348
12349
12350
12351
12352
12353
12354
12355
12356
12357
12358
12359
12360
12361
12362
12363
12364
12365
12366
12367
12368
12369
12370
12371
12372
12373
12374
12375
12376
12377
12378
12379
12380
12381
12382
12383
12384
12385
12386
12387
12388
12389
12390
12391
12392
12393
12394
12395
12396
12397
12398
12399
12400
12401
12402
12403
12404
12405
12406
12407
12408
12409
12410
12411
12412
12413
12414
12415
12416
12417
12418
12419
12420
12421
12422
12423
12424
12425
12426
12427
12428
12429
12430
12431
12432
12433
12434
12435
12436
12437
12438
12439
12440
12441
12442
12443
12444
12445
12446
12447
12448
12449
12450
12451
12452
12453
12454
12455
12456
12457
12458
12459
12460
12461
12462
12463
12464
12465
12466
12467
12468
12469
12470
12471
12472
12473
12474
12475
12476
12477
12478
12479
12480
12481
12482
12483
12484
12485
12486
12487
12488
12489
12490
12491
12492
12493
12494
12495
12496
12497
12498
12499
12500
12501
12502
12503
12504
12505
12506
12507
12508
12509
12510
12511
12512
12513
12514
12515
12516
12517
12518
12519
12520
12521
12522
12523
12524
12525
12526
12527
12528
12529
12530
12531
12532
12533
12534
12535
12536
12537
12538
12539
12540
12541
12542
12543
12544
12545
12546
12547
12548
12549
12550
12551
12552
12553
12554
12555
12556
12557
12558
12559
12560
12561
12562
12563
12564
12565
12566
12567
12568
12569
12570
12571
12572
12573
12574
12575
12576
12577
12578
12579
12580
12581
12582
12583
12584
12585
12586
12587
12588
12589
12590
12591
12592
12593
12594
12595
12596
12597
12598
12599
12600
12601
12602
12603
12604
12605
12606
12607
12608
12609
12610
12611
12612
12613
12614
12615
12616
12617
12618
12619
12620
12621
12622
12623
12624
12625
12626
12627
12628
12629
12630
12631
12632
12633
12634
12635
12636
12637
12638
12639
12640
12641
12642
12643
12644
12645
12646
12647
12648
12649
12650
12651
12652
12653
12654
12655
12656
12657
12658
12659
12660
12661
12662
12663
12664
12665
12666
12667
12668
12669
12670
12671
12672
12673
12674
12675
12676
12677
12678
12679
12680
12681
12682
12683
12684
12685
12686
12687
12688
12689
12690
12691
12692
12693
12694
12695
12696
12697
12698
12699
12700
12701
12702
12703
12704
12705
12706
12707
12708
12709
12710
12711
12712
12713
12714
12715
12716
12717
12718
12719
12720
12721
12722
12723
12724
12725
12726
12727
12728
12729
12730
12731
12732
12733
12734
12735
12736
12737
12738
12739
12740
12741
12742
12743
12744
12745
12746
12747
12748
12749
12750
12751
12752
12753
12754
12755
12756
12757
12758
12759
12760
12761
12762
12763
12764
12765
12766
12767
12768
12769
12770
12771
12772
12773
12774
12775
12776
12777
12778
12779
12780
12781
12782
12783
12784
12785
12786
12787
12788
12789
12790
12791
12792
12793
12794
12795
12796
12797
12798
12799
12800
12801
12802
12803
12804
12805
12806
12807
12808
12809
12810
12811
12812
12813
12814
12815
12816
12817
12818
12819
12820
12821
12822
12823
12824
12825
12826
12827
12828
12829
12830
12831
12832
12833
12834
12835
12836
12837
12838
12839
12840
12841
12842
12843
12844
12845
12846
12847
12848
12849
12850
12851
12852
12853
12854
12855
12856
12857
12858
12859
12860
12861
12862
12863
12864
12865
12866
/*****************************************************************************
  Copyright (c) 2014, Intel Corp.
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name of Intel Corporation nor the names of its contributors
      may be used to endorse or promote products derived from this software
      without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  THE POSSIBILITY OF SUCH DAMAGE.
******************************************************************************
* Contents: Native C interface to LAPACK
* Author: Intel Corporation
*****************************************************************************/

#ifndef _LAPACKE_64_H_
#define _LAPACKE_64_H_

#include "lapacke.h"

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/* C-LAPACK function prototypes */

int64_t LAPACKE_sbdsdc_64( int matrix_layout, char uplo, char compq,
                           int64_t n, float* d, float* e, float* u,
                           int64_t ldu, float* vt, int64_t ldvt, float* q,
                           int64_t* iq );
int64_t LAPACKE_dbdsdc_64( int matrix_layout, char uplo, char compq,
                           int64_t n, double* d, double* e, double* u,
                           int64_t ldu, double* vt, int64_t ldvt,
                           double* q, int64_t* iq );

int64_t LAPACKE_sbdsqr_64( int matrix_layout, char uplo, int64_t n,
                           int64_t ncvt, int64_t nru, int64_t ncc,
                           float* d, float* e, float* vt, int64_t ldvt,
                           float* u, int64_t ldu, float* c, int64_t ldc );
int64_t LAPACKE_dbdsqr_64( int matrix_layout, char uplo, int64_t n,
                           int64_t ncvt, int64_t nru, int64_t ncc,
                           double* d, double* e, double* vt, int64_t ldvt,
                           double* u, int64_t ldu, double* c,
                           int64_t ldc );
int64_t LAPACKE_cbdsqr_64( int matrix_layout, char uplo, int64_t n,
                           int64_t ncvt, int64_t nru, int64_t ncc,
                           float* d, float* e, lapack_complex_float* vt,
                           int64_t ldvt, lapack_complex_float* u,
                           int64_t ldu, lapack_complex_float* c,
                           int64_t ldc );
int64_t LAPACKE_zbdsqr_64( int matrix_layout, char uplo, int64_t n,
                           int64_t ncvt, int64_t nru, int64_t ncc,
                           double* d, double* e, lapack_complex_double* vt,
                           int64_t ldvt, lapack_complex_double* u,
                           int64_t ldu, lapack_complex_double* c,
                           int64_t ldc );
int64_t LAPACKE_sbdsvdx_64( int matrix_layout, char uplo, char jobz, char range,
                           int64_t n, float* d, float* e,
                           float vl, float vu,
                           int64_t il, int64_t iu, int64_t* ns,
                           float* s, float* z, int64_t ldz,
                           int64_t* superb );
int64_t LAPACKE_dbdsvdx_64( int matrix_layout, char uplo, char jobz, char range,
                           int64_t n, double* d, double* e,
                           double vl, double vu,
                           int64_t il, int64_t iu, int64_t* ns,
                           double* s, double* z, int64_t ldz,
                           int64_t* superb );
int64_t LAPACKE_sdisna_64( char job, int64_t m, int64_t n, const float* d,
                           float* sep );
int64_t LAPACKE_ddisna_64( char job, int64_t m, int64_t n,
                           const double* d, double* sep );

int64_t LAPACKE_sgbbrd_64( int matrix_layout, char vect, int64_t m,
                           int64_t n, int64_t ncc, int64_t kl,
                           int64_t ku, float* ab, int64_t ldab, float* d,
                           float* e, float* q, int64_t ldq, float* pt,
                           int64_t ldpt, float* c, int64_t ldc );
int64_t LAPACKE_dgbbrd_64( int matrix_layout, char vect, int64_t m,
                           int64_t n, int64_t ncc, int64_t kl,
                           int64_t ku, double* ab, int64_t ldab,
                           double* d, double* e, double* q, int64_t ldq,
                           double* pt, int64_t ldpt, double* c,
                           int64_t ldc );
int64_t LAPACKE_cgbbrd_64( int matrix_layout, char vect, int64_t m,
                           int64_t n, int64_t ncc, int64_t kl,
                           int64_t ku, lapack_complex_float* ab,
                           int64_t ldab, float* d, float* e,
                           lapack_complex_float* q, int64_t ldq,
                           lapack_complex_float* pt, int64_t ldpt,
                           lapack_complex_float* c, int64_t ldc );
int64_t LAPACKE_zgbbrd_64( int matrix_layout, char vect, int64_t m,
                           int64_t n, int64_t ncc, int64_t kl,
                           int64_t ku, lapack_complex_double* ab,
                           int64_t ldab, double* d, double* e,
                           lapack_complex_double* q, int64_t ldq,
                           lapack_complex_double* pt, int64_t ldpt,
                           lapack_complex_double* c, int64_t ldc );

int64_t LAPACKE_sgbcon_64( int matrix_layout, char norm, int64_t n,
                           int64_t kl, int64_t ku, const float* ab,
                           int64_t ldab, const int64_t* ipiv, float anorm,
                           float* rcond );
int64_t LAPACKE_dgbcon_64( int matrix_layout, char norm, int64_t n,
                           int64_t kl, int64_t ku, const double* ab,
                           int64_t ldab, const int64_t* ipiv,
                           double anorm, double* rcond );
int64_t LAPACKE_cgbcon_64( int matrix_layout, char norm, int64_t n,
                           int64_t kl, int64_t ku,
                           const lapack_complex_float* ab, int64_t ldab,
                           const int64_t* ipiv, float anorm, float* rcond );
int64_t LAPACKE_zgbcon_64( int matrix_layout, char norm, int64_t n,
                           int64_t kl, int64_t ku,
                           const lapack_complex_double* ab, int64_t ldab,
                           const int64_t* ipiv, double anorm,
                           double* rcond );

int64_t LAPACKE_sgbequ_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t kl, int64_t ku, const float* ab,
                           int64_t ldab, float* r, float* c, float* rowcnd,
                           float* colcnd, float* amax );
int64_t LAPACKE_dgbequ_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t kl, int64_t ku, const double* ab,
                           int64_t ldab, double* r, double* c,
                           double* rowcnd, double* colcnd, double* amax );
int64_t LAPACKE_cgbequ_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t kl, int64_t ku,
                           const lapack_complex_float* ab, int64_t ldab,
                           float* r, float* c, float* rowcnd, float* colcnd,
                           float* amax );
int64_t LAPACKE_zgbequ_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t kl, int64_t ku,
                           const lapack_complex_double* ab, int64_t ldab,
                           double* r, double* c, double* rowcnd, double* colcnd,
                           double* amax );

int64_t LAPACKE_sgbequb_64( int matrix_layout, int64_t m, int64_t n,
                            int64_t kl, int64_t ku, const float* ab,
                            int64_t ldab, float* r, float* c, float* rowcnd,
                            float* colcnd, float* amax );
int64_t LAPACKE_dgbequb_64( int matrix_layout, int64_t m, int64_t n,
                            int64_t kl, int64_t ku, const double* ab,
                            int64_t ldab, double* r, double* c,
                            double* rowcnd, double* colcnd, double* amax );
int64_t LAPACKE_cgbequb_64( int matrix_layout, int64_t m, int64_t n,
                            int64_t kl, int64_t ku,
                            const lapack_complex_float* ab, int64_t ldab,
                            float* r, float* c, float* rowcnd, float* colcnd,
                            float* amax );
int64_t LAPACKE_zgbequb_64( int matrix_layout, int64_t m, int64_t n,
                            int64_t kl, int64_t ku,
                            const lapack_complex_double* ab, int64_t ldab,
                            double* r, double* c, double* rowcnd,
                            double* colcnd, double* amax );

int64_t LAPACKE_sgbrfs_64( int matrix_layout, char trans, int64_t n,
                           int64_t kl, int64_t ku, int64_t nrhs,
                           const float* ab, int64_t ldab, const float* afb,
                           int64_t ldafb, const int64_t* ipiv,
                           const float* b, int64_t ldb, float* x,
                           int64_t ldx, float* ferr, float* berr );
int64_t LAPACKE_dgbrfs_64( int matrix_layout, char trans, int64_t n,
                           int64_t kl, int64_t ku, int64_t nrhs,
                           const double* ab, int64_t ldab, const double* afb,
                           int64_t ldafb, const int64_t* ipiv,
                           const double* b, int64_t ldb, double* x,
                           int64_t ldx, double* ferr, double* berr );
int64_t LAPACKE_cgbrfs_64( int matrix_layout, char trans, int64_t n,
                           int64_t kl, int64_t ku, int64_t nrhs,
                           const lapack_complex_float* ab, int64_t ldab,
                           const lapack_complex_float* afb, int64_t ldafb,
                           const int64_t* ipiv,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx, float* ferr,
                           float* berr );
int64_t LAPACKE_zgbrfs_64( int matrix_layout, char trans, int64_t n,
                           int64_t kl, int64_t ku, int64_t nrhs,
                           const lapack_complex_double* ab, int64_t ldab,
                           const lapack_complex_double* afb, int64_t ldafb,
                           const int64_t* ipiv,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* ferr, double* berr );

int64_t LAPACKE_sgbrfsx_64( int matrix_layout, char trans, char equed,
                            int64_t n, int64_t kl, int64_t ku,
                            int64_t nrhs, const float* ab, int64_t ldab,
                            const float* afb, int64_t ldafb,
                            const int64_t* ipiv, const float* r,
                            const float* c, const float* b, int64_t ldb,
                            float* x, int64_t ldx, float* rcond, float* berr,
                            int64_t n_err_bnds, float* err_bnds_norm,
                            float* err_bnds_comp, int64_t nparams,
                            float* params );
int64_t LAPACKE_dgbrfsx_64( int matrix_layout, char trans, char equed,
                            int64_t n, int64_t kl, int64_t ku,
                            int64_t nrhs, const double* ab, int64_t ldab,
                            const double* afb, int64_t ldafb,
                            const int64_t* ipiv, const double* r,
                            const double* c, const double* b, int64_t ldb,
                            double* x, int64_t ldx, double* rcond,
                            double* berr, int64_t n_err_bnds,
                            double* err_bnds_norm, double* err_bnds_comp,
                            int64_t nparams, double* params );
int64_t LAPACKE_cgbrfsx_64( int matrix_layout, char trans, char equed,
                            int64_t n, int64_t kl, int64_t ku,
                            int64_t nrhs, const lapack_complex_float* ab,
                            int64_t ldab, const lapack_complex_float* afb,
                            int64_t ldafb, const int64_t* ipiv,
                            const float* r, const float* c,
                            const lapack_complex_float* b, int64_t ldb,
                            lapack_complex_float* x, int64_t ldx,
                            float* rcond, float* berr, int64_t n_err_bnds,
                            float* err_bnds_norm, float* err_bnds_comp,
                            int64_t nparams, float* params );
int64_t LAPACKE_zgbrfsx_64( int matrix_layout, char trans, char equed,
                            int64_t n, int64_t kl, int64_t ku,
                            int64_t nrhs, const lapack_complex_double* ab,
                            int64_t ldab, const lapack_complex_double* afb,
                            int64_t ldafb, const int64_t* ipiv,
                            const double* r, const double* c,
                            const lapack_complex_double* b, int64_t ldb,
                            lapack_complex_double* x, int64_t ldx,
                            double* rcond, double* berr, int64_t n_err_bnds,
                            double* err_bnds_norm, double* err_bnds_comp,
                            int64_t nparams, double* params );

int64_t LAPACKE_sgbsv_64( int matrix_layout, int64_t n, int64_t kl,
                          int64_t ku, int64_t nrhs, float* ab,
                          int64_t ldab, int64_t* ipiv, float* b,
                          int64_t ldb );
int64_t LAPACKE_dgbsv_64( int matrix_layout, int64_t n, int64_t kl,
                          int64_t ku, int64_t nrhs, double* ab,
                          int64_t ldab, int64_t* ipiv, double* b,
                          int64_t ldb );
int64_t LAPACKE_cgbsv_64( int matrix_layout, int64_t n, int64_t kl,
                          int64_t ku, int64_t nrhs,
                          lapack_complex_float* ab, int64_t ldab,
                          int64_t* ipiv, lapack_complex_float* b,
                          int64_t ldb );
int64_t LAPACKE_zgbsv_64( int matrix_layout, int64_t n, int64_t kl,
                          int64_t ku, int64_t nrhs,
                          lapack_complex_double* ab, int64_t ldab,
                          int64_t* ipiv, lapack_complex_double* b,
                          int64_t ldb );

int64_t LAPACKE_sgbsvx_64( int matrix_layout, char fact, char trans,
                           int64_t n, int64_t kl, int64_t ku,
                           int64_t nrhs, float* ab, int64_t ldab,
                           float* afb, int64_t ldafb, int64_t* ipiv,
                           char* equed, float* r, float* c, float* b,
                           int64_t ldb, float* x, int64_t ldx,
                           float* rcond, float* ferr, float* berr,
                           float* rpivot );
int64_t LAPACKE_dgbsvx_64( int matrix_layout, char fact, char trans,
                           int64_t n, int64_t kl, int64_t ku,
                           int64_t nrhs, double* ab, int64_t ldab,
                           double* afb, int64_t ldafb, int64_t* ipiv,
                           char* equed, double* r, double* c, double* b,
                           int64_t ldb, double* x, int64_t ldx,
                           double* rcond, double* ferr, double* berr,
                           double* rpivot );
int64_t LAPACKE_cgbsvx_64( int matrix_layout, char fact, char trans,
                           int64_t n, int64_t kl, int64_t ku,
                           int64_t nrhs, lapack_complex_float* ab,
                           int64_t ldab, lapack_complex_float* afb,
                           int64_t ldafb, int64_t* ipiv, char* equed,
                           float* r, float* c, lapack_complex_float* b,
                           int64_t ldb, lapack_complex_float* x,
                           int64_t ldx, float* rcond, float* ferr,
                           float* berr, float* rpivot );
int64_t LAPACKE_zgbsvx_64( int matrix_layout, char fact, char trans,
                           int64_t n, int64_t kl, int64_t ku,
                           int64_t nrhs, lapack_complex_double* ab,
                           int64_t ldab, lapack_complex_double* afb,
                           int64_t ldafb, int64_t* ipiv, char* equed,
                           double* r, double* c, lapack_complex_double* b,
                           int64_t ldb, lapack_complex_double* x,
                           int64_t ldx, double* rcond, double* ferr,
                           double* berr, double* rpivot );

int64_t LAPACKE_sgbsvxx_64( int matrix_layout, char fact, char trans,
                            int64_t n, int64_t kl, int64_t ku,
                            int64_t nrhs, float* ab, int64_t ldab,
                            float* afb, int64_t ldafb, int64_t* ipiv,
                            char* equed, float* r, float* c, float* b,
                            int64_t ldb, float* x, int64_t ldx,
                            float* rcond, float* rpvgrw, float* berr,
                            int64_t n_err_bnds, float* err_bnds_norm,
                            float* err_bnds_comp, int64_t nparams,
                            float* params );
int64_t LAPACKE_dgbsvxx_64( int matrix_layout, char fact, char trans,
                            int64_t n, int64_t kl, int64_t ku,
                            int64_t nrhs, double* ab, int64_t ldab,
                            double* afb, int64_t ldafb, int64_t* ipiv,
                            char* equed, double* r, double* c, double* b,
                            int64_t ldb, double* x, int64_t ldx,
                            double* rcond, double* rpvgrw, double* berr,
                            int64_t n_err_bnds, double* err_bnds_norm,
                            double* err_bnds_comp, int64_t nparams,
                            double* params );
int64_t LAPACKE_cgbsvxx_64( int matrix_layout, char fact, char trans,
                            int64_t n, int64_t kl, int64_t ku,
                            int64_t nrhs, lapack_complex_float* ab,
                            int64_t ldab, lapack_complex_float* afb,
                            int64_t ldafb, int64_t* ipiv, char* equed,
                            float* r, float* c, lapack_complex_float* b,
                            int64_t ldb, lapack_complex_float* x,
                            int64_t ldx, float* rcond, float* rpvgrw,
                            float* berr, int64_t n_err_bnds,
                            float* err_bnds_norm, float* err_bnds_comp,
                            int64_t nparams, float* params );
int64_t LAPACKE_zgbsvxx_64( int matrix_layout, char fact, char trans,
                            int64_t n, int64_t kl, int64_t ku,
                            int64_t nrhs, lapack_complex_double* ab,
                            int64_t ldab, lapack_complex_double* afb,
                            int64_t ldafb, int64_t* ipiv, char* equed,
                            double* r, double* c, lapack_complex_double* b,
                            int64_t ldb, lapack_complex_double* x,
                            int64_t ldx, double* rcond, double* rpvgrw,
                            double* berr, int64_t n_err_bnds,
                            double* err_bnds_norm, double* err_bnds_comp,
                            int64_t nparams, double* params );

int64_t LAPACKE_sgbtrf_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t kl, int64_t ku, float* ab,
                           int64_t ldab, int64_t* ipiv );
int64_t LAPACKE_dgbtrf_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t kl, int64_t ku, double* ab,
                           int64_t ldab, int64_t* ipiv );
int64_t LAPACKE_cgbtrf_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t kl, int64_t ku,
                           lapack_complex_float* ab, int64_t ldab,
                           int64_t* ipiv );
int64_t LAPACKE_zgbtrf_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t kl, int64_t ku,
                           lapack_complex_double* ab, int64_t ldab,
                           int64_t* ipiv );

int64_t LAPACKE_sgbtrs_64( int matrix_layout, char trans, int64_t n,
                           int64_t kl, int64_t ku, int64_t nrhs,
                           const float* ab, int64_t ldab,
                           const int64_t* ipiv, float* b, int64_t ldb );
int64_t LAPACKE_dgbtrs_64( int matrix_layout, char trans, int64_t n,
                           int64_t kl, int64_t ku, int64_t nrhs,
                           const double* ab, int64_t ldab,
                           const int64_t* ipiv, double* b, int64_t ldb );
int64_t LAPACKE_cgbtrs_64( int matrix_layout, char trans, int64_t n,
                           int64_t kl, int64_t ku, int64_t nrhs,
                           const lapack_complex_float* ab, int64_t ldab,
                           const int64_t* ipiv, lapack_complex_float* b,
                           int64_t ldb );
int64_t LAPACKE_zgbtrs_64( int matrix_layout, char trans, int64_t n,
                           int64_t kl, int64_t ku, int64_t nrhs,
                           const lapack_complex_double* ab, int64_t ldab,
                           const int64_t* ipiv, lapack_complex_double* b,
                           int64_t ldb );

int64_t LAPACKE_sgebak_64( int matrix_layout, char job, char side, int64_t n,
                           int64_t ilo, int64_t ihi, const float* scale,
                           int64_t m, float* v, int64_t ldv );
int64_t LAPACKE_dgebak_64( int matrix_layout, char job, char side, int64_t n,
                           int64_t ilo, int64_t ihi, const double* scale,
                           int64_t m, double* v, int64_t ldv );
int64_t LAPACKE_cgebak_64( int matrix_layout, char job, char side, int64_t n,
                           int64_t ilo, int64_t ihi, const float* scale,
                           int64_t m, lapack_complex_float* v,
                           int64_t ldv );
int64_t LAPACKE_zgebak_64( int matrix_layout, char job, char side, int64_t n,
                           int64_t ilo, int64_t ihi, const double* scale,
                           int64_t m, lapack_complex_double* v,
                           int64_t ldv );

int64_t LAPACKE_sgebal_64( int matrix_layout, char job, int64_t n, float* a,
                           int64_t lda, int64_t* ilo, int64_t* ihi,
                           float* scale );
int64_t LAPACKE_dgebal_64( int matrix_layout, char job, int64_t n, double* a,
                           int64_t lda, int64_t* ilo, int64_t* ihi,
                           double* scale );
int64_t LAPACKE_cgebal_64( int matrix_layout, char job, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* ilo, int64_t* ihi, float* scale );
int64_t LAPACKE_zgebal_64( int matrix_layout, char job, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* ilo, int64_t* ihi, double* scale );

int64_t LAPACKE_sgebrd_64( int matrix_layout, int64_t m, int64_t n,
                           float* a, int64_t lda, float* d, float* e,
                           float* tauq, float* taup );
int64_t LAPACKE_dgebrd_64( int matrix_layout, int64_t m, int64_t n,
                           double* a, int64_t lda, double* d, double* e,
                           double* tauq, double* taup );
int64_t LAPACKE_cgebrd_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_float* a, int64_t lda, float* d,
                           float* e, lapack_complex_float* tauq,
                           lapack_complex_float* taup );
int64_t LAPACKE_zgebrd_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_double* a, int64_t lda, double* d,
                           double* e, lapack_complex_double* tauq,
                           lapack_complex_double* taup );

int64_t LAPACKE_sgecon_64( int matrix_layout, char norm, int64_t n,
                           const float* a, int64_t lda, float anorm,
                           float* rcond );
int64_t LAPACKE_dgecon_64( int matrix_layout, char norm, int64_t n,
                           const double* a, int64_t lda, double anorm,
                           double* rcond );
int64_t LAPACKE_cgecon_64( int matrix_layout, char norm, int64_t n,
                           const lapack_complex_float* a, int64_t lda,
                           float anorm, float* rcond );
int64_t LAPACKE_zgecon_64( int matrix_layout, char norm, int64_t n,
                           const lapack_complex_double* a, int64_t lda,
                           double anorm, double* rcond );

int64_t LAPACKE_sgeequ_64( int matrix_layout, int64_t m, int64_t n,
                           const float* a, int64_t lda, float* r, float* c,
                           float* rowcnd, float* colcnd, float* amax );
int64_t LAPACKE_dgeequ_64( int matrix_layout, int64_t m, int64_t n,
                           const double* a, int64_t lda, double* r,
                           double* c, double* rowcnd, double* colcnd,
                           double* amax );
int64_t LAPACKE_cgeequ_64( int matrix_layout, int64_t m, int64_t n,
                           const lapack_complex_float* a, int64_t lda,
                           float* r, float* c, float* rowcnd, float* colcnd,
                           float* amax );
int64_t LAPACKE_zgeequ_64( int matrix_layout, int64_t m, int64_t n,
                           const lapack_complex_double* a, int64_t lda,
                           double* r, double* c, double* rowcnd, double* colcnd,
                           double* amax );

int64_t LAPACKE_sgeequb_64( int matrix_layout, int64_t m, int64_t n,
                            const float* a, int64_t lda, float* r, float* c,
                            float* rowcnd, float* colcnd, float* amax );
int64_t LAPACKE_dgeequb_64( int matrix_layout, int64_t m, int64_t n,
                            const double* a, int64_t lda, double* r,
                            double* c, double* rowcnd, double* colcnd,
                            double* amax );
int64_t LAPACKE_cgeequb_64( int matrix_layout, int64_t m, int64_t n,
                            const lapack_complex_float* a, int64_t lda,
                            float* r, float* c, float* rowcnd, float* colcnd,
                            float* amax );
int64_t LAPACKE_zgeequb_64( int matrix_layout, int64_t m, int64_t n,
                            const lapack_complex_double* a, int64_t lda,
                            double* r, double* c, double* rowcnd,
                            double* colcnd, double* amax );

int64_t LAPACKE_sgees_64( int matrix_layout, char jobvs, char sort,
                          LAPACK_S_SELECT2 select, int64_t n, float* a,
                          int64_t lda, int64_t* sdim, float* wr,
                          float* wi, float* vs, int64_t ldvs );
int64_t LAPACKE_dgees_64( int matrix_layout, char jobvs, char sort,
                          LAPACK_D_SELECT2 select, int64_t n, double* a,
                          int64_t lda, int64_t* sdim, double* wr,
                          double* wi, double* vs, int64_t ldvs );
int64_t LAPACKE_cgees_64( int matrix_layout, char jobvs, char sort,
                          LAPACK_C_SELECT1 select, int64_t n,
                          lapack_complex_float* a, int64_t lda,
                          int64_t* sdim, lapack_complex_float* w,
                          lapack_complex_float* vs, int64_t ldvs );
int64_t LAPACKE_zgees_64( int matrix_layout, char jobvs, char sort,
                          LAPACK_Z_SELECT1 select, int64_t n,
                          lapack_complex_double* a, int64_t lda,
                          int64_t* sdim, lapack_complex_double* w,
                          lapack_complex_double* vs, int64_t ldvs );

int64_t LAPACKE_sgeesx_64( int matrix_layout, char jobvs, char sort,
                           LAPACK_S_SELECT2 select, char sense, int64_t n,
                           float* a, int64_t lda, int64_t* sdim,
                           float* wr, float* wi, float* vs, int64_t ldvs,
                           float* rconde, float* rcondv );
int64_t LAPACKE_dgeesx_64( int matrix_layout, char jobvs, char sort,
                           LAPACK_D_SELECT2 select, char sense, int64_t n,
                           double* a, int64_t lda, int64_t* sdim,
                           double* wr, double* wi, double* vs, int64_t ldvs,
                           double* rconde, double* rcondv );
int64_t LAPACKE_cgeesx_64( int matrix_layout, char jobvs, char sort,
                           LAPACK_C_SELECT1 select, char sense, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* sdim, lapack_complex_float* w,
                           lapack_complex_float* vs, int64_t ldvs,
                           float* rconde, float* rcondv );
int64_t LAPACKE_zgeesx_64( int matrix_layout, char jobvs, char sort,
                           LAPACK_Z_SELECT1 select, char sense, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* sdim, lapack_complex_double* w,
                           lapack_complex_double* vs, int64_t ldvs,
                           double* rconde, double* rcondv );

int64_t LAPACKE_sgeev_64( int matrix_layout, char jobvl, char jobvr,
                          int64_t n, float* a, int64_t lda, float* wr,
                          float* wi, float* vl, int64_t ldvl, float* vr,
                          int64_t ldvr );
int64_t LAPACKE_dgeev_64( int matrix_layout, char jobvl, char jobvr,
                          int64_t n, double* a, int64_t lda, double* wr,
                          double* wi, double* vl, int64_t ldvl, double* vr,
                          int64_t ldvr );
int64_t LAPACKE_cgeev_64( int matrix_layout, char jobvl, char jobvr,
                          int64_t n, lapack_complex_float* a, int64_t lda,
                          lapack_complex_float* w, lapack_complex_float* vl,
                          int64_t ldvl, lapack_complex_float* vr,
                          int64_t ldvr );
int64_t LAPACKE_zgeev_64( int matrix_layout, char jobvl, char jobvr,
                          int64_t n, lapack_complex_double* a,
                          int64_t lda, lapack_complex_double* w,
                          lapack_complex_double* vl, int64_t ldvl,
                          lapack_complex_double* vr, int64_t ldvr );

int64_t LAPACKE_sgeevx_64( int matrix_layout, char balanc, char jobvl,
                           char jobvr, char sense, int64_t n, float* a,
                           int64_t lda, float* wr, float* wi, float* vl,
                           int64_t ldvl, float* vr, int64_t ldvr,
                           int64_t* ilo, int64_t* ihi, float* scale,
                           float* abnrm, float* rconde, float* rcondv );
int64_t LAPACKE_dgeevx_64( int matrix_layout, char balanc, char jobvl,
                           char jobvr, char sense, int64_t n, double* a,
                           int64_t lda, double* wr, double* wi, double* vl,
                           int64_t ldvl, double* vr, int64_t ldvr,
                           int64_t* ilo, int64_t* ihi, double* scale,
                           double* abnrm, double* rconde, double* rcondv );
int64_t LAPACKE_cgeevx_64( int matrix_layout, char balanc, char jobvl,
                           char jobvr, char sense, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* w, lapack_complex_float* vl,
                           int64_t ldvl, lapack_complex_float* vr,
                           int64_t ldvr, int64_t* ilo, int64_t* ihi,
                           float* scale, float* abnrm, float* rconde,
                           float* rcondv );
int64_t LAPACKE_zgeevx_64( int matrix_layout, char balanc, char jobvl,
                           char jobvr, char sense, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* w, lapack_complex_double* vl,
                           int64_t ldvl, lapack_complex_double* vr,
                           int64_t ldvr, int64_t* ilo, int64_t* ihi,
                           double* scale, double* abnrm, double* rconde,
                           double* rcondv );

int64_t LAPACKE_sgehrd_64( int matrix_layout, int64_t n, int64_t ilo,
                           int64_t ihi, float* a, int64_t lda,
                           float* tau );
int64_t LAPACKE_dgehrd_64( int matrix_layout, int64_t n, int64_t ilo,
                           int64_t ihi, double* a, int64_t lda,
                           double* tau );
int64_t LAPACKE_cgehrd_64( int matrix_layout, int64_t n, int64_t ilo,
                           int64_t ihi, lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* tau );
int64_t LAPACKE_zgehrd_64( int matrix_layout, int64_t n, int64_t ilo,
                           int64_t ihi, lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* tau );

int64_t LAPACKE_sgejsv_64( int matrix_layout, char joba, char jobu, char jobv,
                           char jobr, char jobt, char jobp, int64_t m,
                           int64_t n, float* a, int64_t lda, float* sva,
                           float* u, int64_t ldu, float* v, int64_t ldv,
                           float* stat, int64_t* istat );
int64_t LAPACKE_dgejsv_64( int matrix_layout, char joba, char jobu, char jobv,
                           char jobr, char jobt, char jobp, int64_t m,
                           int64_t n, double* a, int64_t lda, double* sva,
                           double* u, int64_t ldu, double* v, int64_t ldv,
                           double* stat, int64_t* istat );
int64_t LAPACKE_cgejsv_64( int matrix_layout, char joba, char jobu, char jobv,
                           char jobr, char jobt, char jobp, int64_t m,
                           int64_t n, lapack_complex_float* a, int64_t lda, float* sva,
                           lapack_complex_float* u, int64_t ldu, lapack_complex_float* v, int64_t ldv,
                           float* stat, int64_t* istat );
int64_t LAPACKE_zgejsv_64( int matrix_layout, char joba, char jobu, char jobv,
                           char jobr, char jobt, char jobp, int64_t m,
                           int64_t n, lapack_complex_double* a, int64_t lda, double* sva,
                           lapack_complex_double* u, int64_t ldu, lapack_complex_double* v, int64_t ldv,
                           double* stat, int64_t* istat );

int64_t LAPACKE_sgelq2_64( int matrix_layout, int64_t m, int64_t n,
                           float* a, int64_t lda, float* tau );
int64_t LAPACKE_dgelq2_64( int matrix_layout, int64_t m, int64_t n,
                           double* a, int64_t lda, double* tau );
int64_t LAPACKE_cgelq2_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* tau );
int64_t LAPACKE_zgelq2_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* tau );

int64_t LAPACKE_sgelqf_64( int matrix_layout, int64_t m, int64_t n,
                           float* a, int64_t lda, float* tau );
int64_t LAPACKE_dgelqf_64( int matrix_layout, int64_t m, int64_t n,
                           double* a, int64_t lda, double* tau );
int64_t LAPACKE_cgelqf_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* tau );
int64_t LAPACKE_zgelqf_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* tau );

int64_t LAPACKE_sgels_64( int matrix_layout, char trans, int64_t m,
                          int64_t n, int64_t nrhs, float* a,
                          int64_t lda, float* b, int64_t ldb );
int64_t LAPACKE_dgels_64( int matrix_layout, char trans, int64_t m,
                          int64_t n, int64_t nrhs, double* a,
                          int64_t lda, double* b, int64_t ldb );
int64_t LAPACKE_cgels_64( int matrix_layout, char trans, int64_t m,
                          int64_t n, int64_t nrhs,
                          lapack_complex_float* a, int64_t lda,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zgels_64( int matrix_layout, char trans, int64_t m,
                          int64_t n, int64_t nrhs,
                          lapack_complex_double* a, int64_t lda,
                          lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_sgelsd_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nrhs, float* a, int64_t lda, float* b,
                           int64_t ldb, float* s, float rcond,
                           int64_t* rank );
int64_t LAPACKE_dgelsd_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nrhs, double* a, int64_t lda,
                           double* b, int64_t ldb, double* s, double rcond,
                           int64_t* rank );
int64_t LAPACKE_cgelsd_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nrhs, lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* b,
                           int64_t ldb, float* s, float rcond,
                           int64_t* rank );
int64_t LAPACKE_zgelsd_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nrhs, lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* b,
                           int64_t ldb, double* s, double rcond,
                           int64_t* rank );

int64_t LAPACKE_sgelss_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nrhs, float* a, int64_t lda, float* b,
                           int64_t ldb, float* s, float rcond,
                           int64_t* rank );
int64_t LAPACKE_dgelss_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nrhs, double* a, int64_t lda,
                           double* b, int64_t ldb, double* s, double rcond,
                           int64_t* rank );
int64_t LAPACKE_cgelss_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nrhs, lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* b,
                           int64_t ldb, float* s, float rcond,
                           int64_t* rank );
int64_t LAPACKE_zgelss_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nrhs, lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* b,
                           int64_t ldb, double* s, double rcond,
                           int64_t* rank );

int64_t LAPACKE_sgelsy_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nrhs, float* a, int64_t lda, float* b,
                           int64_t ldb, int64_t* jpvt, float rcond,
                           int64_t* rank );
int64_t LAPACKE_dgelsy_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nrhs, double* a, int64_t lda,
                           double* b, int64_t ldb, int64_t* jpvt,
                           double rcond, int64_t* rank );
int64_t LAPACKE_cgelsy_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nrhs, lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* b,
                           int64_t ldb, int64_t* jpvt, float rcond,
                           int64_t* rank );
int64_t LAPACKE_zgelsy_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nrhs, lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* b,
                           int64_t ldb, int64_t* jpvt, double rcond,
                           int64_t* rank );

int64_t LAPACKE_sgeqlf_64( int matrix_layout, int64_t m, int64_t n,
                           float* a, int64_t lda, float* tau );
int64_t LAPACKE_dgeqlf_64( int matrix_layout, int64_t m, int64_t n,
                           double* a, int64_t lda, double* tau );
int64_t LAPACKE_cgeqlf_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* tau );
int64_t LAPACKE_zgeqlf_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* tau );

int64_t LAPACKE_sgeqp3_64( int matrix_layout, int64_t m, int64_t n,
                           float* a, int64_t lda, int64_t* jpvt,
                           float* tau );
int64_t LAPACKE_dgeqp3_64( int matrix_layout, int64_t m, int64_t n,
                           double* a, int64_t lda, int64_t* jpvt,
                           double* tau );
int64_t LAPACKE_cgeqp3_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* jpvt, lapack_complex_float* tau );
int64_t LAPACKE_zgeqp3_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* jpvt, lapack_complex_double* tau );

int64_t LAPACKE_sgeqpf_64( int matrix_layout, int64_t m, int64_t n,
                           float* a, int64_t lda, int64_t* jpvt,
                           float* tau );
int64_t LAPACKE_dgeqpf_64( int matrix_layout, int64_t m, int64_t n,
                           double* a, int64_t lda, int64_t* jpvt,
                           double* tau );
int64_t LAPACKE_cgeqpf_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* jpvt, lapack_complex_float* tau );
int64_t LAPACKE_zgeqpf_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* jpvt, lapack_complex_double* tau );

int64_t LAPACKE_sgeqr2_64( int matrix_layout, int64_t m, int64_t n,
                           float* a, int64_t lda, float* tau );
int64_t LAPACKE_dgeqr2_64( int matrix_layout, int64_t m, int64_t n,
                           double* a, int64_t lda, double* tau );
int64_t LAPACKE_cgeqr2_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* tau );
int64_t LAPACKE_zgeqr2_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* tau );

int64_t LAPACKE_sgeqrf_64( int matrix_layout, int64_t m, int64_t n,
                           float* a, int64_t lda, float* tau );
int64_t LAPACKE_dgeqrf_64( int matrix_layout, int64_t m, int64_t n,
                           double* a, int64_t lda, double* tau );
int64_t LAPACKE_cgeqrf_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* tau );
int64_t LAPACKE_zgeqrf_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* tau );

int64_t LAPACKE_sgeqrfp_64( int matrix_layout, int64_t m, int64_t n,
                            float* a, int64_t lda, float* tau );
int64_t LAPACKE_dgeqrfp_64( int matrix_layout, int64_t m, int64_t n,
                            double* a, int64_t lda, double* tau );
int64_t LAPACKE_cgeqrfp_64( int matrix_layout, int64_t m, int64_t n,
                            lapack_complex_float* a, int64_t lda,
                            lapack_complex_float* tau );
int64_t LAPACKE_zgeqrfp_64( int matrix_layout, int64_t m, int64_t n,
                            lapack_complex_double* a, int64_t lda,
                            lapack_complex_double* tau );

int64_t LAPACKE_sgerfs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const float* a, int64_t lda,
                           const float* af, int64_t ldaf,
                           const int64_t* ipiv, const float* b,
                           int64_t ldb, float* x, int64_t ldx,
                           float* ferr, float* berr );
int64_t LAPACKE_dgerfs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const double* a, int64_t lda,
                           const double* af, int64_t ldaf,
                           const int64_t* ipiv, const double* b,
                           int64_t ldb, double* x, int64_t ldx,
                           double* ferr, double* berr );
int64_t LAPACKE_cgerfs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const lapack_complex_float* a,
                           int64_t lda, const lapack_complex_float* af,
                           int64_t ldaf, const int64_t* ipiv,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx, float* ferr,
                           float* berr );
int64_t LAPACKE_zgerfs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const lapack_complex_double* a,
                           int64_t lda, const lapack_complex_double* af,
                           int64_t ldaf, const int64_t* ipiv,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* ferr, double* berr );

int64_t LAPACKE_sgerfsx_64( int matrix_layout, char trans, char equed,
                            int64_t n, int64_t nrhs, const float* a,
                            int64_t lda, const float* af, int64_t ldaf,
                            const int64_t* ipiv, const float* r,
                            const float* c, const float* b, int64_t ldb,
                            float* x, int64_t ldx, float* rcond, float* berr,
                            int64_t n_err_bnds, float* err_bnds_norm,
                            float* err_bnds_comp, int64_t nparams,
                            float* params );
int64_t LAPACKE_dgerfsx_64( int matrix_layout, char trans, char equed,
                            int64_t n, int64_t nrhs, const double* a,
                            int64_t lda, const double* af, int64_t ldaf,
                            const int64_t* ipiv, const double* r,
                            const double* c, const double* b, int64_t ldb,
                            double* x, int64_t ldx, double* rcond,
                            double* berr, int64_t n_err_bnds,
                            double* err_bnds_norm, double* err_bnds_comp,
                            int64_t nparams, double* params );
int64_t LAPACKE_cgerfsx_64( int matrix_layout, char trans, char equed,
                            int64_t n, int64_t nrhs,
                            const lapack_complex_float* a, int64_t lda,
                            const lapack_complex_float* af, int64_t ldaf,
                            const int64_t* ipiv, const float* r,
                            const float* c, const lapack_complex_float* b,
                            int64_t ldb, lapack_complex_float* x,
                            int64_t ldx, float* rcond, float* berr,
                            int64_t n_err_bnds, float* err_bnds_norm,
                            float* err_bnds_comp, int64_t nparams,
                            float* params );
int64_t LAPACKE_zgerfsx_64( int matrix_layout, char trans, char equed,
                            int64_t n, int64_t nrhs,
                            const lapack_complex_double* a, int64_t lda,
                            const lapack_complex_double* af, int64_t ldaf,
                            const int64_t* ipiv, const double* r,
                            const double* c, const lapack_complex_double* b,
                            int64_t ldb, lapack_complex_double* x,
                            int64_t ldx, double* rcond, double* berr,
                            int64_t n_err_bnds, double* err_bnds_norm,
                            double* err_bnds_comp, int64_t nparams,
                            double* params );

int64_t LAPACKE_sgerqf_64( int matrix_layout, int64_t m, int64_t n,
                           float* a, int64_t lda, float* tau );
int64_t LAPACKE_dgerqf_64( int matrix_layout, int64_t m, int64_t n,
                           double* a, int64_t lda, double* tau );
int64_t LAPACKE_cgerqf_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* tau );
int64_t LAPACKE_zgerqf_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* tau );

int64_t LAPACKE_sgesdd_64( int matrix_layout, char jobz, int64_t m,
                           int64_t n, float* a, int64_t lda, float* s,
                           float* u, int64_t ldu, float* vt,
                           int64_t ldvt );
int64_t LAPACKE_dgesdd_64( int matrix_layout, char jobz, int64_t m,
                           int64_t n, double* a, int64_t lda, double* s,
                           double* u, int64_t ldu, double* vt,
                           int64_t ldvt );
int64_t LAPACKE_cgesdd_64( int matrix_layout, char jobz, int64_t m,
                           int64_t n, lapack_complex_float* a,
                           int64_t lda, float* s, lapack_complex_float* u,
                           int64_t ldu, lapack_complex_float* vt,
                           int64_t ldvt );
int64_t LAPACKE_zgesdd_64( int matrix_layout, char jobz, int64_t m,
                           int64_t n, lapack_complex_double* a,
                           int64_t lda, double* s, lapack_complex_double* u,
                           int64_t ldu, lapack_complex_double* vt,
                           int64_t ldvt );

int64_t LAPACKE_sgesv_64( int matrix_layout, int64_t n, int64_t nrhs,
                          float* a, int64_t lda, int64_t* ipiv, float* b,
                          int64_t ldb );
int64_t LAPACKE_dgesv_64( int matrix_layout, int64_t n, int64_t nrhs,
                          double* a, int64_t lda, int64_t* ipiv,
                          double* b, int64_t ldb );
int64_t LAPACKE_cgesv_64( int matrix_layout, int64_t n, int64_t nrhs,
                          lapack_complex_float* a, int64_t lda,
                          int64_t* ipiv, lapack_complex_float* b,
                          int64_t ldb );
int64_t LAPACKE_zgesv_64( int matrix_layout, int64_t n, int64_t nrhs,
                          lapack_complex_double* a, int64_t lda,
                          int64_t* ipiv, lapack_complex_double* b,
                          int64_t ldb );
int64_t LAPACKE_dsgesv_64( int matrix_layout, int64_t n, int64_t nrhs,
                           double* a, int64_t lda, int64_t* ipiv,
                           double* b, int64_t ldb, double* x, int64_t ldx,
                           int64_t* iter );
int64_t LAPACKE_zcgesv_64( int matrix_layout, int64_t n, int64_t nrhs,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* ipiv, lapack_complex_double* b,
                           int64_t ldb, lapack_complex_double* x,
                           int64_t ldx, int64_t* iter );

int64_t LAPACKE_sgesvd_64( int matrix_layout, char jobu, char jobvt,
                           int64_t m, int64_t n, float* a, int64_t lda,
                           float* s, float* u, int64_t ldu, float* vt,
                           int64_t ldvt, float* superb );
int64_t LAPACKE_dgesvd_64( int matrix_layout, char jobu, char jobvt,
                           int64_t m, int64_t n, double* a,
                           int64_t lda, double* s, double* u, int64_t ldu,
                           double* vt, int64_t ldvt, double* superb );
int64_t LAPACKE_cgesvd_64( int matrix_layout, char jobu, char jobvt,
                           int64_t m, int64_t n, lapack_complex_float* a,
                           int64_t lda, float* s, lapack_complex_float* u,
                           int64_t ldu, lapack_complex_float* vt,
                           int64_t ldvt, float* superb );
int64_t LAPACKE_zgesvd_64( int matrix_layout, char jobu, char jobvt,
                           int64_t m, int64_t n, lapack_complex_double* a,
                           int64_t lda, double* s, lapack_complex_double* u,
                           int64_t ldu, lapack_complex_double* vt,
                           int64_t ldvt, double* superb );

int64_t LAPACKE_sgesvdx_64( int matrix_layout, char jobu, char jobvt, char range,
                           int64_t m, int64_t n, float* a,
                           int64_t lda, float vl, float vu,
                           int64_t il, int64_t iu, int64_t* ns,
                           float* s, float* u, int64_t ldu,
                           float* vt, int64_t ldvt,
                           int64_t* superb );
int64_t LAPACKE_dgesvdx_64( int matrix_layout, char jobu, char jobvt, char range,
                           int64_t m, int64_t n, double* a,
                           int64_t lda, double vl, double vu,
                           int64_t il, int64_t iu, int64_t* ns,
                           double* s, double* u, int64_t ldu,
                           double* vt, int64_t ldvt,
                           int64_t* superb );
int64_t LAPACKE_cgesvdx_64( int matrix_layout, char jobu, char jobvt, char range,
                           int64_t m, int64_t n, lapack_complex_float* a,
                           int64_t lda, float vl, float vu,
                           int64_t il, int64_t iu, int64_t* ns,
                           float* s, lapack_complex_float* u, int64_t ldu,
                           lapack_complex_float* vt, int64_t ldvt,
                           int64_t* superb );
int64_t LAPACKE_zgesvdx_64( int matrix_layout, char jobu, char jobvt, char range,
                           int64_t m, int64_t n, lapack_complex_double* a,
                           int64_t lda, double vl, double vu,
                           int64_t il, int64_t iu, int64_t* ns,
                           double* s, lapack_complex_double* u, int64_t ldu,
                           lapack_complex_double* vt, int64_t ldvt,
                           int64_t* superb );

int64_t LAPACKE_sgesvdq_64( int matrix_layout, char joba, char jobp, char jobr, char jobu, char jobv,
                           int64_t m, int64_t n, float* a, int64_t lda,
                           float* s, float* u, int64_t ldu, float* v,
                           int64_t ldv, int64_t* numrank );
int64_t LAPACKE_dgesvdq_64( int matrix_layout, char joba, char jobp, char jobr, char jobu, char jobv,
                           int64_t m, int64_t n, double* a,
                           int64_t lda, double* s, double* u, int64_t ldu,
                           double* v, int64_t ldv, int64_t* numrank);
int64_t LAPACKE_cgesvdq_64( int matrix_layout, char joba, char jobp, char jobr, char jobu, char jobv,
                           int64_t m, int64_t n, lapack_complex_float* a,
                           int64_t lda, float* s, lapack_complex_float* u,
                           int64_t ldu, lapack_complex_float* v,
                           int64_t ldv, int64_t* numrank );
int64_t LAPACKE_zgesvdq_64( int matrix_layout, char joba, char jobp, char jobr, char jobu, char jobv,
                           int64_t m, int64_t n, lapack_complex_double* a,
                           int64_t lda, double* s, lapack_complex_double* u,
                           int64_t ldu, lapack_complex_double* v,
                           int64_t ldv, int64_t* numrank );

int64_t LAPACKE_sgesvj_64( int matrix_layout, char joba, char jobu, char jobv,
                           int64_t m, int64_t n, float* a, int64_t lda,
                           float* sva, int64_t mv, float* v, int64_t ldv,
                           float* stat );
int64_t LAPACKE_dgesvj_64( int matrix_layout, char joba, char jobu, char jobv,
                           int64_t m, int64_t n, double* a,
                           int64_t lda, double* sva, int64_t mv,
                           double* v, int64_t ldv, double* stat );
int64_t LAPACKE_cgesvj_64( int matrix_layout, char joba, char jobu, char jobv,
                           int64_t m, int64_t n, lapack_complex_float* a,
                           int64_t lda, float* sva, int64_t mv,
                           lapack_complex_float* v, int64_t ldv, float* stat );
int64_t LAPACKE_zgesvj_64( int matrix_layout, char joba, char jobu, char jobv,
                           int64_t m, int64_t n, lapack_complex_double* a,
                           int64_t lda, double* sva, int64_t mv,
                           lapack_complex_double* v, int64_t ldv, double* stat );

int64_t LAPACKE_sgesvx_64( int matrix_layout, char fact, char trans,
                           int64_t n, int64_t nrhs, float* a,
                           int64_t lda, float* af, int64_t ldaf,
                           int64_t* ipiv, char* equed, float* r, float* c,
                           float* b, int64_t ldb, float* x, int64_t ldx,
                           float* rcond, float* ferr, float* berr,
                           float* rpivot );
int64_t LAPACKE_dgesvx_64( int matrix_layout, char fact, char trans,
                           int64_t n, int64_t nrhs, double* a,
                           int64_t lda, double* af, int64_t ldaf,
                           int64_t* ipiv, char* equed, double* r, double* c,
                           double* b, int64_t ldb, double* x, int64_t ldx,
                           double* rcond, double* ferr, double* berr,
                           double* rpivot );
int64_t LAPACKE_cgesvx_64( int matrix_layout, char fact, char trans,
                           int64_t n, int64_t nrhs,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* af, int64_t ldaf,
                           int64_t* ipiv, char* equed, float* r, float* c,
                           lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx,
                           float* rcond, float* ferr, float* berr,
                           float* rpivot );
int64_t LAPACKE_zgesvx_64( int matrix_layout, char fact, char trans,
                           int64_t n, int64_t nrhs,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* af, int64_t ldaf,
                           int64_t* ipiv, char* equed, double* r, double* c,
                           lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* rcond, double* ferr, double* berr,
                           double* rpivot );

int64_t LAPACKE_sgesvxx_64( int matrix_layout, char fact, char trans,
                            int64_t n, int64_t nrhs, float* a,
                            int64_t lda, float* af, int64_t ldaf,
                            int64_t* ipiv, char* equed, float* r, float* c,
                            float* b, int64_t ldb, float* x, int64_t ldx,
                            float* rcond, float* rpvgrw, float* berr,
                            int64_t n_err_bnds, float* err_bnds_norm,
                            float* err_bnds_comp, int64_t nparams,
                            float* params );
int64_t LAPACKE_dgesvxx_64( int matrix_layout, char fact, char trans,
                            int64_t n, int64_t nrhs, double* a,
                            int64_t lda, double* af, int64_t ldaf,
                            int64_t* ipiv, char* equed, double* r, double* c,
                            double* b, int64_t ldb, double* x,
                            int64_t ldx, double* rcond, double* rpvgrw,
                            double* berr, int64_t n_err_bnds,
                            double* err_bnds_norm, double* err_bnds_comp,
                            int64_t nparams, double* params );
int64_t LAPACKE_cgesvxx_64( int matrix_layout, char fact, char trans,
                            int64_t n, int64_t nrhs,
                            lapack_complex_float* a, int64_t lda,
                            lapack_complex_float* af, int64_t ldaf,
                            int64_t* ipiv, char* equed, float* r, float* c,
                            lapack_complex_float* b, int64_t ldb,
                            lapack_complex_float* x, int64_t ldx,
                            float* rcond, float* rpvgrw, float* berr,
                            int64_t n_err_bnds, float* err_bnds_norm,
                            float* err_bnds_comp, int64_t nparams,
                            float* params );
int64_t LAPACKE_zgesvxx_64( int matrix_layout, char fact, char trans,
                            int64_t n, int64_t nrhs,
                            lapack_complex_double* a, int64_t lda,
                            lapack_complex_double* af, int64_t ldaf,
                            int64_t* ipiv, char* equed, double* r, double* c,
                            lapack_complex_double* b, int64_t ldb,
                            lapack_complex_double* x, int64_t ldx,
                            double* rcond, double* rpvgrw, double* berr,
                            int64_t n_err_bnds, double* err_bnds_norm,
                            double* err_bnds_comp, int64_t nparams,
                            double* params );

int64_t LAPACKE_sgetf2_64( int matrix_layout, int64_t m, int64_t n,
                           float* a, int64_t lda, int64_t* ipiv );
int64_t LAPACKE_dgetf2_64( int matrix_layout, int64_t m, int64_t n,
                           double* a, int64_t lda, int64_t* ipiv );
int64_t LAPACKE_cgetf2_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* ipiv );
int64_t LAPACKE_zgetf2_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* ipiv );

int64_t LAPACKE_sgetrf_64( int matrix_layout, int64_t m, int64_t n,
                           float* a, int64_t lda, int64_t* ipiv );
int64_t LAPACKE_dgetrf_64( int matrix_layout, int64_t m, int64_t n,
                           double* a, int64_t lda, int64_t* ipiv );
int64_t LAPACKE_cgetrf_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* ipiv );
int64_t LAPACKE_zgetrf_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* ipiv );

int64_t LAPACKE_sgetrf2_64( int matrix_layout, int64_t m, int64_t n,
                           float* a, int64_t lda, int64_t* ipiv );
int64_t LAPACKE_dgetrf2_64( int matrix_layout, int64_t m, int64_t n,
                           double* a, int64_t lda, int64_t* ipiv );
int64_t LAPACKE_cgetrf2_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* ipiv );
int64_t LAPACKE_zgetrf2_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* ipiv );

int64_t LAPACKE_sgetri_64( int matrix_layout, int64_t n, float* a,
                           int64_t lda, const int64_t* ipiv );
int64_t LAPACKE_dgetri_64( int matrix_layout, int64_t n, double* a,
                           int64_t lda, const int64_t* ipiv );
int64_t LAPACKE_cgetri_64( int matrix_layout, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           const int64_t* ipiv );
int64_t LAPACKE_zgetri_64( int matrix_layout, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           const int64_t* ipiv );

int64_t LAPACKE_sgetrs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const float* a, int64_t lda,
                           const int64_t* ipiv, float* b, int64_t ldb );
int64_t LAPACKE_dgetrs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const double* a, int64_t lda,
                           const int64_t* ipiv, double* b, int64_t ldb );
int64_t LAPACKE_cgetrs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const lapack_complex_float* a,
                           int64_t lda, const int64_t* ipiv,
                           lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zgetrs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const lapack_complex_double* a,
                           int64_t lda, const int64_t* ipiv,
                           lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_sggbak_64( int matrix_layout, char job, char side, int64_t n,
                           int64_t ilo, int64_t ihi, const float* lscale,
                           const float* rscale, int64_t m, float* v,
                           int64_t ldv );
int64_t LAPACKE_dggbak_64( int matrix_layout, char job, char side, int64_t n,
                           int64_t ilo, int64_t ihi, const double* lscale,
                           const double* rscale, int64_t m, double* v,
                           int64_t ldv );
int64_t LAPACKE_cggbak_64( int matrix_layout, char job, char side, int64_t n,
                           int64_t ilo, int64_t ihi, const float* lscale,
                           const float* rscale, int64_t m,
                           lapack_complex_float* v, int64_t ldv );
int64_t LAPACKE_zggbak_64( int matrix_layout, char job, char side, int64_t n,
                           int64_t ilo, int64_t ihi, const double* lscale,
                           const double* rscale, int64_t m,
                           lapack_complex_double* v, int64_t ldv );

int64_t LAPACKE_sggbal_64( int matrix_layout, char job, int64_t n, float* a,
                           int64_t lda, float* b, int64_t ldb,
                           int64_t* ilo, int64_t* ihi, float* lscale,
                           float* rscale );
int64_t LAPACKE_dggbal_64( int matrix_layout, char job, int64_t n, double* a,
                           int64_t lda, double* b, int64_t ldb,
                           int64_t* ilo, int64_t* ihi, double* lscale,
                           double* rscale );
int64_t LAPACKE_cggbal_64( int matrix_layout, char job, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb,
                           int64_t* ilo, int64_t* ihi, float* lscale,
                           float* rscale );
int64_t LAPACKE_zggbal_64( int matrix_layout, char job, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb,
                           int64_t* ilo, int64_t* ihi, double* lscale,
                           double* rscale );

int64_t LAPACKE_sgges_64( int matrix_layout, char jobvsl, char jobvsr, char sort,
                          LAPACK_S_SELECT3 selctg, int64_t n, float* a,
                          int64_t lda, float* b, int64_t ldb,
                          int64_t* sdim, float* alphar, float* alphai,
                          float* beta, float* vsl, int64_t ldvsl, float* vsr,
                          int64_t ldvsr );
int64_t LAPACKE_dgges_64( int matrix_layout, char jobvsl, char jobvsr, char sort,
                          LAPACK_D_SELECT3 selctg, int64_t n, double* a,
                          int64_t lda, double* b, int64_t ldb,
                          int64_t* sdim, double* alphar, double* alphai,
                          double* beta, double* vsl, int64_t ldvsl,
                          double* vsr, int64_t ldvsr );
int64_t LAPACKE_cgges_64( int matrix_layout, char jobvsl, char jobvsr, char sort,
                          LAPACK_C_SELECT2 selctg, int64_t n,
                          lapack_complex_float* a, int64_t lda,
                          lapack_complex_float* b, int64_t ldb,
                          int64_t* sdim, lapack_complex_float* alpha,
                          lapack_complex_float* beta, lapack_complex_float* vsl,
                          int64_t ldvsl, lapack_complex_float* vsr,
                          int64_t ldvsr );
int64_t LAPACKE_zgges_64( int matrix_layout, char jobvsl, char jobvsr, char sort,
                          LAPACK_Z_SELECT2 selctg, int64_t n,
                          lapack_complex_double* a, int64_t lda,
                          lapack_complex_double* b, int64_t ldb,
                          int64_t* sdim, lapack_complex_double* alpha,
                          lapack_complex_double* beta,
                          lapack_complex_double* vsl, int64_t ldvsl,
                          lapack_complex_double* vsr, int64_t ldvsr );

int64_t LAPACKE_sgges3_64( int matrix_layout, char jobvsl, char jobvsr,
                           char sort, LAPACK_S_SELECT3 selctg, int64_t n,
                           float* a, int64_t lda, float* b, int64_t ldb,
                           int64_t* sdim, float* alphar, float* alphai,
                           float* beta, float* vsl, int64_t ldvsl,
                           float* vsr, int64_t ldvsr );
int64_t LAPACKE_dgges3_64( int matrix_layout, char jobvsl, char jobvsr,
                           char sort, LAPACK_D_SELECT3 selctg, int64_t n,
                           double* a, int64_t lda, double* b, int64_t ldb,
                           int64_t* sdim, double* alphar, double* alphai,
                           double* beta, double* vsl, int64_t ldvsl,
                           double* vsr, int64_t ldvsr );
int64_t LAPACKE_cgges3_64( int matrix_layout, char jobvsl, char jobvsr,
                           char sort, LAPACK_C_SELECT2 selctg, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb,
                           int64_t* sdim, lapack_complex_float* alpha,
                           lapack_complex_float* beta,
                           lapack_complex_float* vsl, int64_t ldvsl,
                           lapack_complex_float* vsr, int64_t ldvsr );
int64_t LAPACKE_zgges3_64( int matrix_layout, char jobvsl, char jobvsr,
                           char sort, LAPACK_Z_SELECT2 selctg, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb,
                           int64_t* sdim, lapack_complex_double* alpha,
                           lapack_complex_double* beta,
                           lapack_complex_double* vsl, int64_t ldvsl,
                           lapack_complex_double* vsr, int64_t ldvsr );

int64_t LAPACKE_sggesx_64( int matrix_layout, char jobvsl, char jobvsr,
                           char sort, LAPACK_S_SELECT3 selctg, char sense,
                           int64_t n, float* a, int64_t lda, float* b,
                           int64_t ldb, int64_t* sdim, float* alphar,
                           float* alphai, float* beta, float* vsl,
                           int64_t ldvsl, float* vsr, int64_t ldvsr,
                           float* rconde, float* rcondv );
int64_t LAPACKE_dggesx_64( int matrix_layout, char jobvsl, char jobvsr,
                           char sort, LAPACK_D_SELECT3 selctg, char sense,
                           int64_t n, double* a, int64_t lda, double* b,
                           int64_t ldb, int64_t* sdim, double* alphar,
                           double* alphai, double* beta, double* vsl,
                           int64_t ldvsl, double* vsr, int64_t ldvsr,
                           double* rconde, double* rcondv );
int64_t LAPACKE_cggesx_64( int matrix_layout, char jobvsl, char jobvsr,
                           char sort, LAPACK_C_SELECT2 selctg, char sense,
                           int64_t n, lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* b,
                           int64_t ldb, int64_t* sdim,
                           lapack_complex_float* alpha,
                           lapack_complex_float* beta,
                           lapack_complex_float* vsl, int64_t ldvsl,
                           lapack_complex_float* vsr, int64_t ldvsr,
                           float* rconde, float* rcondv );
int64_t LAPACKE_zggesx_64( int matrix_layout, char jobvsl, char jobvsr,
                           char sort, LAPACK_Z_SELECT2 selctg, char sense,
                           int64_t n, lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* b,
                           int64_t ldb, int64_t* sdim,
                           lapack_complex_double* alpha,
                           lapack_complex_double* beta,
                           lapack_complex_double* vsl, int64_t ldvsl,
                           lapack_complex_double* vsr, int64_t ldvsr,
                           double* rconde, double* rcondv );

int64_t LAPACKE_sggev_64( int matrix_layout, char jobvl, char jobvr,
                          int64_t n, float* a, int64_t lda, float* b,
                          int64_t ldb, float* alphar, float* alphai,
                          float* beta, float* vl, int64_t ldvl, float* vr,
                          int64_t ldvr );
int64_t LAPACKE_dggev_64( int matrix_layout, char jobvl, char jobvr,
                          int64_t n, double* a, int64_t lda, double* b,
                          int64_t ldb, double* alphar, double* alphai,
                          double* beta, double* vl, int64_t ldvl, double* vr,
                          int64_t ldvr );
int64_t LAPACKE_cggev_64( int matrix_layout, char jobvl, char jobvr,
                          int64_t n, lapack_complex_float* a, int64_t lda,
                          lapack_complex_float* b, int64_t ldb,
                          lapack_complex_float* alpha,
                          lapack_complex_float* beta, lapack_complex_float* vl,
                          int64_t ldvl, lapack_complex_float* vr,
                          int64_t ldvr );
int64_t LAPACKE_zggev_64( int matrix_layout, char jobvl, char jobvr,
                          int64_t n, lapack_complex_double* a,
                          int64_t lda, lapack_complex_double* b,
                          int64_t ldb, lapack_complex_double* alpha,
                          lapack_complex_double* beta,
                          lapack_complex_double* vl, int64_t ldvl,
                          lapack_complex_double* vr, int64_t ldvr );

int64_t LAPACKE_sggev3_64( int matrix_layout, char jobvl, char jobvr,
                           int64_t n, float* a, int64_t lda,
                           float* b, int64_t ldb,
                           float* alphar, float* alphai, float* beta,
                           float* vl, int64_t ldvl,
                           float* vr, int64_t ldvr );
int64_t LAPACKE_dggev3_64( int matrix_layout, char jobvl, char jobvr,
                           int64_t n, double* a, int64_t lda,
                           double* b, int64_t ldb,
                           double* alphar, double* alphai, double* beta,
                           double* vl, int64_t ldvl,
                           double* vr, int64_t ldvr );
int64_t LAPACKE_cggev3_64( int matrix_layout, char jobvl, char jobvr,
                           int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* alpha,
                           lapack_complex_float* beta,
                           lapack_complex_float* vl, int64_t ldvl,
                           lapack_complex_float* vr, int64_t ldvr );
int64_t LAPACKE_zggev3_64( int matrix_layout, char jobvl, char jobvr,
                           int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* alpha,
                           lapack_complex_double* beta,
                           lapack_complex_double* vl, int64_t ldvl,
                           lapack_complex_double* vr, int64_t ldvr );

int64_t LAPACKE_sggevx_64( int matrix_layout, char balanc, char jobvl,
                           char jobvr, char sense, int64_t n, float* a,
                           int64_t lda, float* b, int64_t ldb,
                           float* alphar, float* alphai, float* beta, float* vl,
                           int64_t ldvl, float* vr, int64_t ldvr,
                           int64_t* ilo, int64_t* ihi, float* lscale,
                           float* rscale, float* abnrm, float* bbnrm,
                           float* rconde, float* rcondv );
int64_t LAPACKE_dggevx_64( int matrix_layout, char balanc, char jobvl,
                           char jobvr, char sense, int64_t n, double* a,
                           int64_t lda, double* b, int64_t ldb,
                           double* alphar, double* alphai, double* beta,
                           double* vl, int64_t ldvl, double* vr,
                           int64_t ldvr, int64_t* ilo, int64_t* ihi,
                           double* lscale, double* rscale, double* abnrm,
                           double* bbnrm, double* rconde, double* rcondv );
int64_t LAPACKE_cggevx_64( int matrix_layout, char balanc, char jobvl,
                           char jobvr, char sense, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* alpha,
                           lapack_complex_float* beta, lapack_complex_float* vl,
                           int64_t ldvl, lapack_complex_float* vr,
                           int64_t ldvr, int64_t* ilo, int64_t* ihi,
                           float* lscale, float* rscale, float* abnrm,
                           float* bbnrm, float* rconde, float* rcondv );
int64_t LAPACKE_zggevx_64( int matrix_layout, char balanc, char jobvl,
                           char jobvr, char sense, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* alpha,
                           lapack_complex_double* beta,
                           lapack_complex_double* vl, int64_t ldvl,
                           lapack_complex_double* vr, int64_t ldvr,
                           int64_t* ilo, int64_t* ihi, double* lscale,
                           double* rscale, double* abnrm, double* bbnrm,
                           double* rconde, double* rcondv );

int64_t LAPACKE_sggglm_64( int matrix_layout, int64_t n, int64_t m,
                           int64_t p, float* a, int64_t lda, float* b,
                           int64_t ldb, float* d, float* x, float* y );
int64_t LAPACKE_dggglm_64( int matrix_layout, int64_t n, int64_t m,
                           int64_t p, double* a, int64_t lda, double* b,
                           int64_t ldb, double* d, double* x, double* y );
int64_t LAPACKE_cggglm_64( int matrix_layout, int64_t n, int64_t m,
                           int64_t p, lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* b,
                           int64_t ldb, lapack_complex_float* d,
                           lapack_complex_float* x, lapack_complex_float* y );
int64_t LAPACKE_zggglm_64( int matrix_layout, int64_t n, int64_t m,
                           int64_t p, lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* b,
                           int64_t ldb, lapack_complex_double* d,
                           lapack_complex_double* x, lapack_complex_double* y );

int64_t LAPACKE_sgghrd_64( int matrix_layout, char compq, char compz,
                           int64_t n, int64_t ilo, int64_t ihi,
                           float* a, int64_t lda, float* b, int64_t ldb,
                           float* q, int64_t ldq, float* z, int64_t ldz );
int64_t LAPACKE_dgghrd_64( int matrix_layout, char compq, char compz,
                           int64_t n, int64_t ilo, int64_t ihi,
                           double* a, int64_t lda, double* b, int64_t ldb,
                           double* q, int64_t ldq, double* z,
                           int64_t ldz );
int64_t LAPACKE_cgghrd_64( int matrix_layout, char compq, char compz,
                           int64_t n, int64_t ilo, int64_t ihi,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* q, int64_t ldq,
                           lapack_complex_float* z, int64_t ldz );
int64_t LAPACKE_zgghrd_64( int matrix_layout, char compq, char compz,
                           int64_t n, int64_t ilo, int64_t ihi,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* q, int64_t ldq,
                           lapack_complex_double* z, int64_t ldz );

int64_t LAPACKE_sgghd3_64( int matrix_layout, char compq, char compz,
                           int64_t n, int64_t ilo, int64_t ihi,
                           float* a, int64_t lda, float* b, int64_t ldb,
                           float* q, int64_t ldq, float* z, int64_t ldz );
int64_t LAPACKE_dgghd3_64( int matrix_layout, char compq, char compz,
                           int64_t n, int64_t ilo, int64_t ihi,
                           double* a, int64_t lda, double* b, int64_t ldb,
                           double* q, int64_t ldq, double* z,
                           int64_t ldz );
int64_t LAPACKE_cgghd3_64( int matrix_layout, char compq, char compz,
                           int64_t n, int64_t ilo, int64_t ihi,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* q, int64_t ldq,
                           lapack_complex_float* z, int64_t ldz );
int64_t LAPACKE_zgghd3_64( int matrix_layout, char compq, char compz,
                           int64_t n, int64_t ilo, int64_t ihi,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* q, int64_t ldq,
                           lapack_complex_double* z, int64_t ldz );

int64_t LAPACKE_sgglse_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t p, float* a, int64_t lda, float* b,
                           int64_t ldb, float* c, float* d, float* x );
int64_t LAPACKE_dgglse_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t p, double* a, int64_t lda, double* b,
                           int64_t ldb, double* c, double* d, double* x );
int64_t LAPACKE_cgglse_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t p, lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* b,
                           int64_t ldb, lapack_complex_float* c,
                           lapack_complex_float* d, lapack_complex_float* x );
int64_t LAPACKE_zgglse_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t p, lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* b,
                           int64_t ldb, lapack_complex_double* c,
                           lapack_complex_double* d, lapack_complex_double* x );

int64_t LAPACKE_sggqrf_64( int matrix_layout, int64_t n, int64_t m,
                           int64_t p, float* a, int64_t lda, float* taua,
                           float* b, int64_t ldb, float* taub );
int64_t LAPACKE_dggqrf_64( int matrix_layout, int64_t n, int64_t m,
                           int64_t p, double* a, int64_t lda,
                           double* taua, double* b, int64_t ldb,
                           double* taub );
int64_t LAPACKE_cggqrf_64( int matrix_layout, int64_t n, int64_t m,
                           int64_t p, lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* taua,
                           lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* taub );
int64_t LAPACKE_zggqrf_64( int matrix_layout, int64_t n, int64_t m,
                           int64_t p, lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* taua,
                           lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* taub );

int64_t LAPACKE_sggrqf_64( int matrix_layout, int64_t m, int64_t p,
                           int64_t n, float* a, int64_t lda, float* taua,
                           float* b, int64_t ldb, float* taub );
int64_t LAPACKE_dggrqf_64( int matrix_layout, int64_t m, int64_t p,
                           int64_t n, double* a, int64_t lda,
                           double* taua, double* b, int64_t ldb,
                           double* taub );
int64_t LAPACKE_cggrqf_64( int matrix_layout, int64_t m, int64_t p,
                           int64_t n, lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* taua,
                           lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* taub );
int64_t LAPACKE_zggrqf_64( int matrix_layout, int64_t m, int64_t p,
                           int64_t n, lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* taua,
                           lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* taub );

int64_t LAPACKE_sggsvd_64( int matrix_layout, char jobu, char jobv, char jobq,
                           int64_t m, int64_t n, int64_t p,
                           int64_t* k, int64_t* l, float* a,
                           int64_t lda, float* b, int64_t ldb,
                           float* alpha, float* beta, float* u, int64_t ldu,
                           float* v, int64_t ldv, float* q, int64_t ldq,
                           int64_t* iwork );
int64_t LAPACKE_dggsvd_64( int matrix_layout, char jobu, char jobv, char jobq,
                           int64_t m, int64_t n, int64_t p,
                           int64_t* k, int64_t* l, double* a,
                           int64_t lda, double* b, int64_t ldb,
                           double* alpha, double* beta, double* u,
                           int64_t ldu, double* v, int64_t ldv, double* q,
                           int64_t ldq, int64_t* iwork );
int64_t LAPACKE_cggsvd_64( int matrix_layout, char jobu, char jobv, char jobq,
                           int64_t m, int64_t n, int64_t p,
                           int64_t* k, int64_t* l,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb,
                           float* alpha, float* beta, lapack_complex_float* u,
                           int64_t ldu, lapack_complex_float* v,
                           int64_t ldv, lapack_complex_float* q,
                           int64_t ldq, int64_t* iwork );
int64_t LAPACKE_zggsvd_64( int matrix_layout, char jobu, char jobv, char jobq,
                           int64_t m, int64_t n, int64_t p,
                           int64_t* k, int64_t* l,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb,
                           double* alpha, double* beta,
                           lapack_complex_double* u, int64_t ldu,
                           lapack_complex_double* v, int64_t ldv,
                           lapack_complex_double* q, int64_t ldq,
                           int64_t* iwork );

int64_t LAPACKE_sggsvd3_64( int matrix_layout, char jobu, char jobv, char jobq,
                            int64_t m, int64_t n, int64_t p,
                            int64_t* k, int64_t* l, float* a,
                            int64_t lda, float* b, int64_t ldb,
                            float* alpha, float* beta, float* u, int64_t ldu,
                            float* v, int64_t ldv, float* q, int64_t ldq,
                            int64_t* iwork );
int64_t LAPACKE_dggsvd3_64( int matrix_layout, char jobu, char jobv, char jobq,
                            int64_t m, int64_t n, int64_t p,
                            int64_t* k, int64_t* l, double* a,
                            int64_t lda, double* b, int64_t ldb,
                            double* alpha, double* beta, double* u,
                            int64_t ldu, double* v, int64_t ldv, double* q,
                            int64_t ldq, int64_t* iwork );
int64_t LAPACKE_cggsvd3_64( int matrix_layout, char jobu, char jobv, char jobq,
                            int64_t m, int64_t n, int64_t p,
                            int64_t* k, int64_t* l,
                            lapack_complex_float* a, int64_t lda,
                            lapack_complex_float* b, int64_t ldb,
                            float* alpha, float* beta, lapack_complex_float* u,
                            int64_t ldu, lapack_complex_float* v,
                            int64_t ldv, lapack_complex_float* q,
                            int64_t ldq, int64_t* iwork );
int64_t LAPACKE_zggsvd3_64( int matrix_layout, char jobu, char jobv, char jobq,
                            int64_t m, int64_t n, int64_t p,
                            int64_t* k, int64_t* l,
                            lapack_complex_double* a, int64_t lda,
                            lapack_complex_double* b, int64_t ldb,
                            double* alpha, double* beta,
                            lapack_complex_double* u, int64_t ldu,
                            lapack_complex_double* v, int64_t ldv,
                            lapack_complex_double* q, int64_t ldq,
                            int64_t* iwork );

int64_t LAPACKE_sggsvp_64( int matrix_layout, char jobu, char jobv, char jobq,
                           int64_t m, int64_t p, int64_t n, float* a,
                           int64_t lda, float* b, int64_t ldb, float tola,
                           float tolb, int64_t* k, int64_t* l, float* u,
                           int64_t ldu, float* v, int64_t ldv, float* q,
                           int64_t ldq );
int64_t LAPACKE_dggsvp_64( int matrix_layout, char jobu, char jobv, char jobq,
                           int64_t m, int64_t p, int64_t n, double* a,
                           int64_t lda, double* b, int64_t ldb,
                           double tola, double tolb, int64_t* k,
                           int64_t* l, double* u, int64_t ldu, double* v,
                           int64_t ldv, double* q, int64_t ldq );
int64_t LAPACKE_cggsvp_64( int matrix_layout, char jobu, char jobv, char jobq,
                           int64_t m, int64_t p, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb, float tola,
                           float tolb, int64_t* k, int64_t* l,
                           lapack_complex_float* u, int64_t ldu,
                           lapack_complex_float* v, int64_t ldv,
                           lapack_complex_float* q, int64_t ldq );
int64_t LAPACKE_zggsvp_64( int matrix_layout, char jobu, char jobv, char jobq,
                           int64_t m, int64_t p, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb,
                           double tola, double tolb, int64_t* k,
                           int64_t* l, lapack_complex_double* u,
                           int64_t ldu, lapack_complex_double* v,
                           int64_t ldv, lapack_complex_double* q,
                           int64_t ldq );

int64_t LAPACKE_sggsvp3_64( int matrix_layout, char jobu, char jobv, char jobq,
                            int64_t m, int64_t p, int64_t n, float* a,
                            int64_t lda, float* b, int64_t ldb, float tola,
                            float tolb, int64_t* k, int64_t* l, float* u,
                            int64_t ldu, float* v, int64_t ldv, float* q,
                            int64_t ldq );
int64_t LAPACKE_dggsvp3_64( int matrix_layout, char jobu, char jobv, char jobq,
                            int64_t m, int64_t p, int64_t n, double* a,
                            int64_t lda, double* b, int64_t ldb,
                            double tola, double tolb, int64_t* k,
                            int64_t* l, double* u, int64_t ldu, double* v,
                            int64_t ldv, double* q, int64_t ldq );
int64_t LAPACKE_cggsvp3_64( int matrix_layout, char jobu, char jobv, char jobq,
                            int64_t m, int64_t p, int64_t n,
                            lapack_complex_float* a, int64_t lda,
                            lapack_complex_float* b, int64_t ldb, float tola,
                            float tolb, int64_t* k, int64_t* l,
                            lapack_complex_float* u, int64_t ldu,
                            lapack_complex_float* v, int64_t ldv,
                            lapack_complex_float* q, int64_t ldq );
int64_t LAPACKE_zggsvp3_64( int matrix_layout, char jobu, char jobv, char jobq,
                            int64_t m, int64_t p, int64_t n,
                            lapack_complex_double* a, int64_t lda,
                            lapack_complex_double* b, int64_t ldb,
                            double tola, double tolb, int64_t* k,
                            int64_t* l, lapack_complex_double* u,
                            int64_t ldu, lapack_complex_double* v,
                            int64_t ldv, lapack_complex_double* q,
                            int64_t ldq );

int64_t LAPACKE_sgtcon_64( char norm, int64_t n, const float* dl,
                           const float* d, const float* du, const float* du2,
                           const int64_t* ipiv, float anorm, float* rcond );
int64_t LAPACKE_dgtcon_64( char norm, int64_t n, const double* dl,
                           const double* d, const double* du, const double* du2,
                           const int64_t* ipiv, double anorm,
                           double* rcond );
int64_t LAPACKE_cgtcon_64( char norm, int64_t n,
                           const lapack_complex_float* dl,
                           const lapack_complex_float* d,
                           const lapack_complex_float* du,
                           const lapack_complex_float* du2,
                           const int64_t* ipiv, float anorm, float* rcond );
int64_t LAPACKE_zgtcon_64( char norm, int64_t n,
                           const lapack_complex_double* dl,
                           const lapack_complex_double* d,
                           const lapack_complex_double* du,
                           const lapack_complex_double* du2,
                           const int64_t* ipiv, double anorm,
                           double* rcond );

int64_t LAPACKE_sgtrfs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const float* dl, const float* d,
                           const float* du, const float* dlf, const float* df,
                           const float* duf, const float* du2,
                           const int64_t* ipiv, const float* b,
                           int64_t ldb, float* x, int64_t ldx,
                           float* ferr, float* berr );
int64_t LAPACKE_dgtrfs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const double* dl, const double* d,
                           const double* du, const double* dlf,
                           const double* df, const double* duf,
                           const double* du2, const int64_t* ipiv,
                           const double* b, int64_t ldb, double* x,
                           int64_t ldx, double* ferr, double* berr );
int64_t LAPACKE_cgtrfs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const lapack_complex_float* dl,
                           const lapack_complex_float* d,
                           const lapack_complex_float* du,
                           const lapack_complex_float* dlf,
                           const lapack_complex_float* df,
                           const lapack_complex_float* duf,
                           const lapack_complex_float* du2,
                           const int64_t* ipiv,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx, float* ferr,
                           float* berr );
int64_t LAPACKE_zgtrfs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const lapack_complex_double* dl,
                           const lapack_complex_double* d,
                           const lapack_complex_double* du,
                           const lapack_complex_double* dlf,
                           const lapack_complex_double* df,
                           const lapack_complex_double* duf,
                           const lapack_complex_double* du2,
                           const int64_t* ipiv,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* ferr, double* berr );

int64_t LAPACKE_sgtsv_64( int matrix_layout, int64_t n, int64_t nrhs,
                          float* dl, float* d, float* du, float* b,
                          int64_t ldb );
int64_t LAPACKE_dgtsv_64( int matrix_layout, int64_t n, int64_t nrhs,
                          double* dl, double* d, double* du, double* b,
                          int64_t ldb );
int64_t LAPACKE_cgtsv_64( int matrix_layout, int64_t n, int64_t nrhs,
                          lapack_complex_float* dl, lapack_complex_float* d,
                          lapack_complex_float* du, lapack_complex_float* b,
                          int64_t ldb );
int64_t LAPACKE_zgtsv_64( int matrix_layout, int64_t n, int64_t nrhs,
                          lapack_complex_double* dl, lapack_complex_double* d,
                          lapack_complex_double* du, lapack_complex_double* b,
                          int64_t ldb );

int64_t LAPACKE_sgtsvx_64( int matrix_layout, char fact, char trans,
                           int64_t n, int64_t nrhs, const float* dl,
                           const float* d, const float* du, float* dlf,
                           float* df, float* duf, float* du2, int64_t* ipiv,
                           const float* b, int64_t ldb, float* x,
                           int64_t ldx, float* rcond, float* ferr,
                           float* berr );
int64_t LAPACKE_dgtsvx_64( int matrix_layout, char fact, char trans,
                           int64_t n, int64_t nrhs, const double* dl,
                           const double* d, const double* du, double* dlf,
                           double* df, double* duf, double* du2,
                           int64_t* ipiv, const double* b, int64_t ldb,
                           double* x, int64_t ldx, double* rcond,
                           double* ferr, double* berr );
int64_t LAPACKE_cgtsvx_64( int matrix_layout, char fact, char trans,
                           int64_t n, int64_t nrhs,
                           const lapack_complex_float* dl,
                           const lapack_complex_float* d,
                           const lapack_complex_float* du,
                           lapack_complex_float* dlf, lapack_complex_float* df,
                           lapack_complex_float* duf, lapack_complex_float* du2,
                           int64_t* ipiv, const lapack_complex_float* b,
                           int64_t ldb, lapack_complex_float* x,
                           int64_t ldx, float* rcond, float* ferr,
                           float* berr );
int64_t LAPACKE_zgtsvx_64( int matrix_layout, char fact, char trans,
                           int64_t n, int64_t nrhs,
                           const lapack_complex_double* dl,
                           const lapack_complex_double* d,
                           const lapack_complex_double* du,
                           lapack_complex_double* dlf,
                           lapack_complex_double* df,
                           lapack_complex_double* duf,
                           lapack_complex_double* du2, int64_t* ipiv,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* rcond, double* ferr, double* berr );

int64_t LAPACKE_sgttrf_64( int64_t n, float* dl, float* d, float* du,
                           float* du2, int64_t* ipiv );
int64_t LAPACKE_dgttrf_64( int64_t n, double* dl, double* d, double* du,
                           double* du2, int64_t* ipiv );
int64_t LAPACKE_cgttrf_64( int64_t n, lapack_complex_float* dl,
                           lapack_complex_float* d, lapack_complex_float* du,
                           lapack_complex_float* du2, int64_t* ipiv );
int64_t LAPACKE_zgttrf_64( int64_t n, lapack_complex_double* dl,
                           lapack_complex_double* d, lapack_complex_double* du,
                           lapack_complex_double* du2, int64_t* ipiv );

int64_t LAPACKE_sgttrs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const float* dl, const float* d,
                           const float* du, const float* du2,
                           const int64_t* ipiv, float* b, int64_t ldb );
int64_t LAPACKE_dgttrs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const double* dl, const double* d,
                           const double* du, const double* du2,
                           const int64_t* ipiv, double* b, int64_t ldb );
int64_t LAPACKE_cgttrs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const lapack_complex_float* dl,
                           const lapack_complex_float* d,
                           const lapack_complex_float* du,
                           const lapack_complex_float* du2,
                           const int64_t* ipiv, lapack_complex_float* b,
                           int64_t ldb );
int64_t LAPACKE_zgttrs_64( int matrix_layout, char trans, int64_t n,
                           int64_t nrhs, const lapack_complex_double* dl,
                           const lapack_complex_double* d,
                           const lapack_complex_double* du,
                           const lapack_complex_double* du2,
                           const int64_t* ipiv, lapack_complex_double* b,
                           int64_t ldb );

int64_t LAPACKE_chbev_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          int64_t kd, lapack_complex_float* ab,
                          int64_t ldab, float* w, lapack_complex_float* z,
                          int64_t ldz );
int64_t LAPACKE_zhbev_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          int64_t kd, lapack_complex_double* ab,
                          int64_t ldab, double* w, lapack_complex_double* z,
                          int64_t ldz );

int64_t LAPACKE_chbevd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           int64_t kd, lapack_complex_float* ab,
                           int64_t ldab, float* w, lapack_complex_float* z,
                           int64_t ldz );
int64_t LAPACKE_zhbevd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           int64_t kd, lapack_complex_double* ab,
                           int64_t ldab, double* w, lapack_complex_double* z,
                           int64_t ldz );

int64_t LAPACKE_chbevx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, int64_t kd,
                           lapack_complex_float* ab, int64_t ldab,
                           lapack_complex_float* q, int64_t ldq, float vl,
                           float vu, int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, lapack_complex_float* z,
                           int64_t ldz, int64_t* ifail );
int64_t LAPACKE_zhbevx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, int64_t kd,
                           lapack_complex_double* ab, int64_t ldab,
                           lapack_complex_double* q, int64_t ldq, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w,
                           lapack_complex_double* z, int64_t ldz,
                           int64_t* ifail );

int64_t LAPACKE_chbgst_64( int matrix_layout, char vect, char uplo, int64_t n,
                           int64_t ka, int64_t kb,
                           lapack_complex_float* ab, int64_t ldab,
                           const lapack_complex_float* bb, int64_t ldbb,
                           lapack_complex_float* x, int64_t ldx );
int64_t LAPACKE_zhbgst_64( int matrix_layout, char vect, char uplo, int64_t n,
                           int64_t ka, int64_t kb,
                           lapack_complex_double* ab, int64_t ldab,
                           const lapack_complex_double* bb, int64_t ldbb,
                           lapack_complex_double* x, int64_t ldx );

int64_t LAPACKE_chbgv_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          int64_t ka, int64_t kb,
                          lapack_complex_float* ab, int64_t ldab,
                          lapack_complex_float* bb, int64_t ldbb, float* w,
                          lapack_complex_float* z, int64_t ldz );
int64_t LAPACKE_zhbgv_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          int64_t ka, int64_t kb,
                          lapack_complex_double* ab, int64_t ldab,
                          lapack_complex_double* bb, int64_t ldbb, double* w,
                          lapack_complex_double* z, int64_t ldz );

int64_t LAPACKE_chbgvd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           int64_t ka, int64_t kb,
                           lapack_complex_float* ab, int64_t ldab,
                           lapack_complex_float* bb, int64_t ldbb, float* w,
                           lapack_complex_float* z, int64_t ldz );
int64_t LAPACKE_zhbgvd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           int64_t ka, int64_t kb,
                           lapack_complex_double* ab, int64_t ldab,
                           lapack_complex_double* bb, int64_t ldbb,
                           double* w, lapack_complex_double* z,
                           int64_t ldz );

int64_t LAPACKE_chbgvx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, int64_t ka, int64_t kb,
                           lapack_complex_float* ab, int64_t ldab,
                           lapack_complex_float* bb, int64_t ldbb,
                           lapack_complex_float* q, int64_t ldq, float vl,
                           float vu, int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, lapack_complex_float* z,
                           int64_t ldz, int64_t* ifail );
int64_t LAPACKE_zhbgvx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, int64_t ka, int64_t kb,
                           lapack_complex_double* ab, int64_t ldab,
                           lapack_complex_double* bb, int64_t ldbb,
                           lapack_complex_double* q, int64_t ldq, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w,
                           lapack_complex_double* z, int64_t ldz,
                           int64_t* ifail );

int64_t LAPACKE_chbtrd_64( int matrix_layout, char vect, char uplo, int64_t n,
                           int64_t kd, lapack_complex_float* ab,
                           int64_t ldab, float* d, float* e,
                           lapack_complex_float* q, int64_t ldq );
int64_t LAPACKE_zhbtrd_64( int matrix_layout, char vect, char uplo, int64_t n,
                           int64_t kd, lapack_complex_double* ab,
                           int64_t ldab, double* d, double* e,
                           lapack_complex_double* q, int64_t ldq );

int64_t LAPACKE_checon_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_float* a, int64_t lda,
                           const int64_t* ipiv, float anorm, float* rcond );
int64_t LAPACKE_zhecon_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_double* a, int64_t lda,
                           const int64_t* ipiv, double anorm,
                           double* rcond );

int64_t LAPACKE_cheequb_64( int matrix_layout, char uplo, int64_t n,
                            const lapack_complex_float* a, int64_t lda,
                            float* s, float* scond, float* amax );
int64_t LAPACKE_zheequb_64( int matrix_layout, char uplo, int64_t n,
                            const lapack_complex_double* a, int64_t lda,
                            double* s, double* scond, double* amax );

int64_t LAPACKE_cheev_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          lapack_complex_float* a, int64_t lda, float* w );
int64_t LAPACKE_zheev_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          lapack_complex_double* a, int64_t lda, double* w );

int64_t LAPACKE_cheevd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda, float* w );
int64_t LAPACKE_zheevd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           double* w );

int64_t LAPACKE_cheevr_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, lapack_complex_float* a,
                           int64_t lda, float vl, float vu, int64_t il,
                           int64_t iu, float abstol, int64_t* m, float* w,
                           lapack_complex_float* z, int64_t ldz,
                           int64_t* isuppz );
int64_t LAPACKE_zheevr_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, lapack_complex_double* a,
                           int64_t lda, double vl, double vu, int64_t il,
                           int64_t iu, double abstol, int64_t* m,
                           double* w, lapack_complex_double* z, int64_t ldz,
                           int64_t* isuppz );

int64_t LAPACKE_cheevx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, lapack_complex_float* a,
                           int64_t lda, float vl, float vu, int64_t il,
                           int64_t iu, float abstol, int64_t* m, float* w,
                           lapack_complex_float* z, int64_t ldz,
                           int64_t* ifail );
int64_t LAPACKE_zheevx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, lapack_complex_double* a,
                           int64_t lda, double vl, double vu, int64_t il,
                           int64_t iu, double abstol, int64_t* m,
                           double* w, lapack_complex_double* z, int64_t ldz,
                           int64_t* ifail );

int64_t LAPACKE_chegst_64( int matrix_layout, int64_t itype, char uplo,
                           int64_t n, lapack_complex_float* a,
                           int64_t lda, const lapack_complex_float* b,
                           int64_t ldb );
int64_t LAPACKE_zhegst_64( int matrix_layout, int64_t itype, char uplo,
                           int64_t n, lapack_complex_double* a,
                           int64_t lda, const lapack_complex_double* b,
                           int64_t ldb );

int64_t LAPACKE_chegv_64( int matrix_layout, int64_t itype, char jobz,
                          char uplo, int64_t n, lapack_complex_float* a,
                          int64_t lda, lapack_complex_float* b,
                          int64_t ldb, float* w );
int64_t LAPACKE_zhegv_64( int matrix_layout, int64_t itype, char jobz,
                          char uplo, int64_t n, lapack_complex_double* a,
                          int64_t lda, lapack_complex_double* b,
                          int64_t ldb, double* w );

int64_t LAPACKE_chegvd_64( int matrix_layout, int64_t itype, char jobz,
                           char uplo, int64_t n, lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* b,
                           int64_t ldb, float* w );
int64_t LAPACKE_zhegvd_64( int matrix_layout, int64_t itype, char jobz,
                           char uplo, int64_t n, lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* b,
                           int64_t ldb, double* w );

int64_t LAPACKE_chegvx_64( int matrix_layout, int64_t itype, char jobz,
                           char range, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb, float vl,
                           float vu, int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, lapack_complex_float* z,
                           int64_t ldz, int64_t* ifail );
int64_t LAPACKE_zhegvx_64( int matrix_layout, int64_t itype, char jobz,
                           char range, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w,
                           lapack_complex_double* z, int64_t ldz,
                           int64_t* ifail );

int64_t LAPACKE_cherfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* a,
                           int64_t lda, const lapack_complex_float* af,
                           int64_t ldaf, const int64_t* ipiv,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx, float* ferr,
                           float* berr );
int64_t LAPACKE_zherfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* a,
                           int64_t lda, const lapack_complex_double* af,
                           int64_t ldaf, const int64_t* ipiv,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* ferr, double* berr );

int64_t LAPACKE_cherfsx_64( int matrix_layout, char uplo, char equed,
                            int64_t n, int64_t nrhs,
                            const lapack_complex_float* a, int64_t lda,
                            const lapack_complex_float* af, int64_t ldaf,
                            const int64_t* ipiv, const float* s,
                            const lapack_complex_float* b, int64_t ldb,
                            lapack_complex_float* x, int64_t ldx,
                            float* rcond, float* berr, int64_t n_err_bnds,
                            float* err_bnds_norm, float* err_bnds_comp,
                            int64_t nparams, float* params );
int64_t LAPACKE_zherfsx_64( int matrix_layout, char uplo, char equed,
                            int64_t n, int64_t nrhs,
                            const lapack_complex_double* a, int64_t lda,
                            const lapack_complex_double* af, int64_t ldaf,
                            const int64_t* ipiv, const double* s,
                            const lapack_complex_double* b, int64_t ldb,
                            lapack_complex_double* x, int64_t ldx,
                            double* rcond, double* berr, int64_t n_err_bnds,
                            double* err_bnds_norm, double* err_bnds_comp,
                            int64_t nparams, double* params );

int64_t LAPACKE_chesv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_float* a,
                          int64_t lda, int64_t* ipiv,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zhesv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_double* a,
                          int64_t lda, int64_t* ipiv,
                          lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_chesvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* af,
                           int64_t ldaf, int64_t* ipiv,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx,
                           float* rcond, float* ferr, float* berr );
int64_t LAPACKE_zhesvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* af,
                           int64_t ldaf, int64_t* ipiv,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* rcond, double* ferr, double* berr );

int64_t LAPACKE_chesvxx_64( int matrix_layout, char fact, char uplo,
                            int64_t n, int64_t nrhs,
                            lapack_complex_float* a, int64_t lda,
                            lapack_complex_float* af, int64_t ldaf,
                            int64_t* ipiv, char* equed, float* s,
                            lapack_complex_float* b, int64_t ldb,
                            lapack_complex_float* x, int64_t ldx,
                            float* rcond, float* rpvgrw, float* berr,
                            int64_t n_err_bnds, float* err_bnds_norm,
                            float* err_bnds_comp, int64_t nparams,
                            float* params );
int64_t LAPACKE_zhesvxx_64( int matrix_layout, char fact, char uplo,
                            int64_t n, int64_t nrhs,
                            lapack_complex_double* a, int64_t lda,
                            lapack_complex_double* af, int64_t ldaf,
                            int64_t* ipiv, char* equed, double* s,
                            lapack_complex_double* b, int64_t ldb,
                            lapack_complex_double* x, int64_t ldx,
                            double* rcond, double* rpvgrw, double* berr,
                            int64_t n_err_bnds, double* err_bnds_norm,
                            double* err_bnds_comp, int64_t nparams,
                            double* params );

int64_t LAPACKE_chetrd_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda, float* d,
                           float* e, lapack_complex_float* tau );
int64_t LAPACKE_zhetrd_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda, double* d,
                           double* e, lapack_complex_double* tau );

int64_t LAPACKE_chetrf_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* ipiv );
int64_t LAPACKE_zhetrf_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* ipiv );

int64_t LAPACKE_chetri_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           const int64_t* ipiv );
int64_t LAPACKE_zhetri_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           const int64_t* ipiv );

int64_t LAPACKE_chetrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* a,
                           int64_t lda, const int64_t* ipiv,
                           lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zhetrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* a,
                           int64_t lda, const int64_t* ipiv,
                           lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_chfrk_64( int matrix_layout, char transr, char uplo, char trans,
                          int64_t n, int64_t k, float alpha,
                          const lapack_complex_float* a, int64_t lda,
                          float beta, lapack_complex_float* c );
int64_t LAPACKE_zhfrk_64( int matrix_layout, char transr, char uplo, char trans,
                          int64_t n, int64_t k, double alpha,
                          const lapack_complex_double* a, int64_t lda,
                          double beta, lapack_complex_double* c );

int64_t LAPACKE_shgeqz_64( int matrix_layout, char job, char compq, char compz,
                           int64_t n, int64_t ilo, int64_t ihi,
                           float* h, int64_t ldh, float* t, int64_t ldt,
                           float* alphar, float* alphai, float* beta, float* q,
                           int64_t ldq, float* z, int64_t ldz );
int64_t LAPACKE_dhgeqz_64( int matrix_layout, char job, char compq, char compz,
                           int64_t n, int64_t ilo, int64_t ihi,
                           double* h, int64_t ldh, double* t, int64_t ldt,
                           double* alphar, double* alphai, double* beta,
                           double* q, int64_t ldq, double* z,
                           int64_t ldz );
int64_t LAPACKE_chgeqz_64( int matrix_layout, char job, char compq, char compz,
                           int64_t n, int64_t ilo, int64_t ihi,
                           lapack_complex_float* h, int64_t ldh,
                           lapack_complex_float* t, int64_t ldt,
                           lapack_complex_float* alpha,
                           lapack_complex_float* beta, lapack_complex_float* q,
                           int64_t ldq, lapack_complex_float* z,
                           int64_t ldz );
int64_t LAPACKE_zhgeqz_64( int matrix_layout, char job, char compq, char compz,
                           int64_t n, int64_t ilo, int64_t ihi,
                           lapack_complex_double* h, int64_t ldh,
                           lapack_complex_double* t, int64_t ldt,
                           lapack_complex_double* alpha,
                           lapack_complex_double* beta,
                           lapack_complex_double* q, int64_t ldq,
                           lapack_complex_double* z, int64_t ldz );

int64_t LAPACKE_chpcon_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_float* ap,
                           const int64_t* ipiv, float anorm, float* rcond );
int64_t LAPACKE_zhpcon_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_double* ap,
                           const int64_t* ipiv, double anorm,
                           double* rcond );

int64_t LAPACKE_chpev_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          lapack_complex_float* ap, float* w,
                          lapack_complex_float* z, int64_t ldz );
int64_t LAPACKE_zhpev_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          lapack_complex_double* ap, double* w,
                          lapack_complex_double* z, int64_t ldz );

int64_t LAPACKE_chpevd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           lapack_complex_float* ap, float* w,
                           lapack_complex_float* z, int64_t ldz );
int64_t LAPACKE_zhpevd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           lapack_complex_double* ap, double* w,
                           lapack_complex_double* z, int64_t ldz );

int64_t LAPACKE_chpevx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, lapack_complex_float* ap, float vl,
                           float vu, int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, lapack_complex_float* z,
                           int64_t ldz, int64_t* ifail );
int64_t LAPACKE_zhpevx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, lapack_complex_double* ap, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w,
                           lapack_complex_double* z, int64_t ldz,
                           int64_t* ifail );

int64_t LAPACKE_chpgst_64( int matrix_layout, int64_t itype, char uplo,
                           int64_t n, lapack_complex_float* ap,
                           const lapack_complex_float* bp );
int64_t LAPACKE_zhpgst_64( int matrix_layout, int64_t itype, char uplo,
                           int64_t n, lapack_complex_double* ap,
                           const lapack_complex_double* bp );

int64_t LAPACKE_chpgv_64( int matrix_layout, int64_t itype, char jobz,
                          char uplo, int64_t n, lapack_complex_float* ap,
                          lapack_complex_float* bp, float* w,
                          lapack_complex_float* z, int64_t ldz );
int64_t LAPACKE_zhpgv_64( int matrix_layout, int64_t itype, char jobz,
                          char uplo, int64_t n, lapack_complex_double* ap,
                          lapack_complex_double* bp, double* w,
                          lapack_complex_double* z, int64_t ldz );

int64_t LAPACKE_chpgvd_64( int matrix_layout, int64_t itype, char jobz,
                           char uplo, int64_t n, lapack_complex_float* ap,
                           lapack_complex_float* bp, float* w,
                           lapack_complex_float* z, int64_t ldz );
int64_t LAPACKE_zhpgvd_64( int matrix_layout, int64_t itype, char jobz,
                           char uplo, int64_t n, lapack_complex_double* ap,
                           lapack_complex_double* bp, double* w,
                           lapack_complex_double* z, int64_t ldz );

int64_t LAPACKE_chpgvx_64( int matrix_layout, int64_t itype, char jobz,
                           char range, char uplo, int64_t n,
                           lapack_complex_float* ap, lapack_complex_float* bp,
                           float vl, float vu, int64_t il, int64_t iu,
                           float abstol, int64_t* m, float* w,
                           lapack_complex_float* z, int64_t ldz,
                           int64_t* ifail );
int64_t LAPACKE_zhpgvx_64( int matrix_layout, int64_t itype, char jobz,
                           char range, char uplo, int64_t n,
                           lapack_complex_double* ap, lapack_complex_double* bp,
                           double vl, double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w,
                           lapack_complex_double* z, int64_t ldz,
                           int64_t* ifail );

int64_t LAPACKE_chprfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* ap,
                           const lapack_complex_float* afp,
                           const int64_t* ipiv,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx, float* ferr,
                           float* berr );
int64_t LAPACKE_zhprfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* ap,
                           const lapack_complex_double* afp,
                           const int64_t* ipiv,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* ferr, double* berr );

int64_t LAPACKE_chpsv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_float* ap,
                          int64_t* ipiv, lapack_complex_float* b,
                          int64_t ldb );
int64_t LAPACKE_zhpsv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_double* ap,
                          int64_t* ipiv, lapack_complex_double* b,
                          int64_t ldb );

int64_t LAPACKE_chpsvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* ap,
                           lapack_complex_float* afp, int64_t* ipiv,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx,
                           float* rcond, float* ferr, float* berr );
int64_t LAPACKE_zhpsvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* ap,
                           lapack_complex_double* afp, int64_t* ipiv,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* rcond, double* ferr, double* berr );

int64_t LAPACKE_chptrd_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* ap, float* d, float* e,
                           lapack_complex_float* tau );
int64_t LAPACKE_zhptrd_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* ap, double* d, double* e,
                           lapack_complex_double* tau );

int64_t LAPACKE_chptrf_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* ap, int64_t* ipiv );
int64_t LAPACKE_zhptrf_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* ap, int64_t* ipiv );

int64_t LAPACKE_chptri_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* ap, const int64_t* ipiv );
int64_t LAPACKE_zhptri_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* ap, const int64_t* ipiv );

int64_t LAPACKE_chptrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* ap,
                           const int64_t* ipiv, lapack_complex_float* b,
                           int64_t ldb );
int64_t LAPACKE_zhptrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* ap,
                           const int64_t* ipiv, lapack_complex_double* b,
                           int64_t ldb );

int64_t LAPACKE_shsein_64( int matrix_layout, char job, char eigsrc, char initv,
                           lapack_logical* select, int64_t n, const float* h,
                           int64_t ldh, float* wr, const float* wi,
                           float* vl, int64_t ldvl, float* vr,
                           int64_t ldvr, int64_t mm, int64_t* m,
                           int64_t* ifaill, int64_t* ifailr );
int64_t LAPACKE_dhsein_64( int matrix_layout, char job, char eigsrc, char initv,
                           lapack_logical* select, int64_t n,
                           const double* h, int64_t ldh, double* wr,
                           const double* wi, double* vl, int64_t ldvl,
                           double* vr, int64_t ldvr, int64_t mm,
                           int64_t* m, int64_t* ifaill,
                           int64_t* ifailr );
int64_t LAPACKE_chsein_64( int matrix_layout, char job, char eigsrc, char initv,
                           const lapack_logical* select, int64_t n,
                           const lapack_complex_float* h, int64_t ldh,
                           lapack_complex_float* w, lapack_complex_float* vl,
                           int64_t ldvl, lapack_complex_float* vr,
                           int64_t ldvr, int64_t mm, int64_t* m,
                           int64_t* ifaill, int64_t* ifailr );
int64_t LAPACKE_zhsein_64( int matrix_layout, char job, char eigsrc, char initv,
                           const lapack_logical* select, int64_t n,
                           const lapack_complex_double* h, int64_t ldh,
                           lapack_complex_double* w, lapack_complex_double* vl,
                           int64_t ldvl, lapack_complex_double* vr,
                           int64_t ldvr, int64_t mm, int64_t* m,
                           int64_t* ifaill, int64_t* ifailr );

int64_t LAPACKE_shseqr_64( int matrix_layout, char job, char compz, int64_t n,
                           int64_t ilo, int64_t ihi, float* h,
                           int64_t ldh, float* wr, float* wi, float* z,
                           int64_t ldz );
int64_t LAPACKE_dhseqr_64( int matrix_layout, char job, char compz, int64_t n,
                           int64_t ilo, int64_t ihi, double* h,
                           int64_t ldh, double* wr, double* wi, double* z,
                           int64_t ldz );
int64_t LAPACKE_chseqr_64( int matrix_layout, char job, char compz, int64_t n,
                           int64_t ilo, int64_t ihi,
                           lapack_complex_float* h, int64_t ldh,
                           lapack_complex_float* w, lapack_complex_float* z,
                           int64_t ldz );
int64_t LAPACKE_zhseqr_64( int matrix_layout, char job, char compz, int64_t n,
                           int64_t ilo, int64_t ihi,
                           lapack_complex_double* h, int64_t ldh,
                           lapack_complex_double* w, lapack_complex_double* z,
                           int64_t ldz );

int64_t LAPACKE_clacgv_64( int64_t n, lapack_complex_float* x,
                           int64_t incx );
int64_t LAPACKE_zlacgv_64( int64_t n, lapack_complex_double* x,
                           int64_t incx );

int64_t LAPACKE_slacn2_64( int64_t n, float* v, float* x, int64_t* isgn,
                           float* est, int64_t* kase, int64_t* isave );
int64_t LAPACKE_dlacn2_64( int64_t n, double* v, double* x, int64_t* isgn,
                           double* est, int64_t* kase, int64_t* isave );
int64_t LAPACKE_clacn2_64( int64_t n, lapack_complex_float* v,
                           lapack_complex_float* x,
                           float* est, int64_t* kase, int64_t* isave );
int64_t LAPACKE_zlacn2_64( int64_t n, lapack_complex_double* v,
                           lapack_complex_double* x,
                           double* est, int64_t* kase, int64_t* isave );

int64_t LAPACKE_slacpy_64( int matrix_layout, char uplo, int64_t m,
                           int64_t n, const float* a, int64_t lda, float* b,
                           int64_t ldb );
int64_t LAPACKE_dlacpy_64( int matrix_layout, char uplo, int64_t m,
                           int64_t n, const double* a, int64_t lda, double* b,
                           int64_t ldb );
int64_t LAPACKE_clacpy_64( int matrix_layout, char uplo, int64_t m,
                           int64_t n, const lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* b,
                           int64_t ldb );
int64_t LAPACKE_zlacpy_64( int matrix_layout, char uplo, int64_t m,
                           int64_t n, const lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* b,
                           int64_t ldb );

int64_t LAPACKE_clacp2_64( int matrix_layout, char uplo, int64_t m,
                           int64_t n, const float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zlacp2_64( int matrix_layout, char uplo, int64_t m,
                           int64_t n, const double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_zlag2c_64( int matrix_layout, int64_t m, int64_t n,
                           const lapack_complex_double* a, int64_t lda,
                           lapack_complex_float* sa, int64_t ldsa );

int64_t LAPACKE_slag2d_64( int matrix_layout, int64_t m, int64_t n,
                           const float* sa, int64_t ldsa, double* a,
                           int64_t lda );

int64_t LAPACKE_dlag2s_64( int matrix_layout, int64_t m, int64_t n,
                           const double* a, int64_t lda, float* sa,
                           int64_t ldsa );

int64_t LAPACKE_clag2z_64( int matrix_layout, int64_t m, int64_t n,
                           const lapack_complex_float* sa, int64_t ldsa,
                           lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_slagge_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t kl, int64_t ku, const float* d,
                           float* a, int64_t lda, int64_t* iseed );
int64_t LAPACKE_dlagge_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t kl, int64_t ku, const double* d,
                           double* a, int64_t lda, int64_t* iseed );
int64_t LAPACKE_clagge_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t kl, int64_t ku, const float* d,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* iseed );
int64_t LAPACKE_zlagge_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t kl, int64_t ku, const double* d,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* iseed );

float LAPACKE_slamch_64( char cmach );
double LAPACKE_dlamch_64( char cmach );

float LAPACKE_slangb_64( int matrix_layout, char norm, int64_t n,
                      int64_t kl, int64_t ku, const float* ab,
                      int64_t ldab );
double LAPACKE_dlangb_64( int matrix_layout, char norm, int64_t n,
                       int64_t kl, int64_t ku, const double* ab,
                       int64_t ldab );
float LAPACKE_clangb_64( int matrix_layout, char norm, int64_t n,
                      int64_t kl, int64_t ku,
                      const lapack_complex_float* ab, int64_t ldab );
double LAPACKE_zlangb_64( int matrix_layout, char norm, int64_t n,
                       int64_t kl, int64_t ku,
                       const lapack_complex_double* ab, int64_t ldab );

float LAPACKE_slange_64( int matrix_layout, char norm, int64_t m,
                           int64_t n, const float* a, int64_t lda );
double LAPACKE_dlange_64( int matrix_layout, char norm, int64_t m,
                           int64_t n, const double* a, int64_t lda );
float LAPACKE_clange_64( int matrix_layout, char norm, int64_t m,
                           int64_t n, const lapack_complex_float* a,
                           int64_t lda );
double LAPACKE_zlange_64( int matrix_layout, char norm, int64_t m,
                           int64_t n, const lapack_complex_double* a,
                           int64_t lda );

float LAPACKE_clanhe_64( int matrix_layout, char norm, char uplo, int64_t n,
                           const lapack_complex_float* a, int64_t lda );
double LAPACKE_zlanhe_64( int matrix_layout, char norm, char uplo, int64_t n,
                           const lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_clacrm_64( int matrix_layout, int64_t m, int64_t n,
                          const lapack_complex_float* a,
                          int64_t lda, const float* b,
                          int64_t ldb, lapack_complex_float* c,
                          int64_t ldc );
int64_t LAPACKE_zlacrm_64( int matrix_layout, int64_t m, int64_t n,
                           const lapack_complex_double* a,
                           int64_t lda, const double* b,
                           int64_t ldb, lapack_complex_double* c,
                           int64_t ldc );

int64_t LAPACKE_clarcm_64( int matrix_layout, int64_t m, int64_t n,
                          const float* a, int64_t lda,
                          const lapack_complex_float* b,
                          int64_t ldb, lapack_complex_float* c,
                          int64_t ldc );
int64_t LAPACKE_zlarcm_64( int matrix_layout, int64_t m, int64_t n,
                           const double* a, int64_t lda,
                           const lapack_complex_double* b,
                           int64_t ldb, lapack_complex_double* c,
                           int64_t ldc );

float LAPACKE_slansy_64( int matrix_layout, char norm, char uplo, int64_t n,
                           const float* a, int64_t lda );
double LAPACKE_dlansy_64( int matrix_layout, char norm, char uplo, int64_t n,
                           const double* a, int64_t lda );
float LAPACKE_clansy_64( int matrix_layout, char norm, char uplo, int64_t n,
                           const lapack_complex_float* a, int64_t lda );
double LAPACKE_zlansy_64( int matrix_layout, char norm, char uplo, int64_t n,
                           const lapack_complex_double* a, int64_t lda );

float LAPACKE_slantr_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t m, int64_t n, const float* a,
                           int64_t lda );
double LAPACKE_dlantr_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t m, int64_t n, const double* a,
                           int64_t lda );
float LAPACKE_clantr_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t m, int64_t n, const lapack_complex_float* a,
                           int64_t lda );
double LAPACKE_zlantr_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t m, int64_t n, const lapack_complex_double* a,
                           int64_t lda );


int64_t LAPACKE_slarfb_64( int matrix_layout, char side, char trans, char direct,
                           char storev, int64_t m, int64_t n,
                           int64_t k, const float* v, int64_t ldv,
                           const float* t, int64_t ldt, float* c,
                           int64_t ldc );
int64_t LAPACKE_dlarfb_64( int matrix_layout, char side, char trans, char direct,
                           char storev, int64_t m, int64_t n,
                           int64_t k, const double* v, int64_t ldv,
                           const double* t, int64_t ldt, double* c,
                           int64_t ldc );
int64_t LAPACKE_clarfb_64( int matrix_layout, char side, char trans, char direct,
                           char storev, int64_t m, int64_t n,
                           int64_t k, const lapack_complex_float* v,
                           int64_t ldv, const lapack_complex_float* t,
                           int64_t ldt, lapack_complex_float* c,
                           int64_t ldc );
int64_t LAPACKE_zlarfb_64( int matrix_layout, char side, char trans, char direct,
                           char storev, int64_t m, int64_t n,
                           int64_t k, const lapack_complex_double* v,
                           int64_t ldv, const lapack_complex_double* t,
                           int64_t ldt, lapack_complex_double* c,
                           int64_t ldc );

int64_t LAPACKE_slarfg_64( int64_t n, float* alpha, float* x,
                           int64_t incx, float* tau );
int64_t LAPACKE_dlarfg_64( int64_t n, double* alpha, double* x,
                           int64_t incx, double* tau );
int64_t LAPACKE_clarfg_64( int64_t n, lapack_complex_float* alpha,
                           lapack_complex_float* x, int64_t incx,
                           lapack_complex_float* tau );
int64_t LAPACKE_zlarfg_64( int64_t n, lapack_complex_double* alpha,
                           lapack_complex_double* x, int64_t incx,
                           lapack_complex_double* tau );

int64_t LAPACKE_slarft_64( int matrix_layout, char direct, char storev,
                           int64_t n, int64_t k, const float* v,
                           int64_t ldv, const float* tau, float* t,
                           int64_t ldt );
int64_t LAPACKE_dlarft_64( int matrix_layout, char direct, char storev,
                           int64_t n, int64_t k, const double* v,
                           int64_t ldv, const double* tau, double* t,
                           int64_t ldt );
int64_t LAPACKE_clarft_64( int matrix_layout, char direct, char storev,
                           int64_t n, int64_t k,
                           const lapack_complex_float* v, int64_t ldv,
                           const lapack_complex_float* tau,
                           lapack_complex_float* t, int64_t ldt );
int64_t LAPACKE_zlarft_64( int matrix_layout, char direct, char storev,
                           int64_t n, int64_t k,
                           const lapack_complex_double* v, int64_t ldv,
                           const lapack_complex_double* tau,
                           lapack_complex_double* t, int64_t ldt );

int64_t LAPACKE_slarfx_64( int matrix_layout, char side, int64_t m,
                           int64_t n, const float* v, float tau, float* c,
                           int64_t ldc, float* work );
int64_t LAPACKE_dlarfx_64( int matrix_layout, char side, int64_t m,
                           int64_t n, const double* v, double tau, double* c,
                           int64_t ldc, double* work );
int64_t LAPACKE_clarfx_64( int matrix_layout, char side, int64_t m,
                           int64_t n, const lapack_complex_float* v,
                           lapack_complex_float tau, lapack_complex_float* c,
                           int64_t ldc, lapack_complex_float* work );
int64_t LAPACKE_zlarfx_64( int matrix_layout, char side, int64_t m,
                           int64_t n, const lapack_complex_double* v,
                           lapack_complex_double tau, lapack_complex_double* c,
                           int64_t ldc, lapack_complex_double* work );

int64_t LAPACKE_slarnv_64( int64_t idist, int64_t* iseed, int64_t n,
                           float* x );
int64_t LAPACKE_dlarnv_64( int64_t idist, int64_t* iseed, int64_t n,
                           double* x );
int64_t LAPACKE_clarnv_64( int64_t idist, int64_t* iseed, int64_t n,
                           lapack_complex_float* x );
int64_t LAPACKE_zlarnv_64( int64_t idist, int64_t* iseed, int64_t n,
                           lapack_complex_double* x );

int64_t LAPACKE_slascl_64( int matrix_layout, char type, int64_t kl,
                           int64_t ku, float cfrom, float cto,
                           int64_t m, int64_t n, float* a,
                           int64_t lda );
int64_t LAPACKE_dlascl_64( int matrix_layout, char type, int64_t kl,
                           int64_t ku, double cfrom, double cto,
                           int64_t m, int64_t n, double* a,
                           int64_t lda );
int64_t LAPACKE_clascl_64( int matrix_layout, char type, int64_t kl,
                           int64_t ku, float cfrom, float cto,
                           int64_t m, int64_t n, lapack_complex_float* a,
                           int64_t lda );
int64_t LAPACKE_zlascl_64( int matrix_layout, char type, int64_t kl,
                           int64_t ku, double cfrom, double cto,
                           int64_t m, int64_t n, lapack_complex_double* a,
                           int64_t lda );

int64_t LAPACKE_slaset_64( int matrix_layout, char uplo, int64_t m,
                           int64_t n, float alpha, float beta, float* a,
                           int64_t lda );
int64_t LAPACKE_dlaset_64( int matrix_layout, char uplo, int64_t m,
                           int64_t n, double alpha, double beta, double* a,
                           int64_t lda );
int64_t LAPACKE_claset_64( int matrix_layout, char uplo, int64_t m,
                           int64_t n, lapack_complex_float alpha,
                           lapack_complex_float beta, lapack_complex_float* a,
                           int64_t lda );
int64_t LAPACKE_zlaset_64( int matrix_layout, char uplo, int64_t m,
                           int64_t n, lapack_complex_double alpha,
                           lapack_complex_double beta, lapack_complex_double* a,
                           int64_t lda );

int64_t LAPACKE_slasrt_64( char id, int64_t n, float* d );
int64_t LAPACKE_dlasrt_64( char id, int64_t n, double* d );

int64_t LAPACKE_slassq_64( int64_t n,                 float* x, int64_t incx,  float* scale,  float* sumsq );
int64_t LAPACKE_dlassq_64( int64_t n,                double* x, int64_t incx, double* scale, double* sumsq );
int64_t LAPACKE_classq_64( int64_t n,  lapack_complex_float* x, int64_t incx,  float* scale,  float* sumsq );
int64_t LAPACKE_zlassq_64( int64_t n, lapack_complex_double* x, int64_t incx, double* scale, double* sumsq );

int64_t LAPACKE_slaswp_64( int matrix_layout, int64_t n, float* a,
                           int64_t lda, int64_t k1, int64_t k2,
                           const int64_t* ipiv, int64_t incx );
int64_t LAPACKE_dlaswp_64( int matrix_layout, int64_t n, double* a,
                           int64_t lda, int64_t k1, int64_t k2,
                           const int64_t* ipiv, int64_t incx );
int64_t LAPACKE_claswp_64( int matrix_layout, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t k1, int64_t k2, const int64_t* ipiv,
                           int64_t incx );
int64_t LAPACKE_zlaswp_64( int matrix_layout, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t k1, int64_t k2, const int64_t* ipiv,
                           int64_t incx );

int64_t LAPACKE_slatms_64( int matrix_layout, int64_t m, int64_t n,
                           char dist, int64_t* iseed, char sym, float* d,
                           int64_t mode, float cond, float dmax,
                           int64_t kl, int64_t ku, char pack, float* a,
                           int64_t lda );
int64_t LAPACKE_dlatms_64( int matrix_layout, int64_t m, int64_t n,
                           char dist, int64_t* iseed, char sym, double* d,
                           int64_t mode, double cond, double dmax,
                           int64_t kl, int64_t ku, char pack, double* a,
                           int64_t lda );
int64_t LAPACKE_clatms_64( int matrix_layout, int64_t m, int64_t n,
                           char dist, int64_t* iseed, char sym, float* d,
                           int64_t mode, float cond, float dmax,
                           int64_t kl, int64_t ku, char pack,
                           lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_zlatms_64( int matrix_layout, int64_t m, int64_t n,
                           char dist, int64_t* iseed, char sym, double* d,
                           int64_t mode, double cond, double dmax,
                           int64_t kl, int64_t ku, char pack,
                           lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_slauum_64( int matrix_layout, char uplo, int64_t n, float* a,
                           int64_t lda );
int64_t LAPACKE_dlauum_64( int matrix_layout, char uplo, int64_t n, double* a,
                           int64_t lda );
int64_t LAPACKE_clauum_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_zlauum_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_sopgtr_64( int matrix_layout, char uplo, int64_t n,
                           const float* ap, const float* tau, float* q,
                           int64_t ldq );
int64_t LAPACKE_dopgtr_64( int matrix_layout, char uplo, int64_t n,
                           const double* ap, const double* tau, double* q,
                           int64_t ldq );

int64_t LAPACKE_sopmtr_64( int matrix_layout, char side, char uplo, char trans,
                           int64_t m, int64_t n, const float* ap,
                           const float* tau, float* c, int64_t ldc );
int64_t LAPACKE_dopmtr_64( int matrix_layout, char side, char uplo, char trans,
                           int64_t m, int64_t n, const double* ap,
                           const double* tau, double* c, int64_t ldc );

int64_t LAPACKE_sorgbr_64( int matrix_layout, char vect, int64_t m,
                           int64_t n, int64_t k, float* a, int64_t lda,
                           const float* tau );
int64_t LAPACKE_dorgbr_64( int matrix_layout, char vect, int64_t m,
                           int64_t n, int64_t k, double* a,
                           int64_t lda, const double* tau );

int64_t LAPACKE_sorghr_64( int matrix_layout, int64_t n, int64_t ilo,
                           int64_t ihi, float* a, int64_t lda,
                           const float* tau );
int64_t LAPACKE_dorghr_64( int matrix_layout, int64_t n, int64_t ilo,
                           int64_t ihi, double* a, int64_t lda,
                           const double* tau );

int64_t LAPACKE_sorglq_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, float* a, int64_t lda,
                           const float* tau );
int64_t LAPACKE_dorglq_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, double* a, int64_t lda,
                           const double* tau );

int64_t LAPACKE_sorgql_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, float* a, int64_t lda,
                           const float* tau );
int64_t LAPACKE_dorgql_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, double* a, int64_t lda,
                           const double* tau );

int64_t LAPACKE_sorgqr_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, float* a, int64_t lda,
                           const float* tau );
int64_t LAPACKE_dorgqr_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, double* a, int64_t lda,
                           const double* tau );

int64_t LAPACKE_sorgrq_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, float* a, int64_t lda,
                           const float* tau );
int64_t LAPACKE_dorgrq_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, double* a, int64_t lda,
                           const double* tau );

int64_t LAPACKE_sorgtr_64( int matrix_layout, char uplo, int64_t n, float* a,
                           int64_t lda, const float* tau );
int64_t LAPACKE_dorgtr_64( int matrix_layout, char uplo, int64_t n, double* a,
                           int64_t lda, const double* tau );

int64_t LAPACKE_sorgtsqr_row_64( int matrix_layout, int64_t m, int64_t n,
                                 int64_t mb, int64_t nb,
                                 float* a, int64_t lda,
                                 const float* t, int64_t ldt );
int64_t LAPACKE_dorgtsqr_row_64( int matrix_layout, int64_t m, int64_t n,
                                 int64_t mb, int64_t nb,
                                 double* a, int64_t lda,
                                 const double* t, int64_t ldt );

int64_t LAPACKE_sormbr_64( int matrix_layout, char vect, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const float* a, int64_t lda, const float* tau,
                           float* c, int64_t ldc );
int64_t LAPACKE_dormbr_64( int matrix_layout, char vect, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const double* a, int64_t lda, const double* tau,
                           double* c, int64_t ldc );

int64_t LAPACKE_sormhr_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t ilo,
                           int64_t ihi, const float* a, int64_t lda,
                           const float* tau, float* c, int64_t ldc );
int64_t LAPACKE_dormhr_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t ilo,
                           int64_t ihi, const double* a, int64_t lda,
                           const double* tau, double* c, int64_t ldc );

int64_t LAPACKE_sormlq_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const float* a, int64_t lda, const float* tau,
                           float* c, int64_t ldc );
int64_t LAPACKE_dormlq_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const double* a, int64_t lda, const double* tau,
                           double* c, int64_t ldc );

int64_t LAPACKE_sormql_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const float* a, int64_t lda, const float* tau,
                           float* c, int64_t ldc );
int64_t LAPACKE_dormql_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const double* a, int64_t lda, const double* tau,
                           double* c, int64_t ldc );

int64_t LAPACKE_sormqr_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const float* a, int64_t lda, const float* tau,
                           float* c, int64_t ldc );
int64_t LAPACKE_dormqr_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const double* a, int64_t lda, const double* tau,
                           double* c, int64_t ldc );

int64_t LAPACKE_sormrq_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const float* a, int64_t lda, const float* tau,
                           float* c, int64_t ldc );
int64_t LAPACKE_dormrq_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const double* a, int64_t lda, const double* tau,
                           double* c, int64_t ldc );

int64_t LAPACKE_sormrz_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           int64_t l, const float* a, int64_t lda,
                           const float* tau, float* c, int64_t ldc );
int64_t LAPACKE_dormrz_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           int64_t l, const double* a, int64_t lda,
                           const double* tau, double* c, int64_t ldc );

int64_t LAPACKE_sormtr_64( int matrix_layout, char side, char uplo, char trans,
                           int64_t m, int64_t n, const float* a,
                           int64_t lda, const float* tau, float* c,
                           int64_t ldc );
int64_t LAPACKE_dormtr_64( int matrix_layout, char side, char uplo, char trans,
                           int64_t m, int64_t n, const double* a,
                           int64_t lda, const double* tau, double* c,
                           int64_t ldc );

int64_t LAPACKE_spbcon_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, const float* ab, int64_t ldab,
                           float anorm, float* rcond );
int64_t LAPACKE_dpbcon_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, const double* ab, int64_t ldab,
                           double anorm, double* rcond );
int64_t LAPACKE_cpbcon_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, const lapack_complex_float* ab,
                           int64_t ldab, float anorm, float* rcond );
int64_t LAPACKE_zpbcon_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, const lapack_complex_double* ab,
                           int64_t ldab, double anorm, double* rcond );

int64_t LAPACKE_spbequ_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, const float* ab, int64_t ldab,
                           float* s, float* scond, float* amax );
int64_t LAPACKE_dpbequ_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, const double* ab, int64_t ldab,
                           double* s, double* scond, double* amax );
int64_t LAPACKE_cpbequ_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, const lapack_complex_float* ab,
                           int64_t ldab, float* s, float* scond,
                           float* amax );
int64_t LAPACKE_zpbequ_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, const lapack_complex_double* ab,
                           int64_t ldab, double* s, double* scond,
                           double* amax );

int64_t LAPACKE_spbrfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, int64_t nrhs, const float* ab,
                           int64_t ldab, const float* afb, int64_t ldafb,
                           const float* b, int64_t ldb, float* x,
                           int64_t ldx, float* ferr, float* berr );
int64_t LAPACKE_dpbrfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, int64_t nrhs, const double* ab,
                           int64_t ldab, const double* afb, int64_t ldafb,
                           const double* b, int64_t ldb, double* x,
                           int64_t ldx, double* ferr, double* berr );
int64_t LAPACKE_cpbrfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, int64_t nrhs,
                           const lapack_complex_float* ab, int64_t ldab,
                           const lapack_complex_float* afb, int64_t ldafb,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx, float* ferr,
                           float* berr );
int64_t LAPACKE_zpbrfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, int64_t nrhs,
                           const lapack_complex_double* ab, int64_t ldab,
                           const lapack_complex_double* afb, int64_t ldafb,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* ferr, double* berr );

int64_t LAPACKE_spbstf_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kb, float* bb, int64_t ldbb );
int64_t LAPACKE_dpbstf_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kb, double* bb, int64_t ldbb );
int64_t LAPACKE_cpbstf_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kb, lapack_complex_float* bb,
                           int64_t ldbb );
int64_t LAPACKE_zpbstf_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kb, lapack_complex_double* bb,
                           int64_t ldbb );

int64_t LAPACKE_spbsv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t kd, int64_t nrhs, float* ab,
                          int64_t ldab, float* b, int64_t ldb );
int64_t LAPACKE_dpbsv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t kd, int64_t nrhs, double* ab,
                          int64_t ldab, double* b, int64_t ldb );
int64_t LAPACKE_cpbsv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t kd, int64_t nrhs,
                          lapack_complex_float* ab, int64_t ldab,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zpbsv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t kd, int64_t nrhs,
                          lapack_complex_double* ab, int64_t ldab,
                          lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_spbsvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t kd, int64_t nrhs, float* ab,
                           int64_t ldab, float* afb, int64_t ldafb,
                           char* equed, float* s, float* b, int64_t ldb,
                           float* x, int64_t ldx, float* rcond, float* ferr,
                           float* berr );
int64_t LAPACKE_dpbsvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t kd, int64_t nrhs, double* ab,
                           int64_t ldab, double* afb, int64_t ldafb,
                           char* equed, double* s, double* b, int64_t ldb,
                           double* x, int64_t ldx, double* rcond,
                           double* ferr, double* berr );
int64_t LAPACKE_cpbsvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t kd, int64_t nrhs,
                           lapack_complex_float* ab, int64_t ldab,
                           lapack_complex_float* afb, int64_t ldafb,
                           char* equed, float* s, lapack_complex_float* b,
                           int64_t ldb, lapack_complex_float* x,
                           int64_t ldx, float* rcond, float* ferr,
                           float* berr );
int64_t LAPACKE_zpbsvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t kd, int64_t nrhs,
                           lapack_complex_double* ab, int64_t ldab,
                           lapack_complex_double* afb, int64_t ldafb,
                           char* equed, double* s, lapack_complex_double* b,
                           int64_t ldb, lapack_complex_double* x,
                           int64_t ldx, double* rcond, double* ferr,
                           double* berr );

int64_t LAPACKE_spbtrf_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, float* ab, int64_t ldab );
int64_t LAPACKE_dpbtrf_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, double* ab, int64_t ldab );
int64_t LAPACKE_cpbtrf_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, lapack_complex_float* ab,
                           int64_t ldab );
int64_t LAPACKE_zpbtrf_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, lapack_complex_double* ab,
                           int64_t ldab );

int64_t LAPACKE_spbtrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, int64_t nrhs, const float* ab,
                           int64_t ldab, float* b, int64_t ldb );
int64_t LAPACKE_dpbtrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, int64_t nrhs, const double* ab,
                           int64_t ldab, double* b, int64_t ldb );
int64_t LAPACKE_cpbtrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, int64_t nrhs,
                           const lapack_complex_float* ab, int64_t ldab,
                           lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zpbtrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t kd, int64_t nrhs,
                           const lapack_complex_double* ab, int64_t ldab,
                           lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_spftrf_64( int matrix_layout, char transr, char uplo,
                           int64_t n, float* a );
int64_t LAPACKE_dpftrf_64( int matrix_layout, char transr, char uplo,
                           int64_t n, double* a );
int64_t LAPACKE_cpftrf_64( int matrix_layout, char transr, char uplo,
                           int64_t n, lapack_complex_float* a );
int64_t LAPACKE_zpftrf_64( int matrix_layout, char transr, char uplo,
                           int64_t n, lapack_complex_double* a );

int64_t LAPACKE_spftri_64( int matrix_layout, char transr, char uplo,
                           int64_t n, float* a );
int64_t LAPACKE_dpftri_64( int matrix_layout, char transr, char uplo,
                           int64_t n, double* a );
int64_t LAPACKE_cpftri_64( int matrix_layout, char transr, char uplo,
                           int64_t n, lapack_complex_float* a );
int64_t LAPACKE_zpftri_64( int matrix_layout, char transr, char uplo,
                           int64_t n, lapack_complex_double* a );

int64_t LAPACKE_spftrs_64( int matrix_layout, char transr, char uplo,
                           int64_t n, int64_t nrhs, const float* a,
                           float* b, int64_t ldb );
int64_t LAPACKE_dpftrs_64( int matrix_layout, char transr, char uplo,
                           int64_t n, int64_t nrhs, const double* a,
                           double* b, int64_t ldb );
int64_t LAPACKE_cpftrs_64( int matrix_layout, char transr, char uplo,
                           int64_t n, int64_t nrhs,
                           const lapack_complex_float* a,
                           lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zpftrs_64( int matrix_layout, char transr, char uplo,
                           int64_t n, int64_t nrhs,
                           const lapack_complex_double* a,
                           lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_spocon_64( int matrix_layout, char uplo, int64_t n,
                           const float* a, int64_t lda, float anorm,
                           float* rcond );
int64_t LAPACKE_dpocon_64( int matrix_layout, char uplo, int64_t n,
                           const double* a, int64_t lda, double anorm,
                           double* rcond );
int64_t LAPACKE_cpocon_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_float* a, int64_t lda,
                           float anorm, float* rcond );
int64_t LAPACKE_zpocon_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_double* a, int64_t lda,
                           double anorm, double* rcond );

int64_t LAPACKE_spoequ_64( int matrix_layout, int64_t n, const float* a,
                           int64_t lda, float* s, float* scond,
                           float* amax );
int64_t LAPACKE_dpoequ_64( int matrix_layout, int64_t n, const double* a,
                           int64_t lda, double* s, double* scond,
                           double* amax );
int64_t LAPACKE_cpoequ_64( int matrix_layout, int64_t n,
                           const lapack_complex_float* a, int64_t lda,
                           float* s, float* scond, float* amax );
int64_t LAPACKE_zpoequ_64( int matrix_layout, int64_t n,
                           const lapack_complex_double* a, int64_t lda,
                           double* s, double* scond, double* amax );

int64_t LAPACKE_spoequb_64( int matrix_layout, int64_t n, const float* a,
                            int64_t lda, float* s, float* scond,
                            float* amax );
int64_t LAPACKE_dpoequb_64( int matrix_layout, int64_t n, const double* a,
                            int64_t lda, double* s, double* scond,
                            double* amax );
int64_t LAPACKE_cpoequb_64( int matrix_layout, int64_t n,
                            const lapack_complex_float* a, int64_t lda,
                            float* s, float* scond, float* amax );
int64_t LAPACKE_zpoequb_64( int matrix_layout, int64_t n,
                            const lapack_complex_double* a, int64_t lda,
                            double* s, double* scond, double* amax );

int64_t LAPACKE_sporfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const float* a, int64_t lda,
                           const float* af, int64_t ldaf, const float* b,
                           int64_t ldb, float* x, int64_t ldx,
                           float* ferr, float* berr );
int64_t LAPACKE_dporfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const double* a, int64_t lda,
                           const double* af, int64_t ldaf, const double* b,
                           int64_t ldb, double* x, int64_t ldx,
                           double* ferr, double* berr );
int64_t LAPACKE_cporfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* a,
                           int64_t lda, const lapack_complex_float* af,
                           int64_t ldaf, const lapack_complex_float* b,
                           int64_t ldb, lapack_complex_float* x,
                           int64_t ldx, float* ferr, float* berr );
int64_t LAPACKE_zporfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* a,
                           int64_t lda, const lapack_complex_double* af,
                           int64_t ldaf, const lapack_complex_double* b,
                           int64_t ldb, lapack_complex_double* x,
                           int64_t ldx, double* ferr, double* berr );

int64_t LAPACKE_sporfsx_64( int matrix_layout, char uplo, char equed,
                            int64_t n, int64_t nrhs, const float* a,
                            int64_t lda, const float* af, int64_t ldaf,
                            const float* s, const float* b, int64_t ldb,
                            float* x, int64_t ldx, float* rcond, float* berr,
                            int64_t n_err_bnds, float* err_bnds_norm,
                            float* err_bnds_comp, int64_t nparams,
                            float* params );
int64_t LAPACKE_dporfsx_64( int matrix_layout, char uplo, char equed,
                            int64_t n, int64_t nrhs, const double* a,
                            int64_t lda, const double* af, int64_t ldaf,
                            const double* s, const double* b, int64_t ldb,
                            double* x, int64_t ldx, double* rcond,
                            double* berr, int64_t n_err_bnds,
                            double* err_bnds_norm, double* err_bnds_comp,
                            int64_t nparams, double* params );
int64_t LAPACKE_cporfsx_64( int matrix_layout, char uplo, char equed,
                            int64_t n, int64_t nrhs,
                            const lapack_complex_float* a, int64_t lda,
                            const lapack_complex_float* af, int64_t ldaf,
                            const float* s, const lapack_complex_float* b,
                            int64_t ldb, lapack_complex_float* x,
                            int64_t ldx, float* rcond, float* berr,
                            int64_t n_err_bnds, float* err_bnds_norm,
                            float* err_bnds_comp, int64_t nparams,
                            float* params );
int64_t LAPACKE_zporfsx_64( int matrix_layout, char uplo, char equed,
                            int64_t n, int64_t nrhs,
                            const lapack_complex_double* a, int64_t lda,
                            const lapack_complex_double* af, int64_t ldaf,
                            const double* s, const lapack_complex_double* b,
                            int64_t ldb, lapack_complex_double* x,
                            int64_t ldx, double* rcond, double* berr,
                            int64_t n_err_bnds, double* err_bnds_norm,
                            double* err_bnds_comp, int64_t nparams,
                            double* params );

int64_t LAPACKE_sposv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, float* a, int64_t lda, float* b,
                          int64_t ldb );
int64_t LAPACKE_dposv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, double* a, int64_t lda, double* b,
                          int64_t ldb );
int64_t LAPACKE_cposv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_float* a,
                          int64_t lda, lapack_complex_float* b,
                          int64_t ldb );
int64_t LAPACKE_zposv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_double* a,
                          int64_t lda, lapack_complex_double* b,
                          int64_t ldb );
int64_t LAPACKE_dsposv_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, double* a, int64_t lda,
                           double* b, int64_t ldb, double* x, int64_t ldx,
                           int64_t* iter );
int64_t LAPACKE_zcposv_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* b,
                           int64_t ldb, lapack_complex_double* x,
                           int64_t ldx, int64_t* iter );

int64_t LAPACKE_sposvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, float* a, int64_t lda, float* af,
                           int64_t ldaf, char* equed, float* s, float* b,
                           int64_t ldb, float* x, int64_t ldx,
                           float* rcond, float* ferr, float* berr );
int64_t LAPACKE_dposvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, double* a, int64_t lda,
                           double* af, int64_t ldaf, char* equed, double* s,
                           double* b, int64_t ldb, double* x, int64_t ldx,
                           double* rcond, double* ferr, double* berr );
int64_t LAPACKE_cposvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* af,
                           int64_t ldaf, char* equed, float* s,
                           lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx,
                           float* rcond, float* ferr, float* berr );
int64_t LAPACKE_zposvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* af,
                           int64_t ldaf, char* equed, double* s,
                           lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* rcond, double* ferr, double* berr );

int64_t LAPACKE_sposvxx_64( int matrix_layout, char fact, char uplo,
                            int64_t n, int64_t nrhs, float* a,
                            int64_t lda, float* af, int64_t ldaf,
                            char* equed, float* s, float* b, int64_t ldb,
                            float* x, int64_t ldx, float* rcond,
                            float* rpvgrw, float* berr, int64_t n_err_bnds,
                            float* err_bnds_norm, float* err_bnds_comp,
                            int64_t nparams, float* params );
int64_t LAPACKE_dposvxx_64( int matrix_layout, char fact, char uplo,
                            int64_t n, int64_t nrhs, double* a,
                            int64_t lda, double* af, int64_t ldaf,
                            char* equed, double* s, double* b, int64_t ldb,
                            double* x, int64_t ldx, double* rcond,
                            double* rpvgrw, double* berr, int64_t n_err_bnds,
                            double* err_bnds_norm, double* err_bnds_comp,
                            int64_t nparams, double* params );
int64_t LAPACKE_cposvxx_64( int matrix_layout, char fact, char uplo,
                            int64_t n, int64_t nrhs,
                            lapack_complex_float* a, int64_t lda,
                            lapack_complex_float* af, int64_t ldaf,
                            char* equed, float* s, lapack_complex_float* b,
                            int64_t ldb, lapack_complex_float* x,
                            int64_t ldx, float* rcond, float* rpvgrw,
                            float* berr, int64_t n_err_bnds,
                            float* err_bnds_norm, float* err_bnds_comp,
                            int64_t nparams, float* params );
int64_t LAPACKE_zposvxx_64( int matrix_layout, char fact, char uplo,
                            int64_t n, int64_t nrhs,
                            lapack_complex_double* a, int64_t lda,
                            lapack_complex_double* af, int64_t ldaf,
                            char* equed, double* s, lapack_complex_double* b,
                            int64_t ldb, lapack_complex_double* x,
                            int64_t ldx, double* rcond, double* rpvgrw,
                            double* berr, int64_t n_err_bnds,
                            double* err_bnds_norm, double* err_bnds_comp,
                            int64_t nparams, double* params );

int64_t LAPACKE_spotrf2_64( int matrix_layout, char uplo, int64_t n, float* a,
                           int64_t lda );
int64_t LAPACKE_dpotrf2_64( int matrix_layout, char uplo, int64_t n, double* a,
                           int64_t lda );
int64_t LAPACKE_cpotrf2_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_zpotrf2_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_spotrf_64( int matrix_layout, char uplo, int64_t n, float* a,
                           int64_t lda );
int64_t LAPACKE_dpotrf_64( int matrix_layout, char uplo, int64_t n, double* a,
                           int64_t lda );
int64_t LAPACKE_cpotrf_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_zpotrf_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_spotri_64( int matrix_layout, char uplo, int64_t n, float* a,
                           int64_t lda );
int64_t LAPACKE_dpotri_64( int matrix_layout, char uplo, int64_t n, double* a,
                           int64_t lda );
int64_t LAPACKE_cpotri_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_zpotri_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_spotrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const float* a, int64_t lda,
                           float* b, int64_t ldb );
int64_t LAPACKE_dpotrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const double* a, int64_t lda,
                           double* b, int64_t ldb );
int64_t LAPACKE_cpotrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* b,
                           int64_t ldb );
int64_t LAPACKE_zpotrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* b,
                           int64_t ldb );

int64_t LAPACKE_sppcon_64( int matrix_layout, char uplo, int64_t n,
                           const float* ap, float anorm, float* rcond );
int64_t LAPACKE_dppcon_64( int matrix_layout, char uplo, int64_t n,
                           const double* ap, double anorm, double* rcond );
int64_t LAPACKE_cppcon_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_float* ap, float anorm,
                           float* rcond );
int64_t LAPACKE_zppcon_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_double* ap, double anorm,
                           double* rcond );

int64_t LAPACKE_sppequ_64( int matrix_layout, char uplo, int64_t n,
                           const float* ap, float* s, float* scond,
                           float* amax );
int64_t LAPACKE_dppequ_64( int matrix_layout, char uplo, int64_t n,
                           const double* ap, double* s, double* scond,
                           double* amax );
int64_t LAPACKE_cppequ_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_float* ap, float* s,
                           float* scond, float* amax );
int64_t LAPACKE_zppequ_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_double* ap, double* s,
                           double* scond, double* amax );

int64_t LAPACKE_spprfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const float* ap, const float* afp,
                           const float* b, int64_t ldb, float* x,
                           int64_t ldx, float* ferr, float* berr );
int64_t LAPACKE_dpprfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const double* ap, const double* afp,
                           const double* b, int64_t ldb, double* x,
                           int64_t ldx, double* ferr, double* berr );
int64_t LAPACKE_cpprfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* ap,
                           const lapack_complex_float* afp,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx, float* ferr,
                           float* berr );
int64_t LAPACKE_zpprfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* ap,
                           const lapack_complex_double* afp,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* ferr, double* berr );

int64_t LAPACKE_sppsv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, float* ap, float* b,
                          int64_t ldb );
int64_t LAPACKE_dppsv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, double* ap, double* b,
                          int64_t ldb );
int64_t LAPACKE_cppsv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_float* ap,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zppsv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_double* ap,
                          lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_sppsvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, float* ap, float* afp, char* equed,
                           float* s, float* b, int64_t ldb, float* x,
                           int64_t ldx, float* rcond, float* ferr,
                           float* berr );
int64_t LAPACKE_dppsvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, double* ap, double* afp,
                           char* equed, double* s, double* b, int64_t ldb,
                           double* x, int64_t ldx, double* rcond,
                           double* ferr, double* berr );
int64_t LAPACKE_cppsvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, lapack_complex_float* ap,
                           lapack_complex_float* afp, char* equed, float* s,
                           lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx,
                           float* rcond, float* ferr, float* berr );
int64_t LAPACKE_zppsvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, lapack_complex_double* ap,
                           lapack_complex_double* afp, char* equed, double* s,
                           lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* rcond, double* ferr, double* berr );

int64_t LAPACKE_spptrf_64( int matrix_layout, char uplo, int64_t n,
                           float* ap );
int64_t LAPACKE_dpptrf_64( int matrix_layout, char uplo, int64_t n,
                           double* ap );
int64_t LAPACKE_cpptrf_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* ap );
int64_t LAPACKE_zpptrf_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* ap );

int64_t LAPACKE_spptri_64( int matrix_layout, char uplo, int64_t n,
                           float* ap );
int64_t LAPACKE_dpptri_64( int matrix_layout, char uplo, int64_t n,
                           double* ap );
int64_t LAPACKE_cpptri_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* ap );
int64_t LAPACKE_zpptri_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* ap );

int64_t LAPACKE_spptrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const float* ap, float* b,
                           int64_t ldb );
int64_t LAPACKE_dpptrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const double* ap, double* b,
                           int64_t ldb );
int64_t LAPACKE_cpptrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* ap,
                           lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zpptrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* ap,
                           lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_spstrf_64( int matrix_layout, char uplo, int64_t n, float* a,
                           int64_t lda, int64_t* piv, int64_t* rank,
                           float tol );
int64_t LAPACKE_dpstrf_64( int matrix_layout, char uplo, int64_t n, double* a,
                           int64_t lda, int64_t* piv, int64_t* rank,
                           double tol );
int64_t LAPACKE_cpstrf_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* piv, int64_t* rank, float tol );
int64_t LAPACKE_zpstrf_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* piv, int64_t* rank, double tol );

int64_t LAPACKE_sptcon_64( int64_t n, const float* d, const float* e,
                           float anorm, float* rcond );
int64_t LAPACKE_dptcon_64( int64_t n, const double* d, const double* e,
                           double anorm, double* rcond );
int64_t LAPACKE_cptcon_64( int64_t n, const float* d,
                           const lapack_complex_float* e, float anorm,
                           float* rcond );
int64_t LAPACKE_zptcon_64( int64_t n, const double* d,
                           const lapack_complex_double* e, double anorm,
                           double* rcond );

int64_t LAPACKE_spteqr_64( int matrix_layout, char compz, int64_t n, float* d,
                           float* e, float* z, int64_t ldz );
int64_t LAPACKE_dpteqr_64( int matrix_layout, char compz, int64_t n,
                           double* d, double* e, double* z, int64_t ldz );
int64_t LAPACKE_cpteqr_64( int matrix_layout, char compz, int64_t n, float* d,
                           float* e, lapack_complex_float* z, int64_t ldz );
int64_t LAPACKE_zpteqr_64( int matrix_layout, char compz, int64_t n,
                           double* d, double* e, lapack_complex_double* z,
                           int64_t ldz );

int64_t LAPACKE_sptrfs_64( int matrix_layout, int64_t n, int64_t nrhs,
                           const float* d, const float* e, const float* df,
                           const float* ef, const float* b, int64_t ldb,
                           float* x, int64_t ldx, float* ferr, float* berr );
int64_t LAPACKE_dptrfs_64( int matrix_layout, int64_t n, int64_t nrhs,
                           const double* d, const double* e, const double* df,
                           const double* ef, const double* b, int64_t ldb,
                           double* x, int64_t ldx, double* ferr,
                           double* berr );
int64_t LAPACKE_cptrfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const float* d,
                           const lapack_complex_float* e, const float* df,
                           const lapack_complex_float* ef,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx, float* ferr,
                           float* berr );
int64_t LAPACKE_zptrfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const double* d,
                           const lapack_complex_double* e, const double* df,
                           const lapack_complex_double* ef,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* ferr, double* berr );

int64_t LAPACKE_sptsv_64( int matrix_layout, int64_t n, int64_t nrhs,
                          float* d, float* e, float* b, int64_t ldb );
int64_t LAPACKE_dptsv_64( int matrix_layout, int64_t n, int64_t nrhs,
                          double* d, double* e, double* b, int64_t ldb );
int64_t LAPACKE_cptsv_64( int matrix_layout, int64_t n, int64_t nrhs,
                          float* d, lapack_complex_float* e,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zptsv_64( int matrix_layout, int64_t n, int64_t nrhs,
                          double* d, lapack_complex_double* e,
                          lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_sptsvx_64( int matrix_layout, char fact, int64_t n,
                           int64_t nrhs, const float* d, const float* e,
                           float* df, float* ef, const float* b, int64_t ldb,
                           float* x, int64_t ldx, float* rcond, float* ferr,
                           float* berr );
int64_t LAPACKE_dptsvx_64( int matrix_layout, char fact, int64_t n,
                           int64_t nrhs, const double* d, const double* e,
                           double* df, double* ef, const double* b,
                           int64_t ldb, double* x, int64_t ldx,
                           double* rcond, double* ferr, double* berr );
int64_t LAPACKE_cptsvx_64( int matrix_layout, char fact, int64_t n,
                           int64_t nrhs, const float* d,
                           const lapack_complex_float* e, float* df,
                           lapack_complex_float* ef,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx,
                           float* rcond, float* ferr, float* berr );
int64_t LAPACKE_zptsvx_64( int matrix_layout, char fact, int64_t n,
                           int64_t nrhs, const double* d,
                           const lapack_complex_double* e, double* df,
                           lapack_complex_double* ef,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* rcond, double* ferr, double* berr );

int64_t LAPACKE_spttrf_64( int64_t n, float* d, float* e );
int64_t LAPACKE_dpttrf_64( int64_t n, double* d, double* e );
int64_t LAPACKE_cpttrf_64( int64_t n, float* d, lapack_complex_float* e );
int64_t LAPACKE_zpttrf_64( int64_t n, double* d, lapack_complex_double* e );

int64_t LAPACKE_spttrs_64( int matrix_layout, int64_t n, int64_t nrhs,
                           const float* d, const float* e, float* b,
                           int64_t ldb );
int64_t LAPACKE_dpttrs_64( int matrix_layout, int64_t n, int64_t nrhs,
                           const double* d, const double* e, double* b,
                           int64_t ldb );
int64_t LAPACKE_cpttrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const float* d,
                           const lapack_complex_float* e,
                           lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zpttrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const double* d,
                           const lapack_complex_double* e,
                           lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_ssbev_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          int64_t kd, float* ab, int64_t ldab, float* w,
                          float* z, int64_t ldz );
int64_t LAPACKE_dsbev_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          int64_t kd, double* ab, int64_t ldab, double* w,
                          double* z, int64_t ldz );

int64_t LAPACKE_ssbevd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           int64_t kd, float* ab, int64_t ldab, float* w,
                           float* z, int64_t ldz );
int64_t LAPACKE_dsbevd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           int64_t kd, double* ab, int64_t ldab,
                           double* w, double* z, int64_t ldz );

int64_t LAPACKE_ssbevx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, int64_t kd, float* ab,
                           int64_t ldab, float* q, int64_t ldq, float vl,
                           float vu, int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, float* z, int64_t ldz,
                           int64_t* ifail );
int64_t LAPACKE_dsbevx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, int64_t kd, double* ab,
                           int64_t ldab, double* q, int64_t ldq,
                           double vl, double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w, double* z,
                           int64_t ldz, int64_t* ifail );

int64_t LAPACKE_ssbgst_64( int matrix_layout, char vect, char uplo, int64_t n,
                           int64_t ka, int64_t kb, float* ab,
                           int64_t ldab, const float* bb, int64_t ldbb,
                           float* x, int64_t ldx );
int64_t LAPACKE_dsbgst_64( int matrix_layout, char vect, char uplo, int64_t n,
                           int64_t ka, int64_t kb, double* ab,
                           int64_t ldab, const double* bb, int64_t ldbb,
                           double* x, int64_t ldx );

int64_t LAPACKE_ssbgv_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          int64_t ka, int64_t kb, float* ab,
                          int64_t ldab, float* bb, int64_t ldbb, float* w,
                          float* z, int64_t ldz );
int64_t LAPACKE_dsbgv_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          int64_t ka, int64_t kb, double* ab,
                          int64_t ldab, double* bb, int64_t ldbb,
                          double* w, double* z, int64_t ldz );

int64_t LAPACKE_ssbgvd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           int64_t ka, int64_t kb, float* ab,
                           int64_t ldab, float* bb, int64_t ldbb,
                           float* w, float* z, int64_t ldz );
int64_t LAPACKE_dsbgvd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           int64_t ka, int64_t kb, double* ab,
                           int64_t ldab, double* bb, int64_t ldbb,
                           double* w, double* z, int64_t ldz );

int64_t LAPACKE_ssbgvx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, int64_t ka, int64_t kb,
                           float* ab, int64_t ldab, float* bb,
                           int64_t ldbb, float* q, int64_t ldq, float vl,
                           float vu, int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, float* z, int64_t ldz,
                           int64_t* ifail );
int64_t LAPACKE_dsbgvx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, int64_t ka, int64_t kb,
                           double* ab, int64_t ldab, double* bb,
                           int64_t ldbb, double* q, int64_t ldq,
                           double vl, double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w, double* z,
                           int64_t ldz, int64_t* ifail );

int64_t LAPACKE_ssbtrd_64( int matrix_layout, char vect, char uplo, int64_t n,
                           int64_t kd, float* ab, int64_t ldab, float* d,
                           float* e, float* q, int64_t ldq );
int64_t LAPACKE_dsbtrd_64( int matrix_layout, char vect, char uplo, int64_t n,
                           int64_t kd, double* ab, int64_t ldab,
                           double* d, double* e, double* q, int64_t ldq );

int64_t LAPACKE_ssfrk_64( int matrix_layout, char transr, char uplo, char trans,
                          int64_t n, int64_t k, float alpha,
                          const float* a, int64_t lda, float beta,
                          float* c );
int64_t LAPACKE_dsfrk_64( int matrix_layout, char transr, char uplo, char trans,
                          int64_t n, int64_t k, double alpha,
                          const double* a, int64_t lda, double beta,
                          double* c );

int64_t LAPACKE_sspcon_64( int matrix_layout, char uplo, int64_t n,
                           const float* ap, const int64_t* ipiv, float anorm,
                           float* rcond );
int64_t LAPACKE_dspcon_64( int matrix_layout, char uplo, int64_t n,
                           const double* ap, const int64_t* ipiv,
                           double anorm, double* rcond );
int64_t LAPACKE_cspcon_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_float* ap,
                           const int64_t* ipiv, float anorm, float* rcond );
int64_t LAPACKE_zspcon_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_double* ap,
                           const int64_t* ipiv, double anorm,
                           double* rcond );

int64_t LAPACKE_sspev_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          float* ap, float* w, float* z, int64_t ldz );
int64_t LAPACKE_dspev_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          double* ap, double* w, double* z, int64_t ldz );

int64_t LAPACKE_sspevd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           float* ap, float* w, float* z, int64_t ldz );
int64_t LAPACKE_dspevd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           double* ap, double* w, double* z, int64_t ldz );

int64_t LAPACKE_sspevx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, float* ap, float vl, float vu,
                           int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, float* z, int64_t ldz,
                           int64_t* ifail );
int64_t LAPACKE_dspevx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, double* ap, double vl, double vu,
                           int64_t il, int64_t iu, double abstol,
                           int64_t* m, double* w, double* z, int64_t ldz,
                           int64_t* ifail );

int64_t LAPACKE_sspgst_64( int matrix_layout, int64_t itype, char uplo,
                           int64_t n, float* ap, const float* bp );
int64_t LAPACKE_dspgst_64( int matrix_layout, int64_t itype, char uplo,
                           int64_t n, double* ap, const double* bp );

int64_t LAPACKE_sspgv_64( int matrix_layout, int64_t itype, char jobz,
                          char uplo, int64_t n, float* ap, float* bp,
                          float* w, float* z, int64_t ldz );
int64_t LAPACKE_dspgv_64( int matrix_layout, int64_t itype, char jobz,
                          char uplo, int64_t n, double* ap, double* bp,
                          double* w, double* z, int64_t ldz );

int64_t LAPACKE_sspgvd_64( int matrix_layout, int64_t itype, char jobz,
                           char uplo, int64_t n, float* ap, float* bp,
                           float* w, float* z, int64_t ldz );
int64_t LAPACKE_dspgvd_64( int matrix_layout, int64_t itype, char jobz,
                           char uplo, int64_t n, double* ap, double* bp,
                           double* w, double* z, int64_t ldz );

int64_t LAPACKE_sspgvx_64( int matrix_layout, int64_t itype, char jobz,
                           char range, char uplo, int64_t n, float* ap,
                           float* bp, float vl, float vu, int64_t il,
                           int64_t iu, float abstol, int64_t* m, float* w,
                           float* z, int64_t ldz, int64_t* ifail );
int64_t LAPACKE_dspgvx_64( int matrix_layout, int64_t itype, char jobz,
                           char range, char uplo, int64_t n, double* ap,
                           double* bp, double vl, double vu, int64_t il,
                           int64_t iu, double abstol, int64_t* m,
                           double* w, double* z, int64_t ldz,
                           int64_t* ifail );

int64_t LAPACKE_ssprfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const float* ap, const float* afp,
                           const int64_t* ipiv, const float* b,
                           int64_t ldb, float* x, int64_t ldx,
                           float* ferr, float* berr );
int64_t LAPACKE_dsprfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const double* ap, const double* afp,
                           const int64_t* ipiv, const double* b,
                           int64_t ldb, double* x, int64_t ldx,
                           double* ferr, double* berr );
int64_t LAPACKE_csprfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* ap,
                           const lapack_complex_float* afp,
                           const int64_t* ipiv,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx, float* ferr,
                           float* berr );
int64_t LAPACKE_zsprfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* ap,
                           const lapack_complex_double* afp,
                           const int64_t* ipiv,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* ferr, double* berr );

int64_t LAPACKE_sspsv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, float* ap, int64_t* ipiv,
                          float* b, int64_t ldb );
int64_t LAPACKE_dspsv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, double* ap, int64_t* ipiv,
                          double* b, int64_t ldb );
int64_t LAPACKE_cspsv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_float* ap,
                          int64_t* ipiv, lapack_complex_float* b,
                          int64_t ldb );
int64_t LAPACKE_zspsv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_double* ap,
                          int64_t* ipiv, lapack_complex_double* b,
                          int64_t ldb );

int64_t LAPACKE_sspsvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, const float* ap, float* afp,
                           int64_t* ipiv, const float* b, int64_t ldb,
                           float* x, int64_t ldx, float* rcond, float* ferr,
                           float* berr );
int64_t LAPACKE_dspsvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, const double* ap, double* afp,
                           int64_t* ipiv, const double* b, int64_t ldb,
                           double* x, int64_t ldx, double* rcond,
                           double* ferr, double* berr );
int64_t LAPACKE_cspsvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* ap,
                           lapack_complex_float* afp, int64_t* ipiv,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx,
                           float* rcond, float* ferr, float* berr );
int64_t LAPACKE_zspsvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* ap,
                           lapack_complex_double* afp, int64_t* ipiv,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* rcond, double* ferr, double* berr );

int64_t LAPACKE_ssptrd_64( int matrix_layout, char uplo, int64_t n, float* ap,
                           float* d, float* e, float* tau );
int64_t LAPACKE_dsptrd_64( int matrix_layout, char uplo, int64_t n,
                           double* ap, double* d, double* e, double* tau );

int64_t LAPACKE_ssptrf_64( int matrix_layout, char uplo, int64_t n, float* ap,
                           int64_t* ipiv );
int64_t LAPACKE_dsptrf_64( int matrix_layout, char uplo, int64_t n,
                           double* ap, int64_t* ipiv );
int64_t LAPACKE_csptrf_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* ap, int64_t* ipiv );
int64_t LAPACKE_zsptrf_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* ap, int64_t* ipiv );

int64_t LAPACKE_ssptri_64( int matrix_layout, char uplo, int64_t n, float* ap,
                           const int64_t* ipiv );
int64_t LAPACKE_dsptri_64( int matrix_layout, char uplo, int64_t n,
                           double* ap, const int64_t* ipiv );
int64_t LAPACKE_csptri_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* ap, const int64_t* ipiv );
int64_t LAPACKE_zsptri_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* ap, const int64_t* ipiv );

int64_t LAPACKE_ssptrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const float* ap,
                           const int64_t* ipiv, float* b, int64_t ldb );
int64_t LAPACKE_dsptrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const double* ap,
                           const int64_t* ipiv, double* b, int64_t ldb );
int64_t LAPACKE_csptrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* ap,
                           const int64_t* ipiv, lapack_complex_float* b,
                           int64_t ldb );
int64_t LAPACKE_zsptrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* ap,
                           const int64_t* ipiv, lapack_complex_double* b,
                           int64_t ldb );

int64_t LAPACKE_sstebz_64( char range, char order, int64_t n, float vl,
                           float vu, int64_t il, int64_t iu, float abstol,
                           const float* d, const float* e, int64_t* m,
                           int64_t* nsplit, float* w, int64_t* iblock,
                           int64_t* isplit );
int64_t LAPACKE_dstebz_64( char range, char order, int64_t n, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, const double* d, const double* e,
                           int64_t* m, int64_t* nsplit, double* w,
                           int64_t* iblock, int64_t* isplit );

int64_t LAPACKE_sstedc_64( int matrix_layout, char compz, int64_t n, float* d,
                           float* e, float* z, int64_t ldz );
int64_t LAPACKE_dstedc_64( int matrix_layout, char compz, int64_t n,
                           double* d, double* e, double* z, int64_t ldz );
int64_t LAPACKE_cstedc_64( int matrix_layout, char compz, int64_t n, float* d,
                           float* e, lapack_complex_float* z, int64_t ldz );
int64_t LAPACKE_zstedc_64( int matrix_layout, char compz, int64_t n,
                           double* d, double* e, lapack_complex_double* z,
                           int64_t ldz );

int64_t LAPACKE_sstegr_64( int matrix_layout, char jobz, char range,
                           int64_t n, float* d, float* e, float vl, float vu,
                           int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, float* z, int64_t ldz,
                           int64_t* isuppz );
int64_t LAPACKE_dstegr_64( int matrix_layout, char jobz, char range,
                           int64_t n, double* d, double* e, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w, double* z,
                           int64_t ldz, int64_t* isuppz );
int64_t LAPACKE_cstegr_64( int matrix_layout, char jobz, char range,
                           int64_t n, float* d, float* e, float vl, float vu,
                           int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, lapack_complex_float* z,
                           int64_t ldz, int64_t* isuppz );
int64_t LAPACKE_zstegr_64( int matrix_layout, char jobz, char range,
                           int64_t n, double* d, double* e, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w,
                           lapack_complex_double* z, int64_t ldz,
                           int64_t* isuppz );

int64_t LAPACKE_sstein_64( int matrix_layout, int64_t n, const float* d,
                           const float* e, int64_t m, const float* w,
                           const int64_t* iblock, const int64_t* isplit,
                           float* z, int64_t ldz, int64_t* ifailv );
int64_t LAPACKE_dstein_64( int matrix_layout, int64_t n, const double* d,
                           const double* e, int64_t m, const double* w,
                           const int64_t* iblock, const int64_t* isplit,
                           double* z, int64_t ldz, int64_t* ifailv );
int64_t LAPACKE_cstein_64( int matrix_layout, int64_t n, const float* d,
                           const float* e, int64_t m, const float* w,
                           const int64_t* iblock, const int64_t* isplit,
                           lapack_complex_float* z, int64_t ldz,
                           int64_t* ifailv );
int64_t LAPACKE_zstein_64( int matrix_layout, int64_t n, const double* d,
                           const double* e, int64_t m, const double* w,
                           const int64_t* iblock, const int64_t* isplit,
                           lapack_complex_double* z, int64_t ldz,
                           int64_t* ifailv );

int64_t LAPACKE_sstemr_64( int matrix_layout, char jobz, char range,
                           int64_t n, float* d, float* e, float vl, float vu,
                           int64_t il, int64_t iu, int64_t* m,
                           float* w, float* z, int64_t ldz, int64_t nzc,
                           int64_t* isuppz, lapack_logical* tryrac );
int64_t LAPACKE_dstemr_64( int matrix_layout, char jobz, char range,
                           int64_t n, double* d, double* e, double vl,
                           double vu, int64_t il, int64_t iu,
                           int64_t* m, double* w, double* z, int64_t ldz,
                           int64_t nzc, int64_t* isuppz,
                           lapack_logical* tryrac );
int64_t LAPACKE_cstemr_64( int matrix_layout, char jobz, char range,
                           int64_t n, float* d, float* e, float vl, float vu,
                           int64_t il, int64_t iu, int64_t* m,
                           float* w, lapack_complex_float* z, int64_t ldz,
                           int64_t nzc, int64_t* isuppz,
                           lapack_logical* tryrac );
int64_t LAPACKE_zstemr_64( int matrix_layout, char jobz, char range,
                           int64_t n, double* d, double* e, double vl,
                           double vu, int64_t il, int64_t iu,
                           int64_t* m, double* w, lapack_complex_double* z,
                           int64_t ldz, int64_t nzc, int64_t* isuppz,
                           lapack_logical* tryrac );

int64_t LAPACKE_ssteqr_64( int matrix_layout, char compz, int64_t n, float* d,
                           float* e, float* z, int64_t ldz );
int64_t LAPACKE_dsteqr_64( int matrix_layout, char compz, int64_t n,
                           double* d, double* e, double* z, int64_t ldz );
int64_t LAPACKE_csteqr_64( int matrix_layout, char compz, int64_t n, float* d,
                           float* e, lapack_complex_float* z, int64_t ldz );
int64_t LAPACKE_zsteqr_64( int matrix_layout, char compz, int64_t n,
                           double* d, double* e, lapack_complex_double* z,
                           int64_t ldz );

int64_t LAPACKE_ssterf_64( int64_t n, float* d, float* e );
int64_t LAPACKE_dsterf_64( int64_t n, double* d, double* e );

int64_t LAPACKE_sstev_64( int matrix_layout, char jobz, int64_t n, float* d,
                          float* e, float* z, int64_t ldz );
int64_t LAPACKE_dstev_64( int matrix_layout, char jobz, int64_t n, double* d,
                          double* e, double* z, int64_t ldz );

int64_t LAPACKE_sstevd_64( int matrix_layout, char jobz, int64_t n, float* d,
                           float* e, float* z, int64_t ldz );
int64_t LAPACKE_dstevd_64( int matrix_layout, char jobz, int64_t n, double* d,
                           double* e, double* z, int64_t ldz );

int64_t LAPACKE_sstevr_64( int matrix_layout, char jobz, char range,
                           int64_t n, float* d, float* e, float vl, float vu,
                           int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, float* z, int64_t ldz,
                           int64_t* isuppz );
int64_t LAPACKE_dstevr_64( int matrix_layout, char jobz, char range,
                           int64_t n, double* d, double* e, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w, double* z,
                           int64_t ldz, int64_t* isuppz );

int64_t LAPACKE_sstevx_64( int matrix_layout, char jobz, char range,
                           int64_t n, float* d, float* e, float vl, float vu,
                           int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, float* z, int64_t ldz,
                           int64_t* ifail );
int64_t LAPACKE_dstevx_64( int matrix_layout, char jobz, char range,
                           int64_t n, double* d, double* e, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w, double* z,
                           int64_t ldz, int64_t* ifail );

int64_t LAPACKE_ssycon_64( int matrix_layout, char uplo, int64_t n,
                           const float* a, int64_t lda,
                           const int64_t* ipiv, float anorm, float* rcond );
int64_t LAPACKE_dsycon_64( int matrix_layout, char uplo, int64_t n,
                           const double* a, int64_t lda,
                           const int64_t* ipiv, double anorm,
                           double* rcond );
int64_t LAPACKE_csycon_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_float* a, int64_t lda,
                           const int64_t* ipiv, float anorm, float* rcond );
int64_t LAPACKE_zsycon_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_double* a, int64_t lda,
                           const int64_t* ipiv, double anorm,
                           double* rcond );

int64_t LAPACKE_ssyequb_64( int matrix_layout, char uplo, int64_t n,
                            const float* a, int64_t lda, float* s,
                            float* scond, float* amax );
int64_t LAPACKE_dsyequb_64( int matrix_layout, char uplo, int64_t n,
                            const double* a, int64_t lda, double* s,
                            double* scond, double* amax );
int64_t LAPACKE_csyequb_64( int matrix_layout, char uplo, int64_t n,
                            const lapack_complex_float* a, int64_t lda,
                            float* s, float* scond, float* amax );
int64_t LAPACKE_zsyequb_64( int matrix_layout, char uplo, int64_t n,
                            const lapack_complex_double* a, int64_t lda,
                            double* s, double* scond, double* amax );

int64_t LAPACKE_ssyev_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          float* a, int64_t lda, float* w );
int64_t LAPACKE_dsyev_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          double* a, int64_t lda, double* w );

int64_t LAPACKE_ssyevd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           float* a, int64_t lda, float* w );
int64_t LAPACKE_dsyevd_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           double* a, int64_t lda, double* w );

int64_t LAPACKE_ssyevr_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, float* a, int64_t lda, float vl,
                           float vu, int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, float* z, int64_t ldz,
                           int64_t* isuppz );
int64_t LAPACKE_dsyevr_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, double* a, int64_t lda, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w, double* z,
                           int64_t ldz, int64_t* isuppz );

int64_t LAPACKE_ssyevx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, float* a, int64_t lda, float vl,
                           float vu, int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, float* z, int64_t ldz,
                           int64_t* ifail );
int64_t LAPACKE_dsyevx_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, double* a, int64_t lda, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w, double* z,
                           int64_t ldz, int64_t* ifail );

int64_t LAPACKE_ssygst_64( int matrix_layout, int64_t itype, char uplo,
                           int64_t n, float* a, int64_t lda,
                           const float* b, int64_t ldb );
int64_t LAPACKE_dsygst_64( int matrix_layout, int64_t itype, char uplo,
                           int64_t n, double* a, int64_t lda,
                           const double* b, int64_t ldb );

int64_t LAPACKE_ssygv_64( int matrix_layout, int64_t itype, char jobz,
                          char uplo, int64_t n, float* a, int64_t lda,
                          float* b, int64_t ldb, float* w );
int64_t LAPACKE_dsygv_64( int matrix_layout, int64_t itype, char jobz,
                          char uplo, int64_t n, double* a, int64_t lda,
                          double* b, int64_t ldb, double* w );

int64_t LAPACKE_ssygvd_64( int matrix_layout, int64_t itype, char jobz,
                           char uplo, int64_t n, float* a, int64_t lda,
                           float* b, int64_t ldb, float* w );
int64_t LAPACKE_dsygvd_64( int matrix_layout, int64_t itype, char jobz,
                           char uplo, int64_t n, double* a, int64_t lda,
                           double* b, int64_t ldb, double* w );

int64_t LAPACKE_ssygvx_64( int matrix_layout, int64_t itype, char jobz,
                           char range, char uplo, int64_t n, float* a,
                           int64_t lda, float* b, int64_t ldb, float vl,
                           float vu, int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, float* z, int64_t ldz,
                           int64_t* ifail );
int64_t LAPACKE_dsygvx_64( int matrix_layout, int64_t itype, char jobz,
                           char range, char uplo, int64_t n, double* a,
                           int64_t lda, double* b, int64_t ldb, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w, double* z,
                           int64_t ldz, int64_t* ifail );

int64_t LAPACKE_ssyrfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const float* a, int64_t lda,
                           const float* af, int64_t ldaf,
                           const int64_t* ipiv, const float* b,
                           int64_t ldb, float* x, int64_t ldx,
                           float* ferr, float* berr );
int64_t LAPACKE_dsyrfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const double* a, int64_t lda,
                           const double* af, int64_t ldaf,
                           const int64_t* ipiv, const double* b,
                           int64_t ldb, double* x, int64_t ldx,
                           double* ferr, double* berr );
int64_t LAPACKE_csyrfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* a,
                           int64_t lda, const lapack_complex_float* af,
                           int64_t ldaf, const int64_t* ipiv,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx, float* ferr,
                           float* berr );
int64_t LAPACKE_zsyrfs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* a,
                           int64_t lda, const lapack_complex_double* af,
                           int64_t ldaf, const int64_t* ipiv,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* ferr, double* berr );

int64_t LAPACKE_ssyrfsx_64( int matrix_layout, char uplo, char equed,
                            int64_t n, int64_t nrhs, const float* a,
                            int64_t lda, const float* af, int64_t ldaf,
                            const int64_t* ipiv, const float* s,
                            const float* b, int64_t ldb, float* x,
                            int64_t ldx, float* rcond, float* berr,
                            int64_t n_err_bnds, float* err_bnds_norm,
                            float* err_bnds_comp, int64_t nparams,
                            float* params );
int64_t LAPACKE_dsyrfsx_64( int matrix_layout, char uplo, char equed,
                            int64_t n, int64_t nrhs, const double* a,
                            int64_t lda, const double* af, int64_t ldaf,
                            const int64_t* ipiv, const double* s,
                            const double* b, int64_t ldb, double* x,
                            int64_t ldx, double* rcond, double* berr,
                            int64_t n_err_bnds, double* err_bnds_norm,
                            double* err_bnds_comp, int64_t nparams,
                            double* params );
int64_t LAPACKE_csyrfsx_64( int matrix_layout, char uplo, char equed,
                            int64_t n, int64_t nrhs,
                            const lapack_complex_float* a, int64_t lda,
                            const lapack_complex_float* af, int64_t ldaf,
                            const int64_t* ipiv, const float* s,
                            const lapack_complex_float* b, int64_t ldb,
                            lapack_complex_float* x, int64_t ldx,
                            float* rcond, float* berr, int64_t n_err_bnds,
                            float* err_bnds_norm, float* err_bnds_comp,
                            int64_t nparams, float* params );
int64_t LAPACKE_zsyrfsx_64( int matrix_layout, char uplo, char equed,
                            int64_t n, int64_t nrhs,
                            const lapack_complex_double* a, int64_t lda,
                            const lapack_complex_double* af, int64_t ldaf,
                            const int64_t* ipiv, const double* s,
                            const lapack_complex_double* b, int64_t ldb,
                            lapack_complex_double* x, int64_t ldx,
                            double* rcond, double* berr, int64_t n_err_bnds,
                            double* err_bnds_norm, double* err_bnds_comp,
                            int64_t nparams, double* params );

int64_t LAPACKE_ssysv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, float* a, int64_t lda,
                          int64_t* ipiv, float* b, int64_t ldb );
int64_t LAPACKE_dsysv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, double* a, int64_t lda,
                          int64_t* ipiv, double* b, int64_t ldb );
int64_t LAPACKE_csysv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_float* a,
                          int64_t lda, int64_t* ipiv,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zsysv_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_double* a,
                          int64_t lda, int64_t* ipiv,
                          lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_ssysvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, const float* a, int64_t lda,
                           float* af, int64_t ldaf, int64_t* ipiv,
                           const float* b, int64_t ldb, float* x,
                           int64_t ldx, float* rcond, float* ferr,
                           float* berr );
int64_t LAPACKE_dsysvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, const double* a, int64_t lda,
                           double* af, int64_t ldaf, int64_t* ipiv,
                           const double* b, int64_t ldb, double* x,
                           int64_t ldx, double* rcond, double* ferr,
                           double* berr );
int64_t LAPACKE_csysvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* af,
                           int64_t ldaf, int64_t* ipiv,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* x, int64_t ldx,
                           float* rcond, float* ferr, float* berr );
int64_t LAPACKE_zsysvx_64( int matrix_layout, char fact, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* af,
                           int64_t ldaf, int64_t* ipiv,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* x, int64_t ldx,
                           double* rcond, double* ferr, double* berr );

int64_t LAPACKE_ssysvxx_64( int matrix_layout, char fact, char uplo,
                            int64_t n, int64_t nrhs, float* a,
                            int64_t lda, float* af, int64_t ldaf,
                            int64_t* ipiv, char* equed, float* s, float* b,
                            int64_t ldb, float* x, int64_t ldx,
                            float* rcond, float* rpvgrw, float* berr,
                            int64_t n_err_bnds, float* err_bnds_norm,
                            float* err_bnds_comp, int64_t nparams,
                            float* params );
int64_t LAPACKE_dsysvxx_64( int matrix_layout, char fact, char uplo,
                            int64_t n, int64_t nrhs, double* a,
                            int64_t lda, double* af, int64_t ldaf,
                            int64_t* ipiv, char* equed, double* s, double* b,
                            int64_t ldb, double* x, int64_t ldx,
                            double* rcond, double* rpvgrw, double* berr,
                            int64_t n_err_bnds, double* err_bnds_norm,
                            double* err_bnds_comp, int64_t nparams,
                            double* params );
int64_t LAPACKE_csysvxx_64( int matrix_layout, char fact, char uplo,
                            int64_t n, int64_t nrhs,
                            lapack_complex_float* a, int64_t lda,
                            lapack_complex_float* af, int64_t ldaf,
                            int64_t* ipiv, char* equed, float* s,
                            lapack_complex_float* b, int64_t ldb,
                            lapack_complex_float* x, int64_t ldx,
                            float* rcond, float* rpvgrw, float* berr,
                            int64_t n_err_bnds, float* err_bnds_norm,
                            float* err_bnds_comp, int64_t nparams,
                            float* params );
int64_t LAPACKE_zsysvxx_64( int matrix_layout, char fact, char uplo,
                            int64_t n, int64_t nrhs,
                            lapack_complex_double* a, int64_t lda,
                            lapack_complex_double* af, int64_t ldaf,
                            int64_t* ipiv, char* equed, double* s,
                            lapack_complex_double* b, int64_t ldb,
                            lapack_complex_double* x, int64_t ldx,
                            double* rcond, double* rpvgrw, double* berr,
                            int64_t n_err_bnds, double* err_bnds_norm,
                            double* err_bnds_comp, int64_t nparams,
                            double* params );

int64_t LAPACKE_ssytrd_64( int matrix_layout, char uplo, int64_t n, float* a,
                           int64_t lda, float* d, float* e, float* tau );
int64_t LAPACKE_dsytrd_64( int matrix_layout, char uplo, int64_t n, double* a,
                           int64_t lda, double* d, double* e, double* tau );

int64_t LAPACKE_ssytrf_64( int matrix_layout, char uplo, int64_t n, float* a,
                           int64_t lda, int64_t* ipiv );
int64_t LAPACKE_dsytrf_64( int matrix_layout, char uplo, int64_t n, double* a,
                           int64_t lda, int64_t* ipiv );
int64_t LAPACKE_csytrf_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* ipiv );
int64_t LAPACKE_zsytrf_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* ipiv );

int64_t LAPACKE_ssytri_64( int matrix_layout, char uplo, int64_t n, float* a,
                           int64_t lda, const int64_t* ipiv );
int64_t LAPACKE_dsytri_64( int matrix_layout, char uplo, int64_t n, double* a,
                           int64_t lda, const int64_t* ipiv );
int64_t LAPACKE_csytri_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           const int64_t* ipiv );
int64_t LAPACKE_zsytri_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           const int64_t* ipiv );

int64_t LAPACKE_ssytrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const float* a, int64_t lda,
                           const int64_t* ipiv, float* b, int64_t ldb );
int64_t LAPACKE_dsytrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const double* a, int64_t lda,
                           const int64_t* ipiv, double* b, int64_t ldb );
int64_t LAPACKE_csytrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* a,
                           int64_t lda, const int64_t* ipiv,
                           lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zsytrs_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* a,
                           int64_t lda, const int64_t* ipiv,
                           lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_stbcon_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t n, int64_t kd, const float* ab,
                           int64_t ldab, float* rcond );
int64_t LAPACKE_dtbcon_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t n, int64_t kd, const double* ab,
                           int64_t ldab, double* rcond );
int64_t LAPACKE_ctbcon_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t n, int64_t kd,
                           const lapack_complex_float* ab, int64_t ldab,
                           float* rcond );
int64_t LAPACKE_ztbcon_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t n, int64_t kd,
                           const lapack_complex_double* ab, int64_t ldab,
                           double* rcond );

int64_t LAPACKE_stbrfs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t kd, int64_t nrhs,
                           const float* ab, int64_t ldab, const float* b,
                           int64_t ldb, const float* x, int64_t ldx,
                           float* ferr, float* berr );
int64_t LAPACKE_dtbrfs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t kd, int64_t nrhs,
                           const double* ab, int64_t ldab, const double* b,
                           int64_t ldb, const double* x, int64_t ldx,
                           double* ferr, double* berr );
int64_t LAPACKE_ctbrfs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t kd, int64_t nrhs,
                           const lapack_complex_float* ab, int64_t ldab,
                           const lapack_complex_float* b, int64_t ldb,
                           const lapack_complex_float* x, int64_t ldx,
                           float* ferr, float* berr );
int64_t LAPACKE_ztbrfs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t kd, int64_t nrhs,
                           const lapack_complex_double* ab, int64_t ldab,
                           const lapack_complex_double* b, int64_t ldb,
                           const lapack_complex_double* x, int64_t ldx,
                           double* ferr, double* berr );

int64_t LAPACKE_stbtrs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t kd, int64_t nrhs,
                           const float* ab, int64_t ldab, float* b,
                           int64_t ldb );
int64_t LAPACKE_dtbtrs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t kd, int64_t nrhs,
                           const double* ab, int64_t ldab, double* b,
                           int64_t ldb );
int64_t LAPACKE_ctbtrs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t kd, int64_t nrhs,
                           const lapack_complex_float* ab, int64_t ldab,
                           lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_ztbtrs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t kd, int64_t nrhs,
                           const lapack_complex_double* ab, int64_t ldab,
                           lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_stfsm_64( int matrix_layout, char transr, char side, char uplo,
                          char trans, char diag, int64_t m, int64_t n,
                          float alpha, const float* a, float* b,
                          int64_t ldb );
int64_t LAPACKE_dtfsm_64( int matrix_layout, char transr, char side, char uplo,
                          char trans, char diag, int64_t m, int64_t n,
                          double alpha, const double* a, double* b,
                          int64_t ldb );
int64_t LAPACKE_ctfsm_64( int matrix_layout, char transr, char side, char uplo,
                          char trans, char diag, int64_t m, int64_t n,
                          lapack_complex_float alpha,
                          const lapack_complex_float* a,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_ztfsm_64( int matrix_layout, char transr, char side, char uplo,
                          char trans, char diag, int64_t m, int64_t n,
                          lapack_complex_double alpha,
                          const lapack_complex_double* a,
                          lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_stftri_64( int matrix_layout, char transr, char uplo, char diag,
                           int64_t n, float* a );
int64_t LAPACKE_dtftri_64( int matrix_layout, char transr, char uplo, char diag,
                           int64_t n, double* a );
int64_t LAPACKE_ctftri_64( int matrix_layout, char transr, char uplo, char diag,
                           int64_t n, lapack_complex_float* a );
int64_t LAPACKE_ztftri_64( int matrix_layout, char transr, char uplo, char diag,
                           int64_t n, lapack_complex_double* a );

int64_t LAPACKE_stfttp_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const float* arf, float* ap );
int64_t LAPACKE_dtfttp_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const double* arf, double* ap );
int64_t LAPACKE_ctfttp_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const lapack_complex_float* arf,
                           lapack_complex_float* ap );
int64_t LAPACKE_ztfttp_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const lapack_complex_double* arf,
                           lapack_complex_double* ap );

int64_t LAPACKE_stfttr_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const float* arf, float* a,
                           int64_t lda );
int64_t LAPACKE_dtfttr_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const double* arf, double* a,
                           int64_t lda );
int64_t LAPACKE_ctfttr_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const lapack_complex_float* arf,
                           lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_ztfttr_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const lapack_complex_double* arf,
                           lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_stgevc_64( int matrix_layout, char side, char howmny,
                           const lapack_logical* select, int64_t n,
                           const float* s, int64_t lds, const float* p,
                           int64_t ldp, float* vl, int64_t ldvl,
                           float* vr, int64_t ldvr, int64_t mm,
                           int64_t* m );
int64_t LAPACKE_dtgevc_64( int matrix_layout, char side, char howmny,
                           const lapack_logical* select, int64_t n,
                           const double* s, int64_t lds, const double* p,
                           int64_t ldp, double* vl, int64_t ldvl,
                           double* vr, int64_t ldvr, int64_t mm,
                           int64_t* m );
int64_t LAPACKE_ctgevc_64( int matrix_layout, char side, char howmny,
                           const lapack_logical* select, int64_t n,
                           const lapack_complex_float* s, int64_t lds,
                           const lapack_complex_float* p, int64_t ldp,
                           lapack_complex_float* vl, int64_t ldvl,
                           lapack_complex_float* vr, int64_t ldvr,
                           int64_t mm, int64_t* m );
int64_t LAPACKE_ztgevc_64( int matrix_layout, char side, char howmny,
                           const lapack_logical* select, int64_t n,
                           const lapack_complex_double* s, int64_t lds,
                           const lapack_complex_double* p, int64_t ldp,
                           lapack_complex_double* vl, int64_t ldvl,
                           lapack_complex_double* vr, int64_t ldvr,
                           int64_t mm, int64_t* m );

int64_t LAPACKE_stgexc_64( int matrix_layout, lapack_logical wantq,
                           lapack_logical wantz, int64_t n, float* a,
                           int64_t lda, float* b, int64_t ldb, float* q,
                           int64_t ldq, float* z, int64_t ldz,
                           int64_t* ifst, int64_t* ilst );
int64_t LAPACKE_dtgexc_64( int matrix_layout, lapack_logical wantq,
                           lapack_logical wantz, int64_t n, double* a,
                           int64_t lda, double* b, int64_t ldb, double* q,
                           int64_t ldq, double* z, int64_t ldz,
                           int64_t* ifst, int64_t* ilst );
int64_t LAPACKE_ctgexc_64( int matrix_layout, lapack_logical wantq,
                           lapack_logical wantz, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* q, int64_t ldq,
                           lapack_complex_float* z, int64_t ldz,
                           int64_t ifst, int64_t ilst );
int64_t LAPACKE_ztgexc_64( int matrix_layout, lapack_logical wantq,
                           lapack_logical wantz, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* q, int64_t ldq,
                           lapack_complex_double* z, int64_t ldz,
                           int64_t ifst, int64_t ilst );

int64_t LAPACKE_stgsen_64( int matrix_layout, int64_t ijob,
                           lapack_logical wantq, lapack_logical wantz,
                           const lapack_logical* select, int64_t n, float* a,
                           int64_t lda, float* b, int64_t ldb,
                           float* alphar, float* alphai, float* beta, float* q,
                           int64_t ldq, float* z, int64_t ldz,
                           int64_t* m, float* pl, float* pr, float* dif );
int64_t LAPACKE_dtgsen_64( int matrix_layout, int64_t ijob,
                           lapack_logical wantq, lapack_logical wantz,
                           const lapack_logical* select, int64_t n,
                           double* a, int64_t lda, double* b, int64_t ldb,
                           double* alphar, double* alphai, double* beta,
                           double* q, int64_t ldq, double* z, int64_t ldz,
                           int64_t* m, double* pl, double* pr, double* dif );
int64_t LAPACKE_ctgsen_64( int matrix_layout, int64_t ijob,
                           lapack_logical wantq, lapack_logical wantz,
                           const lapack_logical* select, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* alpha,
                           lapack_complex_float* beta, lapack_complex_float* q,
                           int64_t ldq, lapack_complex_float* z,
                           int64_t ldz, int64_t* m, float* pl, float* pr,
                           float* dif );
int64_t LAPACKE_ztgsen_64( int matrix_layout, int64_t ijob,
                           lapack_logical wantq, lapack_logical wantz,
                           const lapack_logical* select, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* alpha,
                           lapack_complex_double* beta,
                           lapack_complex_double* q, int64_t ldq,
                           lapack_complex_double* z, int64_t ldz,
                           int64_t* m, double* pl, double* pr, double* dif );

int64_t LAPACKE_stgsja_64( int matrix_layout, char jobu, char jobv, char jobq,
                           int64_t m, int64_t p, int64_t n,
                           int64_t k, int64_t l, float* a, int64_t lda,
                           float* b, int64_t ldb, float tola, float tolb,
                           float* alpha, float* beta, float* u, int64_t ldu,
                           float* v, int64_t ldv, float* q, int64_t ldq,
                           int64_t* ncycle );
int64_t LAPACKE_dtgsja_64( int matrix_layout, char jobu, char jobv, char jobq,
                           int64_t m, int64_t p, int64_t n,
                           int64_t k, int64_t l, double* a,
                           int64_t lda, double* b, int64_t ldb,
                           double tola, double tolb, double* alpha,
                           double* beta, double* u, int64_t ldu, double* v,
                           int64_t ldv, double* q, int64_t ldq,
                           int64_t* ncycle );
int64_t LAPACKE_ctgsja_64( int matrix_layout, char jobu, char jobv, char jobq,
                           int64_t m, int64_t p, int64_t n,
                           int64_t k, int64_t l, lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* b,
                           int64_t ldb, float tola, float tolb, float* alpha,
                           float* beta, lapack_complex_float* u, int64_t ldu,
                           lapack_complex_float* v, int64_t ldv,
                           lapack_complex_float* q, int64_t ldq,
                           int64_t* ncycle );
int64_t LAPACKE_ztgsja_64( int matrix_layout, char jobu, char jobv, char jobq,
                           int64_t m, int64_t p, int64_t n,
                           int64_t k, int64_t l, lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* b,
                           int64_t ldb, double tola, double tolb,
                           double* alpha, double* beta,
                           lapack_complex_double* u, int64_t ldu,
                           lapack_complex_double* v, int64_t ldv,
                           lapack_complex_double* q, int64_t ldq,
                           int64_t* ncycle );

int64_t LAPACKE_stgsna_64( int matrix_layout, char job, char howmny,
                           const lapack_logical* select, int64_t n,
                           const float* a, int64_t lda, const float* b,
                           int64_t ldb, const float* vl, int64_t ldvl,
                           const float* vr, int64_t ldvr, float* s,
                           float* dif, int64_t mm, int64_t* m );
int64_t LAPACKE_dtgsna_64( int matrix_layout, char job, char howmny,
                           const lapack_logical* select, int64_t n,
                           const double* a, int64_t lda, const double* b,
                           int64_t ldb, const double* vl, int64_t ldvl,
                           const double* vr, int64_t ldvr, double* s,
                           double* dif, int64_t mm, int64_t* m );
int64_t LAPACKE_ctgsna_64( int matrix_layout, char job, char howmny,
                           const lapack_logical* select, int64_t n,
                           const lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* b, int64_t ldb,
                           const lapack_complex_float* vl, int64_t ldvl,
                           const lapack_complex_float* vr, int64_t ldvr,
                           float* s, float* dif, int64_t mm, int64_t* m );
int64_t LAPACKE_ztgsna_64( int matrix_layout, char job, char howmny,
                           const lapack_logical* select, int64_t n,
                           const lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* b, int64_t ldb,
                           const lapack_complex_double* vl, int64_t ldvl,
                           const lapack_complex_double* vr, int64_t ldvr,
                           double* s, double* dif, int64_t mm,
                           int64_t* m );

int64_t LAPACKE_stgsyl_64( int matrix_layout, char trans, int64_t ijob,
                           int64_t m, int64_t n, const float* a,
                           int64_t lda, const float* b, int64_t ldb,
                           float* c, int64_t ldc, const float* d,
                           int64_t ldd, const float* e, int64_t lde,
                           float* f, int64_t ldf, float* scale, float* dif );
int64_t LAPACKE_dtgsyl_64( int matrix_layout, char trans, int64_t ijob,
                           int64_t m, int64_t n, const double* a,
                           int64_t lda, const double* b, int64_t ldb,
                           double* c, int64_t ldc, const double* d,
                           int64_t ldd, const double* e, int64_t lde,
                           double* f, int64_t ldf, double* scale,
                           double* dif );
int64_t LAPACKE_ctgsyl_64( int matrix_layout, char trans, int64_t ijob,
                           int64_t m, int64_t n,
                           const lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* c, int64_t ldc,
                           const lapack_complex_float* d, int64_t ldd,
                           const lapack_complex_float* e, int64_t lde,
                           lapack_complex_float* f, int64_t ldf,
                           float* scale, float* dif );
int64_t LAPACKE_ztgsyl_64( int matrix_layout, char trans, int64_t ijob,
                           int64_t m, int64_t n,
                           const lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* c, int64_t ldc,
                           const lapack_complex_double* d, int64_t ldd,
                           const lapack_complex_double* e, int64_t lde,
                           lapack_complex_double* f, int64_t ldf,
                           double* scale, double* dif );

int64_t LAPACKE_stpcon_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t n, const float* ap, float* rcond );
int64_t LAPACKE_dtpcon_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t n, const double* ap, double* rcond );
int64_t LAPACKE_ctpcon_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t n, const lapack_complex_float* ap,
                           float* rcond );
int64_t LAPACKE_ztpcon_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t n, const lapack_complex_double* ap,
                           double* rcond );

int64_t LAPACKE_stprfs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs, const float* ap,
                           const float* b, int64_t ldb, const float* x,
                           int64_t ldx, float* ferr, float* berr );
int64_t LAPACKE_dtprfs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs, const double* ap,
                           const double* b, int64_t ldb, const double* x,
                           int64_t ldx, double* ferr, double* berr );
int64_t LAPACKE_ctprfs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs,
                           const lapack_complex_float* ap,
                           const lapack_complex_float* b, int64_t ldb,
                           const lapack_complex_float* x, int64_t ldx,
                           float* ferr, float* berr );
int64_t LAPACKE_ztprfs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs,
                           const lapack_complex_double* ap,
                           const lapack_complex_double* b, int64_t ldb,
                           const lapack_complex_double* x, int64_t ldx,
                           double* ferr, double* berr );

int64_t LAPACKE_stptri_64( int matrix_layout, char uplo, char diag, int64_t n,
                           float* ap );
int64_t LAPACKE_dtptri_64( int matrix_layout, char uplo, char diag, int64_t n,
                           double* ap );
int64_t LAPACKE_ctptri_64( int matrix_layout, char uplo, char diag, int64_t n,
                           lapack_complex_float* ap );
int64_t LAPACKE_ztptri_64( int matrix_layout, char uplo, char diag, int64_t n,
                           lapack_complex_double* ap );

int64_t LAPACKE_stptrs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs, const float* ap,
                           float* b, int64_t ldb );
int64_t LAPACKE_dtptrs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs, const double* ap,
                           double* b, int64_t ldb );
int64_t LAPACKE_ctptrs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs,
                           const lapack_complex_float* ap,
                           lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_ztptrs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs,
                           const lapack_complex_double* ap,
                           lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_stpttf_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const float* ap, float* arf );
int64_t LAPACKE_dtpttf_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const double* ap, double* arf );
int64_t LAPACKE_ctpttf_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const lapack_complex_float* ap,
                           lapack_complex_float* arf );
int64_t LAPACKE_ztpttf_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const lapack_complex_double* ap,
                           lapack_complex_double* arf );

int64_t LAPACKE_stpttr_64( int matrix_layout, char uplo, int64_t n,
                           const float* ap, float* a, int64_t lda );
int64_t LAPACKE_dtpttr_64( int matrix_layout, char uplo, int64_t n,
                           const double* ap, double* a, int64_t lda );
int64_t LAPACKE_ctpttr_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_float* ap,
                           lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_ztpttr_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_double* ap,
                           lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_strcon_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t n, const float* a, int64_t lda,
                           float* rcond );
int64_t LAPACKE_dtrcon_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t n, const double* a, int64_t lda,
                           double* rcond );
int64_t LAPACKE_ctrcon_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t n, const lapack_complex_float* a,
                           int64_t lda, float* rcond );
int64_t LAPACKE_ztrcon_64( int matrix_layout, char norm, char uplo, char diag,
                           int64_t n, const lapack_complex_double* a,
                           int64_t lda, double* rcond );

int64_t LAPACKE_strevc_64( int matrix_layout, char side, char howmny,
                           lapack_logical* select, int64_t n, const float* t,
                           int64_t ldt, float* vl, int64_t ldvl,
                           float* vr, int64_t ldvr, int64_t mm,
                           int64_t* m );
int64_t LAPACKE_dtrevc_64( int matrix_layout, char side, char howmny,
                           lapack_logical* select, int64_t n,
                           const double* t, int64_t ldt, double* vl,
                           int64_t ldvl, double* vr, int64_t ldvr,
                           int64_t mm, int64_t* m );
int64_t LAPACKE_ctrevc_64( int matrix_layout, char side, char howmny,
                           const lapack_logical* select, int64_t n,
                           lapack_complex_float* t, int64_t ldt,
                           lapack_complex_float* vl, int64_t ldvl,
                           lapack_complex_float* vr, int64_t ldvr,
                           int64_t mm, int64_t* m );
int64_t LAPACKE_ztrevc_64( int matrix_layout, char side, char howmny,
                           const lapack_logical* select, int64_t n,
                           lapack_complex_double* t, int64_t ldt,
                           lapack_complex_double* vl, int64_t ldvl,
                           lapack_complex_double* vr, int64_t ldvr,
                           int64_t mm, int64_t* m );

int64_t LAPACKE_strexc_64( int matrix_layout, char compq, int64_t n, float* t,
                           int64_t ldt, float* q, int64_t ldq,
                           int64_t* ifst, int64_t* ilst );
int64_t LAPACKE_dtrexc_64( int matrix_layout, char compq, int64_t n,
                           double* t, int64_t ldt, double* q, int64_t ldq,
                           int64_t* ifst, int64_t* ilst );
int64_t LAPACKE_ctrexc_64( int matrix_layout, char compq, int64_t n,
                           lapack_complex_float* t, int64_t ldt,
                           lapack_complex_float* q, int64_t ldq,
                           int64_t ifst, int64_t ilst );
int64_t LAPACKE_ztrexc_64( int matrix_layout, char compq, int64_t n,
                           lapack_complex_double* t, int64_t ldt,
                           lapack_complex_double* q, int64_t ldq,
                           int64_t ifst, int64_t ilst );

int64_t LAPACKE_strrfs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs, const float* a,
                           int64_t lda, const float* b, int64_t ldb,
                           const float* x, int64_t ldx, float* ferr,
                           float* berr );
int64_t LAPACKE_dtrrfs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs, const double* a,
                           int64_t lda, const double* b, int64_t ldb,
                           const double* x, int64_t ldx, double* ferr,
                           double* berr );
int64_t LAPACKE_ctrrfs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs,
                           const lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* b, int64_t ldb,
                           const lapack_complex_float* x, int64_t ldx,
                           float* ferr, float* berr );
int64_t LAPACKE_ztrrfs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs,
                           const lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* b, int64_t ldb,
                           const lapack_complex_double* x, int64_t ldx,
                           double* ferr, double* berr );

int64_t LAPACKE_strsen_64( int matrix_layout, char job, char compq,
                           const lapack_logical* select, int64_t n, float* t,
                           int64_t ldt, float* q, int64_t ldq, float* wr,
                           float* wi, int64_t* m, float* s, float* sep );
int64_t LAPACKE_dtrsen_64( int matrix_layout, char job, char compq,
                           const lapack_logical* select, int64_t n,
                           double* t, int64_t ldt, double* q, int64_t ldq,
                           double* wr, double* wi, int64_t* m, double* s,
                           double* sep );
int64_t LAPACKE_ctrsen_64( int matrix_layout, char job, char compq,
                           const lapack_logical* select, int64_t n,
                           lapack_complex_float* t, int64_t ldt,
                           lapack_complex_float* q, int64_t ldq,
                           lapack_complex_float* w, int64_t* m, float* s,
                           float* sep );
int64_t LAPACKE_ztrsen_64( int matrix_layout, char job, char compq,
                           const lapack_logical* select, int64_t n,
                           lapack_complex_double* t, int64_t ldt,
                           lapack_complex_double* q, int64_t ldq,
                           lapack_complex_double* w, int64_t* m, double* s,
                           double* sep );

int64_t LAPACKE_strsna_64( int matrix_layout, char job, char howmny,
                           const lapack_logical* select, int64_t n,
                           const float* t, int64_t ldt, const float* vl,
                           int64_t ldvl, const float* vr, int64_t ldvr,
                           float* s, float* sep, int64_t mm, int64_t* m );
int64_t LAPACKE_dtrsna_64( int matrix_layout, char job, char howmny,
                           const lapack_logical* select, int64_t n,
                           const double* t, int64_t ldt, const double* vl,
                           int64_t ldvl, const double* vr, int64_t ldvr,
                           double* s, double* sep, int64_t mm,
                           int64_t* m );
int64_t LAPACKE_ctrsna_64( int matrix_layout, char job, char howmny,
                           const lapack_logical* select, int64_t n,
                           const lapack_complex_float* t, int64_t ldt,
                           const lapack_complex_float* vl, int64_t ldvl,
                           const lapack_complex_float* vr, int64_t ldvr,
                           float* s, float* sep, int64_t mm, int64_t* m );
int64_t LAPACKE_ztrsna_64( int matrix_layout, char job, char howmny,
                           const lapack_logical* select, int64_t n,
                           const lapack_complex_double* t, int64_t ldt,
                           const lapack_complex_double* vl, int64_t ldvl,
                           const lapack_complex_double* vr, int64_t ldvr,
                           double* s, double* sep, int64_t mm,
                           int64_t* m );

int64_t LAPACKE_strsyl_64( int matrix_layout, char trana, char tranb,
                           int64_t isgn, int64_t m, int64_t n,
                           const float* a, int64_t lda, const float* b,
                           int64_t ldb, float* c, int64_t ldc,
                           float* scale );
int64_t LAPACKE_dtrsyl_64( int matrix_layout, char trana, char tranb,
                           int64_t isgn, int64_t m, int64_t n,
                           const double* a, int64_t lda, const double* b,
                           int64_t ldb, double* c, int64_t ldc,
                           double* scale );
int64_t LAPACKE_ctrsyl_64( int matrix_layout, char trana, char tranb,
                           int64_t isgn, int64_t m, int64_t n,
                           const lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* c, int64_t ldc,
                           float* scale );
int64_t LAPACKE_ztrsyl_64( int matrix_layout, char trana, char tranb,
                           int64_t isgn, int64_t m, int64_t n,
                           const lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* c, int64_t ldc,
                           double* scale );

int64_t LAPACKE_strsyl3_64( int matrix_layout, char trana, char tranb,
                            int64_t isgn, int64_t m, int64_t n,
                            const float* a, int64_t lda, const float* b,
                            int64_t ldb, float* c, int64_t ldc,
                            float* scale );
int64_t LAPACKE_dtrsyl3_64( int matrix_layout, char trana, char tranb,
                            int64_t isgn, int64_t m, int64_t n,
                            const double* a, int64_t lda, const double* b,
                            int64_t ldb, double* c, int64_t ldc,
                            double* scale );
int64_t LAPACKE_ztrsyl3_64( int matrix_layout, char trana, char tranb,
                            int64_t isgn, int64_t m, int64_t n,
                            const lapack_complex_double* a, int64_t lda,
                            const lapack_complex_double* b, int64_t ldb,
                            lapack_complex_double* c, int64_t ldc,
                            double* scale );

int64_t LAPACKE_strtri_64( int matrix_layout, char uplo, char diag, int64_t n,
                           float* a, int64_t lda );
int64_t LAPACKE_dtrtri_64( int matrix_layout, char uplo, char diag, int64_t n,
                           double* a, int64_t lda );
int64_t LAPACKE_ctrtri_64( int matrix_layout, char uplo, char diag, int64_t n,
                           lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_ztrtri_64( int matrix_layout, char uplo, char diag, int64_t n,
                           lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_strtrs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs, const float* a,
                           int64_t lda, float* b, int64_t ldb );
int64_t LAPACKE_dtrtrs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs, const double* a,
                           int64_t lda, double* b, int64_t ldb );
int64_t LAPACKE_ctrtrs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs,
                           const lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_ztrtrs_64( int matrix_layout, char uplo, char trans, char diag,
                           int64_t n, int64_t nrhs,
                           const lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_strttf_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const float* a, int64_t lda,
                           float* arf );
int64_t LAPACKE_dtrttf_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const double* a, int64_t lda,
                           double* arf );
int64_t LAPACKE_ctrttf_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* arf );
int64_t LAPACKE_ztrttf_64( int matrix_layout, char transr, char uplo,
                           int64_t n, const lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* arf );

int64_t LAPACKE_strttp_64( int matrix_layout, char uplo, int64_t n,
                           const float* a, int64_t lda, float* ap );
int64_t LAPACKE_dtrttp_64( int matrix_layout, char uplo, int64_t n,
                           const double* a, int64_t lda, double* ap );
int64_t LAPACKE_ctrttp_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* ap );
int64_t LAPACKE_ztrttp_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* ap );

int64_t LAPACKE_stzrzf_64( int matrix_layout, int64_t m, int64_t n,
                           float* a, int64_t lda, float* tau );
int64_t LAPACKE_dtzrzf_64( int matrix_layout, int64_t m, int64_t n,
                           double* a, int64_t lda, double* tau );
int64_t LAPACKE_ctzrzf_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* tau );
int64_t LAPACKE_ztzrzf_64( int matrix_layout, int64_t m, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* tau );

int64_t LAPACKE_cungbr_64( int matrix_layout, char vect, int64_t m,
                           int64_t n, int64_t k, lapack_complex_float* a,
                           int64_t lda, const lapack_complex_float* tau );
int64_t LAPACKE_zungbr_64( int matrix_layout, char vect, int64_t m,
                           int64_t n, int64_t k, lapack_complex_double* a,
                           int64_t lda, const lapack_complex_double* tau );

int64_t LAPACKE_cunghr_64( int matrix_layout, int64_t n, int64_t ilo,
                           int64_t ihi, lapack_complex_float* a,
                           int64_t lda, const lapack_complex_float* tau );
int64_t LAPACKE_zunghr_64( int matrix_layout, int64_t n, int64_t ilo,
                           int64_t ihi, lapack_complex_double* a,
                           int64_t lda, const lapack_complex_double* tau );

int64_t LAPACKE_cunglq_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, lapack_complex_float* a,
                           int64_t lda, const lapack_complex_float* tau );
int64_t LAPACKE_zunglq_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, lapack_complex_double* a,
                           int64_t lda, const lapack_complex_double* tau );

int64_t LAPACKE_cungql_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, lapack_complex_float* a,
                           int64_t lda, const lapack_complex_float* tau );
int64_t LAPACKE_zungql_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, lapack_complex_double* a,
                           int64_t lda, const lapack_complex_double* tau );

int64_t LAPACKE_cungqr_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, lapack_complex_float* a,
                           int64_t lda, const lapack_complex_float* tau );
int64_t LAPACKE_zungqr_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, lapack_complex_double* a,
                           int64_t lda, const lapack_complex_double* tau );

int64_t LAPACKE_cungrq_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, lapack_complex_float* a,
                           int64_t lda, const lapack_complex_float* tau );
int64_t LAPACKE_zungrq_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t k, lapack_complex_double* a,
                           int64_t lda, const lapack_complex_double* tau );

int64_t LAPACKE_cungtr_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* tau );
int64_t LAPACKE_zungtr_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* tau );

int64_t LAPACKE_cungtsqr_row_64( int matrix_layout, int64_t m, int64_t n,
                                 int64_t mb, int64_t nb,
                                 lapack_complex_float* a, int64_t lda,
                                 const lapack_complex_float* t, int64_t ldt );
int64_t LAPACKE_zungtsqr_row_64( int matrix_layout, int64_t m, int64_t n,
                                 int64_t mb, int64_t nb,
                                 lapack_complex_double* a, int64_t lda,
                                 const lapack_complex_double* t, int64_t ldt );

int64_t LAPACKE_cunmbr_64( int matrix_layout, char vect, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* tau,
                           lapack_complex_float* c, int64_t ldc );
int64_t LAPACKE_zunmbr_64( int matrix_layout, char vect, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* tau,
                           lapack_complex_double* c, int64_t ldc );

int64_t LAPACKE_cunmhr_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t ilo,
                           int64_t ihi, const lapack_complex_float* a,
                           int64_t lda, const lapack_complex_float* tau,
                           lapack_complex_float* c, int64_t ldc );
int64_t LAPACKE_zunmhr_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t ilo,
                           int64_t ihi, const lapack_complex_double* a,
                           int64_t lda, const lapack_complex_double* tau,
                           lapack_complex_double* c, int64_t ldc );

int64_t LAPACKE_cunmlq_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* tau,
                           lapack_complex_float* c, int64_t ldc );
int64_t LAPACKE_zunmlq_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* tau,
                           lapack_complex_double* c, int64_t ldc );

int64_t LAPACKE_cunmql_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* tau,
                           lapack_complex_float* c, int64_t ldc );
int64_t LAPACKE_zunmql_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* tau,
                           lapack_complex_double* c, int64_t ldc );

int64_t LAPACKE_cunmqr_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* tau,
                           lapack_complex_float* c, int64_t ldc );
int64_t LAPACKE_zunmqr_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* tau,
                           lapack_complex_double* c, int64_t ldc );

int64_t LAPACKE_cunmrq_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* tau,
                           lapack_complex_float* c, int64_t ldc );
int64_t LAPACKE_zunmrq_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* tau,
                           lapack_complex_double* c, int64_t ldc );

int64_t LAPACKE_cunmrz_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           int64_t l, const lapack_complex_float* a,
                           int64_t lda, const lapack_complex_float* tau,
                           lapack_complex_float* c, int64_t ldc );
int64_t LAPACKE_zunmrz_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           int64_t l, const lapack_complex_double* a,
                           int64_t lda, const lapack_complex_double* tau,
                           lapack_complex_double* c, int64_t ldc );

int64_t LAPACKE_cunmtr_64( int matrix_layout, char side, char uplo, char trans,
                           int64_t m, int64_t n,
                           const lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* tau,
                           lapack_complex_float* c, int64_t ldc );
int64_t LAPACKE_zunmtr_64( int matrix_layout, char side, char uplo, char trans,
                           int64_t m, int64_t n,
                           const lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* tau,
                           lapack_complex_double* c, int64_t ldc );

int64_t LAPACKE_cupgtr_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_float* ap,
                           const lapack_complex_float* tau,
                           lapack_complex_float* q, int64_t ldq );
int64_t LAPACKE_zupgtr_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_double* ap,
                           const lapack_complex_double* tau,
                           lapack_complex_double* q, int64_t ldq );

int64_t LAPACKE_cupmtr_64( int matrix_layout, char side, char uplo, char trans,
                           int64_t m, int64_t n,
                           const lapack_complex_float* ap,
                           const lapack_complex_float* tau,
                           lapack_complex_float* c, int64_t ldc );
int64_t LAPACKE_zupmtr_64( int matrix_layout, char side, char uplo, char trans,
                           int64_t m, int64_t n,
                           const lapack_complex_double* ap,
                           const lapack_complex_double* tau,
                           lapack_complex_double* c, int64_t ldc );

int64_t LAPACKE_sbdsdc_work_64( int matrix_layout, char uplo, char compq,
                                int64_t n, float* d, float* e, float* u,
                                int64_t ldu, float* vt, int64_t ldvt,
                                float* q, int64_t* iq, float* work,
                                int64_t* iwork );
int64_t LAPACKE_dbdsdc_work_64( int matrix_layout, char uplo, char compq,
                                int64_t n, double* d, double* e, double* u,
                                int64_t ldu, double* vt, int64_t ldvt,
                                double* q, int64_t* iq, double* work,
                                int64_t* iwork );

int64_t LAPACKE_sbdsvdx_work_64( int matrix_layout, char uplo, char jobz, char range,
                                 int64_t n, float* d, float* e,
                                 float vl, float vu,
                                 int64_t il, int64_t iu, int64_t* ns,
                                 float* s, float* z, int64_t ldz,
                                 float* work, int64_t* iwork );
int64_t LAPACKE_dbdsvdx_work_64( int matrix_layout, char uplo, char jobz, char range,
                                 int64_t n, double* d, double* e,
                                 double vl, double vu,
                                 int64_t il, int64_t iu, int64_t* ns,
                                 double* s, double* z, int64_t ldz,
                                 double* work, int64_t* iwork );

int64_t LAPACKE_sbdsqr_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t ncvt, int64_t nru, int64_t ncc,
                                float* d, float* e, float* vt, int64_t ldvt,
                                float* u, int64_t ldu, float* c,
                                int64_t ldc, float* work );
int64_t LAPACKE_dbdsqr_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t ncvt, int64_t nru, int64_t ncc,
                                double* d, double* e, double* vt,
                                int64_t ldvt, double* u, int64_t ldu,
                                double* c, int64_t ldc, double* work );
int64_t LAPACKE_cbdsqr_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t ncvt, int64_t nru, int64_t ncc,
                                float* d, float* e, lapack_complex_float* vt,
                                int64_t ldvt, lapack_complex_float* u,
                                int64_t ldu, lapack_complex_float* c,
                                int64_t ldc, float* work );
int64_t LAPACKE_zbdsqr_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t ncvt, int64_t nru, int64_t ncc,
                                double* d, double* e, lapack_complex_double* vt,
                                int64_t ldvt, lapack_complex_double* u,
                                int64_t ldu, lapack_complex_double* c,
                                int64_t ldc, double* work );

int64_t LAPACKE_sdisna_work_64( char job, int64_t m, int64_t n,
                                const float* d, float* sep );
int64_t LAPACKE_ddisna_work_64( char job, int64_t m, int64_t n,
                                const double* d, double* sep );

int64_t LAPACKE_sgbbrd_work_64( int matrix_layout, char vect, int64_t m,
                                int64_t n, int64_t ncc, int64_t kl,
                                int64_t ku, float* ab, int64_t ldab,
                                float* d, float* e, float* q, int64_t ldq,
                                float* pt, int64_t ldpt, float* c,
                                int64_t ldc, float* work );
int64_t LAPACKE_dgbbrd_work_64( int matrix_layout, char vect, int64_t m,
                                int64_t n, int64_t ncc, int64_t kl,
                                int64_t ku, double* ab, int64_t ldab,
                                double* d, double* e, double* q, int64_t ldq,
                                double* pt, int64_t ldpt, double* c,
                                int64_t ldc, double* work );
int64_t LAPACKE_cgbbrd_work_64( int matrix_layout, char vect, int64_t m,
                                int64_t n, int64_t ncc, int64_t kl,
                                int64_t ku, lapack_complex_float* ab,
                                int64_t ldab, float* d, float* e,
                                lapack_complex_float* q, int64_t ldq,
                                lapack_complex_float* pt, int64_t ldpt,
                                lapack_complex_float* c, int64_t ldc,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zgbbrd_work_64( int matrix_layout, char vect, int64_t m,
                                int64_t n, int64_t ncc, int64_t kl,
                                int64_t ku, lapack_complex_double* ab,
                                int64_t ldab, double* d, double* e,
                                lapack_complex_double* q, int64_t ldq,
                                lapack_complex_double* pt, int64_t ldpt,
                                lapack_complex_double* c, int64_t ldc,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_sgbcon_work_64( int matrix_layout, char norm, int64_t n,
                                int64_t kl, int64_t ku, const float* ab,
                                int64_t ldab, const int64_t* ipiv,
                                float anorm, float* rcond, float* work,
                                int64_t* iwork );
int64_t LAPACKE_dgbcon_work_64( int matrix_layout, char norm, int64_t n,
                                int64_t kl, int64_t ku, const double* ab,
                                int64_t ldab, const int64_t* ipiv,
                                double anorm, double* rcond, double* work,
                                int64_t* iwork );
int64_t LAPACKE_cgbcon_work_64( int matrix_layout, char norm, int64_t n,
                                int64_t kl, int64_t ku,
                                const lapack_complex_float* ab, int64_t ldab,
                                const int64_t* ipiv, float anorm,
                                float* rcond, lapack_complex_float* work,
                                float* rwork );
int64_t LAPACKE_zgbcon_work_64( int matrix_layout, char norm, int64_t n,
                                int64_t kl, int64_t ku,
                                const lapack_complex_double* ab,
                                int64_t ldab, const int64_t* ipiv,
                                double anorm, double* rcond,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_sgbequ_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t kl, int64_t ku, const float* ab,
                                int64_t ldab, float* r, float* c,
                                float* rowcnd, float* colcnd, float* amax );
int64_t LAPACKE_dgbequ_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t kl, int64_t ku, const double* ab,
                                int64_t ldab, double* r, double* c,
                                double* rowcnd, double* colcnd, double* amax );
int64_t LAPACKE_cgbequ_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t kl, int64_t ku,
                                const lapack_complex_float* ab, int64_t ldab,
                                float* r, float* c, float* rowcnd,
                                float* colcnd, float* amax );
int64_t LAPACKE_zgbequ_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t kl, int64_t ku,
                                const lapack_complex_double* ab,
                                int64_t ldab, double* r, double* c,
                                double* rowcnd, double* colcnd, double* amax );

int64_t LAPACKE_sgbequb_work_64( int matrix_layout, int64_t m, int64_t n,
                                 int64_t kl, int64_t ku, const float* ab,
                                 int64_t ldab, float* r, float* c,
                                 float* rowcnd, float* colcnd, float* amax );
int64_t LAPACKE_dgbequb_work_64( int matrix_layout, int64_t m, int64_t n,
                                 int64_t kl, int64_t ku, const double* ab,
                                 int64_t ldab, double* r, double* c,
                                 double* rowcnd, double* colcnd, double* amax );
int64_t LAPACKE_cgbequb_work_64( int matrix_layout, int64_t m, int64_t n,
                                 int64_t kl, int64_t ku,
                                 const lapack_complex_float* ab,
                                 int64_t ldab, float* r, float* c,
                                 float* rowcnd, float* colcnd, float* amax );
int64_t LAPACKE_zgbequb_work_64( int matrix_layout, int64_t m, int64_t n,
                                 int64_t kl, int64_t ku,
                                 const lapack_complex_double* ab,
                                 int64_t ldab, double* r, double* c,
                                 double* rowcnd, double* colcnd, double* amax );

int64_t LAPACKE_sgbrfs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t kl, int64_t ku, int64_t nrhs,
                                const float* ab, int64_t ldab,
                                const float* afb, int64_t ldafb,
                                const int64_t* ipiv, const float* b,
                                int64_t ldb, float* x, int64_t ldx,
                                float* ferr, float* berr, float* work,
                                int64_t* iwork );
int64_t LAPACKE_dgbrfs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t kl, int64_t ku, int64_t nrhs,
                                const double* ab, int64_t ldab,
                                const double* afb, int64_t ldafb,
                                const int64_t* ipiv, const double* b,
                                int64_t ldb, double* x, int64_t ldx,
                                double* ferr, double* berr, double* work,
                                int64_t* iwork );
int64_t LAPACKE_cgbrfs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t kl, int64_t ku, int64_t nrhs,
                                const lapack_complex_float* ab, int64_t ldab,
                                const lapack_complex_float* afb,
                                int64_t ldafb, const int64_t* ipiv,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* x, int64_t ldx,
                                float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zgbrfs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t kl, int64_t ku, int64_t nrhs,
                                const lapack_complex_double* ab,
                                int64_t ldab,
                                const lapack_complex_double* afb,
                                int64_t ldafb, const int64_t* ipiv,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_sgbrfsx_work_64( int matrix_layout, char trans, char equed,
                                 int64_t n, int64_t kl, int64_t ku,
                                 int64_t nrhs, const float* ab,
                                 int64_t ldab, const float* afb,
                                 int64_t ldafb, const int64_t* ipiv,
                                 const float* r, const float* c, const float* b,
                                 int64_t ldb, float* x, int64_t ldx,
                                 float* rcond, float* berr,
                                 int64_t n_err_bnds, float* err_bnds_norm,
                                 float* err_bnds_comp, int64_t nparams,
                                 float* params, float* work,
                                 int64_t* iwork );
int64_t LAPACKE_dgbrfsx_work_64( int matrix_layout, char trans, char equed,
                                 int64_t n, int64_t kl, int64_t ku,
                                 int64_t nrhs, const double* ab,
                                 int64_t ldab, const double* afb,
                                 int64_t ldafb, const int64_t* ipiv,
                                 const double* r, const double* c,
                                 const double* b, int64_t ldb, double* x,
                                 int64_t ldx, double* rcond, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, double* work,
                                 int64_t* iwork );
int64_t LAPACKE_cgbrfsx_work_64( int matrix_layout, char trans, char equed,
                                 int64_t n, int64_t kl, int64_t ku,
                                 int64_t nrhs,
                                 const lapack_complex_float* ab,
                                 int64_t ldab,
                                 const lapack_complex_float* afb,
                                 int64_t ldafb, const int64_t* ipiv,
                                 const float* r, const float* c,
                                 const lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* x, int64_t ldx,
                                 float* rcond, float* berr,
                                 int64_t n_err_bnds, float* err_bnds_norm,
                                 float* err_bnds_comp, int64_t nparams,
                                 float* params, lapack_complex_float* work,
                                 float* rwork );
int64_t LAPACKE_zgbrfsx_work_64( int matrix_layout, char trans, char equed,
                                 int64_t n, int64_t kl, int64_t ku,
                                 int64_t nrhs,
                                 const lapack_complex_double* ab,
                                 int64_t ldab,
                                 const lapack_complex_double* afb,
                                 int64_t ldafb, const int64_t* ipiv,
                                 const double* r, const double* c,
                                 const lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* x, int64_t ldx,
                                 double* rcond, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, lapack_complex_double* work,
                                 double* rwork );

int64_t LAPACKE_sgbsv_work_64( int matrix_layout, int64_t n, int64_t kl,
                               int64_t ku, int64_t nrhs, float* ab,
                               int64_t ldab, int64_t* ipiv, float* b,
                               int64_t ldb );
int64_t LAPACKE_dgbsv_work_64( int matrix_layout, int64_t n, int64_t kl,
                               int64_t ku, int64_t nrhs, double* ab,
                               int64_t ldab, int64_t* ipiv, double* b,
                               int64_t ldb );
int64_t LAPACKE_cgbsv_work_64( int matrix_layout, int64_t n, int64_t kl,
                               int64_t ku, int64_t nrhs,
                               lapack_complex_float* ab, int64_t ldab,
                               int64_t* ipiv, lapack_complex_float* b,
                               int64_t ldb );
int64_t LAPACKE_zgbsv_work_64( int matrix_layout, int64_t n, int64_t kl,
                               int64_t ku, int64_t nrhs,
                               lapack_complex_double* ab, int64_t ldab,
                               int64_t* ipiv, lapack_complex_double* b,
                               int64_t ldb );

int64_t LAPACKE_sgbsvx_work_64( int matrix_layout, char fact, char trans,
                                int64_t n, int64_t kl, int64_t ku,
                                int64_t nrhs, float* ab, int64_t ldab,
                                float* afb, int64_t ldafb, int64_t* ipiv,
                                char* equed, float* r, float* c, float* b,
                                int64_t ldb, float* x, int64_t ldx,
                                float* rcond, float* ferr, float* berr,
                                float* work, int64_t* iwork );
int64_t LAPACKE_dgbsvx_work_64( int matrix_layout, char fact, char trans,
                                int64_t n, int64_t kl, int64_t ku,
                                int64_t nrhs, double* ab, int64_t ldab,
                                double* afb, int64_t ldafb, int64_t* ipiv,
                                char* equed, double* r, double* c, double* b,
                                int64_t ldb, double* x, int64_t ldx,
                                double* rcond, double* ferr, double* berr,
                                double* work, int64_t* iwork );
int64_t LAPACKE_cgbsvx_work_64( int matrix_layout, char fact, char trans,
                                int64_t n, int64_t kl, int64_t ku,
                                int64_t nrhs, lapack_complex_float* ab,
                                int64_t ldab, lapack_complex_float* afb,
                                int64_t ldafb, int64_t* ipiv, char* equed,
                                float* r, float* c, lapack_complex_float* b,
                                int64_t ldb, lapack_complex_float* x,
                                int64_t ldx, float* rcond, float* ferr,
                                float* berr, lapack_complex_float* work,
                                float* rwork );
int64_t LAPACKE_zgbsvx_work_64( int matrix_layout, char fact, char trans,
                                int64_t n, int64_t kl, int64_t ku,
                                int64_t nrhs, lapack_complex_double* ab,
                                int64_t ldab, lapack_complex_double* afb,
                                int64_t ldafb, int64_t* ipiv, char* equed,
                                double* r, double* c, lapack_complex_double* b,
                                int64_t ldb, lapack_complex_double* x,
                                int64_t ldx, double* rcond, double* ferr,
                                double* berr, lapack_complex_double* work,
                                double* rwork );

int64_t LAPACKE_sgbsvxx_work_64( int matrix_layout, char fact, char trans,
                                 int64_t n, int64_t kl, int64_t ku,
                                 int64_t nrhs, float* ab, int64_t ldab,
                                 float* afb, int64_t ldafb, int64_t* ipiv,
                                 char* equed, float* r, float* c, float* b,
                                 int64_t ldb, float* x, int64_t ldx,
                                 float* rcond, float* rpvgrw, float* berr,
                                 int64_t n_err_bnds, float* err_bnds_norm,
                                 float* err_bnds_comp, int64_t nparams,
                                 float* params, float* work,
                                 int64_t* iwork );
int64_t LAPACKE_dgbsvxx_work_64( int matrix_layout, char fact, char trans,
                                 int64_t n, int64_t kl, int64_t ku,
                                 int64_t nrhs, double* ab, int64_t ldab,
                                 double* afb, int64_t ldafb,
                                 int64_t* ipiv, char* equed, double* r,
                                 double* c, double* b, int64_t ldb,
                                 double* x, int64_t ldx, double* rcond,
                                 double* rpvgrw, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, double* work,
                                 int64_t* iwork );
int64_t LAPACKE_cgbsvxx_work_64( int matrix_layout, char fact, char trans,
                                 int64_t n, int64_t kl, int64_t ku,
                                 int64_t nrhs, lapack_complex_float* ab,
                                 int64_t ldab, lapack_complex_float* afb,
                                 int64_t ldafb, int64_t* ipiv,
                                 char* equed, float* r, float* c,
                                 lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* x, int64_t ldx,
                                 float* rcond, float* rpvgrw, float* berr,
                                 int64_t n_err_bnds, float* err_bnds_norm,
                                 float* err_bnds_comp, int64_t nparams,
                                 float* params, lapack_complex_float* work,
                                 float* rwork );
int64_t LAPACKE_zgbsvxx_work_64( int matrix_layout, char fact, char trans,
                                 int64_t n, int64_t kl, int64_t ku,
                                 int64_t nrhs, lapack_complex_double* ab,
                                 int64_t ldab, lapack_complex_double* afb,
                                 int64_t ldafb, int64_t* ipiv,
                                 char* equed, double* r, double* c,
                                 lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* x, int64_t ldx,
                                 double* rcond, double* rpvgrw, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, lapack_complex_double* work,
                                 double* rwork );

int64_t LAPACKE_sgbtrf_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t kl, int64_t ku, float* ab,
                                int64_t ldab, int64_t* ipiv );
int64_t LAPACKE_dgbtrf_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t kl, int64_t ku, double* ab,
                                int64_t ldab, int64_t* ipiv );
int64_t LAPACKE_cgbtrf_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t kl, int64_t ku,
                                lapack_complex_float* ab, int64_t ldab,
                                int64_t* ipiv );
int64_t LAPACKE_zgbtrf_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t kl, int64_t ku,
                                lapack_complex_double* ab, int64_t ldab,
                                int64_t* ipiv );

int64_t LAPACKE_sgbtrs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t kl, int64_t ku, int64_t nrhs,
                                const float* ab, int64_t ldab,
                                const int64_t* ipiv, float* b,
                                int64_t ldb );
int64_t LAPACKE_dgbtrs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t kl, int64_t ku, int64_t nrhs,
                                const double* ab, int64_t ldab,
                                const int64_t* ipiv, double* b,
                                int64_t ldb );
int64_t LAPACKE_cgbtrs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t kl, int64_t ku, int64_t nrhs,
                                const lapack_complex_float* ab, int64_t ldab,
                                const int64_t* ipiv, lapack_complex_float* b,
                                int64_t ldb );
int64_t LAPACKE_zgbtrs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t kl, int64_t ku, int64_t nrhs,
                                const lapack_complex_double* ab,
                                int64_t ldab, const int64_t* ipiv,
                                lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_sgebak_work_64( int matrix_layout, char job, char side,
                                int64_t n, int64_t ilo, int64_t ihi,
                                const float* scale, int64_t m, float* v,
                                int64_t ldv );
int64_t LAPACKE_dgebak_work_64( int matrix_layout, char job, char side,
                                int64_t n, int64_t ilo, int64_t ihi,
                                const double* scale, int64_t m, double* v,
                                int64_t ldv );
int64_t LAPACKE_cgebak_work_64( int matrix_layout, char job, char side,
                                int64_t n, int64_t ilo, int64_t ihi,
                                const float* scale, int64_t m,
                                lapack_complex_float* v, int64_t ldv );
int64_t LAPACKE_zgebak_work_64( int matrix_layout, char job, char side,
                                int64_t n, int64_t ilo, int64_t ihi,
                                const double* scale, int64_t m,
                                lapack_complex_double* v, int64_t ldv );

int64_t LAPACKE_sgebal_work_64( int matrix_layout, char job, int64_t n,
                                float* a, int64_t lda, int64_t* ilo,
                                int64_t* ihi, float* scale );
int64_t LAPACKE_dgebal_work_64( int matrix_layout, char job, int64_t n,
                                double* a, int64_t lda, int64_t* ilo,
                                int64_t* ihi, double* scale );
int64_t LAPACKE_cgebal_work_64( int matrix_layout, char job, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                int64_t* ilo, int64_t* ihi,
                                float* scale );
int64_t LAPACKE_zgebal_work_64( int matrix_layout, char job, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* ilo, int64_t* ihi,
                                double* scale );

int64_t LAPACKE_sgebrd_work_64( int matrix_layout, int64_t m, int64_t n,
                                float* a, int64_t lda, float* d, float* e,
                                float* tauq, float* taup, float* work,
                                int64_t lwork );
int64_t LAPACKE_dgebrd_work_64( int matrix_layout, int64_t m, int64_t n,
                                double* a, int64_t lda, double* d, double* e,
                                double* tauq, double* taup, double* work,
                                int64_t lwork );
int64_t LAPACKE_cgebrd_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                float* d, float* e, lapack_complex_float* tauq,
                                lapack_complex_float* taup,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgebrd_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                double* d, double* e,
                                lapack_complex_double* tauq,
                                lapack_complex_double* taup,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgecon_work_64( int matrix_layout, char norm, int64_t n,
                                const float* a, int64_t lda, float anorm,
                                float* rcond, float* work, int64_t* iwork );
int64_t LAPACKE_dgecon_work_64( int matrix_layout, char norm, int64_t n,
                                const double* a, int64_t lda, double anorm,
                                double* rcond, double* work,
                                int64_t* iwork );
int64_t LAPACKE_cgecon_work_64( int matrix_layout, char norm, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                float anorm, float* rcond,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zgecon_work_64( int matrix_layout, char norm, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                double anorm, double* rcond,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_sgeequ_work_64( int matrix_layout, int64_t m, int64_t n,
                                const float* a, int64_t lda, float* r,
                                float* c, float* rowcnd, float* colcnd,
                                float* amax );
int64_t LAPACKE_dgeequ_work_64( int matrix_layout, int64_t m, int64_t n,
                                const double* a, int64_t lda, double* r,
                                double* c, double* rowcnd, double* colcnd,
                                double* amax );
int64_t LAPACKE_cgeequ_work_64( int matrix_layout, int64_t m, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                float* r, float* c, float* rowcnd,
                                float* colcnd, float* amax );
int64_t LAPACKE_zgeequ_work_64( int matrix_layout, int64_t m, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                double* r, double* c, double* rowcnd,
                                double* colcnd, double* amax );

int64_t LAPACKE_sgeequb_work_64( int matrix_layout, int64_t m, int64_t n,
                                 const float* a, int64_t lda, float* r,
                                 float* c, float* rowcnd, float* colcnd,
                                 float* amax );
int64_t LAPACKE_dgeequb_work_64( int matrix_layout, int64_t m, int64_t n,
                                 const double* a, int64_t lda, double* r,
                                 double* c, double* rowcnd, double* colcnd,
                                 double* amax );
int64_t LAPACKE_cgeequb_work_64( int matrix_layout, int64_t m, int64_t n,
                                 const lapack_complex_float* a, int64_t lda,
                                 float* r, float* c, float* rowcnd,
                                 float* colcnd, float* amax );
int64_t LAPACKE_zgeequb_work_64( int matrix_layout, int64_t m, int64_t n,
                                 const lapack_complex_double* a, int64_t lda,
                                 double* r, double* c, double* rowcnd,
                                 double* colcnd, double* amax );

int64_t LAPACKE_sgees_work_64( int matrix_layout, char jobvs, char sort,
                               LAPACK_S_SELECT2 select, int64_t n, float* a,
                               int64_t lda, int64_t* sdim, float* wr,
                               float* wi, float* vs, int64_t ldvs,
                               float* work, int64_t lwork,
                               lapack_logical* bwork );
int64_t LAPACKE_dgees_work_64( int matrix_layout, char jobvs, char sort,
                               LAPACK_D_SELECT2 select, int64_t n, double* a,
                               int64_t lda, int64_t* sdim, double* wr,
                               double* wi, double* vs, int64_t ldvs,
                               double* work, int64_t lwork,
                               lapack_logical* bwork );
int64_t LAPACKE_cgees_work_64( int matrix_layout, char jobvs, char sort,
                               LAPACK_C_SELECT1 select, int64_t n,
                               lapack_complex_float* a, int64_t lda,
                               int64_t* sdim, lapack_complex_float* w,
                               lapack_complex_float* vs, int64_t ldvs,
                               lapack_complex_float* work, int64_t lwork,
                               float* rwork, lapack_logical* bwork );
int64_t LAPACKE_zgees_work_64( int matrix_layout, char jobvs, char sort,
                               LAPACK_Z_SELECT1 select, int64_t n,
                               lapack_complex_double* a, int64_t lda,
                               int64_t* sdim, lapack_complex_double* w,
                               lapack_complex_double* vs, int64_t ldvs,
                               lapack_complex_double* work, int64_t lwork,
                               double* rwork, lapack_logical* bwork );

int64_t LAPACKE_sgeesx_work_64( int matrix_layout, char jobvs, char sort,
                                LAPACK_S_SELECT2 select, char sense,
                                int64_t n, float* a, int64_t lda,
                                int64_t* sdim, float* wr, float* wi,
                                float* vs, int64_t ldvs, float* rconde,
                                float* rcondv, float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork,
                                lapack_logical* bwork );
int64_t LAPACKE_dgeesx_work_64( int matrix_layout, char jobvs, char sort,
                                LAPACK_D_SELECT2 select, char sense,
                                int64_t n, double* a, int64_t lda,
                                int64_t* sdim, double* wr, double* wi,
                                double* vs, int64_t ldvs, double* rconde,
                                double* rcondv, double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork,
                                lapack_logical* bwork );
int64_t LAPACKE_cgeesx_work_64( int matrix_layout, char jobvs, char sort,
                                LAPACK_C_SELECT1 select, char sense,
                                int64_t n, lapack_complex_float* a,
                                int64_t lda, int64_t* sdim,
                                lapack_complex_float* w,
                                lapack_complex_float* vs, int64_t ldvs,
                                float* rconde, float* rcondv,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork, lapack_logical* bwork );
int64_t LAPACKE_zgeesx_work_64( int matrix_layout, char jobvs, char sort,
                                LAPACK_Z_SELECT1 select, char sense,
                                int64_t n, lapack_complex_double* a,
                                int64_t lda, int64_t* sdim,
                                lapack_complex_double* w,
                                lapack_complex_double* vs, int64_t ldvs,
                                double* rconde, double* rcondv,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork, lapack_logical* bwork );

int64_t LAPACKE_sgeev_work_64( int matrix_layout, char jobvl, char jobvr,
                               int64_t n, float* a, int64_t lda,
                               float* wr, float* wi, float* vl, int64_t ldvl,
                               float* vr, int64_t ldvr, float* work,
                               int64_t lwork );
int64_t LAPACKE_dgeev_work_64( int matrix_layout, char jobvl, char jobvr,
                               int64_t n, double* a, int64_t lda,
                               double* wr, double* wi, double* vl,
                               int64_t ldvl, double* vr, int64_t ldvr,
                               double* work, int64_t lwork );
int64_t LAPACKE_cgeev_work_64( int matrix_layout, char jobvl, char jobvr,
                               int64_t n, lapack_complex_float* a,
                               int64_t lda, lapack_complex_float* w,
                               lapack_complex_float* vl, int64_t ldvl,
                               lapack_complex_float* vr, int64_t ldvr,
                               lapack_complex_float* work, int64_t lwork,
                               float* rwork );
int64_t LAPACKE_zgeev_work_64( int matrix_layout, char jobvl, char jobvr,
                               int64_t n, lapack_complex_double* a,
                               int64_t lda, lapack_complex_double* w,
                               lapack_complex_double* vl, int64_t ldvl,
                               lapack_complex_double* vr, int64_t ldvr,
                               lapack_complex_double* work, int64_t lwork,
                               double* rwork );

int64_t LAPACKE_sgeevx_work_64( int matrix_layout, char balanc, char jobvl,
                                char jobvr, char sense, int64_t n, float* a,
                                int64_t lda, float* wr, float* wi, float* vl,
                                int64_t ldvl, float* vr, int64_t ldvr,
                                int64_t* ilo, int64_t* ihi, float* scale,
                                float* abnrm, float* rconde, float* rcondv,
                                float* work, int64_t lwork,
                                int64_t* iwork );
int64_t LAPACKE_dgeevx_work_64( int matrix_layout, char balanc, char jobvl,
                                char jobvr, char sense, int64_t n, double* a,
                                int64_t lda, double* wr, double* wi,
                                double* vl, int64_t ldvl, double* vr,
                                int64_t ldvr, int64_t* ilo,
                                int64_t* ihi, double* scale, double* abnrm,
                                double* rconde, double* rcondv, double* work,
                                int64_t lwork, int64_t* iwork );
int64_t LAPACKE_cgeevx_work_64( int matrix_layout, char balanc, char jobvl,
                                char jobvr, char sense, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* w,
                                lapack_complex_float* vl, int64_t ldvl,
                                lapack_complex_float* vr, int64_t ldvr,
                                int64_t* ilo, int64_t* ihi, float* scale,
                                float* abnrm, float* rconde, float* rcondv,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork );
int64_t LAPACKE_zgeevx_work_64( int matrix_layout, char balanc, char jobvl,
                                char jobvr, char sense, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* w,
                                lapack_complex_double* vl, int64_t ldvl,
                                lapack_complex_double* vr, int64_t ldvr,
                                int64_t* ilo, int64_t* ihi, double* scale,
                                double* abnrm, double* rconde, double* rcondv,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork );

int64_t LAPACKE_sgehrd_work_64( int matrix_layout, int64_t n, int64_t ilo,
                                int64_t ihi, float* a, int64_t lda,
                                float* tau, float* work, int64_t lwork );
int64_t LAPACKE_dgehrd_work_64( int matrix_layout, int64_t n, int64_t ilo,
                                int64_t ihi, double* a, int64_t lda,
                                double* tau, double* work, int64_t lwork );
int64_t LAPACKE_cgehrd_work_64( int matrix_layout, int64_t n, int64_t ilo,
                                int64_t ihi, lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgehrd_work_64( int matrix_layout, int64_t n, int64_t ilo,
                                int64_t ihi, lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgejsv_work_64( int matrix_layout, char joba, char jobu,
                                char jobv, char jobr, char jobt, char jobp,
                                int64_t m, int64_t n, float* a,
                                int64_t lda, float* sva, float* u,
                                int64_t ldu, float* v, int64_t ldv,
                                float* work, int64_t lwork,
                                int64_t* iwork );
int64_t LAPACKE_dgejsv_work_64( int matrix_layout, char joba, char jobu,
                                char jobv, char jobr, char jobt, char jobp,
                                int64_t m, int64_t n, double* a,
                                int64_t lda, double* sva, double* u,
                                int64_t ldu, double* v, int64_t ldv,
                                double* work, int64_t lwork,
                                int64_t* iwork );
int64_t LAPACKE_cgejsv_work_64( int matrix_layout, char joba, char jobu,
                                char jobv, char jobr, char jobt, char jobp,
                                int64_t m, int64_t n, lapack_complex_float* a,
                                int64_t lda, float* sva, lapack_complex_float* u,
                                int64_t ldu, lapack_complex_float* v, int64_t ldv,
                                lapack_complex_float* cwork, int64_t lwork,
                                float* work, int64_t lrwork,
                                int64_t* iwork );
int64_t LAPACKE_zgejsv_work_64( int matrix_layout, char joba, char jobu,
                                char jobv, char jobr, char jobt, char jobp,
                                int64_t m, int64_t n, lapack_complex_double* a,
                                int64_t lda, double* sva, lapack_complex_double* u,
                                int64_t ldu, lapack_complex_double* v, int64_t ldv,
                                lapack_complex_double* cwork, int64_t lwork,
                                double* work, int64_t lrwork,
                                int64_t* iwork );

int64_t LAPACKE_sgelq2_work_64( int matrix_layout, int64_t m, int64_t n,
                                float* a, int64_t lda, float* tau,
                                float* work );
int64_t LAPACKE_dgelq2_work_64( int matrix_layout, int64_t m, int64_t n,
                                double* a, int64_t lda, double* tau,
                                double* work );
int64_t LAPACKE_cgelq2_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* tau,
                                lapack_complex_float* work );
int64_t LAPACKE_zgelq2_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* tau,
                                lapack_complex_double* work );

int64_t LAPACKE_sgelqf_work_64( int matrix_layout, int64_t m, int64_t n,
                                float* a, int64_t lda, float* tau,
                                float* work, int64_t lwork );
int64_t LAPACKE_dgelqf_work_64( int matrix_layout, int64_t m, int64_t n,
                                double* a, int64_t lda, double* tau,
                                double* work, int64_t lwork );
int64_t LAPACKE_cgelqf_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgelqf_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgels_work_64( int matrix_layout, char trans, int64_t m,
                               int64_t n, int64_t nrhs, float* a,
                               int64_t lda, float* b, int64_t ldb,
                               float* work, int64_t lwork );
int64_t LAPACKE_dgels_work_64( int matrix_layout, char trans, int64_t m,
                               int64_t n, int64_t nrhs, double* a,
                               int64_t lda, double* b, int64_t ldb,
                               double* work, int64_t lwork );
int64_t LAPACKE_cgels_work_64( int matrix_layout, char trans, int64_t m,
                               int64_t n, int64_t nrhs,
                               lapack_complex_float* a, int64_t lda,
                               lapack_complex_float* b, int64_t ldb,
                               lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgels_work_64( int matrix_layout, char trans, int64_t m,
                               int64_t n, int64_t nrhs,
                               lapack_complex_double* a, int64_t lda,
                               lapack_complex_double* b, int64_t ldb,
                               lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgelsd_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nrhs, float* a, int64_t lda,
                                float* b, int64_t ldb, float* s, float rcond,
                                int64_t* rank, float* work, int64_t lwork,
                                int64_t* iwork );
int64_t LAPACKE_dgelsd_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nrhs, double* a, int64_t lda,
                                double* b, int64_t ldb, double* s,
                                double rcond, int64_t* rank, double* work,
                                int64_t lwork, int64_t* iwork );
int64_t LAPACKE_cgelsd_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nrhs, lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* b,
                                int64_t ldb, float* s, float rcond,
                                int64_t* rank, lapack_complex_float* work,
                                int64_t lwork, float* rwork,
                                int64_t* iwork );
int64_t LAPACKE_zgelsd_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nrhs, lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* b,
                                int64_t ldb, double* s, double rcond,
                                int64_t* rank, lapack_complex_double* work,
                                int64_t lwork, double* rwork,
                                int64_t* iwork );

int64_t LAPACKE_sgelss_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nrhs, float* a, int64_t lda,
                                float* b, int64_t ldb, float* s, float rcond,
                                int64_t* rank, float* work,
                                int64_t lwork );
int64_t LAPACKE_dgelss_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nrhs, double* a, int64_t lda,
                                double* b, int64_t ldb, double* s,
                                double rcond, int64_t* rank, double* work,
                                int64_t lwork );
int64_t LAPACKE_cgelss_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nrhs, lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* b,
                                int64_t ldb, float* s, float rcond,
                                int64_t* rank, lapack_complex_float* work,
                                int64_t lwork, float* rwork );
int64_t LAPACKE_zgelss_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nrhs, lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* b,
                                int64_t ldb, double* s, double rcond,
                                int64_t* rank, lapack_complex_double* work,
                                int64_t lwork, double* rwork );

int64_t LAPACKE_sgelsy_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nrhs, float* a, int64_t lda,
                                float* b, int64_t ldb, int64_t* jpvt,
                                float rcond, int64_t* rank, float* work,
                                int64_t lwork );
int64_t LAPACKE_dgelsy_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nrhs, double* a, int64_t lda,
                                double* b, int64_t ldb, int64_t* jpvt,
                                double rcond, int64_t* rank, double* work,
                                int64_t lwork );
int64_t LAPACKE_cgelsy_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nrhs, lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* b,
                                int64_t ldb, int64_t* jpvt, float rcond,
                                int64_t* rank, lapack_complex_float* work,
                                int64_t lwork, float* rwork );
int64_t LAPACKE_zgelsy_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nrhs, lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* b,
                                int64_t ldb, int64_t* jpvt, double rcond,
                                int64_t* rank, lapack_complex_double* work,
                                int64_t lwork, double* rwork );

int64_t LAPACKE_sgeqlf_work_64( int matrix_layout, int64_t m, int64_t n,
                                float* a, int64_t lda, float* tau,
                                float* work, int64_t lwork );
int64_t LAPACKE_dgeqlf_work_64( int matrix_layout, int64_t m, int64_t n,
                                double* a, int64_t lda, double* tau,
                                double* work, int64_t lwork );
int64_t LAPACKE_cgeqlf_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgeqlf_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgeqp3_work_64( int matrix_layout, int64_t m, int64_t n,
                                float* a, int64_t lda, int64_t* jpvt,
                                float* tau, float* work, int64_t lwork );
int64_t LAPACKE_dgeqp3_work_64( int matrix_layout, int64_t m, int64_t n,
                                double* a, int64_t lda, int64_t* jpvt,
                                double* tau, double* work, int64_t lwork );
int64_t LAPACKE_cgeqp3_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                int64_t* jpvt, lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork );
int64_t LAPACKE_zgeqp3_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* jpvt, lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork );

int64_t LAPACKE_sgeqpf_work_64( int matrix_layout, int64_t m, int64_t n,
                                float* a, int64_t lda, int64_t* jpvt,
                                float* tau, float* work );
int64_t LAPACKE_dgeqpf_work_64( int matrix_layout, int64_t m, int64_t n,
                                double* a, int64_t lda, int64_t* jpvt,
                                double* tau, double* work );
int64_t LAPACKE_cgeqpf_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                int64_t* jpvt, lapack_complex_float* tau,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zgeqpf_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* jpvt, lapack_complex_double* tau,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_sgeqr2_work_64( int matrix_layout, int64_t m, int64_t n,
                                float* a, int64_t lda, float* tau,
                                float* work );
int64_t LAPACKE_dgeqr2_work_64( int matrix_layout, int64_t m, int64_t n,
                                double* a, int64_t lda, double* tau,
                                double* work );
int64_t LAPACKE_cgeqr2_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* tau,
                                lapack_complex_float* work );
int64_t LAPACKE_zgeqr2_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* tau,
                                lapack_complex_double* work );

int64_t LAPACKE_sgeqrf_work_64( int matrix_layout, int64_t m, int64_t n,
                                float* a, int64_t lda, float* tau,
                                float* work, int64_t lwork );
int64_t LAPACKE_dgeqrf_work_64( int matrix_layout, int64_t m, int64_t n,
                                double* a, int64_t lda, double* tau,
                                double* work, int64_t lwork );
int64_t LAPACKE_cgeqrf_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgeqrf_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgeqrfp_work_64( int matrix_layout, int64_t m, int64_t n,
                                 float* a, int64_t lda, float* tau,
                                 float* work, int64_t lwork );
int64_t LAPACKE_dgeqrfp_work_64( int matrix_layout, int64_t m, int64_t n,
                                 double* a, int64_t lda, double* tau,
                                 double* work, int64_t lwork );
int64_t LAPACKE_cgeqrfp_work_64( int matrix_layout, int64_t m, int64_t n,
                                 lapack_complex_float* a, int64_t lda,
                                 lapack_complex_float* tau,
                                 lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgeqrfp_work_64( int matrix_layout, int64_t m, int64_t n,
                                 lapack_complex_double* a, int64_t lda,
                                 lapack_complex_double* tau,
                                 lapack_complex_double* work,
                                 int64_t lwork );

int64_t LAPACKE_sgerfs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs, const float* a, int64_t lda,
                                const float* af, int64_t ldaf,
                                const int64_t* ipiv, const float* b,
                                int64_t ldb, float* x, int64_t ldx,
                                float* ferr, float* berr, float* work,
                                int64_t* iwork );
int64_t LAPACKE_dgerfs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs, const double* a,
                                int64_t lda, const double* af,
                                int64_t ldaf, const int64_t* ipiv,
                                const double* b, int64_t ldb, double* x,
                                int64_t ldx, double* ferr, double* berr,
                                double* work, int64_t* iwork );
int64_t LAPACKE_cgerfs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs, const lapack_complex_float* a,
                                int64_t lda, const lapack_complex_float* af,
                                int64_t ldaf, const int64_t* ipiv,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* x, int64_t ldx,
                                float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zgerfs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs, const lapack_complex_double* a,
                                int64_t lda, const lapack_complex_double* af,
                                int64_t ldaf, const int64_t* ipiv,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_sgerfsx_work_64( int matrix_layout, char trans, char equed,
                                 int64_t n, int64_t nrhs, const float* a,
                                 int64_t lda, const float* af,
                                 int64_t ldaf, const int64_t* ipiv,
                                 const float* r, const float* c, const float* b,
                                 int64_t ldb, float* x, int64_t ldx,
                                 float* rcond, float* berr,
                                 int64_t n_err_bnds, float* err_bnds_norm,
                                 float* err_bnds_comp, int64_t nparams,
                                 float* params, float* work,
                                 int64_t* iwork );
int64_t LAPACKE_dgerfsx_work_64( int matrix_layout, char trans, char equed,
                                 int64_t n, int64_t nrhs, const double* a,
                                 int64_t lda, const double* af,
                                 int64_t ldaf, const int64_t* ipiv,
                                 const double* r, const double* c,
                                 const double* b, int64_t ldb, double* x,
                                 int64_t ldx, double* rcond, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, double* work,
                                 int64_t* iwork );
int64_t LAPACKE_cgerfsx_work_64( int matrix_layout, char trans, char equed,
                                 int64_t n, int64_t nrhs,
                                 const lapack_complex_float* a, int64_t lda,
                                 const lapack_complex_float* af,
                                 int64_t ldaf, const int64_t* ipiv,
                                 const float* r, const float* c,
                                 const lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* x, int64_t ldx,
                                 float* rcond, float* berr,
                                 int64_t n_err_bnds, float* err_bnds_norm,
                                 float* err_bnds_comp, int64_t nparams,
                                 float* params, lapack_complex_float* work,
                                 float* rwork );
int64_t LAPACKE_zgerfsx_work_64( int matrix_layout, char trans, char equed,
                                 int64_t n, int64_t nrhs,
                                 const lapack_complex_double* a, int64_t lda,
                                 const lapack_complex_double* af,
                                 int64_t ldaf, const int64_t* ipiv,
                                 const double* r, const double* c,
                                 const lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* x, int64_t ldx,
                                 double* rcond, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, lapack_complex_double* work,
                                 double* rwork );

int64_t LAPACKE_sgerqf_work_64( int matrix_layout, int64_t m, int64_t n,
                                float* a, int64_t lda, float* tau,
                                float* work, int64_t lwork );
int64_t LAPACKE_dgerqf_work_64( int matrix_layout, int64_t m, int64_t n,
                                double* a, int64_t lda, double* tau,
                                double* work, int64_t lwork );
int64_t LAPACKE_cgerqf_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgerqf_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgesdd_work_64( int matrix_layout, char jobz, int64_t m,
                                int64_t n, float* a, int64_t lda,
                                float* s, float* u, int64_t ldu, float* vt,
                                int64_t ldvt, float* work, int64_t lwork,
                                int64_t* iwork );
int64_t LAPACKE_dgesdd_work_64( int matrix_layout, char jobz, int64_t m,
                                int64_t n, double* a, int64_t lda,
                                double* s, double* u, int64_t ldu,
                                double* vt, int64_t ldvt, double* work,
                                int64_t lwork, int64_t* iwork );
int64_t LAPACKE_cgesdd_work_64( int matrix_layout, char jobz, int64_t m,
                                int64_t n, lapack_complex_float* a,
                                int64_t lda, float* s,
                                lapack_complex_float* u, int64_t ldu,
                                lapack_complex_float* vt, int64_t ldvt,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork, int64_t* iwork );
int64_t LAPACKE_zgesdd_work_64( int matrix_layout, char jobz, int64_t m,
                                int64_t n, lapack_complex_double* a,
                                int64_t lda, double* s,
                                lapack_complex_double* u, int64_t ldu,
                                lapack_complex_double* vt, int64_t ldvt,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork, int64_t* iwork );

int64_t LAPACKE_sgedmd_work_64( int matrix_layout, char jobs, char jobz,
                                char jobr, char jobf, int64_t whtsvd,
                                int64_t m, int64_t n, float* x,
                                int64_t ldx, float* y, int64_t ldy,
                                int64_t nrnk, float* tol, int64_t k,
                                float* reig, float* imeig,
                                float* z, int64_t ldz, float* res,
                                float* b, int64_t ldb, float* w,
                                int64_t ldw, float* s, int64_t lds,
                                float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_dgedmd_work_64( int matrix_layout, char jobs, char jobz,
                                char jobr, char jobf, int64_t whtsvd,
                                int64_t m, int64_t n, double* x,
                                int64_t ldx, double* y, int64_t ldy,
                                int64_t nrnk, double* tol, int64_t k,
                                double* reig, double *imeig,
                                double* z, int64_t ldz, double* res,
                                double* b, int64_t ldb, double* w,
                                int64_t ldw, double* s, int64_t lds,
                                double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_cgedmd_work_64( int matrix_layout, char jobs, char jobz,
                                char jobr, char jobf, int64_t whtsvd,
                                int64_t m, int64_t n,
                                lapack_complex_float* x, int64_t ldx,
                                lapack_complex_float* y, int64_t ldy,
                                int64_t nrnk, float* tol, int64_t k,
                                lapack_complex_float* eigs,
                                lapack_complex_float* z, int64_t ldz,
                                float* res,
                                lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* w, int64_t ldw,
                                lapack_complex_float* s, int64_t lds,
                                lapack_complex_float* zwork, int64_t lzwork,
                                float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_zgedmd_work_64( int matrix_layout, char jobs, char jobz,
                                char jobr, char jobf, int64_t whtsvd,
                                int64_t m, int64_t n,
                                lapack_complex_double* x, int64_t ldx,
                                lapack_complex_double* y, int64_t ldy,
                                int64_t nrnk, double* tol, int64_t k, 
                                lapack_complex_double* eigs,
                                lapack_complex_double* z, int64_t ldz,
                                double* res,
                                lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* w, int64_t ldw,
                                lapack_complex_double* s, int64_t lds,
                                lapack_complex_double* zwork, int64_t lzwork,
                                double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_sgedmdq_work_64( int matrix_layout, char jobs, char jobz,
                                 char jobr, char jobq, char jobt, char jobf,
                                 int64_t whtsvd, int64_t m, int64_t n,
                                 float* f, int64_t ldf, float* x,
                                 int64_t ldx, float* y, int64_t ldy,
                                 int64_t nrnk, float* tol, int64_t k,
                                 float* reig, float *imeig, float* z,
                                 int64_t ldz, float* res, float* b,
                                 int64_t ldb, float* v, int64_t ldv,
                                 float* s, int64_t lds, float* work,
                                 int64_t lwork, int64_t* iwork,
                                 int64_t liwork );

int64_t LAPACKE_dgedmdq_work_64( int matrix_layout, char jobs, char jobz,
                                 char jobr, char jobq, char jobt, char jobf,
                                 int64_t whtsvd, int64_t m, int64_t n,
                                 double* f, int64_t ldf, double* x,
                                 int64_t ldx, double* y, int64_t ldy,
                                 int64_t nrnk, double* tol, int64_t k,
                                 double* reig, double* imeig, double* z,
                                 int64_t ldz, double* res, double* b,
                                 int64_t ldb, double* v, int64_t ldv,
                                 double* s, int64_t lds, double* work,
                                 int64_t lwork, int64_t* iwork,
                                 int64_t liwork );

int64_t LAPACKE_cgedmdq_work_64( int matrix_layout, char jobs, char jobz,
                                 char jobr, char jobq, char jobt, char jobf,
                                 int64_t whtsvd, int64_t m, int64_t n,
                                 lapack_complex_float* f, int64_t ldf,
                                 lapack_complex_float* x, int64_t ldx,
                                 lapack_complex_float* y, int64_t ldy,
                                 int64_t nrnk, float* tol, int64_t k,
                                 lapack_complex_float* eigs,
                                 lapack_complex_float* z, int64_t ldz,
                                 float* res,
                                 lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* v, int64_t ldv,
                                 lapack_complex_float* s, int64_t lds,
                                 lapack_complex_float* zwork, int64_t lzwork,
                                 float* work, int64_t lwork,
                                 int64_t* iwork, int64_t liwork);

int64_t LAPACKE_zgedmdq_work_64( int matrix_layout, char jobs, char jobz,
                                 char jobr, char jobq, char jobt, char jobf,
                                 int64_t whtsvd, int64_t m, int64_t n,
                                 lapack_complex_double* f, int64_t ldf,
                                 lapack_complex_double* x, int64_t ldx,
                                 lapack_complex_double* y, int64_t ldy,
                                 int64_t nrnk, double* tol, int64_t k,
                                 lapack_complex_double* eigs,
                                 lapack_complex_double* z, int64_t ldz,
                                 double* res,
                                 lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* v, int64_t ldv,
                                 lapack_complex_double* s, int64_t lds,
                                 lapack_complex_double* zwork, int64_t lzwork,
                                 double* work, int64_t lwork,
                                 int64_t* iwork, int64_t liwork);


int64_t LAPACKE_sgesv_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                               float* a, int64_t lda, int64_t* ipiv,
                               float* b, int64_t ldb );
int64_t LAPACKE_dgesv_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                               double* a, int64_t lda, int64_t* ipiv,
                               double* b, int64_t ldb );
int64_t LAPACKE_cgesv_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                               lapack_complex_float* a, int64_t lda,
                               int64_t* ipiv, lapack_complex_float* b,
                               int64_t ldb );
int64_t LAPACKE_zgesv_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                               lapack_complex_double* a, int64_t lda,
                               int64_t* ipiv, lapack_complex_double* b,
                               int64_t ldb );
int64_t LAPACKE_dsgesv_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                                double* a, int64_t lda, int64_t* ipiv,
                                double* b, int64_t ldb, double* x,
                                int64_t ldx, double* work, float* swork,
                                int64_t* iter );
int64_t LAPACKE_zcgesv_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* ipiv, lapack_complex_double* b,
                                int64_t ldb, lapack_complex_double* x,
                                int64_t ldx, lapack_complex_double* work,
                                lapack_complex_float* swork, double* rwork,
                                int64_t* iter );

int64_t LAPACKE_sgesvd_work_64( int matrix_layout, char jobu, char jobvt,
                                int64_t m, int64_t n, float* a,
                                int64_t lda, float* s, float* u,
                                int64_t ldu, float* vt, int64_t ldvt,
                                float* work, int64_t lwork );
int64_t LAPACKE_dgesvd_work_64( int matrix_layout, char jobu, char jobvt,
                                int64_t m, int64_t n, double* a,
                                int64_t lda, double* s, double* u,
                                int64_t ldu, double* vt, int64_t ldvt,
                                double* work, int64_t lwork );
int64_t LAPACKE_cgesvd_work_64( int matrix_layout, char jobu, char jobvt,
                                int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                float* s, lapack_complex_float* u,
                                int64_t ldu, lapack_complex_float* vt,
                                int64_t ldvt, lapack_complex_float* work,
                                int64_t lwork, float* rwork );
int64_t LAPACKE_zgesvd_work_64( int matrix_layout, char jobu, char jobvt,
                                int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                double* s, lapack_complex_double* u,
                                int64_t ldu, lapack_complex_double* vt,
                                int64_t ldvt, lapack_complex_double* work,
                                int64_t lwork, double* rwork );

int64_t LAPACKE_sgesvdx_work_64( int matrix_layout, char jobu, char jobvt, char range,
                                 int64_t m, int64_t n, float* a,
                                 int64_t lda, float vl, float vu,
                                 int64_t il, int64_t iu, int64_t* ns,
                                 float* s, float* u, int64_t ldu,
                                 float* vt, int64_t ldvt,
                                 float* work, int64_t lwork, int64_t* iwork );
int64_t LAPACKE_dgesvdx_work_64( int matrix_layout, char jobu, char jobvt, char range,
                                 int64_t m, int64_t n, double* a,
                                 int64_t lda, double vl, double vu,
                                 int64_t il, int64_t iu, int64_t* ns,
                                 double* s, double* u, int64_t ldu,
                                 double* vt, int64_t ldvt,
                                 double* work, int64_t lwork, int64_t* iwork );
int64_t LAPACKE_cgesvdx_work_64( int matrix_layout, char jobu, char jobvt, char range,
                                 int64_t m, int64_t n, lapack_complex_float* a,
                                 int64_t lda, float vl, float vu,
                                 int64_t il, int64_t iu, int64_t* ns,
                                 float* s, lapack_complex_float* u, int64_t ldu,
                                 lapack_complex_float* vt, int64_t ldvt,
                                 lapack_complex_float* work, int64_t lwork,
                                 float* rwork, int64_t* iwork );
int64_t LAPACKE_zgesvdx_work_64( int matrix_layout, char jobu, char jobvt, char range,
                                 int64_t m, int64_t n, lapack_complex_double* a,
                                 int64_t lda, double vl, double vu,
                                 int64_t il, int64_t iu, int64_t* ns,
                                 double* s, lapack_complex_double* u, int64_t ldu,
                                 lapack_complex_double* vt, int64_t ldvt,
                                 lapack_complex_double* work, int64_t lwork,
                                 double* rwork, int64_t* iwork );

int64_t LAPACKE_sgesvdq_work_64( int matrix_layout, char joba, char jobp,
                                char jobr, char jobu, char jobv,
                                int64_t m, int64_t n, float* a,
                                int64_t lda, float* s, float* u,
                                int64_t ldu, float* v, int64_t ldv,
                                int64_t* numrank,
                                int64_t* iwork, int64_t liwork,
                                float* work, int64_t lwork,
                                float* rwork, int64_t lrwork);
int64_t LAPACKE_dgesvdq_work_64( int matrix_layout, char joba, char jobp,
                                char jobr, char jobu, char jobv,
                                int64_t m, int64_t n, double* a,
                                int64_t lda, double* s, double* u,
                                int64_t ldu, double* v, int64_t ldv,
                                int64_t* numrank,
                                int64_t* iwork, int64_t liwork,
                                double* work, int64_t lwork,
                                double* rwork, int64_t lrwork);
int64_t LAPACKE_cgesvdq_work_64( int matrix_layout, char joba, char jobp,
                                char jobr, char jobu, char jobv,
                                int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                float* s, lapack_complex_float* u,
                                int64_t ldu, lapack_complex_float* v,
                                int64_t ldv, int64_t* numrank,
                                int64_t* iwork, int64_t liwork,
                                lapack_complex_float* cwork, int64_t lcwork,
                                float* rwork, int64_t lrwork);
int64_t LAPACKE_zgesvdq_work_64( int matrix_layout, char joba, char jobp,
                                char jobr, char jobu, char jobv,
                                int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                double* s, lapack_complex_double* u,
                                int64_t ldu, lapack_complex_double* v,
                                int64_t ldv, int64_t* numrank,
                                int64_t* iwork, int64_t liwork,
                                lapack_complex_double* cwork, int64_t lcwork,
                                double* rwork, int64_t lrwork);

int64_t LAPACKE_sgesvj_work_64( int matrix_layout, char joba, char jobu,
                                char jobv, int64_t m, int64_t n, float* a,
                                int64_t lda, float* sva, int64_t mv,
                                float* v, int64_t ldv, float* work,
                                int64_t lwork );
int64_t LAPACKE_dgesvj_work_64( int matrix_layout, char joba, char jobu,
                                char jobv, int64_t m, int64_t n,
                                double* a, int64_t lda, double* sva,
                                int64_t mv, double* v, int64_t ldv,
                                double* work, int64_t lwork );
int64_t LAPACKE_cgesvj_work_64( int matrix_layout, char joba, char jobu,
                                char jobv, int64_t m, int64_t n, lapack_complex_float* a,
                                int64_t lda, float* sva, int64_t mv,
                                lapack_complex_float* v, int64_t ldv,
                                lapack_complex_float* cwork, int64_t lwork,
                                float* rwork,int64_t lrwork );
int64_t LAPACKE_zgesvj_work_64( int matrix_layout, char joba, char jobu,
                                char jobv, int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda, double* sva,
                                int64_t mv, lapack_complex_double* v, int64_t ldv,
                                lapack_complex_double* cwork, int64_t lwork,
                                double* rwork, int64_t lrwork );

int64_t LAPACKE_sgesvx_work_64( int matrix_layout, char fact, char trans,
                                int64_t n, int64_t nrhs, float* a,
                                int64_t lda, float* af, int64_t ldaf,
                                int64_t* ipiv, char* equed, float* r,
                                float* c, float* b, int64_t ldb, float* x,
                                int64_t ldx, float* rcond, float* ferr,
                                float* berr, float* work, int64_t* iwork );
int64_t LAPACKE_dgesvx_work_64( int matrix_layout, char fact, char trans,
                                int64_t n, int64_t nrhs, double* a,
                                int64_t lda, double* af, int64_t ldaf,
                                int64_t* ipiv, char* equed, double* r,
                                double* c, double* b, int64_t ldb, double* x,
                                int64_t ldx, double* rcond, double* ferr,
                                double* berr, double* work, int64_t* iwork );
int64_t LAPACKE_cgesvx_work_64( int matrix_layout, char fact, char trans,
                                int64_t n, int64_t nrhs,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* af, int64_t ldaf,
                                int64_t* ipiv, char* equed, float* r,
                                float* c, lapack_complex_float* b,
                                int64_t ldb, lapack_complex_float* x,
                                int64_t ldx, float* rcond, float* ferr,
                                float* berr, lapack_complex_float* work,
                                float* rwork );
int64_t LAPACKE_zgesvx_work_64( int matrix_layout, char fact, char trans,
                                int64_t n, int64_t nrhs,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* af, int64_t ldaf,
                                int64_t* ipiv, char* equed, double* r,
                                double* c, lapack_complex_double* b,
                                int64_t ldb, lapack_complex_double* x,
                                int64_t ldx, double* rcond, double* ferr,
                                double* berr, lapack_complex_double* work,
                                double* rwork );

int64_t LAPACKE_sgesvxx_work_64( int matrix_layout, char fact, char trans,
                                 int64_t n, int64_t nrhs, float* a,
                                 int64_t lda, float* af, int64_t ldaf,
                                 int64_t* ipiv, char* equed, float* r,
                                 float* c, float* b, int64_t ldb, float* x,
                                 int64_t ldx, float* rcond, float* rpvgrw,
                                 float* berr, int64_t n_err_bnds,
                                 float* err_bnds_norm, float* err_bnds_comp,
                                 int64_t nparams, float* params, float* work,
                                 int64_t* iwork );
int64_t LAPACKE_dgesvxx_work_64( int matrix_layout, char fact, char trans,
                                 int64_t n, int64_t nrhs, double* a,
                                 int64_t lda, double* af, int64_t ldaf,
                                 int64_t* ipiv, char* equed, double* r,
                                 double* c, double* b, int64_t ldb,
                                 double* x, int64_t ldx, double* rcond,
                                 double* rpvgrw, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, double* work,
                                 int64_t* iwork );
int64_t LAPACKE_cgesvxx_work_64( int matrix_layout, char fact, char trans,
                                 int64_t n, int64_t nrhs,
                                 lapack_complex_float* a, int64_t lda,
                                 lapack_complex_float* af, int64_t ldaf,
                                 int64_t* ipiv, char* equed, float* r,
                                 float* c, lapack_complex_float* b,
                                 int64_t ldb, lapack_complex_float* x,
                                 int64_t ldx, float* rcond, float* rpvgrw,
                                 float* berr, int64_t n_err_bnds,
                                 float* err_bnds_norm, float* err_bnds_comp,
                                 int64_t nparams, float* params,
                                 lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zgesvxx_work_64( int matrix_layout, char fact, char trans,
                                 int64_t n, int64_t nrhs,
                                 lapack_complex_double* a, int64_t lda,
                                 lapack_complex_double* af, int64_t ldaf,
                                 int64_t* ipiv, char* equed, double* r,
                                 double* c, lapack_complex_double* b,
                                 int64_t ldb, lapack_complex_double* x,
                                 int64_t ldx, double* rcond, double* rpvgrw,
                                 double* berr, int64_t n_err_bnds,
                                 double* err_bnds_norm, double* err_bnds_comp,
                                 int64_t nparams, double* params,
                                 lapack_complex_double* work, double* rwork );

int64_t LAPACKE_sgetf2_work_64( int matrix_layout, int64_t m, int64_t n,
                                float* a, int64_t lda, int64_t* ipiv );
int64_t LAPACKE_dgetf2_work_64( int matrix_layout, int64_t m, int64_t n,
                                double* a, int64_t lda, int64_t* ipiv );
int64_t LAPACKE_cgetf2_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                int64_t* ipiv );
int64_t LAPACKE_zgetf2_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* ipiv );

int64_t LAPACKE_sgetrf_work_64( int matrix_layout, int64_t m, int64_t n,
                                float* a, int64_t lda, int64_t* ipiv );
int64_t LAPACKE_dgetrf_work_64( int matrix_layout, int64_t m, int64_t n,
                                double* a, int64_t lda, int64_t* ipiv );
int64_t LAPACKE_cgetrf_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                int64_t* ipiv );
int64_t LAPACKE_zgetrf_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* ipiv );

int64_t LAPACKE_sgetrf2_work_64( int matrix_layout, int64_t m, int64_t n,
                                float* a, int64_t lda, int64_t* ipiv );
int64_t LAPACKE_dgetrf2_work_64( int matrix_layout, int64_t m, int64_t n,
                                double* a, int64_t lda, int64_t* ipiv );
int64_t LAPACKE_cgetrf2_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                int64_t* ipiv );
int64_t LAPACKE_zgetrf2_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* ipiv );

int64_t LAPACKE_sgetri_work_64( int matrix_layout, int64_t n, float* a,
                                int64_t lda, const int64_t* ipiv,
                                float* work, int64_t lwork );
int64_t LAPACKE_dgetri_work_64( int matrix_layout, int64_t n, double* a,
                                int64_t lda, const int64_t* ipiv,
                                double* work, int64_t lwork );
int64_t LAPACKE_cgetri_work_64( int matrix_layout, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                const int64_t* ipiv,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgetri_work_64( int matrix_layout, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                const int64_t* ipiv,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgetrs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs, const float* a, int64_t lda,
                                const int64_t* ipiv, float* b,
                                int64_t ldb );
int64_t LAPACKE_dgetrs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs, const double* a,
                                int64_t lda, const int64_t* ipiv,
                                double* b, int64_t ldb );
int64_t LAPACKE_cgetrs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs, const lapack_complex_float* a,
                                int64_t lda, const int64_t* ipiv,
                                lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zgetrs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs, const lapack_complex_double* a,
                                int64_t lda, const int64_t* ipiv,
                                lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_sggbak_work_64( int matrix_layout, char job, char side,
                                int64_t n, int64_t ilo, int64_t ihi,
                                const float* lscale, const float* rscale,
                                int64_t m, float* v, int64_t ldv );
int64_t LAPACKE_dggbak_work_64( int matrix_layout, char job, char side,
                                int64_t n, int64_t ilo, int64_t ihi,
                                const double* lscale, const double* rscale,
                                int64_t m, double* v, int64_t ldv );
int64_t LAPACKE_cggbak_work_64( int matrix_layout, char job, char side,
                                int64_t n, int64_t ilo, int64_t ihi,
                                const float* lscale, const float* rscale,
                                int64_t m, lapack_complex_float* v,
                                int64_t ldv );
int64_t LAPACKE_zggbak_work_64( int matrix_layout, char job, char side,
                                int64_t n, int64_t ilo, int64_t ihi,
                                const double* lscale, const double* rscale,
                                int64_t m, lapack_complex_double* v,
                                int64_t ldv );

int64_t LAPACKE_sggbal_work_64( int matrix_layout, char job, int64_t n,
                                float* a, int64_t lda, float* b,
                                int64_t ldb, int64_t* ilo,
                                int64_t* ihi, float* lscale, float* rscale,
                                float* work );
int64_t LAPACKE_dggbal_work_64( int matrix_layout, char job, int64_t n,
                                double* a, int64_t lda, double* b,
                                int64_t ldb, int64_t* ilo,
                                int64_t* ihi, double* lscale, double* rscale,
                                double* work );
int64_t LAPACKE_cggbal_work_64( int matrix_layout, char job, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb,
                                int64_t* ilo, int64_t* ihi, float* lscale,
                                float* rscale, float* work );
int64_t LAPACKE_zggbal_work_64( int matrix_layout, char job, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb,
                                int64_t* ilo, int64_t* ihi,
                                double* lscale, double* rscale, double* work );

int64_t LAPACKE_sgges_work_64( int matrix_layout, char jobvsl, char jobvsr,
                               char sort, LAPACK_S_SELECT3 selctg, int64_t n,
                               float* a, int64_t lda, float* b,
                               int64_t ldb, int64_t* sdim, float* alphar,
                               float* alphai, float* beta, float* vsl,
                               int64_t ldvsl, float* vsr, int64_t ldvsr,
                               float* work, int64_t lwork,
                               lapack_logical* bwork );
int64_t LAPACKE_dgges_work_64( int matrix_layout, char jobvsl, char jobvsr,
                               char sort, LAPACK_D_SELECT3 selctg, int64_t n,
                               double* a, int64_t lda, double* b,
                               int64_t ldb, int64_t* sdim, double* alphar,
                               double* alphai, double* beta, double* vsl,
                               int64_t ldvsl, double* vsr, int64_t ldvsr,
                               double* work, int64_t lwork,
                               lapack_logical* bwork );
int64_t LAPACKE_cgges_work_64( int matrix_layout, char jobvsl, char jobvsr,
                               char sort, LAPACK_C_SELECT2 selctg, int64_t n,
                               lapack_complex_float* a, int64_t lda,
                               lapack_complex_float* b, int64_t ldb,
                               int64_t* sdim, lapack_complex_float* alpha,
                               lapack_complex_float* beta,
                               lapack_complex_float* vsl, int64_t ldvsl,
                               lapack_complex_float* vsr, int64_t ldvsr,
                               lapack_complex_float* work, int64_t lwork,
                               float* rwork, lapack_logical* bwork );
int64_t LAPACKE_zgges_work_64( int matrix_layout, char jobvsl, char jobvsr,
                               char sort, LAPACK_Z_SELECT2 selctg, int64_t n,
                               lapack_complex_double* a, int64_t lda,
                               lapack_complex_double* b, int64_t ldb,
                               int64_t* sdim, lapack_complex_double* alpha,
                               lapack_complex_double* beta,
                               lapack_complex_double* vsl, int64_t ldvsl,
                               lapack_complex_double* vsr, int64_t ldvsr,
                               lapack_complex_double* work, int64_t lwork,
                               double* rwork, lapack_logical* bwork );

int64_t LAPACKE_sgges3_work_64( int matrix_layout, char jobvsl, char jobvsr,
                                char sort, LAPACK_S_SELECT3 selctg,
                                int64_t n,
                                float* a, int64_t lda,
                                float* b, int64_t ldb, int64_t* sdim,
                                float* alphar, float* alphai, float* beta,
                                float* vsl, int64_t ldvsl,
                                float* vsr, int64_t ldvsr,
                                float* work, int64_t lwork,
                                lapack_logical* bwork );
int64_t LAPACKE_dgges3_work_64( int matrix_layout, char jobvsl, char jobvsr,
                                char sort, LAPACK_D_SELECT3 selctg,
                                int64_t n,
                                double* a, int64_t lda,
                                double* b, int64_t ldb, int64_t* sdim,
                                double* alphar, double* alphai, double* beta,
                                double* vsl, int64_t ldvsl,
                                double* vsr, int64_t ldvsr,
                                double* work, int64_t lwork,
                                lapack_logical* bwork );
int64_t LAPACKE_cgges3_work_64( int matrix_layout, char jobvsl, char jobvsr,
                                char sort, LAPACK_C_SELECT2 selctg,
                                int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb,
                                int64_t* sdim, lapack_complex_float* alpha,
                                lapack_complex_float* beta,
                                lapack_complex_float* vsl, int64_t ldvsl,
                                lapack_complex_float* vsr, int64_t ldvsr,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork, lapack_logical* bwork );
int64_t LAPACKE_zgges3_work_64( int matrix_layout, char jobvsl, char jobvsr,
                                char sort, LAPACK_Z_SELECT2 selctg,
                                int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb,
                                int64_t* sdim, lapack_complex_double* alpha,
                                lapack_complex_double* beta,
                                lapack_complex_double* vsl, int64_t ldvsl,
                                lapack_complex_double* vsr, int64_t ldvsr,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork, lapack_logical* bwork );

int64_t LAPACKE_sggesx_work_64( int matrix_layout, char jobvsl, char jobvsr,
                                char sort, LAPACK_S_SELECT3 selctg, char sense,
                                int64_t n, float* a, int64_t lda,
                                float* b, int64_t ldb, int64_t* sdim,
                                float* alphar, float* alphai, float* beta,
                                float* vsl, int64_t ldvsl, float* vsr,
                                int64_t ldvsr, float* rconde, float* rcondv,
                                float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork,
                                lapack_logical* bwork );
int64_t LAPACKE_dggesx_work_64( int matrix_layout, char jobvsl, char jobvsr,
                                char sort, LAPACK_D_SELECT3 selctg, char sense,
                                int64_t n, double* a, int64_t lda,
                                double* b, int64_t ldb, int64_t* sdim,
                                double* alphar, double* alphai, double* beta,
                                double* vsl, int64_t ldvsl, double* vsr,
                                int64_t ldvsr, double* rconde,
                                double* rcondv, double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork,
                                lapack_logical* bwork );
int64_t LAPACKE_cggesx_work_64( int matrix_layout, char jobvsl, char jobvsr,
                                char sort, LAPACK_C_SELECT2 selctg, char sense,
                                int64_t n, lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* b,
                                int64_t ldb, int64_t* sdim,
                                lapack_complex_float* alpha,
                                lapack_complex_float* beta,
                                lapack_complex_float* vsl, int64_t ldvsl,
                                lapack_complex_float* vsr, int64_t ldvsr,
                                float* rconde, float* rcondv,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork, int64_t* iwork,
                                int64_t liwork, lapack_logical* bwork );
int64_t LAPACKE_zggesx_work_64( int matrix_layout, char jobvsl, char jobvsr,
                                char sort, LAPACK_Z_SELECT2 selctg, char sense,
                                int64_t n, lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* b,
                                int64_t ldb, int64_t* sdim,
                                lapack_complex_double* alpha,
                                lapack_complex_double* beta,
                                lapack_complex_double* vsl, int64_t ldvsl,
                                lapack_complex_double* vsr, int64_t ldvsr,
                                double* rconde, double* rcondv,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork, int64_t* iwork,
                                int64_t liwork, lapack_logical* bwork );

int64_t LAPACKE_sggev_work_64( int matrix_layout, char jobvl, char jobvr,
                               int64_t n, float* a, int64_t lda, float* b,
                               int64_t ldb, float* alphar, float* alphai,
                               float* beta, float* vl, int64_t ldvl,
                               float* vr, int64_t ldvr, float* work,
                               int64_t lwork );
int64_t LAPACKE_dggev_work_64( int matrix_layout, char jobvl, char jobvr,
                               int64_t n, double* a, int64_t lda,
                               double* b, int64_t ldb, double* alphar,
                               double* alphai, double* beta, double* vl,
                               int64_t ldvl, double* vr, int64_t ldvr,
                               double* work, int64_t lwork );
int64_t LAPACKE_cggev_work_64( int matrix_layout, char jobvl, char jobvr,
                               int64_t n, lapack_complex_float* a,
                               int64_t lda, lapack_complex_float* b,
                               int64_t ldb, lapack_complex_float* alpha,
                               lapack_complex_float* beta,
                               lapack_complex_float* vl, int64_t ldvl,
                               lapack_complex_float* vr, int64_t ldvr,
                               lapack_complex_float* work, int64_t lwork,
                               float* rwork );
int64_t LAPACKE_zggev_work_64( int matrix_layout, char jobvl, char jobvr,
                               int64_t n, lapack_complex_double* a,
                               int64_t lda, lapack_complex_double* b,
                               int64_t ldb, lapack_complex_double* alpha,
                               lapack_complex_double* beta,
                               lapack_complex_double* vl, int64_t ldvl,
                               lapack_complex_double* vr, int64_t ldvr,
                               lapack_complex_double* work, int64_t lwork,
                               double* rwork );

int64_t LAPACKE_sggev3_work_64( int matrix_layout, char jobvl, char jobvr,
                                int64_t n,
                                float* a, int64_t lda,
                                float* b, int64_t ldb,
                                float* alphar, float* alphai, float* beta,
                                float* vl, int64_t ldvl,
                                float* vr, int64_t ldvr,
                                float* work, int64_t lwork );
int64_t LAPACKE_dggev3_work_64( int matrix_layout, char jobvl, char jobvr,
                                int64_t n,
                                double* a, int64_t lda,
                                double* b, int64_t ldb,
                                double* alphar, double* alphai, double* beta,
                                double* vl, int64_t ldvl,
                                double* vr, int64_t ldvr,
                                double* work, int64_t lwork );
int64_t LAPACKE_cggev3_work_64( int matrix_layout, char jobvl, char jobvr,
                                int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* alpha,
                                lapack_complex_float* beta,
                                lapack_complex_float* vl, int64_t ldvl,
                                lapack_complex_float* vr, int64_t ldvr,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork );
int64_t LAPACKE_zggev3_work_64( int matrix_layout, char jobvl, char jobvr,
                                int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* alpha,
                                lapack_complex_double* beta,
                                lapack_complex_double* vl, int64_t ldvl,
                                lapack_complex_double* vr, int64_t ldvr,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork );

int64_t LAPACKE_sggevx_work_64( int matrix_layout, char balanc, char jobvl,
                                char jobvr, char sense, int64_t n, float* a,
                                int64_t lda, float* b, int64_t ldb,
                                float* alphar, float* alphai, float* beta,
                                float* vl, int64_t ldvl, float* vr,
                                int64_t ldvr, int64_t* ilo,
                                int64_t* ihi, float* lscale, float* rscale,
                                float* abnrm, float* bbnrm, float* rconde,
                                float* rcondv, float* work, int64_t lwork,
                                int64_t* iwork, lapack_logical* bwork );
int64_t LAPACKE_dggevx_work_64( int matrix_layout, char balanc, char jobvl,
                                char jobvr, char sense, int64_t n, double* a,
                                int64_t lda, double* b, int64_t ldb,
                                double* alphar, double* alphai, double* beta,
                                double* vl, int64_t ldvl, double* vr,
                                int64_t ldvr, int64_t* ilo,
                                int64_t* ihi, double* lscale, double* rscale,
                                double* abnrm, double* bbnrm, double* rconde,
                                double* rcondv, double* work, int64_t lwork,
                                int64_t* iwork, lapack_logical* bwork );
int64_t LAPACKE_cggevx_work_64( int matrix_layout, char balanc, char jobvl,
                                char jobvr, char sense, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* alpha,
                                lapack_complex_float* beta,
                                lapack_complex_float* vl, int64_t ldvl,
                                lapack_complex_float* vr, int64_t ldvr,
                                int64_t* ilo, int64_t* ihi, float* lscale,
                                float* rscale, float* abnrm, float* bbnrm,
                                float* rconde, float* rcondv,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork, int64_t* iwork,
                                lapack_logical* bwork );
int64_t LAPACKE_zggevx_work_64( int matrix_layout, char balanc, char jobvl,
                                char jobvr, char sense, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* alpha,
                                lapack_complex_double* beta,
                                lapack_complex_double* vl, int64_t ldvl,
                                lapack_complex_double* vr, int64_t ldvr,
                                int64_t* ilo, int64_t* ihi,
                                double* lscale, double* rscale, double* abnrm,
                                double* bbnrm, double* rconde, double* rcondv,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork, int64_t* iwork,
                                lapack_logical* bwork );

int64_t LAPACKE_sggglm_work_64( int matrix_layout, int64_t n, int64_t m,
                                int64_t p, float* a, int64_t lda,
                                float* b, int64_t ldb, float* d, float* x,
                                float* y, float* work, int64_t lwork );
int64_t LAPACKE_dggglm_work_64( int matrix_layout, int64_t n, int64_t m,
                                int64_t p, double* a, int64_t lda,
                                double* b, int64_t ldb, double* d, double* x,
                                double* y, double* work, int64_t lwork );
int64_t LAPACKE_cggglm_work_64( int matrix_layout, int64_t n, int64_t m,
                                int64_t p, lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* b,
                                int64_t ldb, lapack_complex_float* d,
                                lapack_complex_float* x,
                                lapack_complex_float* y,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zggglm_work_64( int matrix_layout, int64_t n, int64_t m,
                                int64_t p, lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* b,
                                int64_t ldb, lapack_complex_double* d,
                                lapack_complex_double* x,
                                lapack_complex_double* y,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgghrd_work_64( int matrix_layout, char compq, char compz,
                                int64_t n, int64_t ilo, int64_t ihi,
                                float* a, int64_t lda, float* b,
                                int64_t ldb, float* q, int64_t ldq,
                                float* z, int64_t ldz );
int64_t LAPACKE_dgghrd_work_64( int matrix_layout, char compq, char compz,
                                int64_t n, int64_t ilo, int64_t ihi,
                                double* a, int64_t lda, double* b,
                                int64_t ldb, double* q, int64_t ldq,
                                double* z, int64_t ldz );
int64_t LAPACKE_cgghrd_work_64( int matrix_layout, char compq, char compz,
                                int64_t n, int64_t ilo, int64_t ihi,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* q, int64_t ldq,
                                lapack_complex_float* z, int64_t ldz );
int64_t LAPACKE_zgghrd_work_64( int matrix_layout, char compq, char compz,
                                int64_t n, int64_t ilo, int64_t ihi,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* q, int64_t ldq,
                                lapack_complex_double* z, int64_t ldz );

int64_t LAPACKE_sgghd3_work_64( int matrix_layout, char compq, char compz,
                                int64_t n, int64_t ilo, int64_t ihi,
                                float* a, int64_t lda,
                                float* b, int64_t ldb,
                                float* q, int64_t ldq,
                                float* z, int64_t ldz,
                                float* work, int64_t lwork );
int64_t LAPACKE_dgghd3_work_64( int matrix_layout, char compq, char compz,
                                int64_t n, int64_t ilo, int64_t ihi,
                                double* a, int64_t lda,
                                double* b, int64_t ldb,
                                double* q, int64_t ldq,
                                double* z, int64_t ldz,
                                double* work, int64_t lwork );
int64_t LAPACKE_cgghd3_work_64( int matrix_layout, char compq, char compz,
                                int64_t n, int64_t ilo, int64_t ihi,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* q, int64_t ldq,
                                lapack_complex_float* z, int64_t ldz,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgghd3_work_64( int matrix_layout, char compq, char compz,
                                int64_t n, int64_t ilo, int64_t ihi,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* q, int64_t ldq,
                                lapack_complex_double* z, int64_t ldz,
                                lapack_complex_double* work,
                                int64_t lwork );

int64_t LAPACKE_sgglse_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t p, float* a, int64_t lda,
                                float* b, int64_t ldb, float* c, float* d,
                                float* x, float* work, int64_t lwork );
int64_t LAPACKE_dgglse_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t p, double* a, int64_t lda,
                                double* b, int64_t ldb, double* c, double* d,
                                double* x, double* work, int64_t lwork );
int64_t LAPACKE_cgglse_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t p, lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* b,
                                int64_t ldb, lapack_complex_float* c,
                                lapack_complex_float* d,
                                lapack_complex_float* x,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgglse_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t p, lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* b,
                                int64_t ldb, lapack_complex_double* c,
                                lapack_complex_double* d,
                                lapack_complex_double* x,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sggqrf_work_64( int matrix_layout, int64_t n, int64_t m,
                                int64_t p, float* a, int64_t lda,
                                float* taua, float* b, int64_t ldb,
                                float* taub, float* work, int64_t lwork );
int64_t LAPACKE_dggqrf_work_64( int matrix_layout, int64_t n, int64_t m,
                                int64_t p, double* a, int64_t lda,
                                double* taua, double* b, int64_t ldb,
                                double* taub, double* work, int64_t lwork );
int64_t LAPACKE_cggqrf_work_64( int matrix_layout, int64_t n, int64_t m,
                                int64_t p, lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* taua,
                                lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* taub,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zggqrf_work_64( int matrix_layout, int64_t n, int64_t m,
                                int64_t p, lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* taua,
                                lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* taub,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sggrqf_work_64( int matrix_layout, int64_t m, int64_t p,
                                int64_t n, float* a, int64_t lda,
                                float* taua, float* b, int64_t ldb,
                                float* taub, float* work, int64_t lwork );
int64_t LAPACKE_dggrqf_work_64( int matrix_layout, int64_t m, int64_t p,
                                int64_t n, double* a, int64_t lda,
                                double* taua, double* b, int64_t ldb,
                                double* taub, double* work, int64_t lwork );
int64_t LAPACKE_cggrqf_work_64( int matrix_layout, int64_t m, int64_t p,
                                int64_t n, lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* taua,
                                lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* taub,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zggrqf_work_64( int matrix_layout, int64_t m, int64_t p,
                                int64_t n, lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* taua,
                                lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* taub,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sggsvd_work_64( int matrix_layout, char jobu, char jobv,
                                char jobq, int64_t m, int64_t n,
                                int64_t p, int64_t* k, int64_t* l,
                                float* a, int64_t lda, float* b,
                                int64_t ldb, float* alpha, float* beta,
                                float* u, int64_t ldu, float* v,
                                int64_t ldv, float* q, int64_t ldq,
                                float* work, int64_t* iwork );
int64_t LAPACKE_dggsvd_work_64( int matrix_layout, char jobu, char jobv,
                                char jobq, int64_t m, int64_t n,
                                int64_t p, int64_t* k, int64_t* l,
                                double* a, int64_t lda, double* b,
                                int64_t ldb, double* alpha, double* beta,
                                double* u, int64_t ldu, double* v,
                                int64_t ldv, double* q, int64_t ldq,
                                double* work, int64_t* iwork );
int64_t LAPACKE_cggsvd_work_64( int matrix_layout, char jobu, char jobv,
                                char jobq, int64_t m, int64_t n,
                                int64_t p, int64_t* k, int64_t* l,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb,
                                float* alpha, float* beta,
                                lapack_complex_float* u, int64_t ldu,
                                lapack_complex_float* v, int64_t ldv,
                                lapack_complex_float* q, int64_t ldq,
                                lapack_complex_float* work, float* rwork,
                                int64_t* iwork );
int64_t LAPACKE_zggsvd_work_64( int matrix_layout, char jobu, char jobv,
                                char jobq, int64_t m, int64_t n,
                                int64_t p, int64_t* k, int64_t* l,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb,
                                double* alpha, double* beta,
                                lapack_complex_double* u, int64_t ldu,
                                lapack_complex_double* v, int64_t ldv,
                                lapack_complex_double* q, int64_t ldq,
                                lapack_complex_double* work, double* rwork,
                                int64_t* iwork );

int64_t LAPACKE_sggsvd3_work_64( int matrix_layout, char jobu, char jobv,
                                 char jobq, int64_t m, int64_t n,
                                 int64_t p, int64_t* k, int64_t* l,
                                 float* a, int64_t lda, float* b,
                                 int64_t ldb, float* alpha, float* beta,
                                 float* u, int64_t ldu, float* v,
                                 int64_t ldv, float* q, int64_t ldq,
                                 float* work, int64_t lwork,
                                 int64_t* iwork );
int64_t LAPACKE_dggsvd3_work_64( int matrix_layout, char jobu, char jobv,
                                 char jobq, int64_t m, int64_t n,
                                 int64_t p, int64_t* k, int64_t* l,
                                 double* a, int64_t lda, double* b,
                                 int64_t ldb, double* alpha, double* beta,
                                 double* u, int64_t ldu, double* v,
                                 int64_t ldv, double* q, int64_t ldq,
                                 double* work, int64_t lwork,
                                 int64_t* iwork );
int64_t LAPACKE_cggsvd3_work_64( int matrix_layout, char jobu, char jobv,
                                 char jobq, int64_t m, int64_t n,
                                 int64_t p, int64_t* k, int64_t* l,
                                 lapack_complex_float* a, int64_t lda,
                                 lapack_complex_float* b, int64_t ldb,
                                 float* alpha, float* beta,
                                 lapack_complex_float* u, int64_t ldu,
                                 lapack_complex_float* v, int64_t ldv,
                                 lapack_complex_float* q, int64_t ldq,
                                 lapack_complex_float* work, int64_t lwork,
                                 float* rwork, int64_t* iwork );
int64_t LAPACKE_zggsvd3_work_64( int matrix_layout, char jobu, char jobv,
                                 char jobq, int64_t m, int64_t n,
                                 int64_t p, int64_t* k, int64_t* l,
                                 lapack_complex_double* a, int64_t lda,
                                 lapack_complex_double* b, int64_t ldb,
                                 double* alpha, double* beta,
                                 lapack_complex_double* u, int64_t ldu,
                                 lapack_complex_double* v, int64_t ldv,
                                 lapack_complex_double* q, int64_t ldq,
                                 lapack_complex_double* work, int64_t lwork,
                                 double* rwork, int64_t* iwork );

int64_t LAPACKE_sggsvp_work_64( int matrix_layout, char jobu, char jobv,
                                char jobq, int64_t m, int64_t p,
                                int64_t n, float* a, int64_t lda,
                                float* b, int64_t ldb, float tola,
                                float tolb, int64_t* k, int64_t* l,
                                float* u, int64_t ldu, float* v,
                                int64_t ldv, float* q, int64_t ldq,
                                int64_t* iwork, float* tau, float* work );
int64_t LAPACKE_dggsvp_work_64( int matrix_layout, char jobu, char jobv,
                                char jobq, int64_t m, int64_t p,
                                int64_t n, double* a, int64_t lda,
                                double* b, int64_t ldb, double tola,
                                double tolb, int64_t* k, int64_t* l,
                                double* u, int64_t ldu, double* v,
                                int64_t ldv, double* q, int64_t ldq,
                                int64_t* iwork, double* tau, double* work );
int64_t LAPACKE_cggsvp_work_64( int matrix_layout, char jobu, char jobv,
                                char jobq, int64_t m, int64_t p,
                                int64_t n, lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* b,
                                int64_t ldb, float tola, float tolb,
                                int64_t* k, int64_t* l,
                                lapack_complex_float* u, int64_t ldu,
                                lapack_complex_float* v, int64_t ldv,
                                lapack_complex_float* q, int64_t ldq,
                                int64_t* iwork, float* rwork,
                                lapack_complex_float* tau,
                                lapack_complex_float* work );
int64_t LAPACKE_zggsvp_work_64( int matrix_layout, char jobu, char jobv,
                                char jobq, int64_t m, int64_t p,
                                int64_t n, lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* b,
                                int64_t ldb, double tola, double tolb,
                                int64_t* k, int64_t* l,
                                lapack_complex_double* u, int64_t ldu,
                                lapack_complex_double* v, int64_t ldv,
                                lapack_complex_double* q, int64_t ldq,
                                int64_t* iwork, double* rwork,
                                lapack_complex_double* tau,
                                lapack_complex_double* work );

int64_t LAPACKE_sggsvp3_work_64( int matrix_layout, char jobu, char jobv,
                                 char jobq, int64_t m, int64_t p,
                                 int64_t n, float* a, int64_t lda,
                                 float* b, int64_t ldb, float tola,
                                 float tolb, int64_t* k, int64_t* l,
                                 float* u, int64_t ldu, float* v,
                                 int64_t ldv, float* q, int64_t ldq,
                                 int64_t* iwork, float* tau,
                                 float* work, int64_t lwork );
int64_t LAPACKE_dggsvp3_work_64( int matrix_layout, char jobu, char jobv,
                                 char jobq, int64_t m, int64_t p,
                                 int64_t n, double* a, int64_t lda,
                                 double* b, int64_t ldb, double tola,
                                 double tolb, int64_t* k, int64_t* l,
                                 double* u, int64_t ldu, double* v,
                                 int64_t ldv, double* q, int64_t ldq,
                                 int64_t* iwork, double* tau, double* work,
                                 int64_t lwork );
int64_t LAPACKE_cggsvp3_work_64( int matrix_layout, char jobu, char jobv,
                                 char jobq, int64_t m, int64_t p,
                                 int64_t n, lapack_complex_float* a,
                                 int64_t lda, lapack_complex_float* b,
                                 int64_t ldb, float tola, float tolb,
                                 int64_t* k, int64_t* l,
                                 lapack_complex_float* u, int64_t ldu,
                                 lapack_complex_float* v, int64_t ldv,
                                 lapack_complex_float* q, int64_t ldq,
                                 int64_t* iwork, float* rwork,
                                 lapack_complex_float* tau,
                                 lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zggsvp3_work_64( int matrix_layout, char jobu, char jobv,
                                 char jobq, int64_t m, int64_t p,
                                 int64_t n, lapack_complex_double* a,
                                 int64_t lda, lapack_complex_double* b,
                                 int64_t ldb, double tola, double tolb,
                                 int64_t* k, int64_t* l,
                                 lapack_complex_double* u, int64_t ldu,
                                 lapack_complex_double* v, int64_t ldv,
                                 lapack_complex_double* q, int64_t ldq,
                                 int64_t* iwork, double* rwork,
                                 lapack_complex_double* tau,
                                 lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgtcon_work_64( char norm, int64_t n, const float* dl,
                                const float* d, const float* du,
                                const float* du2, const int64_t* ipiv,
                                float anorm, float* rcond, float* work,
                                int64_t* iwork );
int64_t LAPACKE_dgtcon_work_64( char norm, int64_t n, const double* dl,
                                const double* d, const double* du,
                                const double* du2, const int64_t* ipiv,
                                double anorm, double* rcond, double* work,
                                int64_t* iwork );
int64_t LAPACKE_cgtcon_work_64( char norm, int64_t n,
                                const lapack_complex_float* dl,
                                const lapack_complex_float* d,
                                const lapack_complex_float* du,
                                const lapack_complex_float* du2,
                                const int64_t* ipiv, float anorm,
                                float* rcond, lapack_complex_float* work );
int64_t LAPACKE_zgtcon_work_64( char norm, int64_t n,
                                const lapack_complex_double* dl,
                                const lapack_complex_double* d,
                                const lapack_complex_double* du,
                                const lapack_complex_double* du2,
                                const int64_t* ipiv, double anorm,
                                double* rcond, lapack_complex_double* work );

int64_t LAPACKE_sgtrfs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs, const float* dl,
                                const float* d, const float* du,
                                const float* dlf, const float* df,
                                const float* duf, const float* du2,
                                const int64_t* ipiv, const float* b,
                                int64_t ldb, float* x, int64_t ldx,
                                float* ferr, float* berr, float* work,
                                int64_t* iwork );
int64_t LAPACKE_dgtrfs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs, const double* dl,
                                const double* d, const double* du,
                                const double* dlf, const double* df,
                                const double* duf, const double* du2,
                                const int64_t* ipiv, const double* b,
                                int64_t ldb, double* x, int64_t ldx,
                                double* ferr, double* berr, double* work,
                                int64_t* iwork );
int64_t LAPACKE_cgtrfs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs, const lapack_complex_float* dl,
                                const lapack_complex_float* d,
                                const lapack_complex_float* du,
                                const lapack_complex_float* dlf,
                                const lapack_complex_float* df,
                                const lapack_complex_float* duf,
                                const lapack_complex_float* du2,
                                const int64_t* ipiv,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* x, int64_t ldx,
                                float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zgtrfs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs,
                                const lapack_complex_double* dl,
                                const lapack_complex_double* d,
                                const lapack_complex_double* du,
                                const lapack_complex_double* dlf,
                                const lapack_complex_double* df,
                                const lapack_complex_double* duf,
                                const lapack_complex_double* du2,
                                const int64_t* ipiv,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_sgtsv_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                               float* dl, float* d, float* du, float* b,
                               int64_t ldb );
int64_t LAPACKE_dgtsv_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                               double* dl, double* d, double* du, double* b,
                               int64_t ldb );
int64_t LAPACKE_cgtsv_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                               lapack_complex_float* dl,
                               lapack_complex_float* d,
                               lapack_complex_float* du,
                               lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zgtsv_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                               lapack_complex_double* dl,
                               lapack_complex_double* d,
                               lapack_complex_double* du,
                               lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_sgtsvx_work_64( int matrix_layout, char fact, char trans,
                                int64_t n, int64_t nrhs, const float* dl,
                                const float* d, const float* du, float* dlf,
                                float* df, float* duf, float* du2,
                                int64_t* ipiv, const float* b,
                                int64_t ldb, float* x, int64_t ldx,
                                float* rcond, float* ferr, float* berr,
                                float* work, int64_t* iwork );
int64_t LAPACKE_dgtsvx_work_64( int matrix_layout, char fact, char trans,
                                int64_t n, int64_t nrhs, const double* dl,
                                const double* d, const double* du, double* dlf,
                                double* df, double* duf, double* du2,
                                int64_t* ipiv, const double* b,
                                int64_t ldb, double* x, int64_t ldx,
                                double* rcond, double* ferr, double* berr,
                                double* work, int64_t* iwork );
int64_t LAPACKE_cgtsvx_work_64( int matrix_layout, char fact, char trans,
                                int64_t n, int64_t nrhs,
                                const lapack_complex_float* dl,
                                const lapack_complex_float* d,
                                const lapack_complex_float* du,
                                lapack_complex_float* dlf,
                                lapack_complex_float* df,
                                lapack_complex_float* duf,
                                lapack_complex_float* du2, int64_t* ipiv,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* x, int64_t ldx,
                                float* rcond, float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zgtsvx_work_64( int matrix_layout, char fact, char trans,
                                int64_t n, int64_t nrhs,
                                const lapack_complex_double* dl,
                                const lapack_complex_double* d,
                                const lapack_complex_double* du,
                                lapack_complex_double* dlf,
                                lapack_complex_double* df,
                                lapack_complex_double* duf,
                                lapack_complex_double* du2, int64_t* ipiv,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* rcond, double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_sgttrf_work_64( int64_t n, float* dl, float* d, float* du,
                                float* du2, int64_t* ipiv );
int64_t LAPACKE_dgttrf_work_64( int64_t n, double* dl, double* d, double* du,
                                double* du2, int64_t* ipiv );
int64_t LAPACKE_cgttrf_work_64( int64_t n, lapack_complex_float* dl,
                                lapack_complex_float* d,
                                lapack_complex_float* du,
                                lapack_complex_float* du2, int64_t* ipiv );
int64_t LAPACKE_zgttrf_work_64( int64_t n, lapack_complex_double* dl,
                                lapack_complex_double* d,
                                lapack_complex_double* du,
                                lapack_complex_double* du2, int64_t* ipiv );

int64_t LAPACKE_sgttrs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs, const float* dl,
                                const float* d, const float* du,
                                const float* du2, const int64_t* ipiv,
                                float* b, int64_t ldb );
int64_t LAPACKE_dgttrs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs, const double* dl,
                                const double* d, const double* du,
                                const double* du2, const int64_t* ipiv,
                                double* b, int64_t ldb );
int64_t LAPACKE_cgttrs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs, const lapack_complex_float* dl,
                                const lapack_complex_float* d,
                                const lapack_complex_float* du,
                                const lapack_complex_float* du2,
                                const int64_t* ipiv, lapack_complex_float* b,
                                int64_t ldb );
int64_t LAPACKE_zgttrs_work_64( int matrix_layout, char trans, int64_t n,
                                int64_t nrhs,
                                const lapack_complex_double* dl,
                                const lapack_complex_double* d,
                                const lapack_complex_double* du,
                                const lapack_complex_double* du2,
                                const int64_t* ipiv,
                                lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_chbev_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, int64_t kd,
                               lapack_complex_float* ab, int64_t ldab,
                               float* w, lapack_complex_float* z,
                               int64_t ldz, lapack_complex_float* work,
                               float* rwork );
int64_t LAPACKE_zhbev_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, int64_t kd,
                               lapack_complex_double* ab, int64_t ldab,
                               double* w, lapack_complex_double* z,
                               int64_t ldz, lapack_complex_double* work,
                               double* rwork );

int64_t LAPACKE_chbevd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, int64_t kd,
                                lapack_complex_float* ab, int64_t ldab,
                                float* w, lapack_complex_float* z,
                                int64_t ldz, lapack_complex_float* work,
                                int64_t lwork, float* rwork,
                                int64_t lrwork, int64_t* iwork,
                                int64_t liwork );
int64_t LAPACKE_zhbevd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, int64_t kd,
                                lapack_complex_double* ab, int64_t ldab,
                                double* w, lapack_complex_double* z,
                                int64_t ldz, lapack_complex_double* work,
                                int64_t lwork, double* rwork,
                                int64_t lrwork, int64_t* iwork,
                                int64_t liwork );

int64_t LAPACKE_chbevx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, int64_t kd,
                                lapack_complex_float* ab, int64_t ldab,
                                lapack_complex_float* q, int64_t ldq,
                                float vl, float vu, int64_t il,
                                int64_t iu, float abstol, int64_t* m,
                                float* w, lapack_complex_float* z,
                                int64_t ldz, lapack_complex_float* work,
                                float* rwork, int64_t* iwork,
                                int64_t* ifail );
int64_t LAPACKE_zhbevx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, int64_t kd,
                                lapack_complex_double* ab, int64_t ldab,
                                lapack_complex_double* q, int64_t ldq,
                                double vl, double vu, int64_t il,
                                int64_t iu, double abstol, int64_t* m,
                                double* w, lapack_complex_double* z,
                                int64_t ldz, lapack_complex_double* work,
                                double* rwork, int64_t* iwork,
                                int64_t* ifail );

int64_t LAPACKE_chbgst_work_64( int matrix_layout, char vect, char uplo,
                                int64_t n, int64_t ka, int64_t kb,
                                lapack_complex_float* ab, int64_t ldab,
                                const lapack_complex_float* bb, int64_t ldbb,
                                lapack_complex_float* x, int64_t ldx,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zhbgst_work_64( int matrix_layout, char vect, char uplo,
                                int64_t n, int64_t ka, int64_t kb,
                                lapack_complex_double* ab, int64_t ldab,
                                const lapack_complex_double* bb,
                                int64_t ldbb, lapack_complex_double* x,
                                int64_t ldx, lapack_complex_double* work,
                                double* rwork );

int64_t LAPACKE_chbgv_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, int64_t ka, int64_t kb,
                               lapack_complex_float* ab, int64_t ldab,
                               lapack_complex_float* bb, int64_t ldbb,
                               float* w, lapack_complex_float* z,
                               int64_t ldz, lapack_complex_float* work,
                               float* rwork );
int64_t LAPACKE_zhbgv_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, int64_t ka, int64_t kb,
                               lapack_complex_double* ab, int64_t ldab,
                               lapack_complex_double* bb, int64_t ldbb,
                               double* w, lapack_complex_double* z,
                               int64_t ldz, lapack_complex_double* work,
                               double* rwork );

int64_t LAPACKE_chbgvd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, int64_t ka, int64_t kb,
                                lapack_complex_float* ab, int64_t ldab,
                                lapack_complex_float* bb, int64_t ldbb,
                                float* w, lapack_complex_float* z,
                                int64_t ldz, lapack_complex_float* work,
                                int64_t lwork, float* rwork,
                                int64_t lrwork, int64_t* iwork,
                                int64_t liwork );
int64_t LAPACKE_zhbgvd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, int64_t ka, int64_t kb,
                                lapack_complex_double* ab, int64_t ldab,
                                lapack_complex_double* bb, int64_t ldbb,
                                double* w, lapack_complex_double* z,
                                int64_t ldz, lapack_complex_double* work,
                                int64_t lwork, double* rwork,
                                int64_t lrwork, int64_t* iwork,
                                int64_t liwork );

int64_t LAPACKE_chbgvx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, int64_t ka,
                                int64_t kb, lapack_complex_float* ab,
                                int64_t ldab, lapack_complex_float* bb,
                                int64_t ldbb, lapack_complex_float* q,
                                int64_t ldq, float vl, float vu,
                                int64_t il, int64_t iu, float abstol,
                                int64_t* m, float* w,
                                lapack_complex_float* z, int64_t ldz,
                                lapack_complex_float* work, float* rwork,
                                int64_t* iwork, int64_t* ifail );
int64_t LAPACKE_zhbgvx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, int64_t ka,
                                int64_t kb, lapack_complex_double* ab,
                                int64_t ldab, lapack_complex_double* bb,
                                int64_t ldbb, lapack_complex_double* q,
                                int64_t ldq, double vl, double vu,
                                int64_t il, int64_t iu, double abstol,
                                int64_t* m, double* w,
                                lapack_complex_double* z, int64_t ldz,
                                lapack_complex_double* work, double* rwork,
                                int64_t* iwork, int64_t* ifail );

int64_t LAPACKE_chbtrd_work_64( int matrix_layout, char vect, char uplo,
                                int64_t n, int64_t kd,
                                lapack_complex_float* ab, int64_t ldab,
                                float* d, float* e, lapack_complex_float* q,
                                int64_t ldq, lapack_complex_float* work );
int64_t LAPACKE_zhbtrd_work_64( int matrix_layout, char vect, char uplo,
                                int64_t n, int64_t kd,
                                lapack_complex_double* ab, int64_t ldab,
                                double* d, double* e, lapack_complex_double* q,
                                int64_t ldq, lapack_complex_double* work );

int64_t LAPACKE_checon_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                const int64_t* ipiv, float anorm,
                                float* rcond, lapack_complex_float* work );
int64_t LAPACKE_zhecon_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                const int64_t* ipiv, double anorm,
                                double* rcond, lapack_complex_double* work );

int64_t LAPACKE_cheequb_work_64( int matrix_layout, char uplo, int64_t n,
                                 const lapack_complex_float* a, int64_t lda,
                                 float* s, float* scond, float* amax,
                                 lapack_complex_float* work );
int64_t LAPACKE_zheequb_work_64( int matrix_layout, char uplo, int64_t n,
                                 const lapack_complex_double* a, int64_t lda,
                                 double* s, double* scond, double* amax,
                                 lapack_complex_double* work );

int64_t LAPACKE_cheev_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, lapack_complex_float* a,
                               int64_t lda, float* w,
                               lapack_complex_float* work, int64_t lwork,
                               float* rwork );
int64_t LAPACKE_zheev_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, lapack_complex_double* a,
                               int64_t lda, double* w,
                               lapack_complex_double* work, int64_t lwork,
                               double* rwork );

int64_t LAPACKE_cheevd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, lapack_complex_float* a,
                                int64_t lda, float* w,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork, int64_t lrwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_zheevd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, lapack_complex_double* a,
                                int64_t lda, double* w,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork, int64_t lrwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_cheevr_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                float vl, float vu, int64_t il,
                                int64_t iu, float abstol, int64_t* m,
                                float* w, lapack_complex_float* z,
                                int64_t ldz, int64_t* isuppz,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork, int64_t lrwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_zheevr_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                double vl, double vu, int64_t il,
                                int64_t iu, double abstol, int64_t* m,
                                double* w, lapack_complex_double* z,
                                int64_t ldz, int64_t* isuppz,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork, int64_t lrwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_cheevx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                float vl, float vu, int64_t il,
                                int64_t iu, float abstol, int64_t* m,
                                float* w, lapack_complex_float* z,
                                int64_t ldz, lapack_complex_float* work,
                                int64_t lwork, float* rwork,
                                int64_t* iwork, int64_t* ifail );
int64_t LAPACKE_zheevx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                double vl, double vu, int64_t il,
                                int64_t iu, double abstol, int64_t* m,
                                double* w, lapack_complex_double* z,
                                int64_t ldz, lapack_complex_double* work,
                                int64_t lwork, double* rwork,
                                int64_t* iwork, int64_t* ifail );

int64_t LAPACKE_chegst_work_64( int matrix_layout, int64_t itype, char uplo,
                                int64_t n, lapack_complex_float* a,
                                int64_t lda, const lapack_complex_float* b,
                                int64_t ldb );
int64_t LAPACKE_zhegst_work_64( int matrix_layout, int64_t itype, char uplo,
                                int64_t n, lapack_complex_double* a,
                                int64_t lda, const lapack_complex_double* b,
                                int64_t ldb );

int64_t LAPACKE_chegv_work_64( int matrix_layout, int64_t itype, char jobz,
                               char uplo, int64_t n, lapack_complex_float* a,
                               int64_t lda, lapack_complex_float* b,
                               int64_t ldb, float* w,
                               lapack_complex_float* work, int64_t lwork,
                               float* rwork );
int64_t LAPACKE_zhegv_work_64( int matrix_layout, int64_t itype, char jobz,
                               char uplo, int64_t n,
                               lapack_complex_double* a, int64_t lda,
                               lapack_complex_double* b, int64_t ldb,
                               double* w, lapack_complex_double* work,
                               int64_t lwork, double* rwork );

int64_t LAPACKE_chegvd_work_64( int matrix_layout, int64_t itype, char jobz,
                                char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb,
                                float* w, lapack_complex_float* work,
                                int64_t lwork, float* rwork,
                                int64_t lrwork, int64_t* iwork,
                                int64_t liwork );
int64_t LAPACKE_zhegvd_work_64( int matrix_layout, int64_t itype, char jobz,
                                char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb,
                                double* w, lapack_complex_double* work,
                                int64_t lwork, double* rwork,
                                int64_t lrwork, int64_t* iwork,
                                int64_t liwork );

int64_t LAPACKE_chegvx_work_64( int matrix_layout, int64_t itype, char jobz,
                                char range, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb,
                                float vl, float vu, int64_t il,
                                int64_t iu, float abstol, int64_t* m,
                                float* w, lapack_complex_float* z,
                                int64_t ldz, lapack_complex_float* work,
                                int64_t lwork, float* rwork,
                                int64_t* iwork, int64_t* ifail );
int64_t LAPACKE_zhegvx_work_64( int matrix_layout, int64_t itype, char jobz,
                                char range, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb,
                                double vl, double vu, int64_t il,
                                int64_t iu, double abstol, int64_t* m,
                                double* w, lapack_complex_double* z,
                                int64_t ldz, lapack_complex_double* work,
                                int64_t lwork, double* rwork,
                                int64_t* iwork, int64_t* ifail );

int64_t LAPACKE_cherfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_float* a,
                                int64_t lda, const lapack_complex_float* af,
                                int64_t ldaf, const int64_t* ipiv,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* x, int64_t ldx,
                                float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zherfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_double* a,
                                int64_t lda, const lapack_complex_double* af,
                                int64_t ldaf, const int64_t* ipiv,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_cherfsx_work_64( int matrix_layout, char uplo, char equed,
                                 int64_t n, int64_t nrhs,
                                 const lapack_complex_float* a, int64_t lda,
                                 const lapack_complex_float* af,
                                 int64_t ldaf, const int64_t* ipiv,
                                 const float* s, const lapack_complex_float* b,
                                 int64_t ldb, lapack_complex_float* x,
                                 int64_t ldx, float* rcond, float* berr,
                                 int64_t n_err_bnds, float* err_bnds_norm,
                                 float* err_bnds_comp, int64_t nparams,
                                 float* params, lapack_complex_float* work,
                                 float* rwork );
int64_t LAPACKE_zherfsx_work_64( int matrix_layout, char uplo, char equed,
                                 int64_t n, int64_t nrhs,
                                 const lapack_complex_double* a, int64_t lda,
                                 const lapack_complex_double* af,
                                 int64_t ldaf, const int64_t* ipiv,
                                 const double* s,
                                 const lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* x, int64_t ldx,
                                 double* rcond, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, lapack_complex_double* work,
                                 double* rwork );

int64_t LAPACKE_chesv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* a,
                               int64_t lda, int64_t* ipiv,
                               lapack_complex_float* b, int64_t ldb,
                               lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zhesv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* a,
                               int64_t lda, int64_t* ipiv,
                               lapack_complex_double* b, int64_t ldb,
                               lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_chesvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs,
                                const lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* af, int64_t ldaf,
                                int64_t* ipiv, const lapack_complex_float* b,
                                int64_t ldb, lapack_complex_float* x,
                                int64_t ldx, float* rcond, float* ferr,
                                float* berr, lapack_complex_float* work,
                                int64_t lwork, float* rwork );
int64_t LAPACKE_zhesvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs,
                                const lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* af, int64_t ldaf,
                                int64_t* ipiv,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* rcond, double* ferr, double* berr,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork );

int64_t LAPACKE_chesvxx_work_64( int matrix_layout, char fact, char uplo,
                                 int64_t n, int64_t nrhs,
                                 lapack_complex_float* a, int64_t lda,
                                 lapack_complex_float* af, int64_t ldaf,
                                 int64_t* ipiv, char* equed, float* s,
                                 lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* x, int64_t ldx,
                                 float* rcond, float* rpvgrw, float* berr,
                                 int64_t n_err_bnds, float* err_bnds_norm,
                                 float* err_bnds_comp, int64_t nparams,
                                 float* params, lapack_complex_float* work,
                                 float* rwork );
int64_t LAPACKE_zhesvxx_work_64( int matrix_layout, char fact, char uplo,
                                 int64_t n, int64_t nrhs,
                                 lapack_complex_double* a, int64_t lda,
                                 lapack_complex_double* af, int64_t ldaf,
                                 int64_t* ipiv, char* equed, double* s,
                                 lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* x, int64_t ldx,
                                 double* rcond, double* rpvgrw, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, lapack_complex_double* work,
                                 double* rwork );

int64_t LAPACKE_chetrd_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                float* d, float* e, lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zhetrd_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                double* d, double* e,
                                lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_chetrf_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                int64_t* ipiv, lapack_complex_float* work,
                                int64_t lwork );
int64_t LAPACKE_zhetrf_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* ipiv, lapack_complex_double* work,
                                int64_t lwork );

int64_t LAPACKE_chetri_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                const int64_t* ipiv,
                                lapack_complex_float* work );
int64_t LAPACKE_zhetri_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                const int64_t* ipiv,
                                lapack_complex_double* work );

int64_t LAPACKE_chetrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_float* a,
                                int64_t lda, const int64_t* ipiv,
                                lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zhetrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_double* a,
                                int64_t lda, const int64_t* ipiv,
                                lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_chfrk_work_64( int matrix_layout, char transr, char uplo,
                               char trans, int64_t n, int64_t k,
                               float alpha, const lapack_complex_float* a,
                               int64_t lda, float beta,
                               lapack_complex_float* c );
int64_t LAPACKE_zhfrk_work_64( int matrix_layout, char transr, char uplo,
                               char trans, int64_t n, int64_t k,
                               double alpha, const lapack_complex_double* a,
                               int64_t lda, double beta,
                               lapack_complex_double* c );

int64_t LAPACKE_shgeqz_work_64( int matrix_layout, char job, char compq,
                                char compz, int64_t n, int64_t ilo,
                                int64_t ihi, float* h, int64_t ldh,
                                float* t, int64_t ldt, float* alphar,
                                float* alphai, float* beta, float* q,
                                int64_t ldq, float* z, int64_t ldz,
                                float* work, int64_t lwork );
int64_t LAPACKE_dhgeqz_work_64( int matrix_layout, char job, char compq,
                                char compz, int64_t n, int64_t ilo,
                                int64_t ihi, double* h, int64_t ldh,
                                double* t, int64_t ldt, double* alphar,
                                double* alphai, double* beta, double* q,
                                int64_t ldq, double* z, int64_t ldz,
                                double* work, int64_t lwork );
int64_t LAPACKE_chgeqz_work_64( int matrix_layout, char job, char compq,
                                char compz, int64_t n, int64_t ilo,
                                int64_t ihi, lapack_complex_float* h,
                                int64_t ldh, lapack_complex_float* t,
                                int64_t ldt, lapack_complex_float* alpha,
                                lapack_complex_float* beta,
                                lapack_complex_float* q, int64_t ldq,
                                lapack_complex_float* z, int64_t ldz,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork );
int64_t LAPACKE_zhgeqz_work_64( int matrix_layout, char job, char compq,
                                char compz, int64_t n, int64_t ilo,
                                int64_t ihi, lapack_complex_double* h,
                                int64_t ldh, lapack_complex_double* t,
                                int64_t ldt, lapack_complex_double* alpha,
                                lapack_complex_double* beta,
                                lapack_complex_double* q, int64_t ldq,
                                lapack_complex_double* z, int64_t ldz,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork );

int64_t LAPACKE_chpcon_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_float* ap,
                                const int64_t* ipiv, float anorm,
                                float* rcond, lapack_complex_float* work );
int64_t LAPACKE_zhpcon_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_double* ap,
                                const int64_t* ipiv, double anorm,
                                double* rcond, lapack_complex_double* work );

int64_t LAPACKE_chpev_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, lapack_complex_float* ap, float* w,
                               lapack_complex_float* z, int64_t ldz,
                               lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zhpev_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, lapack_complex_double* ap,
                               double* w, lapack_complex_double* z,
                               int64_t ldz, lapack_complex_double* work,
                               double* rwork );

int64_t LAPACKE_chpevd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, lapack_complex_float* ap,
                                float* w, lapack_complex_float* z,
                                int64_t ldz, lapack_complex_float* work,
                                int64_t lwork, float* rwork,
                                int64_t lrwork, int64_t* iwork,
                                int64_t liwork );
int64_t LAPACKE_zhpevd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, lapack_complex_double* ap,
                                double* w, lapack_complex_double* z,
                                int64_t ldz, lapack_complex_double* work,
                                int64_t lwork, double* rwork,
                                int64_t lrwork, int64_t* iwork,
                                int64_t liwork );

int64_t LAPACKE_chpevx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n,
                                lapack_complex_float* ap, float vl, float vu,
                                int64_t il, int64_t iu, float abstol,
                                int64_t* m, float* w,
                                lapack_complex_float* z, int64_t ldz,
                                lapack_complex_float* work, float* rwork,
                                int64_t* iwork, int64_t* ifail );
int64_t LAPACKE_zhpevx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n,
                                lapack_complex_double* ap, double vl, double vu,
                                int64_t il, int64_t iu, double abstol,
                                int64_t* m, double* w,
                                lapack_complex_double* z, int64_t ldz,
                                lapack_complex_double* work, double* rwork,
                                int64_t* iwork, int64_t* ifail );

int64_t LAPACKE_chpgst_work_64( int matrix_layout, int64_t itype, char uplo,
                                int64_t n, lapack_complex_float* ap,
                                const lapack_complex_float* bp );
int64_t LAPACKE_zhpgst_work_64( int matrix_layout, int64_t itype, char uplo,
                                int64_t n, lapack_complex_double* ap,
                                const lapack_complex_double* bp );

int64_t LAPACKE_chpgv_work_64( int matrix_layout, int64_t itype, char jobz,
                               char uplo, int64_t n,
                               lapack_complex_float* ap,
                               lapack_complex_float* bp, float* w,
                               lapack_complex_float* z, int64_t ldz,
                               lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zhpgv_work_64( int matrix_layout, int64_t itype, char jobz,
                               char uplo, int64_t n,
                               lapack_complex_double* ap,
                               lapack_complex_double* bp, double* w,
                               lapack_complex_double* z, int64_t ldz,
                               lapack_complex_double* work, double* rwork );

int64_t LAPACKE_chpgvd_work_64( int matrix_layout, int64_t itype, char jobz,
                                char uplo, int64_t n,
                                lapack_complex_float* ap,
                                lapack_complex_float* bp, float* w,
                                lapack_complex_float* z, int64_t ldz,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork, int64_t lrwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_zhpgvd_work_64( int matrix_layout, int64_t itype, char jobz,
                                char uplo, int64_t n,
                                lapack_complex_double* ap,
                                lapack_complex_double* bp, double* w,
                                lapack_complex_double* z, int64_t ldz,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork, int64_t lrwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_chpgvx_work_64( int matrix_layout, int64_t itype, char jobz,
                                char range, char uplo, int64_t n,
                                lapack_complex_float* ap,
                                lapack_complex_float* bp, float vl, float vu,
                                int64_t il, int64_t iu, float abstol,
                                int64_t* m, float* w,
                                lapack_complex_float* z, int64_t ldz,
                                lapack_complex_float* work, float* rwork,
                                int64_t* iwork, int64_t* ifail );
int64_t LAPACKE_zhpgvx_work_64( int matrix_layout, int64_t itype, char jobz,
                                char range, char uplo, int64_t n,
                                lapack_complex_double* ap,
                                lapack_complex_double* bp, double vl, double vu,
                                int64_t il, int64_t iu, double abstol,
                                int64_t* m, double* w,
                                lapack_complex_double* z, int64_t ldz,
                                lapack_complex_double* work, double* rwork,
                                int64_t* iwork, int64_t* ifail );

int64_t LAPACKE_chprfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_float* ap,
                                const lapack_complex_float* afp,
                                const int64_t* ipiv,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* x, int64_t ldx,
                                float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zhprfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs,
                                const lapack_complex_double* ap,
                                const lapack_complex_double* afp,
                                const int64_t* ipiv,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_chpsv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* ap,
                               int64_t* ipiv, lapack_complex_float* b,
                               int64_t ldb );
int64_t LAPACKE_zhpsv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* ap,
                               int64_t* ipiv, lapack_complex_double* b,
                               int64_t ldb );

int64_t LAPACKE_chpsvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs,
                                const lapack_complex_float* ap,
                                lapack_complex_float* afp, int64_t* ipiv,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* x, int64_t ldx,
                                float* rcond, float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zhpsvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs,
                                const lapack_complex_double* ap,
                                lapack_complex_double* afp, int64_t* ipiv,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* rcond, double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_chptrd_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* ap, float* d, float* e,
                                lapack_complex_float* tau );
int64_t LAPACKE_zhptrd_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* ap, double* d, double* e,
                                lapack_complex_double* tau );

int64_t LAPACKE_chptrf_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* ap, int64_t* ipiv );
int64_t LAPACKE_zhptrf_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* ap, int64_t* ipiv );

int64_t LAPACKE_chptri_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* ap,
                                const int64_t* ipiv,
                                lapack_complex_float* work );
int64_t LAPACKE_zhptri_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* ap,
                                const int64_t* ipiv,
                                lapack_complex_double* work );

int64_t LAPACKE_chptrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_float* ap,
                                const int64_t* ipiv, lapack_complex_float* b,
                                int64_t ldb );
int64_t LAPACKE_zhptrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs,
                                const lapack_complex_double* ap,
                                const int64_t* ipiv,
                                lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_shsein_work_64( int matrix_layout, char job, char eigsrc,
                                char initv, lapack_logical* select,
                                int64_t n, const float* h, int64_t ldh,
                                float* wr, const float* wi, float* vl,
                                int64_t ldvl, float* vr, int64_t ldvr,
                                int64_t mm, int64_t* m, float* work,
                                int64_t* ifaill, int64_t* ifailr );
int64_t LAPACKE_dhsein_work_64( int matrix_layout, char job, char eigsrc,
                                char initv, lapack_logical* select,
                                int64_t n, const double* h, int64_t ldh,
                                double* wr, const double* wi, double* vl,
                                int64_t ldvl, double* vr, int64_t ldvr,
                                int64_t mm, int64_t* m, double* work,
                                int64_t* ifaill, int64_t* ifailr );
int64_t LAPACKE_chsein_work_64( int matrix_layout, char job, char eigsrc,
                                char initv, const lapack_logical* select,
                                int64_t n, const lapack_complex_float* h,
                                int64_t ldh, lapack_complex_float* w,
                                lapack_complex_float* vl, int64_t ldvl,
                                lapack_complex_float* vr, int64_t ldvr,
                                int64_t mm, int64_t* m,
                                lapack_complex_float* work, float* rwork,
                                int64_t* ifaill, int64_t* ifailr );
int64_t LAPACKE_zhsein_work_64( int matrix_layout, char job, char eigsrc,
                                char initv, const lapack_logical* select,
                                int64_t n, const lapack_complex_double* h,
                                int64_t ldh, lapack_complex_double* w,
                                lapack_complex_double* vl, int64_t ldvl,
                                lapack_complex_double* vr, int64_t ldvr,
                                int64_t mm, int64_t* m,
                                lapack_complex_double* work, double* rwork,
                                int64_t* ifaill, int64_t* ifailr );

int64_t LAPACKE_shseqr_work_64( int matrix_layout, char job, char compz,
                                int64_t n, int64_t ilo, int64_t ihi,
                                float* h, int64_t ldh, float* wr, float* wi,
                                float* z, int64_t ldz, float* work,
                                int64_t lwork );
int64_t LAPACKE_dhseqr_work_64( int matrix_layout, char job, char compz,
                                int64_t n, int64_t ilo, int64_t ihi,
                                double* h, int64_t ldh, double* wr,
                                double* wi, double* z, int64_t ldz,
                                double* work, int64_t lwork );
int64_t LAPACKE_chseqr_work_64( int matrix_layout, char job, char compz,
                                int64_t n, int64_t ilo, int64_t ihi,
                                lapack_complex_float* h, int64_t ldh,
                                lapack_complex_float* w,
                                lapack_complex_float* z, int64_t ldz,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zhseqr_work_64( int matrix_layout, char job, char compz,
                                int64_t n, int64_t ilo, int64_t ihi,
                                lapack_complex_double* h, int64_t ldh,
                                lapack_complex_double* w,
                                lapack_complex_double* z, int64_t ldz,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_clacgv_work_64( int64_t n, lapack_complex_float* x,
                                int64_t incx );
int64_t LAPACKE_zlacgv_work_64( int64_t n, lapack_complex_double* x,
                                int64_t incx );

int64_t LAPACKE_slacn2_work_64( int64_t n, float* v, float* x,
                                int64_t* isgn, float* est, int64_t* kase,
                                int64_t* isave );
int64_t LAPACKE_dlacn2_work_64( int64_t n, double* v, double* x,
                                int64_t* isgn, double* est, int64_t* kase,
                                int64_t* isave );
int64_t LAPACKE_clacn2_work_64( int64_t n, lapack_complex_float* v,
                                lapack_complex_float* x,
                                float* est, int64_t* kase,
                                int64_t* isave );
int64_t LAPACKE_zlacn2_work_64( int64_t n, lapack_complex_double* v,
                                lapack_complex_double* x,
                                double* est, int64_t* kase,
                                int64_t* isave );

int64_t LAPACKE_slacpy_work_64( int matrix_layout, char uplo, int64_t m,
                                int64_t n, const float* a, int64_t lda,
                                float* b, int64_t ldb );
int64_t LAPACKE_dlacpy_work_64( int matrix_layout, char uplo, int64_t m,
                                int64_t n, const double* a, int64_t lda,
                                double* b, int64_t ldb );
int64_t LAPACKE_clacpy_work_64( int matrix_layout, char uplo, int64_t m,
                                int64_t n, const lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* b,
                                int64_t ldb );
int64_t LAPACKE_zlacpy_work_64( int matrix_layout, char uplo, int64_t m,
                                int64_t n, const lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* b,
                                int64_t ldb );

int64_t LAPACKE_clacp2_work_64( int matrix_layout, char uplo, int64_t m,
                                int64_t n, const float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zlacp2_work_64( int matrix_layout, char uplo, int64_t m,
                                int64_t n, const double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_zlag2c_work_64( int matrix_layout, int64_t m, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                lapack_complex_float* sa, int64_t ldsa );

int64_t LAPACKE_slag2d_work_64( int matrix_layout, int64_t m, int64_t n,
                                const float* sa, int64_t ldsa, double* a,
                                int64_t lda );

int64_t LAPACKE_dlag2s_work_64( int matrix_layout, int64_t m, int64_t n,
                                const double* a, int64_t lda, float* sa,
                                int64_t ldsa );

int64_t LAPACKE_clag2z_work_64( int matrix_layout, int64_t m, int64_t n,
                                const lapack_complex_float* sa, int64_t ldsa,
                                lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_slagge_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t kl, int64_t ku, const float* d,
                                float* a, int64_t lda, int64_t* iseed,
                                float* work );
int64_t LAPACKE_dlagge_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t kl, int64_t ku, const double* d,
                                double* a, int64_t lda, int64_t* iseed,
                                double* work );
int64_t LAPACKE_clagge_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t kl, int64_t ku, const float* d,
                                lapack_complex_float* a, int64_t lda,
                                int64_t* iseed, lapack_complex_float* work );
int64_t LAPACKE_zlagge_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t kl, int64_t ku, const double* d,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* iseed,
                                lapack_complex_double* work );

int64_t LAPACKE_claghe_work_64( int matrix_layout, int64_t n, int64_t k,
                                const float* d, lapack_complex_float* a,
                                int64_t lda, int64_t* iseed,
                                lapack_complex_float* work );
int64_t LAPACKE_zlaghe_work_64( int matrix_layout, int64_t n, int64_t k,
                                const double* d, lapack_complex_double* a,
                                int64_t lda, int64_t* iseed,
                                lapack_complex_double* work );

int64_t LAPACKE_slagsy_work_64( int matrix_layout, int64_t n, int64_t k,
                                const float* d, float* a, int64_t lda,
                                int64_t* iseed, float* work );
int64_t LAPACKE_dlagsy_work_64( int matrix_layout, int64_t n, int64_t k,
                                const double* d, double* a, int64_t lda,
                                int64_t* iseed, double* work );
int64_t LAPACKE_clagsy_work_64( int matrix_layout, int64_t n, int64_t k,
                                const float* d, lapack_complex_float* a,
                                int64_t lda, int64_t* iseed,
                                lapack_complex_float* work );
int64_t LAPACKE_zlagsy_work_64( int matrix_layout, int64_t n, int64_t k,
                                const double* d, lapack_complex_double* a,
                                int64_t lda, int64_t* iseed,
                                lapack_complex_double* work );

int64_t LAPACKE_slapmr_work_64( int matrix_layout, lapack_logical forwrd,
                                int64_t m, int64_t n, float* x,
                                int64_t ldx, int64_t* k );
int64_t LAPACKE_dlapmr_work_64( int matrix_layout, lapack_logical forwrd,
                                int64_t m, int64_t n, double* x,
                                int64_t ldx, int64_t* k );
int64_t LAPACKE_clapmr_work_64( int matrix_layout, lapack_logical forwrd,
                                int64_t m, int64_t n,
                                lapack_complex_float* x, int64_t ldx,
                                int64_t* k );
int64_t LAPACKE_zlapmr_work_64( int matrix_layout, lapack_logical forwrd,
                                int64_t m, int64_t n,
                                lapack_complex_double* x, int64_t ldx,
                                int64_t* k );

int64_t LAPACKE_slapmt_work_64( int matrix_layout, lapack_logical forwrd,
                                int64_t m, int64_t n, float* x,
                                int64_t ldx, int64_t* k );
int64_t LAPACKE_dlapmt_work_64( int matrix_layout, lapack_logical forwrd,
                                int64_t m, int64_t n, double* x,
                                int64_t ldx, int64_t* k );
int64_t LAPACKE_clapmt_work_64( int matrix_layout, lapack_logical forwrd,
                                int64_t m, int64_t n,
                                lapack_complex_float* x, int64_t ldx,
                                int64_t* k );
int64_t LAPACKE_zlapmt_work_64( int matrix_layout, lapack_logical forwrd,
                                int64_t m, int64_t n,
                                lapack_complex_double* x, int64_t ldx,
                                int64_t* k );

int64_t LAPACKE_slartgp_work_64( float f, float g, float* cs, float* sn,
                                 float* r );
int64_t LAPACKE_dlartgp_work_64( double f, double g, double* cs, double* sn,
                                 double* r );

int64_t LAPACKE_slartgs_work_64( float x, float y, float sigma, float* cs,
                                 float* sn );
int64_t LAPACKE_dlartgs_work_64( double x, double y, double sigma, double* cs,
                                 double* sn );

float LAPACKE_slapy2_work_64( float x, float y );
double LAPACKE_dlapy2_work_64( double x, double y );

float LAPACKE_slapy3_work_64( float x, float y, float z );
double LAPACKE_dlapy3_work_64( double x, double y, double z );

float LAPACKE_slamch_work_64( char cmach );
double LAPACKE_dlamch_work_64( char cmach );

float LAPACKE_slangb_work_64( int matrix_layout, char norm, int64_t n,
                           int64_t kl, int64_t ku, const float* ab,
                           int64_t ldab, float* work );
double LAPACKE_dlangb_work_64( int matrix_layout, char norm, int64_t n,
                            int64_t kl, int64_t ku, const double* ab,
                            int64_t ldab, double* work );
float LAPACKE_clangb_work_64( int matrix_layout, char norm, int64_t n,
                           int64_t kl, int64_t ku,
                           const lapack_complex_float* ab, int64_t ldab,
                           float* work );
double LAPACKE_zlangb_work_64( int matrix_layout, char norm, int64_t n,
                            int64_t kl, int64_t ku,
                            const lapack_complex_double* ab, int64_t ldab,
                            double* work );

float LAPACKE_slange_work_64( int matrix_layout, char norm, int64_t m,
                                int64_t n, const float* a, int64_t lda,
                                float* work );
double LAPACKE_dlange_work_64( int matrix_layout, char norm, int64_t m,
                                int64_t n, const double* a, int64_t lda,
                                double* work );
float LAPACKE_clange_work_64( int matrix_layout, char norm, int64_t m,
                                int64_t n, const lapack_complex_float* a,
                                int64_t lda, float* work );
double LAPACKE_zlange_work_64( int matrix_layout, char norm, int64_t m,
                                int64_t n, const lapack_complex_double* a,
                                int64_t lda, double* work );

float LAPACKE_clanhe_work_64( int matrix_layout, char norm, char uplo,
                                int64_t n, const lapack_complex_float* a,
                                int64_t lda, float* work );
double LAPACKE_zlanhe_work_64( int matrix_layout, char norm, char uplo,
                                int64_t n, const lapack_complex_double* a,
                                int64_t lda, double* work );

int64_t LAPACKE_clacrm_work_64( int matrix_layout, int64_t m, int64_t n,
                                const lapack_complex_float* a,
                                int64_t lda, const float* b,
                                int64_t ldb, lapack_complex_float* c,
                                int64_t ldc, float* work );
int64_t LAPACKE_zlacrm_work_64( int matrix_layout, int64_t m, int64_t n,
                                const lapack_complex_double* a,
                                int64_t lda, const double* b,
                                int64_t ldb, lapack_complex_double* c,
                                int64_t ldc, double* work );

int64_t LAPACKE_clarcm_work_64( int matrix_layout, int64_t m, int64_t n,
                                const float* a, int64_t lda,
                                const lapack_complex_float* b,
                                int64_t ldb, lapack_complex_float* c,
                                int64_t ldc, float* work );
int64_t LAPACKE_zlarcm_work_64( int matrix_layout, int64_t m, int64_t n,
                                const double* a, int64_t lda,
                                const lapack_complex_double* b,
                                int64_t ldb, lapack_complex_double* c,
                                int64_t ldc, double* work );

float LAPACKE_slansy_work_64( int matrix_layout, char norm, char uplo,
                                int64_t n, const float* a, int64_t lda,
                                float* work );
double LAPACKE_dlansy_work_64( int matrix_layout, char norm, char uplo,
                                int64_t n, const double* a, int64_t lda,
                                double* work );
float LAPACKE_clansy_work_64( int matrix_layout, char norm, char uplo,
                                int64_t n, const lapack_complex_float* a,
                                int64_t lda, float* work );
double LAPACKE_zlansy_work_64( int matrix_layout, char norm, char uplo,
                                int64_t n, const lapack_complex_double* a,
                                int64_t lda, double* work );

float LAPACKE_slantr_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t m, int64_t n, const float* a,
                                int64_t lda, float* work );
double LAPACKE_dlantr_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t m, int64_t n,
                                const double* a, int64_t lda, double* work );
float LAPACKE_clantr_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t m, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                float* work );
double LAPACKE_zlantr_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t m, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                double* work );

int64_t LAPACKE_slarfb_work_64( int matrix_layout, char side, char trans,
                                char direct, char storev, int64_t m,
                                int64_t n, int64_t k, const float* v,
                                int64_t ldv, const float* t, int64_t ldt,
                                float* c, int64_t ldc, float* work,
                                int64_t ldwork );
int64_t LAPACKE_dlarfb_work_64( int matrix_layout, char side, char trans,
                                char direct, char storev, int64_t m,
                                int64_t n, int64_t k, const double* v,
                                int64_t ldv, const double* t, int64_t ldt,
                                double* c, int64_t ldc, double* work,
                                int64_t ldwork );
int64_t LAPACKE_clarfb_work_64( int matrix_layout, char side, char trans,
                                char direct, char storev, int64_t m,
                                int64_t n, int64_t k,
                                const lapack_complex_float* v, int64_t ldv,
                                const lapack_complex_float* t, int64_t ldt,
                                lapack_complex_float* c, int64_t ldc,
                                lapack_complex_float* work, int64_t ldwork );
int64_t LAPACKE_zlarfb_work_64( int matrix_layout, char side, char trans,
                                char direct, char storev, int64_t m,
                                int64_t n, int64_t k,
                                const lapack_complex_double* v, int64_t ldv,
                                const lapack_complex_double* t, int64_t ldt,
                                lapack_complex_double* c, int64_t ldc,
                                lapack_complex_double* work,
                                int64_t ldwork );

int64_t LAPACKE_slarfg_work_64( int64_t n, float* alpha, float* x,
                                int64_t incx, float* tau );
int64_t LAPACKE_dlarfg_work_64( int64_t n, double* alpha, double* x,
                                int64_t incx, double* tau );
int64_t LAPACKE_clarfg_work_64( int64_t n, lapack_complex_float* alpha,
                                lapack_complex_float* x, int64_t incx,
                                lapack_complex_float* tau );
int64_t LAPACKE_zlarfg_work_64( int64_t n, lapack_complex_double* alpha,
                                lapack_complex_double* x, int64_t incx,
                                lapack_complex_double* tau );

int64_t LAPACKE_slarft_work_64( int matrix_layout, char direct, char storev,
                                int64_t n, int64_t k, const float* v,
                                int64_t ldv, const float* tau, float* t,
                                int64_t ldt );
int64_t LAPACKE_dlarft_work_64( int matrix_layout, char direct, char storev,
                                int64_t n, int64_t k, const double* v,
                                int64_t ldv, const double* tau, double* t,
                                int64_t ldt );
int64_t LAPACKE_clarft_work_64( int matrix_layout, char direct, char storev,
                                int64_t n, int64_t k,
                                const lapack_complex_float* v, int64_t ldv,
                                const lapack_complex_float* tau,
                                lapack_complex_float* t, int64_t ldt );
int64_t LAPACKE_zlarft_work_64( int matrix_layout, char direct, char storev,
                                int64_t n, int64_t k,
                                const lapack_complex_double* v, int64_t ldv,
                                const lapack_complex_double* tau,
                                lapack_complex_double* t, int64_t ldt );

int64_t LAPACKE_slarfx_work_64( int matrix_layout, char side, int64_t m,
                                int64_t n, const float* v, float tau,
                                float* c, int64_t ldc, float* work );
int64_t LAPACKE_dlarfx_work_64( int matrix_layout, char side, int64_t m,
                                int64_t n, const double* v, double tau,
                                double* c, int64_t ldc, double* work );
int64_t LAPACKE_clarfx_work_64( int matrix_layout, char side, int64_t m,
                                int64_t n, const lapack_complex_float* v,
                                lapack_complex_float tau,
                                lapack_complex_float* c, int64_t ldc,
                                lapack_complex_float* work );
int64_t LAPACKE_zlarfx_work_64( int matrix_layout, char side, int64_t m,
                                int64_t n, const lapack_complex_double* v,
                                lapack_complex_double tau,
                                lapack_complex_double* c, int64_t ldc,
                                lapack_complex_double* work );

int64_t LAPACKE_slarnv_work_64( int64_t idist, int64_t* iseed,
                                int64_t n, float* x );
int64_t LAPACKE_dlarnv_work_64( int64_t idist, int64_t* iseed,
                                int64_t n, double* x );
int64_t LAPACKE_clarnv_work_64( int64_t idist, int64_t* iseed,
                                int64_t n, lapack_complex_float* x );
int64_t LAPACKE_zlarnv_work_64( int64_t idist, int64_t* iseed,
                                int64_t n, lapack_complex_double* x );


int64_t LAPACKE_slascl_work_64( int matrix_layout, char type, int64_t kl,
                           int64_t ku, float cfrom, float cto,
                           int64_t m, int64_t n, float* a,
                           int64_t lda );
int64_t LAPACKE_dlascl_work_64( int matrix_layout, char type, int64_t kl,
                           int64_t ku, double cfrom, double cto,
                           int64_t m, int64_t n, double* a,
                           int64_t lda );
int64_t LAPACKE_clascl_work_64( int matrix_layout, char type, int64_t kl,
                           int64_t ku, float cfrom, float cto,
                           int64_t m, int64_t n, lapack_complex_float* a,
                           int64_t lda );
int64_t LAPACKE_zlascl_work_64( int matrix_layout, char type, int64_t kl,
                           int64_t ku, double cfrom, double cto,
                           int64_t m, int64_t n, lapack_complex_double* a,
                           int64_t lda );

int64_t LAPACKE_slaset_work_64( int matrix_layout, char uplo, int64_t m,
                                int64_t n, float alpha, float beta, float* a,
                                int64_t lda );
int64_t LAPACKE_dlaset_work_64( int matrix_layout, char uplo, int64_t m,
                                int64_t n, double alpha, double beta,
                                double* a, int64_t lda );
int64_t LAPACKE_claset_work_64( int matrix_layout, char uplo, int64_t m,
                                int64_t n, lapack_complex_float alpha,
                                lapack_complex_float beta,
                                lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_zlaset_work_64( int matrix_layout, char uplo, int64_t m,
                                int64_t n, lapack_complex_double alpha,
                                lapack_complex_double beta,
                                lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_slasrt_work_64( char id, int64_t n, float* d );
int64_t LAPACKE_dlasrt_work_64( char id, int64_t n, double* d );

int64_t LAPACKE_slassq_work_64( int64_t n,                 float* x, int64_t incx,  float* scale,  float* sumsq );
int64_t LAPACKE_dlassq_work_64( int64_t n,                double* x, int64_t incx, double* scale, double* sumsq );
int64_t LAPACKE_classq_work_64( int64_t n,  lapack_complex_float* x, int64_t incx,  float* scale,  float* sumsq );
int64_t LAPACKE_zlassq_work_64( int64_t n, lapack_complex_double* x, int64_t incx, double* scale, double* sumsq );

int64_t LAPACKE_slaswp_work_64( int matrix_layout, int64_t n, float* a,
                                int64_t lda, int64_t k1, int64_t k2,
                                const int64_t* ipiv, int64_t incx );
int64_t LAPACKE_dlaswp_work_64( int matrix_layout, int64_t n, double* a,
                                int64_t lda, int64_t k1, int64_t k2,
                                const int64_t* ipiv, int64_t incx );
int64_t LAPACKE_claswp_work_64( int matrix_layout, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                int64_t k1, int64_t k2,
                                const int64_t* ipiv, int64_t incx );
int64_t LAPACKE_zlaswp_work_64( int matrix_layout, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                int64_t k1, int64_t k2,
                                const int64_t* ipiv, int64_t incx );

int64_t LAPACKE_slatms_work_64( int matrix_layout, int64_t m, int64_t n,
                                char dist, int64_t* iseed, char sym,
                                float* d, int64_t mode, float cond,
                                float dmax, int64_t kl, int64_t ku,
                                char pack, float* a, int64_t lda,
                                float* work );
int64_t LAPACKE_dlatms_work_64( int matrix_layout, int64_t m, int64_t n,
                                char dist, int64_t* iseed, char sym,
                                double* d, int64_t mode, double cond,
                                double dmax, int64_t kl, int64_t ku,
                                char pack, double* a, int64_t lda,
                                double* work );
int64_t LAPACKE_clatms_work_64( int matrix_layout, int64_t m, int64_t n,
                                char dist, int64_t* iseed, char sym,
                                float* d, int64_t mode, float cond,
                                float dmax, int64_t kl, int64_t ku,
                                char pack, lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* work );
int64_t LAPACKE_zlatms_work_64( int matrix_layout, int64_t m, int64_t n,
                                char dist, int64_t* iseed, char sym,
                                double* d, int64_t mode, double cond,
                                double dmax, int64_t kl, int64_t ku,
                                char pack, lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* work );

int64_t LAPACKE_slauum_work_64( int matrix_layout, char uplo, int64_t n,
                                float* a, int64_t lda );
int64_t LAPACKE_dlauum_work_64( int matrix_layout, char uplo, int64_t n,
                                double* a, int64_t lda );
int64_t LAPACKE_clauum_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_zlauum_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_sopgtr_work_64( int matrix_layout, char uplo, int64_t n,
                                const float* ap, const float* tau, float* q,
                                int64_t ldq, float* work );
int64_t LAPACKE_dopgtr_work_64( int matrix_layout, char uplo, int64_t n,
                                const double* ap, const double* tau, double* q,
                                int64_t ldq, double* work );

int64_t LAPACKE_sopmtr_work_64( int matrix_layout, char side, char uplo,
                                char trans, int64_t m, int64_t n,
                                const float* ap, const float* tau, float* c,
                                int64_t ldc, float* work );
int64_t LAPACKE_dopmtr_work_64( int matrix_layout, char side, char uplo,
                                char trans, int64_t m, int64_t n,
                                const double* ap, const double* tau, double* c,
                                int64_t ldc, double* work );

int64_t LAPACKE_sorgbr_work_64( int matrix_layout, char vect, int64_t m,
                                int64_t n, int64_t k, float* a,
                                int64_t lda, const float* tau, float* work,
                                int64_t lwork );
int64_t LAPACKE_dorgbr_work_64( int matrix_layout, char vect, int64_t m,
                                int64_t n, int64_t k, double* a,
                                int64_t lda, const double* tau, double* work,
                                int64_t lwork );

int64_t LAPACKE_sorghr_work_64( int matrix_layout, int64_t n, int64_t ilo,
                                int64_t ihi, float* a, int64_t lda,
                                const float* tau, float* work,
                                int64_t lwork );
int64_t LAPACKE_dorghr_work_64( int matrix_layout, int64_t n, int64_t ilo,
                                int64_t ihi, double* a, int64_t lda,
                                const double* tau, double* work,
                                int64_t lwork );

int64_t LAPACKE_sorglq_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, float* a, int64_t lda,
                                const float* tau, float* work,
                                int64_t lwork );
int64_t LAPACKE_dorglq_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, double* a, int64_t lda,
                                const double* tau, double* work,
                                int64_t lwork );

int64_t LAPACKE_sorgql_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, float* a, int64_t lda,
                                const float* tau, float* work,
                                int64_t lwork );
int64_t LAPACKE_dorgql_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, double* a, int64_t lda,
                                const double* tau, double* work,
                                int64_t lwork );

int64_t LAPACKE_sorgqr_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, float* a, int64_t lda,
                                const float* tau, float* work,
                                int64_t lwork );
int64_t LAPACKE_dorgqr_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, double* a, int64_t lda,
                                const double* tau, double* work,
                                int64_t lwork );

int64_t LAPACKE_sorgrq_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, float* a, int64_t lda,
                                const float* tau, float* work,
                                int64_t lwork );
int64_t LAPACKE_dorgrq_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, double* a, int64_t lda,
                                const double* tau, double* work,
                                int64_t lwork );

int64_t LAPACKE_sorgtr_work_64( int matrix_layout, char uplo, int64_t n,
                                float* a, int64_t lda, const float* tau,
                                float* work, int64_t lwork );
int64_t LAPACKE_dorgtr_work_64( int matrix_layout, char uplo, int64_t n,
                                double* a, int64_t lda, const double* tau,
                                double* work, int64_t lwork );

int64_t LAPACKE_sorgtsqr_row_work_64( int matrix_layout,
                                      int64_t m, int64_t n,
                                      int64_t mb, int64_t nb,
                                      float* a, int64_t lda,
                                      const float* t, int64_t ldt,
                                      float* work, int64_t lwork );
int64_t LAPACKE_dorgtsqr_row_work_64( int matrix_layout,
                                      int64_t m, int64_t n,
                                      int64_t mb, int64_t nb,
                                      double* a, int64_t lda,
                                      const double* t, int64_t ldt,
                                      double* work, int64_t lwork );

int64_t LAPACKE_sormbr_work_64( int matrix_layout, char vect, char side,
                                char trans, int64_t m, int64_t n,
                                int64_t k, const float* a, int64_t lda,
                                const float* tau, float* c, int64_t ldc,
                                float* work, int64_t lwork );
int64_t LAPACKE_dormbr_work_64( int matrix_layout, char vect, char side,
                                char trans, int64_t m, int64_t n,
                                int64_t k, const double* a, int64_t lda,
                                const double* tau, double* c, int64_t ldc,
                                double* work, int64_t lwork );

int64_t LAPACKE_sormhr_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t ilo,
                                int64_t ihi, const float* a, int64_t lda,
                                const float* tau, float* c, int64_t ldc,
                                float* work, int64_t lwork );
int64_t LAPACKE_dormhr_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t ilo,
                                int64_t ihi, const double* a, int64_t lda,
                                const double* tau, double* c, int64_t ldc,
                                double* work, int64_t lwork );

int64_t LAPACKE_sormlq_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const float* a, int64_t lda,
                                const float* tau, float* c, int64_t ldc,
                                float* work, int64_t lwork );
int64_t LAPACKE_dormlq_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const double* a, int64_t lda,
                                const double* tau, double* c, int64_t ldc,
                                double* work, int64_t lwork );

int64_t LAPACKE_sormql_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const float* a, int64_t lda,
                                const float* tau, float* c, int64_t ldc,
                                float* work, int64_t lwork );
int64_t LAPACKE_dormql_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const double* a, int64_t lda,
                                const double* tau, double* c, int64_t ldc,
                                double* work, int64_t lwork );

int64_t LAPACKE_sormqr_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const float* a, int64_t lda,
                                const float* tau, float* c, int64_t ldc,
                                float* work, int64_t lwork );
int64_t LAPACKE_dormqr_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const double* a, int64_t lda,
                                const double* tau, double* c, int64_t ldc,
                                double* work, int64_t lwork );

int64_t LAPACKE_sormrq_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const float* a, int64_t lda,
                                const float* tau, float* c, int64_t ldc,
                                float* work, int64_t lwork );
int64_t LAPACKE_dormrq_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const double* a, int64_t lda,
                                const double* tau, double* c, int64_t ldc,
                                double* work, int64_t lwork );

int64_t LAPACKE_sormrz_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                int64_t l, const float* a, int64_t lda,
                                const float* tau, float* c, int64_t ldc,
                                float* work, int64_t lwork );
int64_t LAPACKE_dormrz_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                int64_t l, const double* a, int64_t lda,
                                const double* tau, double* c, int64_t ldc,
                                double* work, int64_t lwork );

int64_t LAPACKE_sormtr_work_64( int matrix_layout, char side, char uplo,
                                char trans, int64_t m, int64_t n,
                                const float* a, int64_t lda,
                                const float* tau, float* c, int64_t ldc,
                                float* work, int64_t lwork );
int64_t LAPACKE_dormtr_work_64( int matrix_layout, char side, char uplo,
                                char trans, int64_t m, int64_t n,
                                const double* a, int64_t lda,
                                const double* tau, double* c, int64_t ldc,
                                double* work, int64_t lwork );

int64_t LAPACKE_spbcon_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, const float* ab, int64_t ldab,
                                float anorm, float* rcond, float* work,
                                int64_t* iwork );
int64_t LAPACKE_dpbcon_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, const double* ab,
                                int64_t ldab, double anorm, double* rcond,
                                double* work, int64_t* iwork );
int64_t LAPACKE_cpbcon_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, const lapack_complex_float* ab,
                                int64_t ldab, float anorm, float* rcond,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zpbcon_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, const lapack_complex_double* ab,
                                int64_t ldab, double anorm, double* rcond,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_spbequ_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, const float* ab, int64_t ldab,
                                float* s, float* scond, float* amax );
int64_t LAPACKE_dpbequ_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, const double* ab,
                                int64_t ldab, double* s, double* scond,
                                double* amax );
int64_t LAPACKE_cpbequ_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, const lapack_complex_float* ab,
                                int64_t ldab, float* s, float* scond,
                                float* amax );
int64_t LAPACKE_zpbequ_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, const lapack_complex_double* ab,
                                int64_t ldab, double* s, double* scond,
                                double* amax );

int64_t LAPACKE_spbrfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, int64_t nrhs, const float* ab,
                                int64_t ldab, const float* afb,
                                int64_t ldafb, const float* b,
                                int64_t ldb, float* x, int64_t ldx,
                                float* ferr, float* berr, float* work,
                                int64_t* iwork );
int64_t LAPACKE_dpbrfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, int64_t nrhs,
                                const double* ab, int64_t ldab,
                                const double* afb, int64_t ldafb,
                                const double* b, int64_t ldb, double* x,
                                int64_t ldx, double* ferr, double* berr,
                                double* work, int64_t* iwork );
int64_t LAPACKE_cpbrfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, int64_t nrhs,
                                const lapack_complex_float* ab, int64_t ldab,
                                const lapack_complex_float* afb,
                                int64_t ldafb, const lapack_complex_float* b,
                                int64_t ldb, lapack_complex_float* x,
                                int64_t ldx, float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zpbrfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, int64_t nrhs,
                                const lapack_complex_double* ab,
                                int64_t ldab,
                                const lapack_complex_double* afb,
                                int64_t ldafb,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_spbstf_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kb, float* bb, int64_t ldbb );
int64_t LAPACKE_dpbstf_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kb, double* bb, int64_t ldbb );
int64_t LAPACKE_cpbstf_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kb, lapack_complex_float* bb,
                                int64_t ldbb );
int64_t LAPACKE_zpbstf_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kb, lapack_complex_double* bb,
                                int64_t ldbb );

int64_t LAPACKE_spbsv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t kd, int64_t nrhs, float* ab,
                               int64_t ldab, float* b, int64_t ldb );
int64_t LAPACKE_dpbsv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t kd, int64_t nrhs, double* ab,
                               int64_t ldab, double* b, int64_t ldb );
int64_t LAPACKE_cpbsv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t kd, int64_t nrhs,
                               lapack_complex_float* ab, int64_t ldab,
                               lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zpbsv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t kd, int64_t nrhs,
                               lapack_complex_double* ab, int64_t ldab,
                               lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_spbsvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t kd, int64_t nrhs,
                                float* ab, int64_t ldab, float* afb,
                                int64_t ldafb, char* equed, float* s,
                                float* b, int64_t ldb, float* x,
                                int64_t ldx, float* rcond, float* ferr,
                                float* berr, float* work, int64_t* iwork );
int64_t LAPACKE_dpbsvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t kd, int64_t nrhs,
                                double* ab, int64_t ldab, double* afb,
                                int64_t ldafb, char* equed, double* s,
                                double* b, int64_t ldb, double* x,
                                int64_t ldx, double* rcond, double* ferr,
                                double* berr, double* work, int64_t* iwork );
int64_t LAPACKE_cpbsvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t kd, int64_t nrhs,
                                lapack_complex_float* ab, int64_t ldab,
                                lapack_complex_float* afb, int64_t ldafb,
                                char* equed, float* s, lapack_complex_float* b,
                                int64_t ldb, lapack_complex_float* x,
                                int64_t ldx, float* rcond, float* ferr,
                                float* berr, lapack_complex_float* work,
                                float* rwork );
int64_t LAPACKE_zpbsvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t kd, int64_t nrhs,
                                lapack_complex_double* ab, int64_t ldab,
                                lapack_complex_double* afb, int64_t ldafb,
                                char* equed, double* s,
                                lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* rcond, double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_spbtrf_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, float* ab, int64_t ldab );
int64_t LAPACKE_dpbtrf_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, double* ab, int64_t ldab );
int64_t LAPACKE_cpbtrf_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, lapack_complex_float* ab,
                                int64_t ldab );
int64_t LAPACKE_zpbtrf_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, lapack_complex_double* ab,
                                int64_t ldab );

int64_t LAPACKE_spbtrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, int64_t nrhs, const float* ab,
                                int64_t ldab, float* b, int64_t ldb );
int64_t LAPACKE_dpbtrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, int64_t nrhs,
                                const double* ab, int64_t ldab, double* b,
                                int64_t ldb );
int64_t LAPACKE_cpbtrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, int64_t nrhs,
                                const lapack_complex_float* ab, int64_t ldab,
                                lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zpbtrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t kd, int64_t nrhs,
                                const lapack_complex_double* ab,
                                int64_t ldab, lapack_complex_double* b,
                                int64_t ldb );

int64_t LAPACKE_spftrf_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, float* a );
int64_t LAPACKE_dpftrf_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, double* a );
int64_t LAPACKE_cpftrf_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, lapack_complex_float* a );
int64_t LAPACKE_zpftrf_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, lapack_complex_double* a );

int64_t LAPACKE_spftri_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, float* a );
int64_t LAPACKE_dpftri_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, double* a );
int64_t LAPACKE_cpftri_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, lapack_complex_float* a );
int64_t LAPACKE_zpftri_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, lapack_complex_double* a );

int64_t LAPACKE_spftrs_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, int64_t nrhs, const float* a,
                                float* b, int64_t ldb );
int64_t LAPACKE_dpftrs_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, int64_t nrhs, const double* a,
                                double* b, int64_t ldb );
int64_t LAPACKE_cpftrs_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, int64_t nrhs,
                                const lapack_complex_float* a,
                                lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zpftrs_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, int64_t nrhs,
                                const lapack_complex_double* a,
                                lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_spocon_work_64( int matrix_layout, char uplo, int64_t n,
                                const float* a, int64_t lda, float anorm,
                                float* rcond, float* work, int64_t* iwork );
int64_t LAPACKE_dpocon_work_64( int matrix_layout, char uplo, int64_t n,
                                const double* a, int64_t lda, double anorm,
                                double* rcond, double* work,
                                int64_t* iwork );
int64_t LAPACKE_cpocon_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                float anorm, float* rcond,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zpocon_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                double anorm, double* rcond,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_spoequ_work_64( int matrix_layout, int64_t n, const float* a,
                                int64_t lda, float* s, float* scond,
                                float* amax );
int64_t LAPACKE_dpoequ_work_64( int matrix_layout, int64_t n, const double* a,
                                int64_t lda, double* s, double* scond,
                                double* amax );
int64_t LAPACKE_cpoequ_work_64( int matrix_layout, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                float* s, float* scond, float* amax );
int64_t LAPACKE_zpoequ_work_64( int matrix_layout, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                double* s, double* scond, double* amax );

int64_t LAPACKE_spoequb_work_64( int matrix_layout, int64_t n, const float* a,
                                 int64_t lda, float* s, float* scond,
                                 float* amax );
int64_t LAPACKE_dpoequb_work_64( int matrix_layout, int64_t n,
                                 const double* a, int64_t lda, double* s,
                                 double* scond, double* amax );
int64_t LAPACKE_cpoequb_work_64( int matrix_layout, int64_t n,
                                 const lapack_complex_float* a, int64_t lda,
                                 float* s, float* scond, float* amax );
int64_t LAPACKE_zpoequb_work_64( int matrix_layout, int64_t n,
                                 const lapack_complex_double* a, int64_t lda,
                                 double* s, double* scond, double* amax );

int64_t LAPACKE_sporfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const float* a, int64_t lda,
                                const float* af, int64_t ldaf,
                                const float* b, int64_t ldb, float* x,
                                int64_t ldx, float* ferr, float* berr,
                                float* work, int64_t* iwork );
int64_t LAPACKE_dporfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const double* a,
                                int64_t lda, const double* af,
                                int64_t ldaf, const double* b,
                                int64_t ldb, double* x, int64_t ldx,
                                double* ferr, double* berr, double* work,
                                int64_t* iwork );
int64_t LAPACKE_cporfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_float* a,
                                int64_t lda, const lapack_complex_float* af,
                                int64_t ldaf, const lapack_complex_float* b,
                                int64_t ldb, lapack_complex_float* x,
                                int64_t ldx, float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zporfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_double* a,
                                int64_t lda, const lapack_complex_double* af,
                                int64_t ldaf, const lapack_complex_double* b,
                                int64_t ldb, lapack_complex_double* x,
                                int64_t ldx, double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_sporfsx_work_64( int matrix_layout, char uplo, char equed,
                                 int64_t n, int64_t nrhs, const float* a,
                                 int64_t lda, const float* af,
                                 int64_t ldaf, const float* s,
                                 const float* b, int64_t ldb, float* x,
                                 int64_t ldx, float* rcond, float* berr,
                                 int64_t n_err_bnds, float* err_bnds_norm,
                                 float* err_bnds_comp, int64_t nparams,
                                 float* params, float* work,
                                 int64_t* iwork );
int64_t LAPACKE_dporfsx_work_64( int matrix_layout, char uplo, char equed,
                                 int64_t n, int64_t nrhs, const double* a,
                                 int64_t lda, const double* af,
                                 int64_t ldaf, const double* s,
                                 const double* b, int64_t ldb, double* x,
                                 int64_t ldx, double* rcond, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, double* work,
                                 int64_t* iwork );
int64_t LAPACKE_cporfsx_work_64( int matrix_layout, char uplo, char equed,
                                 int64_t n, int64_t nrhs,
                                 const lapack_complex_float* a, int64_t lda,
                                 const lapack_complex_float* af,
                                 int64_t ldaf, const float* s,
                                 const lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* x, int64_t ldx,
                                 float* rcond, float* berr,
                                 int64_t n_err_bnds, float* err_bnds_norm,
                                 float* err_bnds_comp, int64_t nparams,
                                 float* params, lapack_complex_float* work,
                                 float* rwork );
int64_t LAPACKE_zporfsx_work_64( int matrix_layout, char uplo, char equed,
                                 int64_t n, int64_t nrhs,
                                 const lapack_complex_double* a, int64_t lda,
                                 const lapack_complex_double* af,
                                 int64_t ldaf, const double* s,
                                 const lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* x, int64_t ldx,
                                 double* rcond, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, lapack_complex_double* work,
                                 double* rwork );

int64_t LAPACKE_sposv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, float* a, int64_t lda,
                               float* b, int64_t ldb );
int64_t LAPACKE_dposv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, double* a, int64_t lda,
                               double* b, int64_t ldb );
int64_t LAPACKE_cposv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* a,
                               int64_t lda, lapack_complex_float* b,
                               int64_t ldb );
int64_t LAPACKE_zposv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* a,
                               int64_t lda, lapack_complex_double* b,
                               int64_t ldb );
int64_t LAPACKE_dsposv_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, double* a, int64_t lda,
                                double* b, int64_t ldb, double* x,
                                int64_t ldx, double* work, float* swork,
                                int64_t* iter );
int64_t LAPACKE_zcposv_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* b,
                                int64_t ldb, lapack_complex_double* x,
                                int64_t ldx, lapack_complex_double* work,
                                lapack_complex_float* swork, double* rwork,
                                int64_t* iter );

int64_t LAPACKE_sposvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs, float* a,
                                int64_t lda, float* af, int64_t ldaf,
                                char* equed, float* s, float* b, int64_t ldb,
                                float* x, int64_t ldx, float* rcond,
                                float* ferr, float* berr, float* work,
                                int64_t* iwork );
int64_t LAPACKE_dposvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs, double* a,
                                int64_t lda, double* af, int64_t ldaf,
                                char* equed, double* s, double* b,
                                int64_t ldb, double* x, int64_t ldx,
                                double* rcond, double* ferr, double* berr,
                                double* work, int64_t* iwork );
int64_t LAPACKE_cposvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* af, int64_t ldaf,
                                char* equed, float* s, lapack_complex_float* b,
                                int64_t ldb, lapack_complex_float* x,
                                int64_t ldx, float* rcond, float* ferr,
                                float* berr, lapack_complex_float* work,
                                float* rwork );
int64_t LAPACKE_zposvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* af, int64_t ldaf,
                                char* equed, double* s,
                                lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* rcond, double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_sposvxx_work_64( int matrix_layout, char fact, char uplo,
                                 int64_t n, int64_t nrhs, float* a,
                                 int64_t lda, float* af, int64_t ldaf,
                                 char* equed, float* s, float* b,
                                 int64_t ldb, float* x, int64_t ldx,
                                 float* rcond, float* rpvgrw, float* berr,
                                 int64_t n_err_bnds, float* err_bnds_norm,
                                 float* err_bnds_comp, int64_t nparams,
                                 float* params, float* work,
                                 int64_t* iwork );
int64_t LAPACKE_dposvxx_work_64( int matrix_layout, char fact, char uplo,
                                 int64_t n, int64_t nrhs, double* a,
                                 int64_t lda, double* af, int64_t ldaf,
                                 char* equed, double* s, double* b,
                                 int64_t ldb, double* x, int64_t ldx,
                                 double* rcond, double* rpvgrw, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, double* work,
                                 int64_t* iwork );
int64_t LAPACKE_cposvxx_work_64( int matrix_layout, char fact, char uplo,
                                 int64_t n, int64_t nrhs,
                                 lapack_complex_float* a, int64_t lda,
                                 lapack_complex_float* af, int64_t ldaf,
                                 char* equed, float* s, lapack_complex_float* b,
                                 int64_t ldb, lapack_complex_float* x,
                                 int64_t ldx, float* rcond, float* rpvgrw,
                                 float* berr, int64_t n_err_bnds,
                                 float* err_bnds_norm, float* err_bnds_comp,
                                 int64_t nparams, float* params,
                                 lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zposvxx_work_64( int matrix_layout, char fact, char uplo,
                                 int64_t n, int64_t nrhs,
                                 lapack_complex_double* a, int64_t lda,
                                 lapack_complex_double* af, int64_t ldaf,
                                 char* equed, double* s,
                                 lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* x, int64_t ldx,
                                 double* rcond, double* rpvgrw, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, lapack_complex_double* work,
                                 double* rwork );

int64_t LAPACKE_spotrf2_work_64( int matrix_layout, char uplo, int64_t n,
                                float* a, int64_t lda );
int64_t LAPACKE_dpotrf2_work_64( int matrix_layout, char uplo, int64_t n,
                                double* a, int64_t lda );
int64_t LAPACKE_cpotrf2_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_zpotrf2_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_spotrf_work_64( int matrix_layout, char uplo, int64_t n,
                                float* a, int64_t lda );
int64_t LAPACKE_dpotrf_work_64( int matrix_layout, char uplo, int64_t n,
                                double* a, int64_t lda );
int64_t LAPACKE_cpotrf_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_zpotrf_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_spotri_work_64( int matrix_layout, char uplo, int64_t n,
                                float* a, int64_t lda );
int64_t LAPACKE_dpotri_work_64( int matrix_layout, char uplo, int64_t n,
                                double* a, int64_t lda );
int64_t LAPACKE_cpotri_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_zpotri_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_spotrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const float* a, int64_t lda,
                                float* b, int64_t ldb );
int64_t LAPACKE_dpotrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const double* a,
                                int64_t lda, double* b, int64_t ldb );
int64_t LAPACKE_cpotrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* b,
                                int64_t ldb );
int64_t LAPACKE_zpotrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* b,
                                int64_t ldb );

int64_t LAPACKE_sppcon_work_64( int matrix_layout, char uplo, int64_t n,
                                const float* ap, float anorm, float* rcond,
                                float* work, int64_t* iwork );
int64_t LAPACKE_dppcon_work_64( int matrix_layout, char uplo, int64_t n,
                                const double* ap, double anorm, double* rcond,
                                double* work, int64_t* iwork );
int64_t LAPACKE_cppcon_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_float* ap, float anorm,
                                float* rcond, lapack_complex_float* work,
                                float* rwork );
int64_t LAPACKE_zppcon_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_double* ap, double anorm,
                                double* rcond, lapack_complex_double* work,
                                double* rwork );

int64_t LAPACKE_sppequ_work_64( int matrix_layout, char uplo, int64_t n,
                                const float* ap, float* s, float* scond,
                                float* amax );
int64_t LAPACKE_dppequ_work_64( int matrix_layout, char uplo, int64_t n,
                                const double* ap, double* s, double* scond,
                                double* amax );
int64_t LAPACKE_cppequ_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_float* ap, float* s,
                                float* scond, float* amax );
int64_t LAPACKE_zppequ_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_double* ap, double* s,
                                double* scond, double* amax );

int64_t LAPACKE_spprfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const float* ap,
                                const float* afp, const float* b,
                                int64_t ldb, float* x, int64_t ldx,
                                float* ferr, float* berr, float* work,
                                int64_t* iwork );
int64_t LAPACKE_dpprfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const double* ap,
                                const double* afp, const double* b,
                                int64_t ldb, double* x, int64_t ldx,
                                double* ferr, double* berr, double* work,
                                int64_t* iwork );
int64_t LAPACKE_cpprfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_float* ap,
                                const lapack_complex_float* afp,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* x, int64_t ldx,
                                float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zpprfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs,
                                const lapack_complex_double* ap,
                                const lapack_complex_double* afp,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_sppsv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, float* ap, float* b,
                               int64_t ldb );
int64_t LAPACKE_dppsv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, double* ap, double* b,
                               int64_t ldb );
int64_t LAPACKE_cppsv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* ap,
                               lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zppsv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* ap,
                               lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_sppsvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs, float* ap,
                                float* afp, char* equed, float* s, float* b,
                                int64_t ldb, float* x, int64_t ldx,
                                float* rcond, float* ferr, float* berr,
                                float* work, int64_t* iwork );
int64_t LAPACKE_dppsvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs, double* ap,
                                double* afp, char* equed, double* s, double* b,
                                int64_t ldb, double* x, int64_t ldx,
                                double* rcond, double* ferr, double* berr,
                                double* work, int64_t* iwork );
int64_t LAPACKE_cppsvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs,
                                lapack_complex_float* ap,
                                lapack_complex_float* afp, char* equed,
                                float* s, lapack_complex_float* b,
                                int64_t ldb, lapack_complex_float* x,
                                int64_t ldx, float* rcond, float* ferr,
                                float* berr, lapack_complex_float* work,
                                float* rwork );
int64_t LAPACKE_zppsvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs,
                                lapack_complex_double* ap,
                                lapack_complex_double* afp, char* equed,
                                double* s, lapack_complex_double* b,
                                int64_t ldb, lapack_complex_double* x,
                                int64_t ldx, double* rcond, double* ferr,
                                double* berr, lapack_complex_double* work,
                                double* rwork );

int64_t LAPACKE_spptrf_work_64( int matrix_layout, char uplo, int64_t n,
                                float* ap );
int64_t LAPACKE_dpptrf_work_64( int matrix_layout, char uplo, int64_t n,
                                double* ap );
int64_t LAPACKE_cpptrf_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* ap );
int64_t LAPACKE_zpptrf_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* ap );

int64_t LAPACKE_spptri_work_64( int matrix_layout, char uplo, int64_t n,
                                float* ap );
int64_t LAPACKE_dpptri_work_64( int matrix_layout, char uplo, int64_t n,
                                double* ap );
int64_t LAPACKE_cpptri_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* ap );
int64_t LAPACKE_zpptri_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* ap );

int64_t LAPACKE_spptrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const float* ap, float* b,
                                int64_t ldb );
int64_t LAPACKE_dpptrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const double* ap, double* b,
                                int64_t ldb );
int64_t LAPACKE_cpptrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_float* ap,
                                lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zpptrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs,
                                const lapack_complex_double* ap,
                                lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_spstrf_work_64( int matrix_layout, char uplo, int64_t n,
                                float* a, int64_t lda, int64_t* piv,
                                int64_t* rank, float tol, float* work );
int64_t LAPACKE_dpstrf_work_64( int matrix_layout, char uplo, int64_t n,
                                double* a, int64_t lda, int64_t* piv,
                                int64_t* rank, double tol, double* work );
int64_t LAPACKE_cpstrf_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                int64_t* piv, int64_t* rank, float tol,
                                float* work );
int64_t LAPACKE_zpstrf_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* piv, int64_t* rank, double tol,
                                double* work );

int64_t LAPACKE_sptcon_work_64( int64_t n, const float* d, const float* e,
                                float anorm, float* rcond, float* work );
int64_t LAPACKE_dptcon_work_64( int64_t n, const double* d, const double* e,
                                double anorm, double* rcond, double* work );
int64_t LAPACKE_cptcon_work_64( int64_t n, const float* d,
                                const lapack_complex_float* e, float anorm,
                                float* rcond, float* work );
int64_t LAPACKE_zptcon_work_64( int64_t n, const double* d,
                                const lapack_complex_double* e, double anorm,
                                double* rcond, double* work );

int64_t LAPACKE_spteqr_work_64( int matrix_layout, char compz, int64_t n,
                                float* d, float* e, float* z, int64_t ldz,
                                float* work );
int64_t LAPACKE_dpteqr_work_64( int matrix_layout, char compz, int64_t n,
                                double* d, double* e, double* z, int64_t ldz,
                                double* work );
int64_t LAPACKE_cpteqr_work_64( int matrix_layout, char compz, int64_t n,
                                float* d, float* e, lapack_complex_float* z,
                                int64_t ldz, float* work );
int64_t LAPACKE_zpteqr_work_64( int matrix_layout, char compz, int64_t n,
                                double* d, double* e, lapack_complex_double* z,
                                int64_t ldz, double* work );

int64_t LAPACKE_sptrfs_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                                const float* d, const float* e, const float* df,
                                const float* ef, const float* b, int64_t ldb,
                                float* x, int64_t ldx, float* ferr,
                                float* berr, float* work );
int64_t LAPACKE_dptrfs_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                                const double* d, const double* e,
                                const double* df, const double* ef,
                                const double* b, int64_t ldb, double* x,
                                int64_t ldx, double* ferr, double* berr,
                                double* work );
int64_t LAPACKE_cptrfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const float* d,
                                const lapack_complex_float* e, const float* df,
                                const lapack_complex_float* ef,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* x, int64_t ldx,
                                float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zptrfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const double* d,
                                const lapack_complex_double* e,
                                const double* df,
                                const lapack_complex_double* ef,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_sptsv_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                               float* d, float* e, float* b, int64_t ldb );
int64_t LAPACKE_dptsv_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                               double* d, double* e, double* b,
                               int64_t ldb );
int64_t LAPACKE_cptsv_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                               float* d, lapack_complex_float* e,
                               lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zptsv_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                               double* d, lapack_complex_double* e,
                               lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_sptsvx_work_64( int matrix_layout, char fact, int64_t n,
                                int64_t nrhs, const float* d, const float* e,
                                float* df, float* ef, const float* b,
                                int64_t ldb, float* x, int64_t ldx,
                                float* rcond, float* ferr, float* berr,
                                float* work );
int64_t LAPACKE_dptsvx_work_64( int matrix_layout, char fact, int64_t n,
                                int64_t nrhs, const double* d,
                                const double* e, double* df, double* ef,
                                const double* b, int64_t ldb, double* x,
                                int64_t ldx, double* rcond, double* ferr,
                                double* berr, double* work );
int64_t LAPACKE_cptsvx_work_64( int matrix_layout, char fact, int64_t n,
                                int64_t nrhs, const float* d,
                                const lapack_complex_float* e, float* df,
                                lapack_complex_float* ef,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* x, int64_t ldx,
                                float* rcond, float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zptsvx_work_64( int matrix_layout, char fact, int64_t n,
                                int64_t nrhs, const double* d,
                                const lapack_complex_double* e, double* df,
                                lapack_complex_double* ef,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* rcond, double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_spttrf_work_64( int64_t n, float* d, float* e );
int64_t LAPACKE_dpttrf_work_64( int64_t n, double* d, double* e );
int64_t LAPACKE_cpttrf_work_64( int64_t n, float* d,
                                lapack_complex_float* e );
int64_t LAPACKE_zpttrf_work_64( int64_t n, double* d,
                                lapack_complex_double* e );

int64_t LAPACKE_spttrs_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                                const float* d, const float* e, float* b,
                                int64_t ldb );
int64_t LAPACKE_dpttrs_work_64( int matrix_layout, int64_t n, int64_t nrhs,
                                const double* d, const double* e, double* b,
                                int64_t ldb );
int64_t LAPACKE_cpttrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const float* d,
                                const lapack_complex_float* e,
                                lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zpttrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const double* d,
                                const lapack_complex_double* e,
                                lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_ssbev_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, int64_t kd, float* ab,
                               int64_t ldab, float* w, float* z,
                               int64_t ldz, float* work );
int64_t LAPACKE_dsbev_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, int64_t kd, double* ab,
                               int64_t ldab, double* w, double* z,
                               int64_t ldz, double* work );

int64_t LAPACKE_ssbevd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, int64_t kd, float* ab,
                                int64_t ldab, float* w, float* z,
                                int64_t ldz, float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_dsbevd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, int64_t kd, double* ab,
                                int64_t ldab, double* w, double* z,
                                int64_t ldz, double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_ssbevx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, int64_t kd,
                                float* ab, int64_t ldab, float* q,
                                int64_t ldq, float vl, float vu,
                                int64_t il, int64_t iu, float abstol,
                                int64_t* m, float* w, float* z,
                                int64_t ldz, float* work,
                                int64_t* iwork, int64_t* ifail );
int64_t LAPACKE_dsbevx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, int64_t kd,
                                double* ab, int64_t ldab, double* q,
                                int64_t ldq, double vl, double vu,
                                int64_t il, int64_t iu, double abstol,
                                int64_t* m, double* w, double* z,
                                int64_t ldz, double* work,
                                int64_t* iwork, int64_t* ifail );

int64_t LAPACKE_ssbgst_work_64( int matrix_layout, char vect, char uplo,
                                int64_t n, int64_t ka, int64_t kb,
                                float* ab, int64_t ldab, const float* bb,
                                int64_t ldbb, float* x, int64_t ldx,
                                float* work );
int64_t LAPACKE_dsbgst_work_64( int matrix_layout, char vect, char uplo,
                                int64_t n, int64_t ka, int64_t kb,
                                double* ab, int64_t ldab, const double* bb,
                                int64_t ldbb, double* x, int64_t ldx,
                                double* work );

int64_t LAPACKE_ssbgv_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, int64_t ka, int64_t kb,
                               float* ab, int64_t ldab, float* bb,
                               int64_t ldbb, float* w, float* z,
                               int64_t ldz, float* work );
int64_t LAPACKE_dsbgv_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, int64_t ka, int64_t kb,
                               double* ab, int64_t ldab, double* bb,
                               int64_t ldbb, double* w, double* z,
                               int64_t ldz, double* work );

int64_t LAPACKE_ssbgvd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, int64_t ka, int64_t kb,
                                float* ab, int64_t ldab, float* bb,
                                int64_t ldbb, float* w, float* z,
                                int64_t ldz, float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_dsbgvd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, int64_t ka, int64_t kb,
                                double* ab, int64_t ldab, double* bb,
                                int64_t ldbb, double* w, double* z,
                                int64_t ldz, double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_ssbgvx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, int64_t ka,
                                int64_t kb, float* ab, int64_t ldab,
                                float* bb, int64_t ldbb, float* q,
                                int64_t ldq, float vl, float vu,
                                int64_t il, int64_t iu, float abstol,
                                int64_t* m, float* w, float* z,
                                int64_t ldz, float* work, int64_t* iwork,
                                int64_t* ifail );
int64_t LAPACKE_dsbgvx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, int64_t ka,
                                int64_t kb, double* ab, int64_t ldab,
                                double* bb, int64_t ldbb, double* q,
                                int64_t ldq, double vl, double vu,
                                int64_t il, int64_t iu, double abstol,
                                int64_t* m, double* w, double* z,
                                int64_t ldz, double* work, int64_t* iwork,
                                int64_t* ifail );

int64_t LAPACKE_ssbtrd_work_64( int matrix_layout, char vect, char uplo,
                                int64_t n, int64_t kd, float* ab,
                                int64_t ldab, float* d, float* e, float* q,
                                int64_t ldq, float* work );
int64_t LAPACKE_dsbtrd_work_64( int matrix_layout, char vect, char uplo,
                                int64_t n, int64_t kd, double* ab,
                                int64_t ldab, double* d, double* e,
                                double* q, int64_t ldq, double* work );

int64_t LAPACKE_ssfrk_work_64( int matrix_layout, char transr, char uplo,
                               char trans, int64_t n, int64_t k,
                               float alpha, const float* a, int64_t lda,
                               float beta, float* c );
int64_t LAPACKE_dsfrk_work_64( int matrix_layout, char transr, char uplo,
                               char trans, int64_t n, int64_t k,
                               double alpha, const double* a, int64_t lda,
                               double beta, double* c );

int64_t LAPACKE_sspcon_work_64( int matrix_layout, char uplo, int64_t n,
                                const float* ap, const int64_t* ipiv,
                                float anorm, float* rcond, float* work,
                                int64_t* iwork );
int64_t LAPACKE_dspcon_work_64( int matrix_layout, char uplo, int64_t n,
                                const double* ap, const int64_t* ipiv,
                                double anorm, double* rcond, double* work,
                                int64_t* iwork );
int64_t LAPACKE_cspcon_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_float* ap,
                                const int64_t* ipiv, float anorm,
                                float* rcond, lapack_complex_float* work );
int64_t LAPACKE_zspcon_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_double* ap,
                                const int64_t* ipiv, double anorm,
                                double* rcond, lapack_complex_double* work );

int64_t LAPACKE_sspev_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, float* ap, float* w, float* z,
                               int64_t ldz, float* work );
int64_t LAPACKE_dspev_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, double* ap, double* w, double* z,
                               int64_t ldz, double* work );

int64_t LAPACKE_sspevd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, float* ap, float* w, float* z,
                                int64_t ldz, float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_dspevd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, double* ap, double* w, double* z,
                                int64_t ldz, double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_sspevx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, float* ap, float vl,
                                float vu, int64_t il, int64_t iu,
                                float abstol, int64_t* m, float* w, float* z,
                                int64_t ldz, float* work, int64_t* iwork,
                                int64_t* ifail );
int64_t LAPACKE_dspevx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, double* ap, double vl,
                                double vu, int64_t il, int64_t iu,
                                double abstol, int64_t* m, double* w,
                                double* z, int64_t ldz, double* work,
                                int64_t* iwork, int64_t* ifail );

int64_t LAPACKE_sspgst_work_64( int matrix_layout, int64_t itype, char uplo,
                                int64_t n, float* ap, const float* bp );
int64_t LAPACKE_dspgst_work_64( int matrix_layout, int64_t itype, char uplo,
                                int64_t n, double* ap, const double* bp );

int64_t LAPACKE_sspgv_work_64( int matrix_layout, int64_t itype, char jobz,
                               char uplo, int64_t n, float* ap, float* bp,
                               float* w, float* z, int64_t ldz,
                               float* work );
int64_t LAPACKE_dspgv_work_64( int matrix_layout, int64_t itype, char jobz,
                               char uplo, int64_t n, double* ap, double* bp,
                               double* w, double* z, int64_t ldz,
                               double* work );

int64_t LAPACKE_sspgvd_work_64( int matrix_layout, int64_t itype, char jobz,
                                char uplo, int64_t n, float* ap, float* bp,
                                float* w, float* z, int64_t ldz, float* work,
                                int64_t lwork, int64_t* iwork,
                                int64_t liwork );
int64_t LAPACKE_dspgvd_work_64( int matrix_layout, int64_t itype, char jobz,
                                char uplo, int64_t n, double* ap, double* bp,
                                double* w, double* z, int64_t ldz,
                                double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_sspgvx_work_64( int matrix_layout, int64_t itype, char jobz,
                                char range, char uplo, int64_t n, float* ap,
                                float* bp, float vl, float vu, int64_t il,
                                int64_t iu, float abstol, int64_t* m,
                                float* w, float* z, int64_t ldz, float* work,
                                int64_t* iwork, int64_t* ifail );
int64_t LAPACKE_dspgvx_work_64( int matrix_layout, int64_t itype, char jobz,
                                char range, char uplo, int64_t n, double* ap,
                                double* bp, double vl, double vu, int64_t il,
                                int64_t iu, double abstol, int64_t* m,
                                double* w, double* z, int64_t ldz,
                                double* work, int64_t* iwork,
                                int64_t* ifail );

int64_t LAPACKE_ssprfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const float* ap,
                                const float* afp, const int64_t* ipiv,
                                const float* b, int64_t ldb, float* x,
                                int64_t ldx, float* ferr, float* berr,
                                float* work, int64_t* iwork );
int64_t LAPACKE_dsprfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const double* ap,
                                const double* afp, const int64_t* ipiv,
                                const double* b, int64_t ldb, double* x,
                                int64_t ldx, double* ferr, double* berr,
                                double* work, int64_t* iwork );
int64_t LAPACKE_csprfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_float* ap,
                                const lapack_complex_float* afp,
                                const int64_t* ipiv,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* x, int64_t ldx,
                                float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zsprfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs,
                                const lapack_complex_double* ap,
                                const lapack_complex_double* afp,
                                const int64_t* ipiv,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_sspsv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, float* ap, int64_t* ipiv,
                               float* b, int64_t ldb );
int64_t LAPACKE_dspsv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, double* ap, int64_t* ipiv,
                               double* b, int64_t ldb );
int64_t LAPACKE_cspsv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* ap,
                               int64_t* ipiv, lapack_complex_float* b,
                               int64_t ldb );
int64_t LAPACKE_zspsv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* ap,
                               int64_t* ipiv, lapack_complex_double* b,
                               int64_t ldb );

int64_t LAPACKE_sspsvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs, const float* ap,
                                float* afp, int64_t* ipiv, const float* b,
                                int64_t ldb, float* x, int64_t ldx,
                                float* rcond, float* ferr, float* berr,
                                float* work, int64_t* iwork );
int64_t LAPACKE_dspsvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs, const double* ap,
                                double* afp, int64_t* ipiv, const double* b,
                                int64_t ldb, double* x, int64_t ldx,
                                double* rcond, double* ferr, double* berr,
                                double* work, int64_t* iwork );
int64_t LAPACKE_cspsvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs,
                                const lapack_complex_float* ap,
                                lapack_complex_float* afp, int64_t* ipiv,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* x, int64_t ldx,
                                float* rcond, float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zspsvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs,
                                const lapack_complex_double* ap,
                                lapack_complex_double* afp, int64_t* ipiv,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* rcond, double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_ssptrd_work_64( int matrix_layout, char uplo, int64_t n,
                                float* ap, float* d, float* e, float* tau );
int64_t LAPACKE_dsptrd_work_64( int matrix_layout, char uplo, int64_t n,
                                double* ap, double* d, double* e, double* tau );

int64_t LAPACKE_ssptrf_work_64( int matrix_layout, char uplo, int64_t n,
                                float* ap, int64_t* ipiv );
int64_t LAPACKE_dsptrf_work_64( int matrix_layout, char uplo, int64_t n,
                                double* ap, int64_t* ipiv );
int64_t LAPACKE_csptrf_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* ap, int64_t* ipiv );
int64_t LAPACKE_zsptrf_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* ap, int64_t* ipiv );

int64_t LAPACKE_ssptri_work_64( int matrix_layout, char uplo, int64_t n,
                                float* ap, const int64_t* ipiv,
                                float* work );
int64_t LAPACKE_dsptri_work_64( int matrix_layout, char uplo, int64_t n,
                                double* ap, const int64_t* ipiv,
                                double* work );
int64_t LAPACKE_csptri_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* ap,
                                const int64_t* ipiv,
                                lapack_complex_float* work );
int64_t LAPACKE_zsptri_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* ap,
                                const int64_t* ipiv,
                                lapack_complex_double* work );

int64_t LAPACKE_ssptrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const float* ap,
                                const int64_t* ipiv, float* b,
                                int64_t ldb );
int64_t LAPACKE_dsptrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const double* ap,
                                const int64_t* ipiv, double* b,
                                int64_t ldb );
int64_t LAPACKE_csptrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_float* ap,
                                const int64_t* ipiv, lapack_complex_float* b,
                                int64_t ldb );
int64_t LAPACKE_zsptrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs,
                                const lapack_complex_double* ap,
                                const int64_t* ipiv,
                                lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_sstebz_work_64( char range, char order, int64_t n, float vl,
                                float vu, int64_t il, int64_t iu,
                                float abstol, const float* d, const float* e,
                                int64_t* m, int64_t* nsplit, float* w,
                                int64_t* iblock, int64_t* isplit,
                                float* work, int64_t* iwork );
int64_t LAPACKE_dstebz_work_64( char range, char order, int64_t n, double vl,
                                double vu, int64_t il, int64_t iu,
                                double abstol, const double* d, const double* e,
                                int64_t* m, int64_t* nsplit, double* w,
                                int64_t* iblock, int64_t* isplit,
                                double* work, int64_t* iwork );

int64_t LAPACKE_sstedc_work_64( int matrix_layout, char compz, int64_t n,
                                float* d, float* e, float* z, int64_t ldz,
                                float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_dstedc_work_64( int matrix_layout, char compz, int64_t n,
                                double* d, double* e, double* z, int64_t ldz,
                                double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_cstedc_work_64( int matrix_layout, char compz, int64_t n,
                                float* d, float* e, lapack_complex_float* z,
                                int64_t ldz, lapack_complex_float* work,
                                int64_t lwork, float* rwork,
                                int64_t lrwork, int64_t* iwork,
                                int64_t liwork );
int64_t LAPACKE_zstedc_work_64( int matrix_layout, char compz, int64_t n,
                                double* d, double* e, lapack_complex_double* z,
                                int64_t ldz, lapack_complex_double* work,
                                int64_t lwork, double* rwork,
                                int64_t lrwork, int64_t* iwork,
                                int64_t liwork );

int64_t LAPACKE_sstegr_work_64( int matrix_layout, char jobz, char range,
                                int64_t n, float* d, float* e, float vl,
                                float vu, int64_t il, int64_t iu,
                                float abstol, int64_t* m, float* w, float* z,
                                int64_t ldz, int64_t* isuppz, float* work,
                                int64_t lwork, int64_t* iwork,
                                int64_t liwork );
int64_t LAPACKE_dstegr_work_64( int matrix_layout, char jobz, char range,
                                int64_t n, double* d, double* e, double vl,
                                double vu, int64_t il, int64_t iu,
                                double abstol, int64_t* m, double* w,
                                double* z, int64_t ldz, int64_t* isuppz,
                                double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_cstegr_work_64( int matrix_layout, char jobz, char range,
                                int64_t n, float* d, float* e, float vl,
                                float vu, int64_t il, int64_t iu,
                                float abstol, int64_t* m, float* w,
                                lapack_complex_float* z, int64_t ldz,
                                int64_t* isuppz, float* work,
                                int64_t lwork, int64_t* iwork,
                                int64_t liwork );
int64_t LAPACKE_zstegr_work_64( int matrix_layout, char jobz, char range,
                                int64_t n, double* d, double* e, double vl,
                                double vu, int64_t il, int64_t iu,
                                double abstol, int64_t* m, double* w,
                                lapack_complex_double* z, int64_t ldz,
                                int64_t* isuppz, double* work,
                                int64_t lwork, int64_t* iwork,
                                int64_t liwork );

int64_t LAPACKE_sstein_work_64( int matrix_layout, int64_t n, const float* d,
                                const float* e, int64_t m, const float* w,
                                const int64_t* iblock,
                                const int64_t* isplit, float* z,
                                int64_t ldz, float* work, int64_t* iwork,
                                int64_t* ifailv );
int64_t LAPACKE_dstein_work_64( int matrix_layout, int64_t n, const double* d,
                                const double* e, int64_t m, const double* w,
                                const int64_t* iblock,
                                const int64_t* isplit, double* z,
                                int64_t ldz, double* work, int64_t* iwork,
                                int64_t* ifailv );
int64_t LAPACKE_cstein_work_64( int matrix_layout, int64_t n, const float* d,
                                const float* e, int64_t m, const float* w,
                                const int64_t* iblock,
                                const int64_t* isplit,
                                lapack_complex_float* z, int64_t ldz,
                                float* work, int64_t* iwork,
                                int64_t* ifailv );
int64_t LAPACKE_zstein_work_64( int matrix_layout, int64_t n, const double* d,
                                const double* e, int64_t m, const double* w,
                                const int64_t* iblock,
                                const int64_t* isplit,
                                lapack_complex_double* z, int64_t ldz,
                                double* work, int64_t* iwork,
                                int64_t* ifailv );

int64_t LAPACKE_sstemr_work_64( int matrix_layout, char jobz, char range,
                                int64_t n, float* d, float* e, float vl,
                                float vu, int64_t il, int64_t iu,
                                int64_t* m, float* w, float* z,
                                int64_t ldz, int64_t nzc,
                                int64_t* isuppz, lapack_logical* tryrac,
                                float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_dstemr_work_64( int matrix_layout, char jobz, char range,
                                int64_t n, double* d, double* e, double vl,
                                double vu, int64_t il, int64_t iu,
                                int64_t* m, double* w, double* z,
                                int64_t ldz, int64_t nzc,
                                int64_t* isuppz, lapack_logical* tryrac,
                                double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_cstemr_work_64( int matrix_layout, char jobz, char range,
                                int64_t n, float* d, float* e, float vl,
                                float vu, int64_t il, int64_t iu,
                                int64_t* m, float* w,
                                lapack_complex_float* z, int64_t ldz,
                                int64_t nzc, int64_t* isuppz,
                                lapack_logical* tryrac, float* work,
                                int64_t lwork, int64_t* iwork,
                                int64_t liwork );
int64_t LAPACKE_zstemr_work_64( int matrix_layout, char jobz, char range,
                                int64_t n, double* d, double* e, double vl,
                                double vu, int64_t il, int64_t iu,
                                int64_t* m, double* w,
                                lapack_complex_double* z, int64_t ldz,
                                int64_t nzc, int64_t* isuppz,
                                lapack_logical* tryrac, double* work,
                                int64_t lwork, int64_t* iwork,
                                int64_t liwork );

int64_t LAPACKE_ssteqr_work_64( int matrix_layout, char compz, int64_t n,
                                float* d, float* e, float* z, int64_t ldz,
                                float* work );
int64_t LAPACKE_dsteqr_work_64( int matrix_layout, char compz, int64_t n,
                                double* d, double* e, double* z, int64_t ldz,
                                double* work );
int64_t LAPACKE_csteqr_work_64( int matrix_layout, char compz, int64_t n,
                                float* d, float* e, lapack_complex_float* z,
                                int64_t ldz, float* work );
int64_t LAPACKE_zsteqr_work_64( int matrix_layout, char compz, int64_t n,
                                double* d, double* e, lapack_complex_double* z,
                                int64_t ldz, double* work );

int64_t LAPACKE_ssterf_work_64( int64_t n, float* d, float* e );
int64_t LAPACKE_dsterf_work_64( int64_t n, double* d, double* e );

int64_t LAPACKE_sstev_work_64( int matrix_layout, char jobz, int64_t n,
                               float* d, float* e, float* z, int64_t ldz,
                               float* work );
int64_t LAPACKE_dstev_work_64( int matrix_layout, char jobz, int64_t n,
                               double* d, double* e, double* z, int64_t ldz,
                               double* work );

int64_t LAPACKE_sstevd_work_64( int matrix_layout, char jobz, int64_t n,
                                float* d, float* e, float* z, int64_t ldz,
                                float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_dstevd_work_64( int matrix_layout, char jobz, int64_t n,
                                double* d, double* e, double* z, int64_t ldz,
                                double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_sstevr_work_64( int matrix_layout, char jobz, char range,
                                int64_t n, float* d, float* e, float vl,
                                float vu, int64_t il, int64_t iu,
                                float abstol, int64_t* m, float* w, float* z,
                                int64_t ldz, int64_t* isuppz, float* work,
                                int64_t lwork, int64_t* iwork,
                                int64_t liwork );
int64_t LAPACKE_dstevr_work_64( int matrix_layout, char jobz, char range,
                                int64_t n, double* d, double* e, double vl,
                                double vu, int64_t il, int64_t iu,
                                double abstol, int64_t* m, double* w,
                                double* z, int64_t ldz, int64_t* isuppz,
                                double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_sstevx_work_64( int matrix_layout, char jobz, char range,
                                int64_t n, float* d, float* e, float vl,
                                float vu, int64_t il, int64_t iu,
                                float abstol, int64_t* m, float* w, float* z,
                                int64_t ldz, float* work, int64_t* iwork,
                                int64_t* ifail );
int64_t LAPACKE_dstevx_work_64( int matrix_layout, char jobz, char range,
                                int64_t n, double* d, double* e, double vl,
                                double vu, int64_t il, int64_t iu,
                                double abstol, int64_t* m, double* w,
                                double* z, int64_t ldz, double* work,
                                int64_t* iwork, int64_t* ifail );

int64_t LAPACKE_ssycon_work_64( int matrix_layout, char uplo, int64_t n,
                                const float* a, int64_t lda,
                                const int64_t* ipiv, float anorm,
                                float* rcond, float* work, int64_t* iwork );
int64_t LAPACKE_dsycon_work_64( int matrix_layout, char uplo, int64_t n,
                                const double* a, int64_t lda,
                                const int64_t* ipiv, double anorm,
                                double* rcond, double* work,
                                int64_t* iwork );
int64_t LAPACKE_csycon_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                const int64_t* ipiv, float anorm,
                                float* rcond, lapack_complex_float* work );
int64_t LAPACKE_zsycon_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                const int64_t* ipiv, double anorm,
                                double* rcond, lapack_complex_double* work );

int64_t LAPACKE_ssyequb_work_64( int matrix_layout, char uplo, int64_t n,
                                 const float* a, int64_t lda, float* s,
                                 float* scond, float* amax, float* work );
int64_t LAPACKE_dsyequb_work_64( int matrix_layout, char uplo, int64_t n,
                                 const double* a, int64_t lda, double* s,
                                 double* scond, double* amax, double* work );
int64_t LAPACKE_csyequb_work_64( int matrix_layout, char uplo, int64_t n,
                                 const lapack_complex_float* a, int64_t lda,
                                 float* s, float* scond, float* amax,
                                 lapack_complex_float* work );
int64_t LAPACKE_zsyequb_work_64( int matrix_layout, char uplo, int64_t n,
                                 const lapack_complex_double* a, int64_t lda,
                                 double* s, double* scond, double* amax,
                                 lapack_complex_double* work );

int64_t LAPACKE_ssyev_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, float* a, int64_t lda, float* w,
                               float* work, int64_t lwork );
int64_t LAPACKE_dsyev_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, double* a, int64_t lda,
                               double* w, double* work, int64_t lwork );

int64_t LAPACKE_ssyevd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, float* a, int64_t lda,
                                float* w, float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_dsyevd_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, double* a, int64_t lda,
                                double* w, double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_ssyevr_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, float* a,
                                int64_t lda, float vl, float vu,
                                int64_t il, int64_t iu, float abstol,
                                int64_t* m, float* w, float* z,
                                int64_t ldz, int64_t* isuppz, float* work,
                                int64_t lwork, int64_t* iwork,
                                int64_t liwork );
int64_t LAPACKE_dsyevr_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, double* a,
                                int64_t lda, double vl, double vu,
                                int64_t il, int64_t iu, double abstol,
                                int64_t* m, double* w, double* z,
                                int64_t ldz, int64_t* isuppz,
                                double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_ssyevx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, float* a,
                                int64_t lda, float vl, float vu,
                                int64_t il, int64_t iu, float abstol,
                                int64_t* m, float* w, float* z,
                                int64_t ldz, float* work, int64_t lwork,
                                int64_t* iwork, int64_t* ifail );
int64_t LAPACKE_dsyevx_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, double* a,
                                int64_t lda, double vl, double vu,
                                int64_t il, int64_t iu, double abstol,
                                int64_t* m, double* w, double* z,
                                int64_t ldz, double* work, int64_t lwork,
                                int64_t* iwork, int64_t* ifail );

int64_t LAPACKE_ssygst_work_64( int matrix_layout, int64_t itype, char uplo,
                                int64_t n, float* a, int64_t lda,
                                const float* b, int64_t ldb );
int64_t LAPACKE_dsygst_work_64( int matrix_layout, int64_t itype, char uplo,
                                int64_t n, double* a, int64_t lda,
                                const double* b, int64_t ldb );

int64_t LAPACKE_ssygv_work_64( int matrix_layout, int64_t itype, char jobz,
                               char uplo, int64_t n, float* a,
                               int64_t lda, float* b, int64_t ldb,
                               float* w, float* work, int64_t lwork );
int64_t LAPACKE_dsygv_work_64( int matrix_layout, int64_t itype, char jobz,
                               char uplo, int64_t n, double* a,
                               int64_t lda, double* b, int64_t ldb,
                               double* w, double* work, int64_t lwork );

int64_t LAPACKE_ssygvd_work_64( int matrix_layout, int64_t itype, char jobz,
                                char uplo, int64_t n, float* a,
                                int64_t lda, float* b, int64_t ldb,
                                float* w, float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_dsygvd_work_64( int matrix_layout, int64_t itype, char jobz,
                                char uplo, int64_t n, double* a,
                                int64_t lda, double* b, int64_t ldb,
                                double* w, double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_ssygvx_work_64( int matrix_layout, int64_t itype, char jobz,
                                char range, char uplo, int64_t n, float* a,
                                int64_t lda, float* b, int64_t ldb,
                                float vl, float vu, int64_t il,
                                int64_t iu, float abstol, int64_t* m,
                                float* w, float* z, int64_t ldz, float* work,
                                int64_t lwork, int64_t* iwork,
                                int64_t* ifail );
int64_t LAPACKE_dsygvx_work_64( int matrix_layout, int64_t itype, char jobz,
                                char range, char uplo, int64_t n, double* a,
                                int64_t lda, double* b, int64_t ldb,
                                double vl, double vu, int64_t il,
                                int64_t iu, double abstol, int64_t* m,
                                double* w, double* z, int64_t ldz,
                                double* work, int64_t lwork,
                                int64_t* iwork, int64_t* ifail );

int64_t LAPACKE_ssyrfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const float* a, int64_t lda,
                                const float* af, int64_t ldaf,
                                const int64_t* ipiv, const float* b,
                                int64_t ldb, float* x, int64_t ldx,
                                float* ferr, float* berr, float* work,
                                int64_t* iwork );
int64_t LAPACKE_dsyrfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const double* a,
                                int64_t lda, const double* af,
                                int64_t ldaf, const int64_t* ipiv,
                                const double* b, int64_t ldb, double* x,
                                int64_t ldx, double* ferr, double* berr,
                                double* work, int64_t* iwork );
int64_t LAPACKE_csyrfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_float* a,
                                int64_t lda, const lapack_complex_float* af,
                                int64_t ldaf, const int64_t* ipiv,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* x, int64_t ldx,
                                float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_zsyrfs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_double* a,
                                int64_t lda, const lapack_complex_double* af,
                                int64_t ldaf, const int64_t* ipiv,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_ssyrfsx_work_64( int matrix_layout, char uplo, char equed,
                                 int64_t n, int64_t nrhs, const float* a,
                                 int64_t lda, const float* af,
                                 int64_t ldaf, const int64_t* ipiv,
                                 const float* s, const float* b, int64_t ldb,
                                 float* x, int64_t ldx, float* rcond,
                                 float* berr, int64_t n_err_bnds,
                                 float* err_bnds_norm, float* err_bnds_comp,
                                 int64_t nparams, float* params, float* work,
                                 int64_t* iwork );
int64_t LAPACKE_dsyrfsx_work_64( int matrix_layout, char uplo, char equed,
                                 int64_t n, int64_t nrhs, const double* a,
                                 int64_t lda, const double* af,
                                 int64_t ldaf, const int64_t* ipiv,
                                 const double* s, const double* b,
                                 int64_t ldb, double* x, int64_t ldx,
                                 double* rcond, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, double* work,
                                 int64_t* iwork );
int64_t LAPACKE_csyrfsx_work_64( int matrix_layout, char uplo, char equed,
                                 int64_t n, int64_t nrhs,
                                 const lapack_complex_float* a, int64_t lda,
                                 const lapack_complex_float* af,
                                 int64_t ldaf, const int64_t* ipiv,
                                 const float* s, const lapack_complex_float* b,
                                 int64_t ldb, lapack_complex_float* x,
                                 int64_t ldx, float* rcond, float* berr,
                                 int64_t n_err_bnds, float* err_bnds_norm,
                                 float* err_bnds_comp, int64_t nparams,
                                 float* params, lapack_complex_float* work,
                                 float* rwork );
int64_t LAPACKE_zsyrfsx_work_64( int matrix_layout, char uplo, char equed,
                                 int64_t n, int64_t nrhs,
                                 const lapack_complex_double* a, int64_t lda,
                                 const lapack_complex_double* af,
                                 int64_t ldaf, const int64_t* ipiv,
                                 const double* s,
                                 const lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* x, int64_t ldx,
                                 double* rcond, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, lapack_complex_double* work,
                                 double* rwork );

int64_t LAPACKE_ssysv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, float* a, int64_t lda,
                               int64_t* ipiv, float* b, int64_t ldb,
                               float* work, int64_t lwork );
int64_t LAPACKE_dsysv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, double* a, int64_t lda,
                               int64_t* ipiv, double* b, int64_t ldb,
                               double* work, int64_t lwork );
int64_t LAPACKE_csysv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* a,
                               int64_t lda, int64_t* ipiv,
                               lapack_complex_float* b, int64_t ldb,
                               lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zsysv_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* a,
                               int64_t lda, int64_t* ipiv,
                               lapack_complex_double* b, int64_t ldb,
                               lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_ssysvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs, const float* a,
                                int64_t lda, float* af, int64_t ldaf,
                                int64_t* ipiv, const float* b,
                                int64_t ldb, float* x, int64_t ldx,
                                float* rcond, float* ferr, float* berr,
                                float* work, int64_t lwork,
                                int64_t* iwork );
int64_t LAPACKE_dsysvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs, const double* a,
                                int64_t lda, double* af, int64_t ldaf,
                                int64_t* ipiv, const double* b,
                                int64_t ldb, double* x, int64_t ldx,
                                double* rcond, double* ferr, double* berr,
                                double* work, int64_t lwork,
                                int64_t* iwork );
int64_t LAPACKE_csysvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs,
                                const lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* af, int64_t ldaf,
                                int64_t* ipiv, const lapack_complex_float* b,
                                int64_t ldb, lapack_complex_float* x,
                                int64_t ldx, float* rcond, float* ferr,
                                float* berr, lapack_complex_float* work,
                                int64_t lwork, float* rwork );
int64_t LAPACKE_zsysvx_work_64( int matrix_layout, char fact, char uplo,
                                int64_t n, int64_t nrhs,
                                const lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* af, int64_t ldaf,
                                int64_t* ipiv,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* x, int64_t ldx,
                                double* rcond, double* ferr, double* berr,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork );

int64_t LAPACKE_ssysvxx_work_64( int matrix_layout, char fact, char uplo,
                                 int64_t n, int64_t nrhs, float* a,
                                 int64_t lda, float* af, int64_t ldaf,
                                 int64_t* ipiv, char* equed, float* s,
                                 float* b, int64_t ldb, float* x,
                                 int64_t ldx, float* rcond, float* rpvgrw,
                                 float* berr, int64_t n_err_bnds,
                                 float* err_bnds_norm, float* err_bnds_comp,
                                 int64_t nparams, float* params, float* work,
                                 int64_t* iwork );
int64_t LAPACKE_dsysvxx_work_64( int matrix_layout, char fact, char uplo,
                                 int64_t n, int64_t nrhs, double* a,
                                 int64_t lda, double* af, int64_t ldaf,
                                 int64_t* ipiv, char* equed, double* s,
                                 double* b, int64_t ldb, double* x,
                                 int64_t ldx, double* rcond, double* rpvgrw,
                                 double* berr, int64_t n_err_bnds,
                                 double* err_bnds_norm, double* err_bnds_comp,
                                 int64_t nparams, double* params,
                                 double* work, int64_t* iwork );
int64_t LAPACKE_csysvxx_work_64( int matrix_layout, char fact, char uplo,
                                 int64_t n, int64_t nrhs,
                                 lapack_complex_float* a, int64_t lda,
                                 lapack_complex_float* af, int64_t ldaf,
                                 int64_t* ipiv, char* equed, float* s,
                                 lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* x, int64_t ldx,
                                 float* rcond, float* rpvgrw, float* berr,
                                 int64_t n_err_bnds, float* err_bnds_norm,
                                 float* err_bnds_comp, int64_t nparams,
                                 float* params, lapack_complex_float* work,
                                 float* rwork );
int64_t LAPACKE_zsysvxx_work_64( int matrix_layout, char fact, char uplo,
                                 int64_t n, int64_t nrhs,
                                 lapack_complex_double* a, int64_t lda,
                                 lapack_complex_double* af, int64_t ldaf,
                                 int64_t* ipiv, char* equed, double* s,
                                 lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* x, int64_t ldx,
                                 double* rcond, double* rpvgrw, double* berr,
                                 int64_t n_err_bnds, double* err_bnds_norm,
                                 double* err_bnds_comp, int64_t nparams,
                                 double* params, lapack_complex_double* work,
                                 double* rwork );

int64_t LAPACKE_ssytrd_work_64( int matrix_layout, char uplo, int64_t n,
                                float* a, int64_t lda, float* d, float* e,
                                float* tau, float* work, int64_t lwork );
int64_t LAPACKE_dsytrd_work_64( int matrix_layout, char uplo, int64_t n,
                                double* a, int64_t lda, double* d, double* e,
                                double* tau, double* work, int64_t lwork );

int64_t LAPACKE_ssytrf_work_64( int matrix_layout, char uplo, int64_t n,
                                float* a, int64_t lda, int64_t* ipiv,
                                float* work, int64_t lwork );
int64_t LAPACKE_dsytrf_work_64( int matrix_layout, char uplo, int64_t n,
                                double* a, int64_t lda, int64_t* ipiv,
                                double* work, int64_t lwork );
int64_t LAPACKE_csytrf_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                int64_t* ipiv, lapack_complex_float* work,
                                int64_t lwork );
int64_t LAPACKE_zsytrf_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* ipiv, lapack_complex_double* work,
                                int64_t lwork );

int64_t LAPACKE_ssytri_work_64( int matrix_layout, char uplo, int64_t n,
                                float* a, int64_t lda,
                                const int64_t* ipiv, float* work );
int64_t LAPACKE_dsytri_work_64( int matrix_layout, char uplo, int64_t n,
                                double* a, int64_t lda,
                                const int64_t* ipiv, double* work );
int64_t LAPACKE_csytri_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                const int64_t* ipiv,
                                lapack_complex_float* work );
int64_t LAPACKE_zsytri_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                const int64_t* ipiv,
                                lapack_complex_double* work );

int64_t LAPACKE_ssytrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const float* a, int64_t lda,
                                const int64_t* ipiv, float* b,
                                int64_t ldb );
int64_t LAPACKE_dsytrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const double* a,
                                int64_t lda, const int64_t* ipiv,
                                double* b, int64_t ldb );
int64_t LAPACKE_csytrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_float* a,
                                int64_t lda, const int64_t* ipiv,
                                lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zsytrs_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_double* a,
                                int64_t lda, const int64_t* ipiv,
                                lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_stbcon_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t n, int64_t kd,
                                const float* ab, int64_t ldab, float* rcond,
                                float* work, int64_t* iwork );
int64_t LAPACKE_dtbcon_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t n, int64_t kd,
                                const double* ab, int64_t ldab,
                                double* rcond, double* work,
                                int64_t* iwork );
int64_t LAPACKE_ctbcon_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t n, int64_t kd,
                                const lapack_complex_float* ab, int64_t ldab,
                                float* rcond, lapack_complex_float* work,
                                float* rwork );
int64_t LAPACKE_ztbcon_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t n, int64_t kd,
                                const lapack_complex_double* ab,
                                int64_t ldab, double* rcond,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_stbrfs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t kd,
                                int64_t nrhs, const float* ab,
                                int64_t ldab, const float* b, int64_t ldb,
                                const float* x, int64_t ldx, float* ferr,
                                float* berr, float* work, int64_t* iwork );
int64_t LAPACKE_dtbrfs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t kd,
                                int64_t nrhs, const double* ab,
                                int64_t ldab, const double* b,
                                int64_t ldb, const double* x, int64_t ldx,
                                double* ferr, double* berr, double* work,
                                int64_t* iwork );
int64_t LAPACKE_ctbrfs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t kd,
                                int64_t nrhs, const lapack_complex_float* ab,
                                int64_t ldab, const lapack_complex_float* b,
                                int64_t ldb, const lapack_complex_float* x,
                                int64_t ldx, float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_ztbrfs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t kd,
                                int64_t nrhs,
                                const lapack_complex_double* ab,
                                int64_t ldab, const lapack_complex_double* b,
                                int64_t ldb, const lapack_complex_double* x,
                                int64_t ldx, double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_stbtrs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t kd,
                                int64_t nrhs, const float* ab,
                                int64_t ldab, float* b, int64_t ldb );
int64_t LAPACKE_dtbtrs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t kd,
                                int64_t nrhs, const double* ab,
                                int64_t ldab, double* b, int64_t ldb );
int64_t LAPACKE_ctbtrs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t kd,
                                int64_t nrhs, const lapack_complex_float* ab,
                                int64_t ldab, lapack_complex_float* b,
                                int64_t ldb );
int64_t LAPACKE_ztbtrs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t kd,
                                int64_t nrhs,
                                const lapack_complex_double* ab,
                                int64_t ldab, lapack_complex_double* b,
                                int64_t ldb );

int64_t LAPACKE_stfsm_work_64( int matrix_layout, char transr, char side,
                               char uplo, char trans, char diag, int64_t m,
                               int64_t n, float alpha, const float* a,
                               float* b, int64_t ldb );
int64_t LAPACKE_dtfsm_work_64( int matrix_layout, char transr, char side,
                               char uplo, char trans, char diag, int64_t m,
                               int64_t n, double alpha, const double* a,
                               double* b, int64_t ldb );
int64_t LAPACKE_ctfsm_work_64( int matrix_layout, char transr, char side,
                               char uplo, char trans, char diag, int64_t m,
                               int64_t n, lapack_complex_float alpha,
                               const lapack_complex_float* a,
                               lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_ztfsm_work_64( int matrix_layout, char transr, char side,
                               char uplo, char trans, char diag, int64_t m,
                               int64_t n, lapack_complex_double alpha,
                               const lapack_complex_double* a,
                               lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_stftri_work_64( int matrix_layout, char transr, char uplo,
                                char diag, int64_t n, float* a );
int64_t LAPACKE_dtftri_work_64( int matrix_layout, char transr, char uplo,
                                char diag, int64_t n, double* a );
int64_t LAPACKE_ctftri_work_64( int matrix_layout, char transr, char uplo,
                                char diag, int64_t n,
                                lapack_complex_float* a );
int64_t LAPACKE_ztftri_work_64( int matrix_layout, char transr, char uplo,
                                char diag, int64_t n,
                                lapack_complex_double* a );

int64_t LAPACKE_stfttp_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const float* arf, float* ap );
int64_t LAPACKE_dtfttp_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const double* arf, double* ap );
int64_t LAPACKE_ctfttp_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const lapack_complex_float* arf,
                                lapack_complex_float* ap );
int64_t LAPACKE_ztfttp_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const lapack_complex_double* arf,
                                lapack_complex_double* ap );

int64_t LAPACKE_stfttr_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const float* arf, float* a,
                                int64_t lda );
int64_t LAPACKE_dtfttr_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const double* arf, double* a,
                                int64_t lda );
int64_t LAPACKE_ctfttr_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const lapack_complex_float* arf,
                                lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_ztfttr_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const lapack_complex_double* arf,
                                lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_stgevc_work_64( int matrix_layout, char side, char howmny,
                                const lapack_logical* select, int64_t n,
                                const float* s, int64_t lds, const float* p,
                                int64_t ldp, float* vl, int64_t ldvl,
                                float* vr, int64_t ldvr, int64_t mm,
                                int64_t* m, float* work );
int64_t LAPACKE_dtgevc_work_64( int matrix_layout, char side, char howmny,
                                const lapack_logical* select, int64_t n,
                                const double* s, int64_t lds,
                                const double* p, int64_t ldp, double* vl,
                                int64_t ldvl, double* vr, int64_t ldvr,
                                int64_t mm, int64_t* m, double* work );
int64_t LAPACKE_ctgevc_work_64( int matrix_layout, char side, char howmny,
                                const lapack_logical* select, int64_t n,
                                const lapack_complex_float* s, int64_t lds,
                                const lapack_complex_float* p, int64_t ldp,
                                lapack_complex_float* vl, int64_t ldvl,
                                lapack_complex_float* vr, int64_t ldvr,
                                int64_t mm, int64_t* m,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_ztgevc_work_64( int matrix_layout, char side, char howmny,
                                const lapack_logical* select, int64_t n,
                                const lapack_complex_double* s, int64_t lds,
                                const lapack_complex_double* p, int64_t ldp,
                                lapack_complex_double* vl, int64_t ldvl,
                                lapack_complex_double* vr, int64_t ldvr,
                                int64_t mm, int64_t* m,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_stgexc_work_64( int matrix_layout, lapack_logical wantq,
                                lapack_logical wantz, int64_t n, float* a,
                                int64_t lda, float* b, int64_t ldb,
                                float* q, int64_t ldq, float* z,
                                int64_t ldz, int64_t* ifst,
                                int64_t* ilst, float* work,
                                int64_t lwork );
int64_t LAPACKE_dtgexc_work_64( int matrix_layout, lapack_logical wantq,
                                lapack_logical wantz, int64_t n, double* a,
                                int64_t lda, double* b, int64_t ldb,
                                double* q, int64_t ldq, double* z,
                                int64_t ldz, int64_t* ifst,
                                int64_t* ilst, double* work,
                                int64_t lwork );
int64_t LAPACKE_ctgexc_work_64( int matrix_layout, lapack_logical wantq,
                                lapack_logical wantz, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* q, int64_t ldq,
                                lapack_complex_float* z, int64_t ldz,
                                int64_t ifst, int64_t ilst );
int64_t LAPACKE_ztgexc_work_64( int matrix_layout, lapack_logical wantq,
                                lapack_logical wantz, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* q, int64_t ldq,
                                lapack_complex_double* z, int64_t ldz,
                                int64_t ifst, int64_t ilst );

int64_t LAPACKE_stgsen_work_64( int matrix_layout, int64_t ijob,
                                lapack_logical wantq, lapack_logical wantz,
                                const lapack_logical* select, int64_t n,
                                float* a, int64_t lda, float* b,
                                int64_t ldb, float* alphar, float* alphai,
                                float* beta, float* q, int64_t ldq, float* z,
                                int64_t ldz, int64_t* m, float* pl,
                                float* pr, float* dif, float* work,
                                int64_t lwork, int64_t* iwork,
                                int64_t liwork );
int64_t LAPACKE_dtgsen_work_64( int matrix_layout, int64_t ijob,
                                lapack_logical wantq, lapack_logical wantz,
                                const lapack_logical* select, int64_t n,
                                double* a, int64_t lda, double* b,
                                int64_t ldb, double* alphar, double* alphai,
                                double* beta, double* q, int64_t ldq,
                                double* z, int64_t ldz, int64_t* m,
                                double* pl, double* pr, double* dif,
                                double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_ctgsen_work_64( int matrix_layout, int64_t ijob,
                                lapack_logical wantq, lapack_logical wantz,
                                const lapack_logical* select, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* alpha,
                                lapack_complex_float* beta,
                                lapack_complex_float* q, int64_t ldq,
                                lapack_complex_float* z, int64_t ldz,
                                int64_t* m, float* pl, float* pr, float* dif,
                                lapack_complex_float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_ztgsen_work_64( int matrix_layout, int64_t ijob,
                                lapack_logical wantq, lapack_logical wantz,
                                const lapack_logical* select, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* alpha,
                                lapack_complex_double* beta,
                                lapack_complex_double* q, int64_t ldq,
                                lapack_complex_double* z, int64_t ldz,
                                int64_t* m, double* pl, double* pr,
                                double* dif, lapack_complex_double* work,
                                int64_t lwork, int64_t* iwork,
                                int64_t liwork );

int64_t LAPACKE_stgsja_work_64( int matrix_layout, char jobu, char jobv,
                                char jobq, int64_t m, int64_t p,
                                int64_t n, int64_t k, int64_t l,
                                float* a, int64_t lda, float* b,
                                int64_t ldb, float tola, float tolb,
                                float* alpha, float* beta, float* u,
                                int64_t ldu, float* v, int64_t ldv,
                                float* q, int64_t ldq, float* work,
                                int64_t* ncycle );
int64_t LAPACKE_dtgsja_work_64( int matrix_layout, char jobu, char jobv,
                                char jobq, int64_t m, int64_t p,
                                int64_t n, int64_t k, int64_t l,
                                double* a, int64_t lda, double* b,
                                int64_t ldb, double tola, double tolb,
                                double* alpha, double* beta, double* u,
                                int64_t ldu, double* v, int64_t ldv,
                                double* q, int64_t ldq, double* work,
                                int64_t* ncycle );
int64_t LAPACKE_ctgsja_work_64( int matrix_layout, char jobu, char jobv,
                                char jobq, int64_t m, int64_t p,
                                int64_t n, int64_t k, int64_t l,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb,
                                float tola, float tolb, float* alpha,
                                float* beta, lapack_complex_float* u,
                                int64_t ldu, lapack_complex_float* v,
                                int64_t ldv, lapack_complex_float* q,
                                int64_t ldq, lapack_complex_float* work,
                                int64_t* ncycle );
int64_t LAPACKE_ztgsja_work_64( int matrix_layout, char jobu, char jobv,
                                char jobq, int64_t m, int64_t p,
                                int64_t n, int64_t k, int64_t l,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb,
                                double tola, double tolb, double* alpha,
                                double* beta, lapack_complex_double* u,
                                int64_t ldu, lapack_complex_double* v,
                                int64_t ldv, lapack_complex_double* q,
                                int64_t ldq, lapack_complex_double* work,
                                int64_t* ncycle );

int64_t LAPACKE_stgsna_work_64( int matrix_layout, char job, char howmny,
                                const lapack_logical* select, int64_t n,
                                const float* a, int64_t lda, const float* b,
                                int64_t ldb, const float* vl,
                                int64_t ldvl, const float* vr,
                                int64_t ldvr, float* s, float* dif,
                                int64_t mm, int64_t* m, float* work,
                                int64_t lwork, int64_t* iwork );
int64_t LAPACKE_dtgsna_work_64( int matrix_layout, char job, char howmny,
                                const lapack_logical* select, int64_t n,
                                const double* a, int64_t lda,
                                const double* b, int64_t ldb,
                                const double* vl, int64_t ldvl,
                                const double* vr, int64_t ldvr, double* s,
                                double* dif, int64_t mm, int64_t* m,
                                double* work, int64_t lwork,
                                int64_t* iwork );
int64_t LAPACKE_ctgsna_work_64( int matrix_layout, char job, char howmny,
                                const lapack_logical* select, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* b, int64_t ldb,
                                const lapack_complex_float* vl, int64_t ldvl,
                                const lapack_complex_float* vr, int64_t ldvr,
                                float* s, float* dif, int64_t mm,
                                int64_t* m, lapack_complex_float* work,
                                int64_t lwork, int64_t* iwork );
int64_t LAPACKE_ztgsna_work_64( int matrix_layout, char job, char howmny,
                                const lapack_logical* select, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* b, int64_t ldb,
                                const lapack_complex_double* vl,
                                int64_t ldvl,
                                const lapack_complex_double* vr,
                                int64_t ldvr, double* s, double* dif,
                                int64_t mm, int64_t* m,
                                lapack_complex_double* work, int64_t lwork,
                                int64_t* iwork );

int64_t LAPACKE_stgsyl_work_64( int matrix_layout, char trans, int64_t ijob,
                                int64_t m, int64_t n, const float* a,
                                int64_t lda, const float* b, int64_t ldb,
                                float* c, int64_t ldc, const float* d,
                                int64_t ldd, const float* e, int64_t lde,
                                float* f, int64_t ldf, float* scale,
                                float* dif, float* work, int64_t lwork,
                                int64_t* iwork );
int64_t LAPACKE_dtgsyl_work_64( int matrix_layout, char trans, int64_t ijob,
                                int64_t m, int64_t n, const double* a,
                                int64_t lda, const double* b, int64_t ldb,
                                double* c, int64_t ldc, const double* d,
                                int64_t ldd, const double* e, int64_t lde,
                                double* f, int64_t ldf, double* scale,
                                double* dif, double* work, int64_t lwork,
                                int64_t* iwork );
int64_t LAPACKE_ctgsyl_work_64( int matrix_layout, char trans, int64_t ijob,
                                int64_t m, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* c, int64_t ldc,
                                const lapack_complex_float* d, int64_t ldd,
                                const lapack_complex_float* e, int64_t lde,
                                lapack_complex_float* f, int64_t ldf,
                                float* scale, float* dif,
                                lapack_complex_float* work, int64_t lwork,
                                int64_t* iwork );
int64_t LAPACKE_ztgsyl_work_64( int matrix_layout, char trans, int64_t ijob,
                                int64_t m, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* c, int64_t ldc,
                                const lapack_complex_double* d, int64_t ldd,
                                const lapack_complex_double* e, int64_t lde,
                                lapack_complex_double* f, int64_t ldf,
                                double* scale, double* dif,
                                lapack_complex_double* work, int64_t lwork,
                                int64_t* iwork );

int64_t LAPACKE_stpcon_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t n, const float* ap,
                                float* rcond, float* work, int64_t* iwork );
int64_t LAPACKE_dtpcon_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t n, const double* ap,
                                double* rcond, double* work,
                                int64_t* iwork );
int64_t LAPACKE_ctpcon_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t n,
                                const lapack_complex_float* ap, float* rcond,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_ztpcon_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t n,
                                const lapack_complex_double* ap, double* rcond,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_stprfs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const float* ap, const float* b, int64_t ldb,
                                const float* x, int64_t ldx, float* ferr,
                                float* berr, float* work, int64_t* iwork );
int64_t LAPACKE_dtprfs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const double* ap, const double* b,
                                int64_t ldb, const double* x, int64_t ldx,
                                double* ferr, double* berr, double* work,
                                int64_t* iwork );
int64_t LAPACKE_ctprfs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const lapack_complex_float* ap,
                                const lapack_complex_float* b, int64_t ldb,
                                const lapack_complex_float* x, int64_t ldx,
                                float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_ztprfs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const lapack_complex_double* ap,
                                const lapack_complex_double* b, int64_t ldb,
                                const lapack_complex_double* x, int64_t ldx,
                                double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_stptri_work_64( int matrix_layout, char uplo, char diag,
                                int64_t n, float* ap );
int64_t LAPACKE_dtptri_work_64( int matrix_layout, char uplo, char diag,
                                int64_t n, double* ap );
int64_t LAPACKE_ctptri_work_64( int matrix_layout, char uplo, char diag,
                                int64_t n, lapack_complex_float* ap );
int64_t LAPACKE_ztptri_work_64( int matrix_layout, char uplo, char diag,
                                int64_t n, lapack_complex_double* ap );

int64_t LAPACKE_stptrs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const float* ap, float* b, int64_t ldb );
int64_t LAPACKE_dtptrs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const double* ap, double* b, int64_t ldb );
int64_t LAPACKE_ctptrs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const lapack_complex_float* ap,
                                lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_ztptrs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const lapack_complex_double* ap,
                                lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_stpttf_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const float* ap, float* arf );
int64_t LAPACKE_dtpttf_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const double* ap, double* arf );
int64_t LAPACKE_ctpttf_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const lapack_complex_float* ap,
                                lapack_complex_float* arf );
int64_t LAPACKE_ztpttf_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const lapack_complex_double* ap,
                                lapack_complex_double* arf );

int64_t LAPACKE_stpttr_work_64( int matrix_layout, char uplo, int64_t n,
                                const float* ap, float* a, int64_t lda );
int64_t LAPACKE_dtpttr_work_64( int matrix_layout, char uplo, int64_t n,
                                const double* ap, double* a, int64_t lda );
int64_t LAPACKE_ctpttr_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_float* ap,
                                lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_ztpttr_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_double* ap,
                                lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_strcon_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t n, const float* a,
                                int64_t lda, float* rcond, float* work,
                                int64_t* iwork );
int64_t LAPACKE_dtrcon_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t n, const double* a,
                                int64_t lda, double* rcond, double* work,
                                int64_t* iwork );
int64_t LAPACKE_ctrcon_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                float* rcond, lapack_complex_float* work,
                                float* rwork );
int64_t LAPACKE_ztrcon_work_64( int matrix_layout, char norm, char uplo,
                                char diag, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                double* rcond, lapack_complex_double* work,
                                double* rwork );

int64_t LAPACKE_strevc_work_64( int matrix_layout, char side, char howmny,
                                lapack_logical* select, int64_t n,
                                const float* t, int64_t ldt, float* vl,
                                int64_t ldvl, float* vr, int64_t ldvr,
                                int64_t mm, int64_t* m, float* work );
int64_t LAPACKE_dtrevc_work_64( int matrix_layout, char side, char howmny,
                                lapack_logical* select, int64_t n,
                                const double* t, int64_t ldt, double* vl,
                                int64_t ldvl, double* vr, int64_t ldvr,
                                int64_t mm, int64_t* m, double* work );
int64_t LAPACKE_ctrevc_work_64( int matrix_layout, char side, char howmny,
                                const lapack_logical* select, int64_t n,
                                lapack_complex_float* t, int64_t ldt,
                                lapack_complex_float* vl, int64_t ldvl,
                                lapack_complex_float* vr, int64_t ldvr,
                                int64_t mm, int64_t* m,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_ztrevc_work_64( int matrix_layout, char side, char howmny,
                                const lapack_logical* select, int64_t n,
                                lapack_complex_double* t, int64_t ldt,
                                lapack_complex_double* vl, int64_t ldvl,
                                lapack_complex_double* vr, int64_t ldvr,
                                int64_t mm, int64_t* m,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_strexc_work_64( int matrix_layout, char compq, int64_t n,
                                float* t, int64_t ldt, float* q,
                                int64_t ldq, int64_t* ifst,
                                int64_t* ilst, float* work );
int64_t LAPACKE_dtrexc_work_64( int matrix_layout, char compq, int64_t n,
                                double* t, int64_t ldt, double* q,
                                int64_t ldq, int64_t* ifst,
                                int64_t* ilst, double* work );
int64_t LAPACKE_ctrexc_work_64( int matrix_layout, char compq, int64_t n,
                                lapack_complex_float* t, int64_t ldt,
                                lapack_complex_float* q, int64_t ldq,
                                int64_t ifst, int64_t ilst );
int64_t LAPACKE_ztrexc_work_64( int matrix_layout, char compq, int64_t n,
                                lapack_complex_double* t, int64_t ldt,
                                lapack_complex_double* q, int64_t ldq,
                                int64_t ifst, int64_t ilst );

int64_t LAPACKE_strrfs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const float* a, int64_t lda, const float* b,
                                int64_t ldb, const float* x, int64_t ldx,
                                float* ferr, float* berr, float* work,
                                int64_t* iwork );
int64_t LAPACKE_dtrrfs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const double* a, int64_t lda,
                                const double* b, int64_t ldb,
                                const double* x, int64_t ldx, double* ferr,
                                double* berr, double* work, int64_t* iwork );
int64_t LAPACKE_ctrrfs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* b, int64_t ldb,
                                const lapack_complex_float* x, int64_t ldx,
                                float* ferr, float* berr,
                                lapack_complex_float* work, float* rwork );
int64_t LAPACKE_ztrrfs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* b, int64_t ldb,
                                const lapack_complex_double* x, int64_t ldx,
                                double* ferr, double* berr,
                                lapack_complex_double* work, double* rwork );

int64_t LAPACKE_strsen_work_64( int matrix_layout, char job, char compq,
                                const lapack_logical* select, int64_t n,
                                float* t, int64_t ldt, float* q,
                                int64_t ldq, float* wr, float* wi,
                                int64_t* m, float* s, float* sep,
                                float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_dtrsen_work_64( int matrix_layout, char job, char compq,
                                const lapack_logical* select, int64_t n,
                                double* t, int64_t ldt, double* q,
                                int64_t ldq, double* wr, double* wi,
                                int64_t* m, double* s, double* sep,
                                double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_ctrsen_work_64( int matrix_layout, char job, char compq,
                                const lapack_logical* select, int64_t n,
                                lapack_complex_float* t, int64_t ldt,
                                lapack_complex_float* q, int64_t ldq,
                                lapack_complex_float* w, int64_t* m,
                                float* s, float* sep,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_ztrsen_work_64( int matrix_layout, char job, char compq,
                                const lapack_logical* select, int64_t n,
                                lapack_complex_double* t, int64_t ldt,
                                lapack_complex_double* q, int64_t ldq,
                                lapack_complex_double* w, int64_t* m,
                                double* s, double* sep,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_strsna_work_64( int matrix_layout, char job, char howmny,
                                const lapack_logical* select, int64_t n,
                                const float* t, int64_t ldt, const float* vl,
                                int64_t ldvl, const float* vr,
                                int64_t ldvr, float* s, float* sep,
                                int64_t mm, int64_t* m, float* work,
                                int64_t ldwork, int64_t* iwork );
int64_t LAPACKE_dtrsna_work_64( int matrix_layout, char job, char howmny,
                                const lapack_logical* select, int64_t n,
                                const double* t, int64_t ldt,
                                const double* vl, int64_t ldvl,
                                const double* vr, int64_t ldvr, double* s,
                                double* sep, int64_t mm, int64_t* m,
                                double* work, int64_t ldwork,
                                int64_t* iwork );
int64_t LAPACKE_ctrsna_work_64( int matrix_layout, char job, char howmny,
                                const lapack_logical* select, int64_t n,
                                const lapack_complex_float* t, int64_t ldt,
                                const lapack_complex_float* vl, int64_t ldvl,
                                const lapack_complex_float* vr, int64_t ldvr,
                                float* s, float* sep, int64_t mm,
                                int64_t* m, lapack_complex_float* work,
                                int64_t ldwork, float* rwork );
int64_t LAPACKE_ztrsna_work_64( int matrix_layout, char job, char howmny,
                                const lapack_logical* select, int64_t n,
                                const lapack_complex_double* t, int64_t ldt,
                                const lapack_complex_double* vl,
                                int64_t ldvl,
                                const lapack_complex_double* vr,
                                int64_t ldvr, double* s, double* sep,
                                int64_t mm, int64_t* m,
                                lapack_complex_double* work, int64_t ldwork,
                                double* rwork );

int64_t LAPACKE_strsyl_work_64( int matrix_layout, char trana, char tranb,
                                int64_t isgn, int64_t m, int64_t n,
                                const float* a, int64_t lda, const float* b,
                                int64_t ldb, float* c, int64_t ldc,
                                float* scale );
int64_t LAPACKE_dtrsyl_work_64( int matrix_layout, char trana, char tranb,
                                int64_t isgn, int64_t m, int64_t n,
                                const double* a, int64_t lda,
                                const double* b, int64_t ldb, double* c,
                                int64_t ldc, double* scale );
int64_t LAPACKE_ctrsyl_work_64( int matrix_layout, char trana, char tranb,
                                int64_t isgn, int64_t m, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* c, int64_t ldc,
                                float* scale );
int64_t LAPACKE_ztrsyl_work_64( int matrix_layout, char trana, char tranb,
                                int64_t isgn, int64_t m, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* c, int64_t ldc,
                                double* scale );

int64_t LAPACKE_strsyl3_work_64( int matrix_layout, char trana, char tranb,
                                 int64_t isgn, int64_t m, int64_t n,
                                 const float* a, int64_t lda,
                                 const float* b, int64_t ldb,
                                 float* c, int64_t ldc, float* scale,
                                 int64_t* iwork, int64_t liwork,
                                 float* swork, int64_t ldswork );
int64_t LAPACKE_dtrsyl3_work_64( int matrix_layout, char trana, char tranb,
                                 int64_t isgn, int64_t m, int64_t n,
                                 const double* a, int64_t lda,
                                 const double* b, int64_t ldb,
                                 double* c, int64_t ldc, double* scale,
                                 int64_t* iwork, int64_t liwork,
                                 double* swork, int64_t ldswork );
int64_t LAPACKE_ctrsyl3_work_64( int matrix_layout, char trana, char tranb,
                                 int64_t isgn, int64_t m, int64_t n,
                                 const lapack_complex_float* a, int64_t lda,
                                 const lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* c, int64_t ldc,
                                 float* scale, float* swork,
                                 int64_t ldswork );
int64_t LAPACKE_ztrsyl3_work_64( int matrix_layout, char trana, char tranb,
                                 int64_t isgn, int64_t m, int64_t n,
                                 const lapack_complex_double* a, int64_t lda,
                                 const lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* c, int64_t ldc,
                                 double* scale, double* swork,
                                 int64_t ldswork );

int64_t LAPACKE_strtri_work_64( int matrix_layout, char uplo, char diag,
                                int64_t n, float* a, int64_t lda );
int64_t LAPACKE_dtrtri_work_64( int matrix_layout, char uplo, char diag,
                                int64_t n, double* a, int64_t lda );
int64_t LAPACKE_ctrtri_work_64( int matrix_layout, char uplo, char diag,
                                int64_t n, lapack_complex_float* a,
                                int64_t lda );
int64_t LAPACKE_ztrtri_work_64( int matrix_layout, char uplo, char diag,
                                int64_t n, lapack_complex_double* a,
                                int64_t lda );

int64_t LAPACKE_strtrs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const float* a, int64_t lda, float* b,
                                int64_t ldb );
int64_t LAPACKE_dtrtrs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const double* a, int64_t lda, double* b,
                                int64_t ldb );
int64_t LAPACKE_ctrtrs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_ztrtrs_work_64( int matrix_layout, char uplo, char trans,
                                char diag, int64_t n, int64_t nrhs,
                                const lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_strttf_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const float* a, int64_t lda,
                                float* arf );
int64_t LAPACKE_dtrttf_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const double* a, int64_t lda,
                                double* arf );
int64_t LAPACKE_ctrttf_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* arf );
int64_t LAPACKE_ztrttf_work_64( int matrix_layout, char transr, char uplo,
                                int64_t n, const lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* arf );

int64_t LAPACKE_strttp_work_64( int matrix_layout, char uplo, int64_t n,
                                const float* a, int64_t lda, float* ap );
int64_t LAPACKE_dtrttp_work_64( int matrix_layout, char uplo, int64_t n,
                                const double* a, int64_t lda, double* ap );
int64_t LAPACKE_ctrttp_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* ap );
int64_t LAPACKE_ztrttp_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* ap );

int64_t LAPACKE_stzrzf_work_64( int matrix_layout, int64_t m, int64_t n,
                                float* a, int64_t lda, float* tau,
                                float* work, int64_t lwork );
int64_t LAPACKE_dtzrzf_work_64( int matrix_layout, int64_t m, int64_t n,
                                double* a, int64_t lda, double* tau,
                                double* work, int64_t lwork );
int64_t LAPACKE_ctzrzf_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_ztzrzf_work_64( int matrix_layout, int64_t m, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cungbr_work_64( int matrix_layout, char vect, int64_t m,
                                int64_t n, int64_t k,
                                lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zungbr_work_64( int matrix_layout, char vect, int64_t m,
                                int64_t n, int64_t k,
                                lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cunghr_work_64( int matrix_layout, int64_t n, int64_t ilo,
                                int64_t ihi, lapack_complex_float* a,
                                int64_t lda, const lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zunghr_work_64( int matrix_layout, int64_t n, int64_t ilo,
                                int64_t ihi, lapack_complex_double* a,
                                int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cunglq_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, lapack_complex_float* a,
                                int64_t lda, const lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zunglq_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, lapack_complex_double* a,
                                int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cungql_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, lapack_complex_float* a,
                                int64_t lda, const lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zungql_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, lapack_complex_double* a,
                                int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cungqr_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, lapack_complex_float* a,
                                int64_t lda, const lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zungqr_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, lapack_complex_double* a,
                                int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cungrq_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, lapack_complex_float* a,
                                int64_t lda, const lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zungrq_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t k, lapack_complex_double* a,
                                int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cungtr_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* tau,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zungtr_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cungtsqr_row_work_64( int matrix_layout,
                                      int64_t m, int64_t n,
                                      int64_t mb, int64_t nb,
                                      lapack_complex_float* a, int64_t lda,
                                      const lapack_complex_float* t, int64_t ldt,
                                      lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zungtsqr_row_work_64( int matrix_layout,
                                      int64_t m, int64_t n,
                                      int64_t mb, int64_t nb,
                                      lapack_complex_double* a, int64_t lda,
                                      const lapack_complex_double* t, int64_t ldt,
                                      lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cunmbr_work_64( int matrix_layout, char vect, char side,
                                char trans, int64_t m, int64_t n,
                                int64_t k, const lapack_complex_float* a,
                                int64_t lda, const lapack_complex_float* tau,
                                lapack_complex_float* c, int64_t ldc,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zunmbr_work_64( int matrix_layout, char vect, char side,
                                char trans, int64_t m, int64_t n,
                                int64_t k, const lapack_complex_double* a,
                                int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* c, int64_t ldc,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cunmhr_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t ilo,
                                int64_t ihi, const lapack_complex_float* a,
                                int64_t lda, const lapack_complex_float* tau,
                                lapack_complex_float* c, int64_t ldc,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zunmhr_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t ilo,
                                int64_t ihi, const lapack_complex_double* a,
                                int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* c, int64_t ldc,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cunmlq_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* tau,
                                lapack_complex_float* c, int64_t ldc,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zunmlq_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* c, int64_t ldc,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cunmql_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* tau,
                                lapack_complex_float* c, int64_t ldc,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zunmql_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* c, int64_t ldc,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cunmqr_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* tau,
                                lapack_complex_float* c, int64_t ldc,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zunmqr_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* c, int64_t ldc,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cunmrq_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* tau,
                                lapack_complex_float* c, int64_t ldc,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zunmrq_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* c, int64_t ldc,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cunmrz_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                int64_t l, const lapack_complex_float* a,
                                int64_t lda, const lapack_complex_float* tau,
                                lapack_complex_float* c, int64_t ldc,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zunmrz_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                int64_t l, const lapack_complex_double* a,
                                int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* c, int64_t ldc,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cunmtr_work_64( int matrix_layout, char side, char uplo,
                                char trans, int64_t m, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* tau,
                                lapack_complex_float* c, int64_t ldc,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zunmtr_work_64( int matrix_layout, char side, char uplo,
                                char trans, int64_t m, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* tau,
                                lapack_complex_double* c, int64_t ldc,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_cupgtr_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_float* ap,
                                const lapack_complex_float* tau,
                                lapack_complex_float* q, int64_t ldq,
                                lapack_complex_float* work );
int64_t LAPACKE_zupgtr_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_double* ap,
                                const lapack_complex_double* tau,
                                lapack_complex_double* q, int64_t ldq,
                                lapack_complex_double* work );

int64_t LAPACKE_cupmtr_work_64( int matrix_layout, char side, char uplo,
                                char trans, int64_t m, int64_t n,
                                const lapack_complex_float* ap,
                                const lapack_complex_float* tau,
                                lapack_complex_float* c, int64_t ldc,
                                lapack_complex_float* work );
int64_t LAPACKE_zupmtr_work_64( int matrix_layout, char side, char uplo,
                                char trans, int64_t m, int64_t n,
                                const lapack_complex_double* ap,
                                const lapack_complex_double* tau,
                                lapack_complex_double* c, int64_t ldc,
                                lapack_complex_double* work );

int64_t LAPACKE_claghe_64( int matrix_layout, int64_t n, int64_t k,
                           const float* d, lapack_complex_float* a,
                           int64_t lda, int64_t* iseed );
int64_t LAPACKE_zlaghe_64( int matrix_layout, int64_t n, int64_t k,
                           const double* d, lapack_complex_double* a,
                           int64_t lda, int64_t* iseed );

int64_t LAPACKE_slagsy_64( int matrix_layout, int64_t n, int64_t k,
                           const float* d, float* a, int64_t lda,
                           int64_t* iseed );
int64_t LAPACKE_dlagsy_64( int matrix_layout, int64_t n, int64_t k,
                           const double* d, double* a, int64_t lda,
                           int64_t* iseed );
int64_t LAPACKE_clagsy_64( int matrix_layout, int64_t n, int64_t k,
                           const float* d, lapack_complex_float* a,
                           int64_t lda, int64_t* iseed );
int64_t LAPACKE_zlagsy_64( int matrix_layout, int64_t n, int64_t k,
                           const double* d, lapack_complex_double* a,
                           int64_t lda, int64_t* iseed );

int64_t LAPACKE_slapmr_64( int matrix_layout, lapack_logical forwrd,
                           int64_t m, int64_t n, float* x, int64_t ldx,
                           int64_t* k );
int64_t LAPACKE_dlapmr_64( int matrix_layout, lapack_logical forwrd,
                           int64_t m, int64_t n, double* x,
                           int64_t ldx, int64_t* k );
int64_t LAPACKE_clapmr_64( int matrix_layout, lapack_logical forwrd,
                           int64_t m, int64_t n, lapack_complex_float* x,
                           int64_t ldx, int64_t* k );
int64_t LAPACKE_zlapmr_64( int matrix_layout, lapack_logical forwrd,
                           int64_t m, int64_t n, lapack_complex_double* x,
                           int64_t ldx, int64_t* k );

int64_t LAPACKE_slapmt_64( int matrix_layout, lapack_logical forwrd,
                           int64_t m, int64_t n, float* x, int64_t ldx,
                           int64_t* k );
int64_t LAPACKE_dlapmt_64( int matrix_layout, lapack_logical forwrd,
                           int64_t m, int64_t n, double* x,
                           int64_t ldx, int64_t* k );
int64_t LAPACKE_clapmt_64( int matrix_layout, lapack_logical forwrd,
                           int64_t m, int64_t n, lapack_complex_float* x,
                           int64_t ldx, int64_t* k );
int64_t LAPACKE_zlapmt_64( int matrix_layout, lapack_logical forwrd,
                           int64_t m, int64_t n, lapack_complex_double* x,
                           int64_t ldx, int64_t* k );

float LAPACKE_slapy2_64( float x, float y );
double LAPACKE_dlapy2_64( double x, double y );

float LAPACKE_slapy3_64( float x, float y, float z );
double LAPACKE_dlapy3_64( double x, double y, double z );

int64_t LAPACKE_slartgp_64( float f, float g, float* cs, float* sn, float* r );
int64_t LAPACKE_dlartgp_64( double f, double g, double* cs, double* sn,
                            double* r );

int64_t LAPACKE_slartgs_64( float x, float y, float sigma, float* cs,
                            float* sn );
int64_t LAPACKE_dlartgs_64( double x, double y, double sigma, double* cs,
                            double* sn );


//LAPACK 3.3.0
int64_t LAPACKE_cbbcsd_64( int matrix_layout, char jobu1, char jobu2,
                           char jobv1t, char jobv2t, char trans, int64_t m,
                           int64_t p, int64_t q, float* theta, float* phi,
                           lapack_complex_float* u1, int64_t ldu1,
                           lapack_complex_float* u2, int64_t ldu2,
                           lapack_complex_float* v1t, int64_t ldv1t,
                           lapack_complex_float* v2t, int64_t ldv2t,
                           float* b11d, float* b11e, float* b12d, float* b12e,
                           float* b21d, float* b21e, float* b22d, float* b22e );
int64_t LAPACKE_cbbcsd_work_64( int matrix_layout, char jobu1, char jobu2,
                                char jobv1t, char jobv2t, char trans,
                                int64_t m, int64_t p, int64_t q,
                                float* theta, float* phi,
                                lapack_complex_float* u1, int64_t ldu1,
                                lapack_complex_float* u2, int64_t ldu2,
                                lapack_complex_float* v1t, int64_t ldv1t,
                                lapack_complex_float* v2t, int64_t ldv2t,
                                float* b11d, float* b11e, float* b12d,
                                float* b12e, float* b21d, float* b21e,
                                float* b22d, float* b22e, float* rwork,
                                int64_t lrwork );
int64_t LAPACKE_cheswapr_64( int matrix_layout, char uplo, int64_t n,
                             lapack_complex_float* a, int64_t lda,
                             int64_t i1, int64_t i2 );
int64_t LAPACKE_cheswapr_work_64( int matrix_layout, char uplo, int64_t n,
                                  lapack_complex_float* a, int64_t lda,
                                  int64_t i1, int64_t i2 );
int64_t LAPACKE_chetri2_64( int matrix_layout, char uplo, int64_t n,
                            lapack_complex_float* a, int64_t lda,
                            const int64_t* ipiv );
int64_t LAPACKE_chetri2_work_64( int matrix_layout, char uplo, int64_t n,
                                 lapack_complex_float* a, int64_t lda,
                                 const int64_t* ipiv,
                                 lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_chetri2x_64( int matrix_layout, char uplo, int64_t n,
                             lapack_complex_float* a, int64_t lda,
                             const int64_t* ipiv, int64_t nb );
int64_t LAPACKE_chetri2x_work_64( int matrix_layout, char uplo, int64_t n,
                                  lapack_complex_float* a, int64_t lda,
                                  const int64_t* ipiv,
                                  lapack_complex_float* work, int64_t nb );
int64_t LAPACKE_chetrs2_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const lapack_complex_float* a,
                            int64_t lda, const int64_t* ipiv,
                            lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_chetrs2_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const lapack_complex_float* a,
                                 int64_t lda, const int64_t* ipiv,
                                 lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* work );
int64_t LAPACKE_csyconv_64( int matrix_layout, char uplo, char way, int64_t n,
                            lapack_complex_float* a, int64_t lda,
                            const int64_t* ipiv, lapack_complex_float* e  );
int64_t LAPACKE_csyconv_work_64( int matrix_layout, char uplo, char way,
                                 int64_t n, lapack_complex_float* a,
                                 int64_t lda, const int64_t* ipiv,
                                 lapack_complex_float* e );
int64_t LAPACKE_csyswapr_64( int matrix_layout, char uplo, int64_t n,
                             lapack_complex_float* a, int64_t lda,
                             int64_t i1, int64_t i2 );
int64_t LAPACKE_csyswapr_work_64( int matrix_layout, char uplo, int64_t n,
                                  lapack_complex_float* a, int64_t lda,
                                  int64_t i1, int64_t i2 );
int64_t LAPACKE_csytri2_64( int matrix_layout, char uplo, int64_t n,
                            lapack_complex_float* a, int64_t lda,
                            const int64_t* ipiv );
int64_t LAPACKE_csytri2_work_64( int matrix_layout, char uplo, int64_t n,
                                 lapack_complex_float* a, int64_t lda,
                                 const int64_t* ipiv,
                                 lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_csytri2x_64( int matrix_layout, char uplo, int64_t n,
                             lapack_complex_float* a, int64_t lda,
                             const int64_t* ipiv, int64_t nb );
int64_t LAPACKE_csytri2x_work_64( int matrix_layout, char uplo, int64_t n,
                                  lapack_complex_float* a, int64_t lda,
                                  const int64_t* ipiv,
                                  lapack_complex_float* work, int64_t nb );
int64_t LAPACKE_csytrs2_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const lapack_complex_float* a,
                            int64_t lda, const int64_t* ipiv,
                            lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_csytrs2_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const lapack_complex_float* a,
                                 int64_t lda, const int64_t* ipiv,
                                 lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* work );
int64_t LAPACKE_cunbdb_64( int matrix_layout, char trans, char signs,
                           int64_t m, int64_t p, int64_t q,
                           lapack_complex_float* x11, int64_t ldx11,
                           lapack_complex_float* x12, int64_t ldx12,
                           lapack_complex_float* x21, int64_t ldx21,
                           lapack_complex_float* x22, int64_t ldx22,
                           float* theta, float* phi,
                           lapack_complex_float* taup1,
                           lapack_complex_float* taup2,
                           lapack_complex_float* tauq1,
                           lapack_complex_float* tauq2 );
int64_t LAPACKE_cunbdb_work_64( int matrix_layout, char trans, char signs,
                                int64_t m, int64_t p, int64_t q,
                                lapack_complex_float* x11, int64_t ldx11,
                                lapack_complex_float* x12, int64_t ldx12,
                                lapack_complex_float* x21, int64_t ldx21,
                                lapack_complex_float* x22, int64_t ldx22,
                                float* theta, float* phi,
                                lapack_complex_float* taup1,
                                lapack_complex_float* taup2,
                                lapack_complex_float* tauq1,
                                lapack_complex_float* tauq2,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_cuncsd_64( int matrix_layout, char jobu1, char jobu2,
                           char jobv1t, char jobv2t, char trans, char signs,
                           int64_t m, int64_t p, int64_t q,
                           lapack_complex_float* x11, int64_t ldx11,
                           lapack_complex_float* x12, int64_t ldx12,
                           lapack_complex_float* x21, int64_t ldx21,
                           lapack_complex_float* x22, int64_t ldx22,
                           float* theta, lapack_complex_float* u1,
                           int64_t ldu1, lapack_complex_float* u2,
                           int64_t ldu2, lapack_complex_float* v1t,
                           int64_t ldv1t, lapack_complex_float* v2t,
                           int64_t ldv2t );
int64_t LAPACKE_cuncsd_work_64( int matrix_layout, char jobu1, char jobu2,
                                char jobv1t, char jobv2t, char trans,
                                char signs, int64_t m, int64_t p,
                                int64_t q, lapack_complex_float* x11,
                                int64_t ldx11, lapack_complex_float* x12,
                                int64_t ldx12, lapack_complex_float* x21,
                                int64_t ldx21, lapack_complex_float* x22,
                                int64_t ldx22, float* theta,
                                lapack_complex_float* u1, int64_t ldu1,
                                lapack_complex_float* u2, int64_t ldu2,
                                lapack_complex_float* v1t, int64_t ldv1t,
                                lapack_complex_float* v2t, int64_t ldv2t,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork, int64_t lrwork,
                                int64_t* iwork );
int64_t LAPACKE_cuncsd2by1_64( int matrix_layout, char jobu1, char jobu2,
                           char jobv1t, int64_t m, int64_t p, int64_t q,
                           lapack_complex_float* x11, int64_t ldx11,
                           lapack_complex_float* x21, int64_t ldx21,
                           float* theta, lapack_complex_float* u1,
                           int64_t ldu1, lapack_complex_float* u2,
                           int64_t ldu2, lapack_complex_float* v1t, int64_t ldv1t );
int64_t LAPACKE_cuncsd2by1_work_64( int matrix_layout, char jobu1, char jobu2,
                                char jobv1t, int64_t m, int64_t p,
                                int64_t q, lapack_complex_float* x11, int64_t ldx11,
                                lapack_complex_float* x21, int64_t ldx21,
                                float* theta, lapack_complex_float* u1,
                                int64_t ldu1, lapack_complex_float* u2,
                                int64_t ldu2, lapack_complex_float* v1t,
                                int64_t ldv1t, lapack_complex_float* work,
                                int64_t lwork, float* rwork, int64_t lrwork,
                                int64_t* iwork );
int64_t LAPACKE_dbbcsd_64( int matrix_layout, char jobu1, char jobu2,
                           char jobv1t, char jobv2t, char trans, int64_t m,
                           int64_t p, int64_t q, double* theta,
                           double* phi, double* u1, int64_t ldu1, double* u2,
                           int64_t ldu2, double* v1t, int64_t ldv1t,
                           double* v2t, int64_t ldv2t, double* b11d,
                           double* b11e, double* b12d, double* b12e,
                           double* b21d, double* b21e, double* b22d,
                           double* b22e );
int64_t LAPACKE_dbbcsd_work_64( int matrix_layout, char jobu1, char jobu2,
                                char jobv1t, char jobv2t, char trans,
                                int64_t m, int64_t p, int64_t q,
                                double* theta, double* phi, double* u1,
                                int64_t ldu1, double* u2, int64_t ldu2,
                                double* v1t, int64_t ldv1t, double* v2t,
                                int64_t ldv2t, double* b11d, double* b11e,
                                double* b12d, double* b12e, double* b21d,
                                double* b21e, double* b22d, double* b22e,
                                double* work, int64_t lwork );
int64_t LAPACKE_dorbdb_64( int matrix_layout, char trans, char signs,
                           int64_t m, int64_t p, int64_t q,
                           double* x11, int64_t ldx11, double* x12,
                           int64_t ldx12, double* x21, int64_t ldx21,
                           double* x22, int64_t ldx22, double* theta,
                           double* phi, double* taup1, double* taup2,
                           double* tauq1, double* tauq2 );
int64_t LAPACKE_dorbdb_work_64( int matrix_layout, char trans, char signs,
                                int64_t m, int64_t p, int64_t q,
                                double* x11, int64_t ldx11, double* x12,
                                int64_t ldx12, double* x21, int64_t ldx21,
                                double* x22, int64_t ldx22, double* theta,
                                double* phi, double* taup1, double* taup2,
                                double* tauq1, double* tauq2, double* work,
                                int64_t lwork );
int64_t LAPACKE_dorcsd_64( int matrix_layout, char jobu1, char jobu2,
                           char jobv1t, char jobv2t, char trans, char signs,
                           int64_t m, int64_t p, int64_t q,
                           double* x11, int64_t ldx11, double* x12,
                           int64_t ldx12, double* x21, int64_t ldx21,
                           double* x22, int64_t ldx22, double* theta,
                           double* u1, int64_t ldu1, double* u2,
                           int64_t ldu2, double* v1t, int64_t ldv1t,
                           double* v2t, int64_t ldv2t );
int64_t LAPACKE_dorcsd_work_64( int matrix_layout, char jobu1, char jobu2,
                                char jobv1t, char jobv2t, char trans,
                                char signs, int64_t m, int64_t p,
                                int64_t q, double* x11, int64_t ldx11,
                                double* x12, int64_t ldx12, double* x21,
                                int64_t ldx21, double* x22, int64_t ldx22,
                                double* theta, double* u1, int64_t ldu1,
                                double* u2, int64_t ldu2, double* v1t,
                                int64_t ldv1t, double* v2t, int64_t ldv2t,
                                double* work, int64_t lwork,
                                int64_t* iwork );
int64_t LAPACKE_dorcsd2by1_64( int matrix_layout, char jobu1, char jobu2,
                           char jobv1t, int64_t m, int64_t p, int64_t q,
                           double* x11, int64_t ldx11, double* x21, int64_t ldx21,
                           double* theta, double* u1, int64_t ldu1, double* u2,
                           int64_t ldu2, double* v1t, int64_t ldv1t);
int64_t LAPACKE_dorcsd2by1_work_64( int matrix_layout, char jobu1, char jobu2,
                           char jobv1t, int64_t m, int64_t p, int64_t q,
                           double* x11, int64_t ldx11, double* x21, int64_t ldx21,
                           double* theta, double* u1, int64_t ldu1, double* u2,
                           int64_t ldu2, double* v1t, int64_t ldv1t,
                           double* work, int64_t lwork, int64_t* iwork );
int64_t LAPACKE_dsyconv_64( int matrix_layout, char uplo, char way, int64_t n,
                            double* a, int64_t lda, const int64_t* ipiv, double* e);
int64_t LAPACKE_dsyconv_work_64( int matrix_layout, char uplo, char way,
                                 int64_t n, double* a, int64_t lda,
                                 const int64_t* ipiv, double* e );
int64_t LAPACKE_dsyswapr_64( int matrix_layout, char uplo, int64_t n,
                             double* a, int64_t lda, int64_t i1,
                             int64_t i2 );
int64_t LAPACKE_dsyswapr_work_64( int matrix_layout, char uplo, int64_t n,
                                  double* a, int64_t lda, int64_t i1,
                                  int64_t i2 );
int64_t LAPACKE_dsytri2_64( int matrix_layout, char uplo, int64_t n,
                            double* a, int64_t lda, const int64_t* ipiv );
int64_t LAPACKE_dsytri2_work_64( int matrix_layout, char uplo, int64_t n,
                                 double* a, int64_t lda,
                                 const int64_t* ipiv,
                                 double* work, int64_t lwork );
int64_t LAPACKE_dsytri2x_64( int matrix_layout, char uplo, int64_t n,
                             double* a, int64_t lda, const int64_t* ipiv,
                             int64_t nb );
int64_t LAPACKE_dsytri2x_work_64( int matrix_layout, char uplo, int64_t n,
                                  double* a, int64_t lda,
                                  const int64_t* ipiv, double* work,
                                  int64_t nb );
int64_t LAPACKE_dsytrs2_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const double* a, int64_t lda,
                            const int64_t* ipiv, double* b, int64_t ldb );
int64_t LAPACKE_dsytrs2_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const double* a,
                                 int64_t lda, const int64_t* ipiv,
                                 double* b, int64_t ldb, double* work );
int64_t LAPACKE_sbbcsd_64( int matrix_layout, char jobu1, char jobu2,
                           char jobv1t, char jobv2t, char trans, int64_t m,
                           int64_t p, int64_t q, float* theta, float* phi,
                           float* u1, int64_t ldu1, float* u2,
                           int64_t ldu2, float* v1t, int64_t ldv1t,
                           float* v2t, int64_t ldv2t, float* b11d,
                           float* b11e, float* b12d, float* b12e, float* b21d,
                           float* b21e, float* b22d, float* b22e );
int64_t LAPACKE_sbbcsd_work_64( int matrix_layout, char jobu1, char jobu2,
                                char jobv1t, char jobv2t, char trans,
                                int64_t m, int64_t p, int64_t q,
                                float* theta, float* phi, float* u1,
                                int64_t ldu1, float* u2, int64_t ldu2,
                                float* v1t, int64_t ldv1t, float* v2t,
                                int64_t ldv2t, float* b11d, float* b11e,
                                float* b12d, float* b12e, float* b21d,
                                float* b21e, float* b22d, float* b22e,
                                float* work, int64_t lwork );
int64_t LAPACKE_sorbdb_64( int matrix_layout, char trans, char signs,
                           int64_t m, int64_t p, int64_t q, float* x11,
                           int64_t ldx11, float* x12, int64_t ldx12,
                           float* x21, int64_t ldx21, float* x22,
                           int64_t ldx22, float* theta, float* phi,
                           float* taup1, float* taup2, float* tauq1,
                           float* tauq2 );
int64_t LAPACKE_sorbdb_work_64( int matrix_layout, char trans, char signs,
                                int64_t m, int64_t p, int64_t q,
                                float* x11, int64_t ldx11, float* x12,
                                int64_t ldx12, float* x21, int64_t ldx21,
                                float* x22, int64_t ldx22, float* theta,
                                float* phi, float* taup1, float* taup2,
                                float* tauq1, float* tauq2, float* work,
                                int64_t lwork );
int64_t LAPACKE_sorcsd_64( int matrix_layout, char jobu1, char jobu2,
                           char jobv1t, char jobv2t, char trans, char signs,
                           int64_t m, int64_t p, int64_t q, float* x11,
                           int64_t ldx11, float* x12, int64_t ldx12,
                           float* x21, int64_t ldx21, float* x22,
                           int64_t ldx22, float* theta, float* u1,
                           int64_t ldu1, float* u2, int64_t ldu2,
                           float* v1t, int64_t ldv1t, float* v2t,
                           int64_t ldv2t );
int64_t LAPACKE_sorcsd_work_64( int matrix_layout, char jobu1, char jobu2,
                                char jobv1t, char jobv2t, char trans,
                                char signs, int64_t m, int64_t p,
                                int64_t q, float* x11, int64_t ldx11,
                                float* x12, int64_t ldx12, float* x21,
                                int64_t ldx21, float* x22, int64_t ldx22,
                                float* theta, float* u1, int64_t ldu1,
                                float* u2, int64_t ldu2, float* v1t,
                                int64_t ldv1t, float* v2t, int64_t ldv2t,
                                float* work, int64_t lwork,
                                int64_t* iwork );
int64_t LAPACKE_sorcsd2by1_64( int matrix_layout, char jobu1, char jobu2,
                           char jobv1t, int64_t m, int64_t p, int64_t q,
                           float* x11, int64_t ldx11, float* x21, int64_t ldx21,
                           float* theta, float* u1, int64_t ldu1, float* u2,
                           int64_t ldu2, float* v1t, int64_t ldv1t);
int64_t LAPACKE_sorcsd2by1_work_64( int matrix_layout, char jobu1, char jobu2,
                           char jobv1t, int64_t m, int64_t p, int64_t q,
                           float* x11, int64_t ldx11, float* x21, int64_t ldx21,
                           float* theta, float* u1, int64_t ldu1, float* u2,
                           int64_t ldu2, float* v1t, int64_t ldv1t,
                           float* work, int64_t lwork, int64_t* iwork );
int64_t LAPACKE_ssyconv_64( int matrix_layout, char uplo, char way, int64_t n,
                            float* a, int64_t lda, const int64_t* ipiv, float* e );
int64_t LAPACKE_ssyconv_work_64( int matrix_layout, char uplo, char way,
                                 int64_t n, float* a, int64_t lda,
                                 const int64_t* ipiv, float* e );
int64_t LAPACKE_ssyswapr_64( int matrix_layout, char uplo, int64_t n,
                             float* a, int64_t lda, int64_t i1,
                             int64_t i2 );
int64_t LAPACKE_ssyswapr_work_64( int matrix_layout, char uplo, int64_t n,
                                  float* a, int64_t lda, int64_t i1,
                                  int64_t i2 );
int64_t LAPACKE_ssytri2_64( int matrix_layout, char uplo, int64_t n, float* a,
                            int64_t lda, const int64_t* ipiv );
int64_t LAPACKE_ssytri2_work_64( int matrix_layout, char uplo, int64_t n,
                                 float* a, int64_t lda,
                                 const int64_t* ipiv,
                                 float* work, int64_t lwork );
int64_t LAPACKE_ssytri2x_64( int matrix_layout, char uplo, int64_t n,
                             float* a, int64_t lda, const int64_t* ipiv,
                             int64_t nb );
int64_t LAPACKE_ssytri2x_work_64( int matrix_layout, char uplo, int64_t n,
                                  float* a, int64_t lda,
                                  const int64_t* ipiv, float* work,
                                  int64_t nb );
int64_t LAPACKE_ssytrs2_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const float* a, int64_t lda,
                            const int64_t* ipiv, float* b, int64_t ldb );
int64_t LAPACKE_ssytrs2_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const float* a,
                                 int64_t lda, const int64_t* ipiv,
                                 float* b, int64_t ldb, float* work );
int64_t LAPACKE_zbbcsd_64( int matrix_layout, char jobu1, char jobu2,
                           char jobv1t, char jobv2t, char trans, int64_t m,
                           int64_t p, int64_t q, double* theta,
                           double* phi, lapack_complex_double* u1,
                           int64_t ldu1, lapack_complex_double* u2,
                           int64_t ldu2, lapack_complex_double* v1t,
                           int64_t ldv1t, lapack_complex_double* v2t,
                           int64_t ldv2t, double* b11d, double* b11e,
                           double* b12d, double* b12e, double* b21d,
                           double* b21e, double* b22d, double* b22e );
int64_t LAPACKE_zbbcsd_work_64( int matrix_layout, char jobu1, char jobu2,
                                char jobv1t, char jobv2t, char trans,
                                int64_t m, int64_t p, int64_t q,
                                double* theta, double* phi,
                                lapack_complex_double* u1, int64_t ldu1,
                                lapack_complex_double* u2, int64_t ldu2,
                                lapack_complex_double* v1t, int64_t ldv1t,
                                lapack_complex_double* v2t, int64_t ldv2t,
                                double* b11d, double* b11e, double* b12d,
                                double* b12e, double* b21d, double* b21e,
                                double* b22d, double* b22e, double* rwork,
                                int64_t lrwork );
int64_t LAPACKE_zheswapr_64( int matrix_layout, char uplo, int64_t n,
                             lapack_complex_double* a, int64_t lda,
                             int64_t i1, int64_t i2 );
int64_t LAPACKE_zheswapr_work_64( int matrix_layout, char uplo, int64_t n,
                                  lapack_complex_double* a, int64_t lda,
                                  int64_t i1, int64_t i2 );
int64_t LAPACKE_zhetri2_64( int matrix_layout, char uplo, int64_t n,
                            lapack_complex_double* a, int64_t lda,
                            const int64_t* ipiv );
int64_t LAPACKE_zhetri2_work_64( int matrix_layout, char uplo, int64_t n,
                                 lapack_complex_double* a, int64_t lda,
                                 const int64_t* ipiv,
                                 lapack_complex_double* work, int64_t lwork );
int64_t LAPACKE_zhetri2x_64( int matrix_layout, char uplo, int64_t n,
                             lapack_complex_double* a, int64_t lda,
                             const int64_t* ipiv, int64_t nb );
int64_t LAPACKE_zhetri2x_work_64( int matrix_layout, char uplo, int64_t n,
                                  lapack_complex_double* a, int64_t lda,
                                  const int64_t* ipiv,
                                  lapack_complex_double* work, int64_t nb );
int64_t LAPACKE_zhetrs2_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const lapack_complex_double* a,
                            int64_t lda, const int64_t* ipiv,
                            lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_zhetrs2_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const lapack_complex_double* a,
                                 int64_t lda, const int64_t* ipiv,
                                 lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* work );
int64_t LAPACKE_zsyconv_64( int matrix_layout, char uplo, char way, int64_t n,
                            lapack_complex_double* a, int64_t lda,
                            const int64_t* ipiv, lapack_complex_double* e );
int64_t LAPACKE_zsyconv_work_64( int matrix_layout, char uplo, char way,
                                 int64_t n, lapack_complex_double* a,
                                 int64_t lda, const int64_t* ipiv,
                                 lapack_complex_double* e );
int64_t LAPACKE_zsyswapr_64( int matrix_layout, char uplo, int64_t n,
                             lapack_complex_double* a, int64_t lda,
                             int64_t i1, int64_t i2 );
int64_t LAPACKE_zsyswapr_work_64( int matrix_layout, char uplo, int64_t n,
                                  lapack_complex_double* a, int64_t lda,
                                  int64_t i1, int64_t i2 );
int64_t LAPACKE_zsytri2_64( int matrix_layout, char uplo, int64_t n,
                            lapack_complex_double* a, int64_t lda,
                            const int64_t* ipiv );
int64_t LAPACKE_zsytri2_work_64( int matrix_layout, char uplo, int64_t n,
                                 lapack_complex_double* a, int64_t lda,
                                 const int64_t* ipiv,
                                 lapack_complex_double* work, int64_t lwork );
int64_t LAPACKE_zsytri2x_64( int matrix_layout, char uplo, int64_t n,
                             lapack_complex_double* a, int64_t lda,
                             const int64_t* ipiv, int64_t nb );
int64_t LAPACKE_zsytri2x_work_64( int matrix_layout, char uplo, int64_t n,
                                  lapack_complex_double* a, int64_t lda,
                                  const int64_t* ipiv,
                                  lapack_complex_double* work, int64_t nb );
int64_t LAPACKE_zsytrs2_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const lapack_complex_double* a,
                            int64_t lda, const int64_t* ipiv,
                            lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_zsytrs2_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const lapack_complex_double* a,
                                 int64_t lda, const int64_t* ipiv,
                                 lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* work );
int64_t LAPACKE_zunbdb_64( int matrix_layout, char trans, char signs,
                           int64_t m, int64_t p, int64_t q,
                           lapack_complex_double* x11, int64_t ldx11,
                           lapack_complex_double* x12, int64_t ldx12,
                           lapack_complex_double* x21, int64_t ldx21,
                           lapack_complex_double* x22, int64_t ldx22,
                           double* theta, double* phi,
                           lapack_complex_double* taup1,
                           lapack_complex_double* taup2,
                           lapack_complex_double* tauq1,
                           lapack_complex_double* tauq2 );
int64_t LAPACKE_zunbdb_work_64( int matrix_layout, char trans, char signs,
                                int64_t m, int64_t p, int64_t q,
                                lapack_complex_double* x11, int64_t ldx11,
                                lapack_complex_double* x12, int64_t ldx12,
                                lapack_complex_double* x21, int64_t ldx21,
                                lapack_complex_double* x22, int64_t ldx22,
                                double* theta, double* phi,
                                lapack_complex_double* taup1,
                                lapack_complex_double* taup2,
                                lapack_complex_double* tauq1,
                                lapack_complex_double* tauq2,
                                lapack_complex_double* work, int64_t lwork );
int64_t LAPACKE_zuncsd_64( int matrix_layout, char jobu1, char jobu2,
                           char jobv1t, char jobv2t, char trans, char signs,
                           int64_t m, int64_t p, int64_t q,
                           lapack_complex_double* x11, int64_t ldx11,
                           lapack_complex_double* x12, int64_t ldx12,
                           lapack_complex_double* x21, int64_t ldx21,
                           lapack_complex_double* x22, int64_t ldx22,
                           double* theta, lapack_complex_double* u1,
                           int64_t ldu1, lapack_complex_double* u2,
                           int64_t ldu2, lapack_complex_double* v1t,
                           int64_t ldv1t, lapack_complex_double* v2t,
                           int64_t ldv2t );
int64_t LAPACKE_zuncsd_work_64( int matrix_layout, char jobu1, char jobu2,
                                char jobv1t, char jobv2t, char trans,
                                char signs, int64_t m, int64_t p,
                                int64_t q, lapack_complex_double* x11,
                                int64_t ldx11, lapack_complex_double* x12,
                                int64_t ldx12, lapack_complex_double* x21,
                                int64_t ldx21, lapack_complex_double* x22,
                                int64_t ldx22, double* theta,
                                lapack_complex_double* u1, int64_t ldu1,
                                lapack_complex_double* u2, int64_t ldu2,
                                lapack_complex_double* v1t, int64_t ldv1t,
                                lapack_complex_double* v2t, int64_t ldv2t,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork, int64_t lrwork,
                                int64_t* iwork );
int64_t LAPACKE_zuncsd2by1_64( int matrix_layout, char jobu1, char jobu2,
                           char jobv1t, int64_t m, int64_t p, int64_t q,
                           lapack_complex_double* x11, int64_t ldx11,
                           lapack_complex_double* x21, int64_t ldx21,
                           double* theta, lapack_complex_double* u1,
                           int64_t ldu1, lapack_complex_double* u2,
                           int64_t ldu2, lapack_complex_double* v1t, int64_t ldv1t );
int64_t LAPACKE_zuncsd2by1_work_64( int matrix_layout, char jobu1, char jobu2,
                                char jobv1t, int64_t m, int64_t p,
                                int64_t q, lapack_complex_double* x11, int64_t ldx11,
                                lapack_complex_double* x21, int64_t ldx21,
                                double* theta, lapack_complex_double* u1,
                                int64_t ldu1, lapack_complex_double* u2,
                                int64_t ldu2, lapack_complex_double* v1t,
                                int64_t ldv1t, lapack_complex_double* work,
                                int64_t lwork, double* rwork, int64_t lrwork,
                                int64_t* iwork );

//LAPACK 3.4.0
int64_t LAPACKE_sgemqrt_64( int matrix_layout, char side, char trans,
                            int64_t m, int64_t n, int64_t k,
                            int64_t nb, const float* v, int64_t ldv,
                            const float* t, int64_t ldt, float* c,
                            int64_t ldc );
int64_t LAPACKE_dgemqrt_64( int matrix_layout, char side, char trans,
                            int64_t m, int64_t n, int64_t k,
                            int64_t nb, const double* v, int64_t ldv,
                            const double* t, int64_t ldt, double* c,
                            int64_t ldc );
int64_t LAPACKE_cgemqrt_64( int matrix_layout, char side, char trans,
                            int64_t m, int64_t n, int64_t k,
                            int64_t nb, const lapack_complex_float* v,
                            int64_t ldv, const lapack_complex_float* t,
                            int64_t ldt, lapack_complex_float* c,
                            int64_t ldc );
int64_t LAPACKE_zgemqrt_64( int matrix_layout, char side, char trans,
                            int64_t m, int64_t n, int64_t k,
                            int64_t nb, const lapack_complex_double* v,
                            int64_t ldv, const lapack_complex_double* t,
                            int64_t ldt, lapack_complex_double* c,
                            int64_t ldc );

int64_t LAPACKE_sgeqrt_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nb, float* a, int64_t lda, float* t,
                           int64_t ldt );
int64_t LAPACKE_dgeqrt_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nb, double* a, int64_t lda, double* t,
                           int64_t ldt );
int64_t LAPACKE_cgeqrt_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nb, lapack_complex_float* a,
                           int64_t lda, lapack_complex_float* t,
                           int64_t ldt );
int64_t LAPACKE_zgeqrt_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t nb, lapack_complex_double* a,
                           int64_t lda, lapack_complex_double* t,
                           int64_t ldt );

int64_t LAPACKE_sgeqrt2_64( int matrix_layout, int64_t m, int64_t n,
                            float* a, int64_t lda, float* t,
                            int64_t ldt );
int64_t LAPACKE_dgeqrt2_64( int matrix_layout, int64_t m, int64_t n,
                            double* a, int64_t lda, double* t,
                            int64_t ldt );
int64_t LAPACKE_cgeqrt2_64( int matrix_layout, int64_t m, int64_t n,
                            lapack_complex_float* a, int64_t lda,
                            lapack_complex_float* t, int64_t ldt );
int64_t LAPACKE_zgeqrt2_64( int matrix_layout, int64_t m, int64_t n,
                            lapack_complex_double* a, int64_t lda,
                            lapack_complex_double* t, int64_t ldt );

int64_t LAPACKE_sgeqrt3_64( int matrix_layout, int64_t m, int64_t n,
                            float* a, int64_t lda, float* t,
                            int64_t ldt );
int64_t LAPACKE_dgeqrt3_64( int matrix_layout, int64_t m, int64_t n,
                            double* a, int64_t lda, double* t,
                            int64_t ldt );
int64_t LAPACKE_cgeqrt3_64( int matrix_layout, int64_t m, int64_t n,
                            lapack_complex_float* a, int64_t lda,
                            lapack_complex_float* t, int64_t ldt );
int64_t LAPACKE_zgeqrt3_64( int matrix_layout, int64_t m, int64_t n,
                            lapack_complex_double* a, int64_t lda,
                            lapack_complex_double* t, int64_t ldt );

int64_t LAPACKE_stpmqrt_64( int matrix_layout, char side, char trans,
                            int64_t m, int64_t n, int64_t k,
                            int64_t l, int64_t nb, const float* v,
                            int64_t ldv, const float* t, int64_t ldt,
                            float* a, int64_t lda, float* b,
                            int64_t ldb );
int64_t LAPACKE_dtpmqrt_64( int matrix_layout, char side, char trans,
                            int64_t m, int64_t n, int64_t k,
                            int64_t l, int64_t nb, const double* v,
                            int64_t ldv, const double* t, int64_t ldt,
                            double* a, int64_t lda, double* b,
                            int64_t ldb );
int64_t LAPACKE_ctpmqrt_64( int matrix_layout, char side, char trans,
                            int64_t m, int64_t n, int64_t k,
                            int64_t l, int64_t nb,
                            const lapack_complex_float* v, int64_t ldv,
                            const lapack_complex_float* t, int64_t ldt,
                            lapack_complex_float* a, int64_t lda,
                            lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_ztpmqrt_64( int matrix_layout, char side, char trans,
                            int64_t m, int64_t n, int64_t k,
                            int64_t l, int64_t nb,
                            const lapack_complex_double* v, int64_t ldv,
                            const lapack_complex_double* t, int64_t ldt,
                            lapack_complex_double* a, int64_t lda,
                            lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_stpqrt_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t l, int64_t nb, float* a,
                           int64_t lda, float* b, int64_t ldb, float* t,
                           int64_t ldt );

int64_t LAPACKE_dtpqrt_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t l, int64_t nb, double* a,
                           int64_t lda, double* b, int64_t ldb, double* t,
                           int64_t ldt );
int64_t LAPACKE_ctpqrt_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t l, int64_t nb,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb,
                           lapack_complex_float* t, int64_t ldt );
int64_t LAPACKE_ztpqrt_64( int matrix_layout, int64_t m, int64_t n,
                           int64_t l, int64_t nb,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb,
                           lapack_complex_double* t, int64_t ldt );

int64_t LAPACKE_stpqrt2_64( int matrix_layout,
                            int64_t m, int64_t n, int64_t l,
                            float* a, int64_t lda,
                            float* b, int64_t ldb,
                            float* t, int64_t ldt );
int64_t LAPACKE_dtpqrt2_64( int matrix_layout,
                            int64_t m, int64_t n, int64_t l,
                            double* a, int64_t lda,
                            double* b, int64_t ldb,
                            double* t, int64_t ldt );
int64_t LAPACKE_ctpqrt2_64( int matrix_layout,
                            int64_t m, int64_t n, int64_t l,
                            lapack_complex_float* a, int64_t lda,
                            lapack_complex_float* b, int64_t ldb,
                            lapack_complex_float* t, int64_t ldt );
int64_t LAPACKE_ztpqrt2_64( int matrix_layout,
                            int64_t m, int64_t n, int64_t l,
                            lapack_complex_double* a, int64_t lda,
                            lapack_complex_double* b, int64_t ldb,
                            lapack_complex_double* t, int64_t ldt );

int64_t LAPACKE_stprfb_64( int matrix_layout, char side, char trans, char direct,
                           char storev, int64_t m, int64_t n,
                           int64_t k, int64_t l, const float* v,
                           int64_t ldv, const float* t, int64_t ldt,
                           float* a, int64_t lda, float* b, int64_t ldb );
int64_t LAPACKE_dtprfb_64( int matrix_layout, char side, char trans, char direct,
                           char storev, int64_t m, int64_t n,
                           int64_t k, int64_t l, const double* v,
                           int64_t ldv, const double* t, int64_t ldt,
                           double* a, int64_t lda, double* b, int64_t ldb );
int64_t LAPACKE_ctprfb_64( int matrix_layout, char side, char trans, char direct,
                           char storev, int64_t m, int64_t n,
                           int64_t k, int64_t l,
                           const lapack_complex_float* v, int64_t ldv,
                           const lapack_complex_float* t, int64_t ldt,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_ztprfb_64( int matrix_layout, char side, char trans, char direct,
                           char storev, int64_t m, int64_t n,
                           int64_t k, int64_t l,
                           const lapack_complex_double* v, int64_t ldv,
                           const lapack_complex_double* t, int64_t ldt,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_sgemqrt_work_64( int matrix_layout, char side, char trans,
                                 int64_t m, int64_t n, int64_t k,
                                 int64_t nb, const float* v, int64_t ldv,
                                 const float* t, int64_t ldt, float* c,
                                 int64_t ldc, float* work );
int64_t LAPACKE_dgemqrt_work_64( int matrix_layout, char side, char trans,
                                 int64_t m, int64_t n, int64_t k,
                                 int64_t nb, const double* v, int64_t ldv,
                                 const double* t, int64_t ldt, double* c,
                                 int64_t ldc, double* work );
int64_t LAPACKE_cgemqrt_work_64( int matrix_layout, char side, char trans,
                                 int64_t m, int64_t n, int64_t k,
                                 int64_t nb, const lapack_complex_float* v,
                                 int64_t ldv, const lapack_complex_float* t,
                                 int64_t ldt, lapack_complex_float* c,
                                 int64_t ldc, lapack_complex_float* work );
int64_t LAPACKE_zgemqrt_work_64( int matrix_layout, char side, char trans,
                                 int64_t m, int64_t n, int64_t k,
                                 int64_t nb, const lapack_complex_double* v,
                                 int64_t ldv, const lapack_complex_double* t,
                                 int64_t ldt, lapack_complex_double* c,
                                 int64_t ldc, lapack_complex_double* work );

int64_t LAPACKE_sgeqrt_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nb, float* a, int64_t lda,
                                float* t, int64_t ldt, float* work );
int64_t LAPACKE_dgeqrt_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nb, double* a, int64_t lda,
                                double* t, int64_t ldt, double* work );
int64_t LAPACKE_cgeqrt_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nb, lapack_complex_float* a,
                                int64_t lda, lapack_complex_float* t,
                                int64_t ldt, lapack_complex_float* work );
int64_t LAPACKE_zgeqrt_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t nb, lapack_complex_double* a,
                                int64_t lda, lapack_complex_double* t,
                                int64_t ldt, lapack_complex_double* work );

int64_t LAPACKE_sgeqrt2_work_64( int matrix_layout, int64_t m, int64_t n,
                                 float* a, int64_t lda, float* t,
                                 int64_t ldt );
int64_t LAPACKE_dgeqrt2_work_64( int matrix_layout, int64_t m, int64_t n,
                                 double* a, int64_t lda, double* t,
                                 int64_t ldt );
int64_t LAPACKE_cgeqrt2_work_64( int matrix_layout, int64_t m, int64_t n,
                                 lapack_complex_float* a, int64_t lda,
                                 lapack_complex_float* t, int64_t ldt );
int64_t LAPACKE_zgeqrt2_work_64( int matrix_layout, int64_t m, int64_t n,
                                 lapack_complex_double* a, int64_t lda,
                                 lapack_complex_double* t, int64_t ldt );

int64_t LAPACKE_sgeqrt3_work_64( int matrix_layout, int64_t m, int64_t n,
                                 float* a, int64_t lda, float* t,
                                 int64_t ldt );
int64_t LAPACKE_dgeqrt3_work_64( int matrix_layout, int64_t m, int64_t n,
                                 double* a, int64_t lda, double* t,
                                 int64_t ldt );
int64_t LAPACKE_cgeqrt3_work_64( int matrix_layout, int64_t m, int64_t n,
                                 lapack_complex_float* a, int64_t lda,
                                 lapack_complex_float* t, int64_t ldt );
int64_t LAPACKE_zgeqrt3_work_64( int matrix_layout, int64_t m, int64_t n,
                                 lapack_complex_double* a, int64_t lda,
                                 lapack_complex_double* t, int64_t ldt );

int64_t LAPACKE_stpmqrt_work_64( int matrix_layout, char side, char trans,
                                 int64_t m, int64_t n, int64_t k,
                                 int64_t l, int64_t nb, const float* v,
                                 int64_t ldv, const float* t, int64_t ldt,
                                 float* a, int64_t lda, float* b,
                                 int64_t ldb, float* work );
int64_t LAPACKE_dtpmqrt_work_64( int matrix_layout, char side, char trans,
                                 int64_t m, int64_t n, int64_t k,
                                 int64_t l, int64_t nb, const double* v,
                                 int64_t ldv, const double* t,
                                 int64_t ldt, double* a, int64_t lda,
                                 double* b, int64_t ldb, double* work );
int64_t LAPACKE_ctpmqrt_work_64( int matrix_layout, char side, char trans,
                                 int64_t m, int64_t n, int64_t k,
                                 int64_t l, int64_t nb,
                                 const lapack_complex_float* v, int64_t ldv,
                                 const lapack_complex_float* t, int64_t ldt,
                                 lapack_complex_float* a, int64_t lda,
                                 lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* work );
int64_t LAPACKE_ztpmqrt_work_64( int matrix_layout, char side, char trans,
                                 int64_t m, int64_t n, int64_t k,
                                 int64_t l, int64_t nb,
                                 const lapack_complex_double* v, int64_t ldv,
                                 const lapack_complex_double* t, int64_t ldt,
                                 lapack_complex_double* a, int64_t lda,
                                 lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* work );

int64_t LAPACKE_stpqrt_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t l, int64_t nb, float* a,
                                int64_t lda, float* b, int64_t ldb,
                                float* t, int64_t ldt, float* work );
int64_t LAPACKE_dtpqrt_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t l, int64_t nb, double* a,
                                int64_t lda, double* b, int64_t ldb,
                                double* t, int64_t ldt, double* work );
int64_t LAPACKE_ctpqrt_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t l, int64_t nb,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* t, int64_t ldt,
                                lapack_complex_float* work );
int64_t LAPACKE_ztpqrt_work_64( int matrix_layout, int64_t m, int64_t n,
                                int64_t l, int64_t nb,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* t, int64_t ldt,
                                lapack_complex_double* work );

int64_t LAPACKE_stpqrt2_work_64( int matrix_layout,
                                 int64_t m, int64_t n, int64_t l,
                                 float* a, int64_t lda,
                                 float* b, int64_t ldb,
                                 float* t, int64_t ldt );
int64_t LAPACKE_dtpqrt2_work_64( int matrix_layout,
                                 int64_t m, int64_t n, int64_t l,
                                 double* a, int64_t lda,
                                 double* b, int64_t ldb,
                                 double* t, int64_t ldt );
int64_t LAPACKE_ctpqrt2_work_64( int matrix_layout,
                                 int64_t m, int64_t n, int64_t l,
                                 lapack_complex_float* a, int64_t lda,
                                 lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* t, int64_t ldt );
int64_t LAPACKE_ztpqrt2_work_64( int matrix_layout,
                                 int64_t m, int64_t n, int64_t l,
                                 lapack_complex_double* a, int64_t lda,
                                 lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* t, int64_t ldt );

int64_t LAPACKE_stprfb_work_64( int matrix_layout, char side, char trans,
                                char direct, char storev, int64_t m,
                                int64_t n, int64_t k, int64_t l,
                                const float* v, int64_t ldv, const float* t,
                                int64_t ldt, float* a, int64_t lda,
                                float* b, int64_t ldb, float* work,
                                int64_t ldwork );
int64_t LAPACKE_dtprfb_work_64( int matrix_layout, char side, char trans,
                                char direct, char storev, int64_t m,
                                int64_t n, int64_t k, int64_t l,
                                const double* v, int64_t ldv,
                                const double* t, int64_t ldt, double* a,
                                int64_t lda, double* b, int64_t ldb,
                                double* work, int64_t ldwork );
int64_t LAPACKE_ctprfb_work_64( int matrix_layout, char side, char trans,
                                char direct, char storev, int64_t m,
                                int64_t n, int64_t k, int64_t l,
                                const lapack_complex_float* v, int64_t ldv,
                                const lapack_complex_float* t, int64_t ldt,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* b, int64_t ldb,
                                lapack_complex_float* work, int64_t ldwork );
int64_t LAPACKE_ztprfb_work_64( int matrix_layout, char side, char trans,
                                char direct, char storev, int64_t m,
                                int64_t n, int64_t k, int64_t l,
                                const lapack_complex_double* v, int64_t ldv,
                                const lapack_complex_double* t, int64_t ldt,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* b, int64_t ldb,
                                lapack_complex_double* work, int64_t ldwork );
//LAPACK 3.X.X
int64_t LAPACKE_ssysv_rook_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, float* a, int64_t lda,
                               int64_t* ipiv, float* b, int64_t ldb );
int64_t LAPACKE_dsysv_rook_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, double* a, int64_t lda,
                               int64_t* ipiv, double* b, int64_t ldb );
int64_t LAPACKE_csysv_rook_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* a,
                               int64_t lda, int64_t* ipiv,
                               lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zsysv_rook_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* a,
                               int64_t lda, int64_t* ipiv,
                               lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_ssytrf_rook_64( int matrix_layout, char uplo, int64_t n, float* a,
                           int64_t lda, int64_t* ipiv );
int64_t LAPACKE_dsytrf_rook_64( int matrix_layout, char uplo, int64_t n, double* a,
                           int64_t lda, int64_t* ipiv );
int64_t LAPACKE_csytrf_rook_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* ipiv );
int64_t LAPACKE_zsytrf_rook_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* ipiv );

int64_t LAPACKE_ssytrs_rook_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const float* a, int64_t lda,
                           const int64_t* ipiv, float* b, int64_t ldb );
int64_t LAPACKE_dsytrs_rook_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const double* a, int64_t lda,
                           const int64_t* ipiv, double* b, int64_t ldb );
int64_t LAPACKE_csytrs_rook_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* a,
                           int64_t lda, const int64_t* ipiv,
                           lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zsytrs_rook_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* a,
                           int64_t lda, const int64_t* ipiv,
                           lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_chetrf_rook_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* ipiv );
int64_t LAPACKE_zhetrf_rook_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* ipiv );

int64_t LAPACKE_chetrs_rook_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_float* a,
                           int64_t lda, const int64_t* ipiv,
                           lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zhetrs_rook_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const lapack_complex_double* a,
                           int64_t lda, const int64_t* ipiv,
                           lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_csyr_64( int matrix_layout, char uplo, int64_t n,
                             lapack_complex_float alpha,
                             const lapack_complex_float* x, int64_t incx,
                             lapack_complex_float* a, int64_t lda );
int64_t LAPACKE_zsyr_64( int matrix_layout, char uplo, int64_t n,
                             lapack_complex_double alpha,
                             const lapack_complex_double* x, int64_t incx,
                             lapack_complex_double* a, int64_t lda );

int64_t LAPACKE_ssysv_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                    int64_t nrhs, float* a, int64_t lda,
                                    int64_t* ipiv, float* b, int64_t ldb,
                                    float* work, int64_t lwork );
int64_t LAPACKE_dsysv_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                    int64_t nrhs, double* a, int64_t lda,
                                    int64_t* ipiv, double* b, int64_t ldb,
                                    double* work, int64_t lwork );
int64_t LAPACKE_csysv_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                    int64_t nrhs, lapack_complex_float* a,
                                    int64_t lda, int64_t* ipiv,
                                    lapack_complex_float* b, int64_t ldb,
                                    lapack_complex_float* work,
                                    int64_t lwork );
int64_t LAPACKE_zsysv_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                    int64_t nrhs, lapack_complex_double* a,
                                    int64_t lda, int64_t* ipiv,
                                    lapack_complex_double* b, int64_t ldb,
                                    lapack_complex_double* work,
                                    int64_t lwork );

int64_t LAPACKE_ssytrf_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                float* a, int64_t lda, int64_t* ipiv,
                                float* work, int64_t lwork );
int64_t LAPACKE_dsytrf_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                double* a, int64_t lda, int64_t* ipiv,
                                double* work, int64_t lwork );
int64_t LAPACKE_csytrf_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                int64_t* ipiv, lapack_complex_float* work,
                                int64_t lwork );
int64_t LAPACKE_zsytrf_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* ipiv, lapack_complex_double* work,
                                int64_t lwork );

int64_t LAPACKE_ssytrs_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const float* a, int64_t lda,
                                const int64_t* ipiv, float* b,
                                int64_t ldb );
int64_t LAPACKE_dsytrs_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const double* a,
                                int64_t lda, const int64_t* ipiv,
                                double* b, int64_t ldb );
int64_t LAPACKE_csytrs_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_float* a,
                                int64_t lda, const int64_t* ipiv,
                                lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zsytrs_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_double* a,
                                int64_t lda, const int64_t* ipiv,
                                lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_chetrf_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                int64_t* ipiv, lapack_complex_float* work,
                                int64_t lwork );
int64_t LAPACKE_zhetrf_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* ipiv, lapack_complex_double* work,
                                int64_t lwork );

int64_t LAPACKE_chetrs_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_float* a,
                                int64_t lda, const int64_t* ipiv,
                                lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zhetrs_rook_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const lapack_complex_double* a,
                                int64_t lda, const int64_t* ipiv,
                                lapack_complex_double* b, int64_t ldb );


int64_t LAPACKE_csyr_work_64( int matrix_layout, char uplo, int64_t n,
                                  lapack_complex_float alpha,
                                  const lapack_complex_float* x,
                                  int64_t incx, lapack_complex_float* a,
                                  int64_t lda );
int64_t LAPACKE_zsyr_work_64( int matrix_layout, char uplo, int64_t n,
                                  lapack_complex_double alpha,
                                  const lapack_complex_double* x,
                                  int64_t incx, lapack_complex_double* a,
                                  int64_t lda );
void LAPACKE_ilaver_64( int64_t* vers_major,
                     int64_t* vers_minor,
                     int64_t* vers_patch );
// LAPACK 3.7.0
int64_t LAPACKE_ssysv_aa_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, float* a, int64_t lda,
                          int64_t* ipiv, float* b, int64_t ldb );
int64_t LAPACKE_ssysv_aa_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, float* a, int64_t lda,
                               int64_t* ipiv, float* b, int64_t ldb,
                               float* work, int64_t lwork );
int64_t LAPACKE_dsysv_aa_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, double* a, int64_t lda,
                          int64_t* ipiv, double* b, int64_t ldb );
int64_t LAPACKE_dsysv_aa_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, double* a, int64_t lda,
                               int64_t* ipiv, double* b, int64_t ldb,
                               double* work, int64_t lwork );
int64_t LAPACKE_csysv_aa_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_float* a,
                          int64_t lda, int64_t* ipiv,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_csysv_aa_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* a,
                               int64_t lda, int64_t* ipiv,
                               lapack_complex_float* b, int64_t ldb,
                               lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zsysv_aa_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_double* a,
                          int64_t lda, int64_t* ipiv,
                          lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_zsysv_aa_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* a,
                               int64_t lda, int64_t* ipiv,
                               lapack_complex_double* b, int64_t ldb,
                               lapack_complex_double* work, int64_t lwork );
int64_t LAPACKE_chesv_aa_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_float* a,
                          int64_t lda, int64_t* ipiv,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_chesv_aa_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* a,
                               int64_t lda, int64_t* ipiv,
                               lapack_complex_float* b, int64_t ldb,
                               lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zhesv_aa_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_double* a,
                          int64_t lda, int64_t* ipiv,
                          lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_zhesv_aa_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* a,
                               int64_t lda, int64_t* ipiv,
                               lapack_complex_double* b, int64_t ldb,
                               lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_ssytrf_aa_64( int matrix_layout, char uplo, int64_t n, float* a,
                           int64_t lda, int64_t* ipiv );
int64_t LAPACKE_dsytrf_aa_64( int matrix_layout, char uplo, int64_t n, double* a,
                           int64_t lda, int64_t* ipiv );
int64_t LAPACKE_csytrf_aa_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* ipiv );
int64_t LAPACKE_zsytrf_aa_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* ipiv );
int64_t LAPACKE_chetrf_aa_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           int64_t* ipiv );
int64_t LAPACKE_zhetrf_aa_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           int64_t* ipiv );

int64_t LAPACKE_ssytrf_aa_work_64( int matrix_layout, char uplo, int64_t n,
                                float* a, int64_t lda, int64_t* ipiv,
                                float* work, int64_t lwork );
int64_t LAPACKE_dsytrf_aa_work_64( int matrix_layout, char uplo, int64_t n,
                                double* a, int64_t lda, int64_t* ipiv,
                                double* work, int64_t lwork );
int64_t LAPACKE_csytrf_aa_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                int64_t* ipiv, lapack_complex_float* work,
                                int64_t lwork );
int64_t LAPACKE_zsytrf_aa_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* ipiv, lapack_complex_double* work,
                                int64_t lwork );
int64_t LAPACKE_chetrf_aa_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                int64_t* ipiv, lapack_complex_float* work,
                                int64_t lwork );
int64_t LAPACKE_zhetrf_aa_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                int64_t* ipiv, lapack_complex_double* work,
                                int64_t lwork );


int64_t LAPACKE_csytrs_aa_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const lapack_complex_float* a,
                            int64_t lda, const int64_t* ipiv,
                            lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_csytrs_aa_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const lapack_complex_float* a,
                                 int64_t lda, const int64_t* ipiv,
                                 lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_chetrs_aa_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const lapack_complex_float* a,
                            int64_t lda, const int64_t* ipiv,
                            lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_chetrs_aa_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const lapack_complex_float* a,
                                 int64_t lda, const int64_t* ipiv,
                                 lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_dsytrs_aa_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const double* a, int64_t lda,
                            const int64_t* ipiv, double* b, int64_t ldb );
int64_t LAPACKE_dsytrs_aa_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const double* a,
                                 int64_t lda, const int64_t* ipiv,
                                 double* b, int64_t ldb, double* work, int64_t lwork );
int64_t LAPACKE_ssytrs_aa_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const float* a, int64_t lda,
                           const int64_t* ipiv, float* b, int64_t ldb );
int64_t LAPACKE_ssytrs_aa_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const float* a, int64_t lda,
                                const int64_t* ipiv, float* b,
                                int64_t ldb, float* work, int64_t lwork );
int64_t LAPACKE_zsytrs_aa_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const lapack_complex_double* a,
                            int64_t lda, const int64_t* ipiv,
                            lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_zsytrs_aa_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const lapack_complex_double* a,
                                 int64_t lda, const int64_t* ipiv,
                                 lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* work,  int64_t lwork);
int64_t LAPACKE_zhetrs_aa_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const lapack_complex_double* a,
                            int64_t lda, const int64_t* ipiv,
                            lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_zhetrs_aa_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const lapack_complex_double* a,
                                 int64_t lda, const int64_t* ipiv,
                                 lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* work,  int64_t lwork);


int64_t LAPACKE_ssysv_rk_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, float* a, int64_t lda,
                          float* e, int64_t* ipiv, float* b, int64_t ldb );
int64_t LAPACKE_ssysv_rk_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, float* a, int64_t lda,
                               float* e, int64_t* ipiv, float* b, int64_t ldb,
                               float* work, int64_t lwork );
int64_t LAPACKE_dsysv_rk_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, double* a, int64_t lda,
                          double* e, int64_t* ipiv, double* b, int64_t ldb );
int64_t LAPACKE_dsysv_rk_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, double* a, int64_t lda,
                               double* e, int64_t* ipiv, double* b, int64_t ldb,
                               double* work, int64_t lwork );
int64_t LAPACKE_csysv_rk_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_float* a,
                          int64_t lda, lapack_complex_float* e, int64_t* ipiv,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_csysv_rk_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* a,
                               int64_t lda, lapack_complex_float* e, int64_t* ipiv,
                               lapack_complex_float* b, int64_t ldb,
                               lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zsysv_rk_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_double* a,
                          int64_t lda, lapack_complex_double* e, int64_t* ipiv,
                          lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_zsysv_rk_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* a,
                               int64_t lda, lapack_complex_double* e, int64_t* ipiv,
                               lapack_complex_double* b, int64_t ldb,
                               lapack_complex_double* work, int64_t lwork );
int64_t LAPACKE_chesv_rk_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_float* a,
                          int64_t lda, lapack_complex_float* e, int64_t* ipiv,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_chesv_rk_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* a,
                               int64_t lda, lapack_complex_float* e, int64_t* ipiv,
                               lapack_complex_float* b, int64_t ldb,
                               lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zhesv_rk_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_double* a,
                          int64_t lda, lapack_complex_double* e, int64_t* ipiv,
                          lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_zhesv_rk_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* a,
                               int64_t lda, lapack_complex_double* e, int64_t* ipiv,
                               lapack_complex_double* b, int64_t ldb,
                               lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_ssytrf_rk_64( int matrix_layout, char uplo, int64_t n, float* a,
                           int64_t lda, float* e, int64_t* ipiv );
int64_t LAPACKE_dsytrf_rk_64( int matrix_layout, char uplo, int64_t n, double* a,
                           int64_t lda, double* e, int64_t* ipiv );
int64_t LAPACKE_csytrf_rk_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* e, int64_t* ipiv );
int64_t LAPACKE_zsytrf_rk_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* e, int64_t* ipiv );
int64_t LAPACKE_chetrf_rk_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           lapack_complex_float* e, int64_t* ipiv );
int64_t LAPACKE_zhetrf_rk_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           lapack_complex_double* e, int64_t* ipiv );
int64_t LAPACKE_ssytrf_rk_work_64( int matrix_layout, char uplo, int64_t n,
                                float* a, int64_t lda, float* e, int64_t* ipiv,
                                float* work, int64_t lwork );
int64_t LAPACKE_dsytrf_rk_work_64( int matrix_layout, char uplo, int64_t n,
                                double* a, int64_t lda, double* e, int64_t* ipiv,
                                double* work, int64_t lwork );
int64_t LAPACKE_csytrf_rk_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* e,
                                int64_t* ipiv, lapack_complex_float* work,
                                int64_t lwork );
int64_t LAPACKE_zsytrf_rk_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* e,
                                int64_t* ipiv, lapack_complex_double* work,
                                int64_t lwork );
int64_t LAPACKE_chetrf_rk_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                lapack_complex_float* e,
                                int64_t* ipiv, lapack_complex_float* work,
                                int64_t lwork );
int64_t LAPACKE_zhetrf_rk_work_64( int matrix_layout, char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                lapack_complex_double* e,
                                int64_t* ipiv, lapack_complex_double* work,
                                int64_t lwork );

int64_t LAPACKE_csytrs_3_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const lapack_complex_float* a,
                            int64_t lda, const lapack_complex_float* e,
                            const int64_t* ipiv,
                            lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_csytrs_3_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const lapack_complex_float* a,
                                 int64_t lda, const lapack_complex_float* e,
                                 const int64_t* ipiv,
                                 lapack_complex_float* b, int64_t ldb);
int64_t LAPACKE_chetrs_3_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const lapack_complex_float* a,
                            int64_t lda, const lapack_complex_float* e,
                            const int64_t* ipiv,
                            lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_chetrs_3_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const lapack_complex_float* a,
                                 int64_t lda, const lapack_complex_float* e,
                                 const int64_t* ipiv,
                                 lapack_complex_float* b, int64_t ldb);
int64_t LAPACKE_dsytrs_3_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const double* a, int64_t lda,
                            const double* e,
                            const int64_t* ipiv, double* b, int64_t ldb );
int64_t LAPACKE_dsytrs_3_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const double* a,
                                 int64_t lda, const double* e,
                                 const int64_t* ipiv,
                                 double* b, int64_t ldb);
int64_t LAPACKE_ssytrs_3_64( int matrix_layout, char uplo, int64_t n,
                           int64_t nrhs, const float* a, int64_t lda,
                           const float* e,
                           const int64_t* ipiv, float* b, int64_t ldb );
int64_t LAPACKE_ssytrs_3_work_64( int matrix_layout, char uplo, int64_t n,
                                int64_t nrhs, const float* a, int64_t lda,
                                const float* e, const int64_t* ipiv, float* b,
                                int64_t ldb);
int64_t LAPACKE_zsytrs_3_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const lapack_complex_double* a,
                            int64_t lda, const lapack_complex_double* e,
                            const int64_t* ipiv,
                            lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_zsytrs_3_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const lapack_complex_double* a,
                                 int64_t lda, const lapack_complex_double* e,
                                 const int64_t* ipiv,
                                 lapack_complex_double* b, int64_t ldb);
int64_t LAPACKE_zhetrs_3_64( int matrix_layout, char uplo, int64_t n,
                            int64_t nrhs, const lapack_complex_double* a,
                            int64_t lda, const lapack_complex_double* e,
                            const int64_t* ipiv,
                            lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_zhetrs_3_work_64( int matrix_layout, char uplo, int64_t n,
                                 int64_t nrhs, const lapack_complex_double* a,
                                 int64_t lda, const lapack_complex_double* e,
                                 const int64_t* ipiv,
                                 lapack_complex_double* b, int64_t ldb);

int64_t LAPACKE_ssytri_3_64( int matrix_layout, char uplo, int64_t n, float* a,
                           int64_t lda, const float* e, const int64_t* ipiv );
int64_t LAPACKE_dsytri_3_64( int matrix_layout, char uplo, int64_t n, double* a,
                           int64_t lda, const double* e, const int64_t* ipiv );
int64_t LAPACKE_csytri_3_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* e, const int64_t* ipiv );
int64_t LAPACKE_zsytri_3_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* e, const int64_t* ipiv );
int64_t LAPACKE_chetri_3_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* e, const int64_t* ipiv );
int64_t LAPACKE_zhetri_3_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* e, const int64_t* ipiv );
int64_t LAPACKE_ssytri_3_work_64( int matrix_layout, char uplo, int64_t n, float* a,
                           int64_t lda, const float* e, const int64_t* ipiv,
                           float* work, int64_t lwork  );
int64_t LAPACKE_dsytri_3_work_64( int matrix_layout, char uplo, int64_t n, double* a,
                           int64_t lda, const double* e, const int64_t* ipiv,
                           double* work, int64_t lwork  );
int64_t LAPACKE_csytri_3_work_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* e, const int64_t* ipiv,
                           lapack_complex_float* work, int64_t lwork  );
int64_t LAPACKE_zsytri_3_work_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* e, const int64_t* ipiv,
                           lapack_complex_double* work, int64_t lwork  );
int64_t LAPACKE_chetri_3_work_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* e, const int64_t* ipiv,
                           lapack_complex_float* work, int64_t lwork  );
int64_t LAPACKE_zhetri_3_work_64( int matrix_layout, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* e, const int64_t* ipiv,
                           lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_ssycon_3_64( int matrix_layout, char uplo, int64_t n,
                           const float* a, int64_t lda, const float* e,
                           const int64_t* ipiv, float anorm, float* rcond );
int64_t LAPACKE_dsycon_3_64( int matrix_layout, char uplo, int64_t n,
                           const double* a, int64_t lda, const double* e,
                           const int64_t* ipiv, double anorm,
                           double* rcond );
int64_t LAPACKE_csycon_3_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* e,
                           const int64_t* ipiv, float anorm, float* rcond );
int64_t LAPACKE_zsycon_3_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* e,
                           const int64_t* ipiv, double anorm,
                           double* rcond );
int64_t LAPACKE_checon_3_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* e,
                           const int64_t* ipiv, float anorm, float* rcond );
int64_t LAPACKE_zhecon_3_64( int matrix_layout, char uplo, int64_t n,
                           const lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* e,
                           const int64_t* ipiv, double anorm,
                           double* rcond );
int64_t LAPACKE_ssycon_3_work_64( int matrix_layout, char uplo, int64_t n,
                                const float* a, int64_t lda, const float* e,
                                const int64_t* ipiv, float anorm,
                                float* rcond, float* work, int64_t* iwork );
int64_t LAPACKE_dsycon_3_work_64( int matrix_layout, char uplo, int64_t n,
                                const double* a, int64_t lda, const double* e,
                                const int64_t* ipiv, double anorm,
                                double* rcond, double* work,
                                int64_t* iwork );
int64_t LAPACKE_csycon_3_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* e,
                                const int64_t* ipiv, float anorm,
                                float* rcond, lapack_complex_float* work );
int64_t LAPACKE_zsycon_3_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* e,
                                const int64_t* ipiv, double anorm,
                                double* rcond, lapack_complex_double* work );
int64_t LAPACKE_checon_3_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* e,
                                const int64_t* ipiv, float anorm,
                                float* rcond, lapack_complex_float* work );
int64_t LAPACKE_zhecon_3_work_64( int matrix_layout, char uplo, int64_t n,
                                const lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* e,
                                const int64_t* ipiv, double anorm,
                                double* rcond, lapack_complex_double* work );

int64_t LAPACKE_sgelq_64( int matrix_layout, int64_t m, int64_t n,
                          float* a, int64_t lda,
                          float* t, int64_t tsize );
int64_t LAPACKE_dgelq_64( int matrix_layout, int64_t m, int64_t n,
                          double* a, int64_t lda,
                          double* t, int64_t tsize );
int64_t LAPACKE_cgelq_64( int matrix_layout, int64_t m, int64_t n,
                          lapack_complex_float* a, int64_t lda,
                          lapack_complex_float* t, int64_t tsize );
int64_t LAPACKE_zgelq_64( int matrix_layout, int64_t m, int64_t n,
                          lapack_complex_double* a, int64_t lda,
                          lapack_complex_double* t, int64_t tsize );

int64_t LAPACKE_sgelq_work_64( int matrix_layout, int64_t m, int64_t n,
                               float* a, int64_t lda,
                               float* t, int64_t tsize,
                               float* work, int64_t lwork );
int64_t LAPACKE_dgelq_work_64( int matrix_layout, int64_t m, int64_t n,
                               double* a, int64_t lda,
                               double* t, int64_t tsize,
                               double* work, int64_t lwork );
int64_t LAPACKE_cgelq_work_64( int matrix_layout, int64_t m, int64_t n,
                               lapack_complex_float* a, int64_t lda,
                               lapack_complex_float* t, int64_t tsize,
                               lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgelq_work_64( int matrix_layout, int64_t m, int64_t n,
                               lapack_complex_double* a, int64_t lda,
                               lapack_complex_double* t, int64_t tsize,
                               lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgemlq_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const float* a, int64_t lda,
                           const float* t, int64_t tsize,
                           float* c, int64_t ldc );
int64_t LAPACKE_dgemlq_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const double* a, int64_t lda,
                           const double* t, int64_t tsize,
                           double* c, int64_t ldc );
int64_t LAPACKE_cgemlq_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* t, int64_t tsize,
                           lapack_complex_float* c, int64_t ldc );
int64_t LAPACKE_zgemlq_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* t, int64_t tsize,
                           lapack_complex_double* c, int64_t ldc );

int64_t LAPACKE_sgemlq_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const float* a, int64_t lda,
                                const float* t, int64_t tsize,
                                float* c, int64_t ldc,
                                float* work, int64_t lwork );
int64_t LAPACKE_dgemlq_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const double* a, int64_t lda,
                                const double* t, int64_t tsize,
                                double* c, int64_t ldc,
                                double* work, int64_t lwork );
int64_t LAPACKE_cgemlq_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* t, int64_t tsize,
                                lapack_complex_float* c, int64_t ldc,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgemlq_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* t, int64_t tsize,
                                lapack_complex_double* c, int64_t ldc,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgeqr_64( int matrix_layout, int64_t m, int64_t n,
                          float* a, int64_t lda,
                          float* t, int64_t tsize );
int64_t LAPACKE_dgeqr_64( int matrix_layout, int64_t m, int64_t n,
                          double* a, int64_t lda,
                          double* t, int64_t tsize );
int64_t LAPACKE_cgeqr_64( int matrix_layout, int64_t m, int64_t n,
                          lapack_complex_float* a, int64_t lda,
                          lapack_complex_float* t, int64_t tsize );
int64_t LAPACKE_zgeqr_64( int matrix_layout, int64_t m, int64_t n,
                          lapack_complex_double* a, int64_t lda,
                          lapack_complex_double* t, int64_t tsize );

int64_t LAPACKE_sgeqr_work_64( int matrix_layout, int64_t m, int64_t n,
                               float* a, int64_t lda,
                               float* t, int64_t tsize,
                               float* work, int64_t lwork );
int64_t LAPACKE_dgeqr_work_64( int matrix_layout, int64_t m, int64_t n,
                               double* a, int64_t lda,
                               double* t, int64_t tsize,
                               double* work, int64_t lwork );
int64_t LAPACKE_cgeqr_work_64( int matrix_layout, int64_t m, int64_t n,
                               lapack_complex_float* a, int64_t lda,
                               lapack_complex_float* t, int64_t tsize,
                               lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgeqr_work_64( int matrix_layout, int64_t m, int64_t n,
                               lapack_complex_double* a, int64_t lda,
                               lapack_complex_double* t, int64_t tsize,
                               lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgemqr_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const float* a, int64_t lda,
                           const float* t, int64_t tsize,
                           float* c, int64_t ldc );
int64_t LAPACKE_dgemqr_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const double* a, int64_t lda,
                           const double* t, int64_t tsize,
                           double* c, int64_t ldc );
int64_t LAPACKE_cgemqr_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const lapack_complex_float* a, int64_t lda,
                           const lapack_complex_float* t, int64_t tsize,
                           lapack_complex_float* c, int64_t ldc );
int64_t LAPACKE_zgemqr_64( int matrix_layout, char side, char trans,
                           int64_t m, int64_t n, int64_t k,
                           const lapack_complex_double* a, int64_t lda,
                           const lapack_complex_double* t, int64_t tsize,
                           lapack_complex_double* c, int64_t ldc );

int64_t LAPACKE_sgemqr_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const float* a, int64_t lda,
                                const float* t, int64_t tsize,
                                float* c, int64_t ldc,
                                float* work, int64_t lwork );
int64_t LAPACKE_dgemqr_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const double* a, int64_t lda,
                                const double* t, int64_t tsize,
                                double* c, int64_t ldc,
                                double* work, int64_t lwork );
int64_t LAPACKE_cgemqr_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const lapack_complex_float* a, int64_t lda,
                                const lapack_complex_float* t, int64_t tsize,
                                lapack_complex_float* c, int64_t ldc,
                                lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgemqr_work_64( int matrix_layout, char side, char trans,
                                int64_t m, int64_t n, int64_t k,
                                const lapack_complex_double* a, int64_t lda,
                                const lapack_complex_double* t, int64_t tsize,
                                lapack_complex_double* c, int64_t ldc,
                                lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgetsls_64( int matrix_layout, char trans, int64_t m,
                            int64_t n, int64_t nrhs, float* a,
                            int64_t lda, float* b, int64_t ldb );
int64_t LAPACKE_dgetsls_64( int matrix_layout, char trans, int64_t m,
                            int64_t n, int64_t nrhs, double* a,
                            int64_t lda, double* b, int64_t ldb );
int64_t LAPACKE_cgetsls_64( int matrix_layout, char trans, int64_t m,
                            int64_t n, int64_t nrhs,
                            lapack_complex_float* a, int64_t lda,
                            lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zgetsls_64( int matrix_layout, char trans, int64_t m,
                            int64_t n, int64_t nrhs,
                            lapack_complex_double* a, int64_t lda,
                            lapack_complex_double* b, int64_t ldb );

int64_t LAPACKE_sgetsls_work_64( int matrix_layout, char trans, int64_t m,
                                 int64_t n, int64_t nrhs, float* a,
                                 int64_t lda, float* b, int64_t ldb,
                                 float* work, int64_t lwork );
int64_t LAPACKE_dgetsls_work_64( int matrix_layout, char trans, int64_t m,
                                 int64_t n, int64_t nrhs, double* a,
                                 int64_t lda, double* b, int64_t ldb,
                                 double* work, int64_t lwork );
int64_t LAPACKE_cgetsls_work_64( int matrix_layout, char trans, int64_t m,
                                 int64_t n, int64_t nrhs,
                                 lapack_complex_float* a, int64_t lda,
                                 lapack_complex_float* b, int64_t ldb,
                                 lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgetsls_work_64( int matrix_layout, char trans, int64_t m,
                                 int64_t n, int64_t nrhs,
                                 lapack_complex_double* a, int64_t lda,
                                 lapack_complex_double* b, int64_t ldb,
                                 lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_sgetsqrhrt_64( int matrix_layout, int64_t m, int64_t n,
                               int64_t mb1, int64_t nb1, int64_t nb2,
                               float* a, int64_t lda,
                               float* t, int64_t ldt );
int64_t LAPACKE_dgetsqrhrt_64( int matrix_layout, int64_t m, int64_t n,
                               int64_t mb1, int64_t nb1, int64_t nb2,
                               double* a, int64_t lda,
                               double* t, int64_t ldt );
int64_t LAPACKE_cgetsqrhrt_64( int matrix_layout, int64_t m, int64_t n,
                               int64_t mb1, int64_t nb1, int64_t nb2,
                               lapack_complex_float* a, int64_t lda,
                               lapack_complex_float* t, int64_t ldt );
int64_t LAPACKE_zgetsqrhrt_64( int matrix_layout, int64_t m, int64_t n,
                               int64_t mb1, int64_t nb1, int64_t nb2,
                               lapack_complex_double* a, int64_t lda,
                               lapack_complex_double* t, int64_t ldt );

int64_t LAPACKE_sgetsqrhrt_work_64( int matrix_layout, int64_t m, int64_t n,
                                    int64_t mb1, int64_t nb1, int64_t nb2,
                                    float* a, int64_t lda,
                                    float* t, int64_t ldt,
                                    float* work, int64_t lwork );
int64_t LAPACKE_dgetsqrhrt_work_64( int matrix_layout, int64_t m, int64_t n,
                                    int64_t mb1, int64_t nb1, int64_t nb2,
                                    double* a, int64_t lda,
                                    double* t, int64_t ldt,
                                    double* work, int64_t lwork );
int64_t LAPACKE_cgetsqrhrt_work_64( int matrix_layout, int64_t m, int64_t n,
                                    int64_t mb1, int64_t nb1, int64_t nb2,
                                    lapack_complex_float* a, int64_t lda,
                                    lapack_complex_float* t, int64_t ldt,
                                    lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zgetsqrhrt_work_64( int matrix_layout, int64_t m, int64_t n,
                                    int64_t mb1, int64_t nb1, int64_t nb2,
                                    lapack_complex_double* a, int64_t lda,
                                    lapack_complex_double* t, int64_t ldt,
                                    lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_ssyev_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          float* a, int64_t lda, float* w );
int64_t LAPACKE_dsyev_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          double* a, int64_t lda, double* w );

int64_t LAPACKE_ssyevd_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           float* a, int64_t lda, float* w );
int64_t LAPACKE_dsyevd_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           double* a, int64_t lda, double* w );

int64_t LAPACKE_ssyevr_2stage_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, float* a, int64_t lda, float vl,
                           float vu, int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, float* z, int64_t ldz,
                           int64_t* isuppz );
int64_t LAPACKE_dsyevr_2stage_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, double* a, int64_t lda, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w, double* z,
                           int64_t ldz, int64_t* isuppz );

int64_t LAPACKE_ssyevx_2stage_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, float* a, int64_t lda, float vl,
                           float vu, int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, float* z, int64_t ldz,
                           int64_t* ifail );
int64_t LAPACKE_dsyevx_2stage_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, double* a, int64_t lda, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w, double* z,
                           int64_t ldz, int64_t* ifail );

int64_t LAPACKE_ssyev_2stage_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, float* a, int64_t lda, float* w,
                               float* work, int64_t lwork );
int64_t LAPACKE_dsyev_2stage_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, double* a, int64_t lda,
                               double* w, double* work, int64_t lwork );

int64_t LAPACKE_ssyevd_2stage_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, float* a, int64_t lda,
                                float* w, float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_dsyevd_2stage_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, double* a, int64_t lda,
                                double* w, double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_ssyevr_2stage_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, float* a,
                                int64_t lda, float vl, float vu,
                                int64_t il, int64_t iu, float abstol,
                                int64_t* m, float* w, float* z,
                                int64_t ldz, int64_t* isuppz, float* work,
                                int64_t lwork, int64_t* iwork,
                                int64_t liwork );
int64_t LAPACKE_dsyevr_2stage_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, double* a,
                                int64_t lda, double vl, double vu,
                                int64_t il, int64_t iu, double abstol,
                                int64_t* m, double* w, double* z,
                                int64_t ldz, int64_t* isuppz,
                                double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_ssyevx_2stage_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, float* a,
                                int64_t lda, float vl, float vu,
                                int64_t il, int64_t iu, float abstol,
                                int64_t* m, float* w, float* z,
                                int64_t ldz, float* work, int64_t lwork,
                                int64_t* iwork, int64_t* ifail );
int64_t LAPACKE_dsyevx_2stage_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, double* a,
                                int64_t lda, double vl, double vu,
                                int64_t il, int64_t iu, double abstol,
                                int64_t* m, double* w, double* z,
                                int64_t ldz, double* work, int64_t lwork,
                                int64_t* iwork, int64_t* ifail );

int64_t LAPACKE_cheev_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          lapack_complex_float* a, int64_t lda, float* w );
int64_t LAPACKE_zheev_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          lapack_complex_double* a, int64_t lda, double* w );

int64_t LAPACKE_cheevd_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           lapack_complex_float* a, int64_t lda, float* w );
int64_t LAPACKE_zheevd_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           lapack_complex_double* a, int64_t lda,
                           double* w );

int64_t LAPACKE_cheevr_2stage_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, lapack_complex_float* a,
                           int64_t lda, float vl, float vu, int64_t il,
                           int64_t iu, float abstol, int64_t* m, float* w,
                           lapack_complex_float* z, int64_t ldz,
                           int64_t* isuppz );
int64_t LAPACKE_zheevr_2stage_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, lapack_complex_double* a,
                           int64_t lda, double vl, double vu, int64_t il,
                           int64_t iu, double abstol, int64_t* m,
                           double* w, lapack_complex_double* z, int64_t ldz,
                           int64_t* isuppz );

int64_t LAPACKE_cheevx_2stage_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, lapack_complex_float* a,
                           int64_t lda, float vl, float vu, int64_t il,
                           int64_t iu, float abstol, int64_t* m, float* w,
                           lapack_complex_float* z, int64_t ldz,
                           int64_t* ifail );
int64_t LAPACKE_zheevx_2stage_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, lapack_complex_double* a,
                           int64_t lda, double vl, double vu, int64_t il,
                           int64_t iu, double abstol, int64_t* m,
                           double* w, lapack_complex_double* z, int64_t ldz,
                           int64_t* ifail );

int64_t LAPACKE_cheev_2stage_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, lapack_complex_float* a,
                               int64_t lda, float* w,
                               lapack_complex_float* work, int64_t lwork,
                               float* rwork );
int64_t LAPACKE_zheev_2stage_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, lapack_complex_double* a,
                               int64_t lda, double* w,
                               lapack_complex_double* work, int64_t lwork,
                               double* rwork );

int64_t LAPACKE_cheevd_2stage_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, lapack_complex_float* a,
                                int64_t lda, float* w,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork, int64_t lrwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_zheevd_2stage_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, lapack_complex_double* a,
                                int64_t lda, double* w,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork, int64_t lrwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_cheevr_2stage_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                float vl, float vu, int64_t il,
                                int64_t iu, float abstol, int64_t* m,
                                float* w, lapack_complex_float* z,
                                int64_t ldz, int64_t* isuppz,
                                lapack_complex_float* work, int64_t lwork,
                                float* rwork, int64_t lrwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_zheevr_2stage_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                double vl, double vu, int64_t il,
                                int64_t iu, double abstol, int64_t* m,
                                double* w, lapack_complex_double* z,
                                int64_t ldz, int64_t* isuppz,
                                lapack_complex_double* work, int64_t lwork,
                                double* rwork, int64_t lrwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_cheevx_2stage_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n,
                                lapack_complex_float* a, int64_t lda,
                                float vl, float vu, int64_t il,
                                int64_t iu, float abstol, int64_t* m,
                                float* w, lapack_complex_float* z,
                                int64_t ldz, lapack_complex_float* work,
                                int64_t lwork, float* rwork,
                                int64_t* iwork, int64_t* ifail );
int64_t LAPACKE_zheevx_2stage_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n,
                                lapack_complex_double* a, int64_t lda,
                                double vl, double vu, int64_t il,
                                int64_t iu, double abstol, int64_t* m,
                                double* w, lapack_complex_double* z,
                                int64_t ldz, lapack_complex_double* work,
                                int64_t lwork, double* rwork,
                                int64_t* iwork, int64_t* ifail );

int64_t LAPACKE_ssbev_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          int64_t kd, float* ab, int64_t ldab, float* w,
                          float* z, int64_t ldz );
int64_t LAPACKE_dsbev_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          int64_t kd, double* ab, int64_t ldab, double* w,
                          double* z, int64_t ldz );

int64_t LAPACKE_ssbevd_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           int64_t kd, float* ab, int64_t ldab, float* w,
                           float* z, int64_t ldz );
int64_t LAPACKE_dsbevd_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           int64_t kd, double* ab, int64_t ldab,
                           double* w, double* z, int64_t ldz );

int64_t LAPACKE_ssbevx_2stage_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, int64_t kd, float* ab,
                           int64_t ldab, float* q, int64_t ldq, float vl,
                           float vu, int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, float* z, int64_t ldz,
                           int64_t* ifail );
int64_t LAPACKE_dsbevx_2stage_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, int64_t kd, double* ab,
                           int64_t ldab, double* q, int64_t ldq,
                           double vl, double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w, double* z,
                           int64_t ldz, int64_t* ifail );

int64_t LAPACKE_ssbev_2stage_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, int64_t kd, float* ab,
                               int64_t ldab, float* w, float* z,
                               int64_t ldz, float* work, int64_t lwork );
int64_t LAPACKE_dsbev_2stage_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, int64_t kd, double* ab,
                               int64_t ldab, double* w, double* z,
                               int64_t ldz, double* work, int64_t lwork );

int64_t LAPACKE_ssbevd_2stage_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, int64_t kd, float* ab,
                                int64_t ldab, float* w, float* z,
                                int64_t ldz, float* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );
int64_t LAPACKE_dsbevd_2stage_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, int64_t kd, double* ab,
                                int64_t ldab, double* w, double* z,
                                int64_t ldz, double* work, int64_t lwork,
                                int64_t* iwork, int64_t liwork );

int64_t LAPACKE_ssbevx_2stage_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, int64_t kd,
                                float* ab, int64_t ldab, float* q,
                                int64_t ldq, float vl, float vu,
                                int64_t il, int64_t iu, float abstol,
                                int64_t* m, float* w, float* z,
                                int64_t ldz, float* work, int64_t lwork, int64_t* iwork,
                                int64_t* ifail );
int64_t LAPACKE_dsbevx_2stage_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, int64_t kd,
                                double* ab, int64_t ldab, double* q,
                                int64_t ldq, double vl, double vu,
                                int64_t il, int64_t iu, double abstol,
                                int64_t* m, double* w, double* z,
                                int64_t ldz, double* work, int64_t lwork, int64_t* iwork,
                                int64_t* ifail );

int64_t LAPACKE_chbev_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          int64_t kd, lapack_complex_float* ab,
                          int64_t ldab, float* w, lapack_complex_float* z,
                          int64_t ldz );
int64_t LAPACKE_zhbev_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                          int64_t kd, lapack_complex_double* ab,
                          int64_t ldab, double* w, lapack_complex_double* z,
                          int64_t ldz );

int64_t LAPACKE_chbevd_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           int64_t kd, lapack_complex_float* ab,
                           int64_t ldab, float* w, lapack_complex_float* z,
                           int64_t ldz );
int64_t LAPACKE_zhbevd_2stage_64( int matrix_layout, char jobz, char uplo, int64_t n,
                           int64_t kd, lapack_complex_double* ab,
                           int64_t ldab, double* w, lapack_complex_double* z,
                           int64_t ldz );

int64_t LAPACKE_chbevx_2stage_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, int64_t kd,
                           lapack_complex_float* ab, int64_t ldab,
                           lapack_complex_float* q, int64_t ldq, float vl,
                           float vu, int64_t il, int64_t iu, float abstol,
                           int64_t* m, float* w, lapack_complex_float* z,
                           int64_t ldz, int64_t* ifail );
int64_t LAPACKE_zhbevx_2stage_64( int matrix_layout, char jobz, char range, char uplo,
                           int64_t n, int64_t kd,
                           lapack_complex_double* ab, int64_t ldab,
                           lapack_complex_double* q, int64_t ldq, double vl,
                           double vu, int64_t il, int64_t iu,
                           double abstol, int64_t* m, double* w,
                           lapack_complex_double* z, int64_t ldz,
                           int64_t* ifail );

int64_t LAPACKE_chbev_2stage_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, int64_t kd,
                               lapack_complex_float* ab, int64_t ldab,
                               float* w, lapack_complex_float* z,
                               int64_t ldz, lapack_complex_float* work,
                               int64_t lwork, float* rwork );
int64_t LAPACKE_zhbev_2stage_work_64( int matrix_layout, char jobz, char uplo,
                               int64_t n, int64_t kd,
                               lapack_complex_double* ab, int64_t ldab,
                               double* w, lapack_complex_double* z,
                               int64_t ldz, lapack_complex_double* work,
                               int64_t lwork, double* rwork );

int64_t LAPACKE_chbevd_2stage_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, int64_t kd,
                                lapack_complex_float* ab, int64_t ldab,
                                float* w, lapack_complex_float* z,
                                int64_t ldz, lapack_complex_float* work,
                                int64_t lwork, float* rwork,
                                int64_t lrwork, int64_t* iwork,
                                int64_t liwork );
int64_t LAPACKE_zhbevd_2stage_work_64( int matrix_layout, char jobz, char uplo,
                                int64_t n, int64_t kd,
                                lapack_complex_double* ab, int64_t ldab,
                                double* w, lapack_complex_double* z,
                                int64_t ldz, lapack_complex_double* work,
                                int64_t lwork, double* rwork,
                                int64_t lrwork, int64_t* iwork,
                                int64_t liwork );

int64_t LAPACKE_chbevx_2stage_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, int64_t kd,
                                lapack_complex_float* ab, int64_t ldab,
                                lapack_complex_float* q, int64_t ldq,
                                float vl, float vu, int64_t il,
                                int64_t iu, float abstol, int64_t* m,
                                float* w, lapack_complex_float* z,
                                int64_t ldz, lapack_complex_float* work,
                                int64_t lwork, float* rwork, int64_t* iwork,
                                int64_t* ifail );
int64_t LAPACKE_zhbevx_2stage_work_64( int matrix_layout, char jobz, char range,
                                char uplo, int64_t n, int64_t kd,
                                lapack_complex_double* ab, int64_t ldab,
                                lapack_complex_double* q, int64_t ldq,
                                double vl, double vu, int64_t il,
                                int64_t iu, double abstol, int64_t* m,
                                double* w, lapack_complex_double* z,
                                int64_t ldz, lapack_complex_double* work,
                                int64_t lwork, double* rwork, int64_t* iwork,
                                int64_t* ifail );

int64_t LAPACKE_ssygv_2stage_64( int matrix_layout, int64_t itype, char jobz,
                          char uplo, int64_t n, float* a, int64_t lda,
                          float* b, int64_t ldb, float* w );
int64_t LAPACKE_dsygv_2stage_64( int matrix_layout, int64_t itype, char jobz,
                          char uplo, int64_t n, double* a, int64_t lda,
                          double* b, int64_t ldb, double* w );
int64_t LAPACKE_ssygv_2stage_work_64( int matrix_layout, int64_t itype, char jobz,
                               char uplo, int64_t n, float* a,
                               int64_t lda, float* b, int64_t ldb,
                               float* w, float* work, int64_t lwork );
int64_t LAPACKE_dsygv_2stage_work_64( int matrix_layout, int64_t itype, char jobz,
                               char uplo, int64_t n, double* a,
                               int64_t lda, double* b, int64_t ldb,
                               double* w, double* work, int64_t lwork );

int64_t LAPACKE_chegv_2stage_64( int matrix_layout, int64_t itype, char jobz,
                          char uplo, int64_t n, lapack_complex_float* a,
                          int64_t lda, lapack_complex_float* b,
                          int64_t ldb, float* w );
int64_t LAPACKE_zhegv_2stage_64( int matrix_layout, int64_t itype, char jobz,
                          char uplo, int64_t n, lapack_complex_double* a,
                          int64_t lda, lapack_complex_double* b,
                          int64_t ldb, double* w );
int64_t LAPACKE_chegv_2stage_work_64( int matrix_layout, int64_t itype, char jobz,
                               char uplo, int64_t n, lapack_complex_float* a,
                               int64_t lda, lapack_complex_float* b,
                               int64_t ldb, float* w,
                               lapack_complex_float* work, int64_t lwork,
                               float* rwork );
int64_t LAPACKE_zhegv_2stage_work_64( int matrix_layout, int64_t itype, char jobz,
                               char uplo, int64_t n,
                               lapack_complex_double* a, int64_t lda,
                               lapack_complex_double* b, int64_t ldb,
                               double* w, lapack_complex_double* work,
                               int64_t lwork, double* rwork );

//LAPACK 3.8.0
int64_t LAPACKE_ssysv_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, float* a, int64_t lda,
                          float* tb, int64_t ltb, int64_t* ipiv,
                          int64_t* ipiv2, float* b, int64_t ldb );
int64_t LAPACKE_ssysv_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, float* a, int64_t lda,
                               float* tb, int64_t ltb, int64_t* ipiv,
                               int64_t* ipiv2, float* b, int64_t ldb,
                               float* work, int64_t lwork );
int64_t LAPACKE_dsysv_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, double* a, int64_t lda,
                          double* tb, int64_t ltb,
                          int64_t* ipiv, int64_t* ipiv2,
                          double* b, int64_t ldb );
int64_t LAPACKE_dsysv_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, double* a, int64_t lda,
                               double* tb, int64_t ltb,
                               int64_t* ipiv, int64_t* ipiv2,
                               double* b, int64_t ldb,
                               double* work, int64_t lwork );
int64_t LAPACKE_csysv_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_float* a,
                          int64_t lda, lapack_complex_float* tb,
                          int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_csysv_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* a,
                               int64_t lda, lapack_complex_float* tb,
                               int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                               lapack_complex_float* b, int64_t ldb,
                               lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zsysv_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_double* a,
                          int64_t lda, lapack_complex_double* tb,
                          int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                          lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_zsysv_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* a,
                               int64_t lda, lapack_complex_double* tb,
                               int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                               lapack_complex_double* b, int64_t ldb,
                               lapack_complex_double* work, int64_t lwork );
int64_t LAPACKE_chesv_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_float* a,
                          int64_t lda, lapack_complex_float* tb,
                          int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_chesv_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* a,
                               int64_t lda, lapack_complex_float* tb,
                               int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                               lapack_complex_float* b, int64_t ldb,
                               lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zhesv_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_double* a,
                          int64_t lda, lapack_complex_double* tb,
                          int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                          lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_zhesv_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* a,
                               int64_t lda, lapack_complex_double* tb,
                               int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                               lapack_complex_double* b, int64_t ldb,
                               lapack_complex_double* work, int64_t lwork );

int64_t LAPACKE_ssytrf_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          float* a, int64_t lda,
                          float* tb, int64_t ltb, int64_t* ipiv,
                          int64_t* ipiv2 );
int64_t LAPACKE_ssytrf_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               float* a, int64_t lda,
                               float* tb, int64_t ltb, int64_t* ipiv,
                               int64_t* ipiv2,
                               float* work, int64_t lwork );
int64_t LAPACKE_dsytrf_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          double* a, int64_t lda,
                          double* tb, int64_t ltb,
                          int64_t* ipiv, int64_t* ipiv2 );
int64_t LAPACKE_dsytrf_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               double* a, int64_t lda,
                               double* tb, int64_t ltb,
                               int64_t* ipiv, int64_t* ipiv2,
                               double* work, int64_t lwork );
int64_t LAPACKE_csytrf_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          lapack_complex_float* a,
                          int64_t lda, lapack_complex_float* tb,
                          int64_t ltb, int64_t* ipiv, int64_t* ipiv2 );
int64_t LAPACKE_csytrf_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               lapack_complex_float* a,
                               int64_t lda, lapack_complex_float* tb,
                               int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                               lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zsytrf_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          lapack_complex_double* a,
                          int64_t lda, lapack_complex_double* tb,
                          int64_t ltb, int64_t* ipiv, int64_t* ipiv2 );
int64_t LAPACKE_zsytrf_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               lapack_complex_double* a,
                               int64_t lda, lapack_complex_double* tb,
                               int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                               lapack_complex_double* work, int64_t lwork );
int64_t LAPACKE_chetrf_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          lapack_complex_float* a,
                          int64_t lda, lapack_complex_float* tb,
                          int64_t ltb, int64_t* ipiv, int64_t* ipiv2 );
int64_t LAPACKE_chetrf_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               lapack_complex_float* a,
                               int64_t lda, lapack_complex_float* tb,
                               int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                               lapack_complex_float* work, int64_t lwork );
int64_t LAPACKE_zhetrf_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          lapack_complex_double* a,
                          int64_t lda, lapack_complex_double* tb,
                          int64_t ltb, int64_t* ipiv, int64_t* ipiv2 );
int64_t LAPACKE_zhetrf_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               lapack_complex_double* a,
                               int64_t lda, lapack_complex_double* tb,
                               int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                               lapack_complex_double* work, int64_t lwork );


int64_t LAPACKE_ssytrs_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, float* a, int64_t lda,
                          float* tb, int64_t ltb, int64_t* ipiv,
                          int64_t* ipiv2, float* b, int64_t ldb );
int64_t LAPACKE_ssytrs_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, float* a, int64_t lda,
                               float* tb, int64_t ltb, int64_t* ipiv,
                               int64_t* ipiv2, float* b, int64_t ldb );
int64_t LAPACKE_dsytrs_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, double* a, int64_t lda,
                          double* tb, int64_t ltb,
                          int64_t* ipiv, int64_t* ipiv2,
                          double* b, int64_t ldb );
int64_t LAPACKE_dsytrs_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, double* a, int64_t lda,
                               double* tb, int64_t ltb,
                               int64_t* ipiv, int64_t* ipiv2,
                               double* b, int64_t ldb );
int64_t LAPACKE_csytrs_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_float* a,
                          int64_t lda, lapack_complex_float* tb,
                          int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_csytrs_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* a,
                               int64_t lda, lapack_complex_float* tb,
                               int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                               lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zsytrs_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_double* a,
                          int64_t lda, lapack_complex_double* tb,
                          int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                          lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_zsytrs_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* a,
                               int64_t lda, lapack_complex_double* tb,
                               int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                               lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_chetrs_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_float* a,
                          int64_t lda, lapack_complex_float* tb,
                          int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                          lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_chetrs_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_float* a,
                               int64_t lda, lapack_complex_float* tb,
                               int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                               lapack_complex_float* b, int64_t ldb );
int64_t LAPACKE_zhetrs_aa_2stage_64( int matrix_layout, char uplo, int64_t n,
                          int64_t nrhs, lapack_complex_double* a,
                          int64_t lda, lapack_complex_double* tb,
                          int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                          lapack_complex_double* b, int64_t ldb );
int64_t LAPACKE_zhetrs_aa_2stage_work_64( int matrix_layout, char uplo, int64_t n,
                               int64_t nrhs, lapack_complex_double* a,
                               int64_t lda, lapack_complex_double* tb,
                               int64_t ltb, int64_t* ipiv, int64_t* ipiv2,
                               lapack_complex_double* b, int64_t ldb );
//LAPACK 3.10.0
int64_t LAPACKE_sorhr_col_64( int matrix_layout, int64_t m, int64_t n,
                              int64_t nb, float* a,
                              int64_t lda, float* t,
                              int64_t ldt, float* d );
int64_t LAPACKE_sorhr_col_work_64( int matrix_layout, int64_t m, int64_t n,
                                   int64_t nb, float* a,
                                   int64_t lda, float* t,
                                   int64_t ldt, float* d );
int64_t LAPACKE_dorhr_col_64( int matrix_layout, int64_t m, int64_t n,
                              int64_t nb, double* a,
                              int64_t lda, double* t,
                              int64_t ldt, double* d );
int64_t LAPACKE_dorhr_col_work_64( int matrix_layout, int64_t m, int64_t n,
                                   int64_t nb, double* a,
                                   int64_t lda, double* t,
                                   int64_t ldt, double* d );
int64_t LAPACKE_cunhr_col_64( int matrix_layout, int64_t m, int64_t n,
                              int64_t nb, lapack_complex_float* a,
                              int64_t lda, lapack_complex_float* t,
                              int64_t ldt, lapack_complex_float* d );
int64_t LAPACKE_cunhr_col_work_64( int matrix_layout, int64_t m, int64_t n,
                                   int64_t nb, lapack_complex_float* a,
                                   int64_t lda, lapack_complex_float* t,
                                   int64_t ldt, lapack_complex_float* d );
int64_t LAPACKE_zunhr_col_64( int matrix_layout, int64_t m, int64_t n,
                              int64_t nb, lapack_complex_double* a,
                              int64_t lda, lapack_complex_double* t,
                              int64_t ldt, lapack_complex_double* d );
int64_t LAPACKE_zunhr_col_work_64( int matrix_layout, int64_t m, int64_t n,
                                   int64_t nb, lapack_complex_double* a,
                                   int64_t lda, lapack_complex_double* t,
                                   int64_t ldt, lapack_complex_double* d );

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* _LAPACKE_64_H_ */