-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathgen01083478021707541248-onnx.mlir
1116 lines (1115 loc) · 74.8 KB
/
gen01083478021707541248-onnx.mlir
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
module attributes {llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
llvm.func @strncmp(!llvm.ptr<i8>, !llvm.ptr<i8>, i64) -> i32
llvm.mlir.global external constant @_entry_point_0("run_main_graph\00") {addr_space = 0 : i32}
llvm.mlir.global external constant @_entry_point_0_in_sig("[ { \22type\22 : \22i32\22 , \22dims\22 : [1 , 1 , 1 , 1] , \22name\22 : \22v0_0\22 }\0A\0A]\00") {addr_space = 0 : i32}
llvm.mlir.global external constant @_entry_point_0_out_sig("[ { \22type\22 : \22i32\22 , \22dims\22 : [1 , 1] , \22name\22 : \22v5_0\22 }\0A , { \22type\22 : \22i32\22 , \22dims\22 : [1 , 1 , 1 , 1] , \22name\22 : \22v3_0\22 }\0A , { \22type\22 : \22f32\22 , \22dims\22 : [1 , 1 , 1 , 1] , \22name\22 : \22v4_0\22 }\0A , { \22type\22 : \22f32\22 , \22dims\22 : [1 , 1 , 1 , 1] , \22name\22 : \22v2_0\22 }\0A\0A]\00") {addr_space = 0 : i32}
llvm.func @omTensorListGetSize(!llvm.ptr<i8>) -> i64
llvm.func @omTensorPrint(!llvm.ptr<i8>, !llvm.ptr<i8>)
llvm.func @omTensorListGetOmtArray(!llvm.ptr<i8>) -> !llvm.ptr<ptr<i8>>
llvm.func @omTensorSetDataType(!llvm.ptr<i8>, i64)
llvm.func @omTensorGetDataType(!llvm.ptr<i8>) -> i64
llvm.func @omTensorGetStrides(!llvm.ptr<i8>) -> !llvm.ptr<i64>
llvm.func @omTensorGetShape(!llvm.ptr<i8>) -> !llvm.ptr<i64>
llvm.func @omTensorGetRank(!llvm.ptr<i8>) -> i64
llvm.func @omTensorSetDataPtr(!llvm.ptr<i8>, i64, !llvm.ptr<i8>, !llvm.ptr<i8>)
llvm.func @omTensorGetDataPtr(!llvm.ptr<i8>) -> !llvm.ptr<i8>
llvm.func @omTensorCreateUntyped(i64) -> !llvm.ptr<i8>
llvm.func @omTensorListCreate(!llvm.ptr<ptr<i8>>, i64, i64) -> !llvm.ptr<i8>
llvm.func @malloc(i64) -> !llvm.ptr<i8>
llvm.mlir.global internal constant @constant_6(dense<1> : tensor<4xi64>) {addr_space = 0 : i32, alignment = 16 : i64} : !llvm.array<4 x i64>
llvm.mlir.global internal constant @constant_5(dense<-1> : tensor<i64>) {addr_space = 0 : i32, alignment = 16 : i64} : !llvm.array<1 x i64>
llvm.mlir.global internal constant @constant_4(dense<1> : tensor<4xi64>) {addr_space = 0 : i32, alignment = 16 : i64} : !llvm.array<4 x i64>
llvm.mlir.global internal constant @constant_3(dense<1> : tensor<4xi64>) {addr_space = 0 : i32, alignment = 16 : i64} : !llvm.array<4 x i64>
llvm.mlir.global internal constant @constant_2(dense<-1> : tensor<i64>) {addr_space = 0 : i32, alignment = 16 : i64} : !llvm.array<1 x i64>
llvm.mlir.global internal constant @constant_1(dense<1> : tensor<4xi64>) {addr_space = 0 : i32, alignment = 16 : i64} : !llvm.array<4 x i64>
llvm.func @main_graph(%arg0: !llvm.ptr<i32>, %arg1: !llvm.ptr<i32>, %arg2: i64, %arg3: i64, %arg4: i64, %arg5: i64, %arg6: i64, %arg7: i64, %arg8: i64, %arg9: i64, %arg10: i64) -> !llvm.struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)> attributes {input_names = ["v0_0"], llvm.emit_c_interface, output_names = ["v5_0", "v3_0", "v4_0", "v2_0"]} {
%0 = llvm.mlir.undef : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%1 = llvm.insertvalue %arg0, %0[0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%2 = llvm.insertvalue %arg1, %1[1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%3 = llvm.insertvalue %arg2, %2[2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%4 = llvm.insertvalue %arg3, %3[3, 0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%5 = llvm.insertvalue %arg7, %4[4, 0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%6 = llvm.insertvalue %arg4, %5[3, 1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%7 = llvm.insertvalue %arg8, %6[4, 1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%8 = llvm.insertvalue %arg5, %7[3, 2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%9 = llvm.insertvalue %arg9, %8[4, 2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%10 = llvm.insertvalue %arg6, %9[3, 3] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%11 = llvm.insertvalue %arg10, %10[4, 3] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%12 = llvm.mlir.constant(1 : i64) : i64
%13 = llvm.mlir.constant(0 : index) : i64
%14 = llvm.mlir.addressof @constant_1 : !llvm.ptr<array<4 x i64>>
%15 = llvm.bitcast %14 : !llvm.ptr<array<4 x i64>> to !llvm.ptr<i64>
%16 = llvm.mlir.undef : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%17 = llvm.insertvalue %15, %16[0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%18 = llvm.insertvalue %15, %17[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%19 = llvm.mlir.constant(0 : index) : i64
%20 = llvm.insertvalue %19, %18[2] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%21 = llvm.mlir.constant(4 : index) : i64
%22 = llvm.insertvalue %21, %20[3, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%23 = llvm.mlir.constant(1 : index) : i64
%24 = llvm.insertvalue %23, %22[4, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%25 = llvm.mlir.addressof @constant_2 : !llvm.ptr<array<1 x i64>>
%26 = llvm.bitcast %25 : !llvm.ptr<array<1 x i64>> to !llvm.ptr<i64>
%27 = llvm.mlir.undef : !llvm.struct<(ptr<i64>, ptr<i64>, i64)>
%28 = llvm.insertvalue %26, %27[0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64)>
%29 = llvm.insertvalue %26, %28[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64)>
%30 = llvm.mlir.constant(0 : index) : i64
%31 = llvm.insertvalue %30, %29[2] : !llvm.struct<(ptr<i64>, ptr<i64>, i64)>
%32 = llvm.mlir.addressof @constant_3 : !llvm.ptr<array<4 x i64>>
%33 = llvm.bitcast %32 : !llvm.ptr<array<4 x i64>> to !llvm.ptr<i64>
%34 = llvm.mlir.undef : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%35 = llvm.insertvalue %33, %34[0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%36 = llvm.insertvalue %33, %35[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%37 = llvm.mlir.constant(0 : index) : i64
%38 = llvm.insertvalue %37, %36[2] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%39 = llvm.mlir.constant(4 : index) : i64
%40 = llvm.insertvalue %39, %38[3, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%41 = llvm.mlir.constant(1 : index) : i64
%42 = llvm.insertvalue %41, %40[4, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%43 = llvm.mlir.addressof @constant_4 : !llvm.ptr<array<4 x i64>>
%44 = llvm.bitcast %43 : !llvm.ptr<array<4 x i64>> to !llvm.ptr<i64>
%45 = llvm.mlir.undef : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%46 = llvm.insertvalue %44, %45[0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%47 = llvm.insertvalue %44, %46[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%48 = llvm.mlir.constant(0 : index) : i64
%49 = llvm.insertvalue %48, %47[2] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%50 = llvm.mlir.constant(4 : index) : i64
%51 = llvm.insertvalue %50, %49[3, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%52 = llvm.mlir.constant(1 : index) : i64
%53 = llvm.insertvalue %52, %51[4, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%54 = llvm.mlir.addressof @constant_5 : !llvm.ptr<array<1 x i64>>
%55 = llvm.bitcast %54 : !llvm.ptr<array<1 x i64>> to !llvm.ptr<i64>
%56 = llvm.mlir.undef : !llvm.struct<(ptr<i64>, ptr<i64>, i64)>
%57 = llvm.insertvalue %55, %56[0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64)>
%58 = llvm.insertvalue %55, %57[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64)>
%59 = llvm.mlir.constant(0 : index) : i64
%60 = llvm.insertvalue %59, %58[2] : !llvm.struct<(ptr<i64>, ptr<i64>, i64)>
%61 = llvm.mlir.addressof @constant_6 : !llvm.ptr<array<4 x i64>>
%62 = llvm.bitcast %61 : !llvm.ptr<array<4 x i64>> to !llvm.ptr<i64>
%63 = llvm.mlir.undef : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%64 = llvm.insertvalue %62, %63[0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%65 = llvm.insertvalue %62, %64[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%66 = llvm.mlir.constant(0 : index) : i64
%67 = llvm.insertvalue %66, %65[2] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%68 = llvm.mlir.constant(4 : index) : i64
%69 = llvm.insertvalue %68, %67[3, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%70 = llvm.mlir.constant(1 : index) : i64
%71 = llvm.insertvalue %70, %69[4, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%72 = llvm.mlir.undef : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>
%73 = llvm.extractvalue %11[0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%74 = llvm.extractvalue %11[1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%75 = llvm.insertvalue %73, %72[0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>
%76 = llvm.insertvalue %74, %75[1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>
%77 = llvm.mlir.constant(0 : index) : i64
%78 = llvm.insertvalue %77, %76[2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>
%79 = llvm.mlir.constant(1 : index) : i64
%80 = llvm.insertvalue %79, %78[3, 0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>
%81 = llvm.mlir.constant(1 : index) : i64
%82 = llvm.insertvalue %81, %80[4, 0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>
%83 = llvm.mlir.constant(1 : index) : i64
%84 = llvm.insertvalue %83, %82[3, 1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>
%85 = llvm.mlir.constant(1 : index) : i64
%86 = llvm.insertvalue %85, %84[4, 1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>
%87 = llvm.mlir.constant(1 : index) : i64
%88 = llvm.mlir.constant(1 : index) : i64
%89 = llvm.mlir.constant(1 : index) : i64
%90 = llvm.mlir.constant(1 : index) : i64
%91 = llvm.mlir.constant(1 : index) : i64
%92 = llvm.mlir.null : !llvm.ptr<i32>
%93 = llvm.getelementptr %92[%87] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32>
%94 = llvm.ptrtoint %93 : !llvm.ptr<i32> to i64
%95 = llvm.mlir.constant(16 : index) : i64
%96 = llvm.add %94, %95 : i64
%97 = llvm.call @malloc(%96) : (i64) -> !llvm.ptr<i8>
%98 = llvm.bitcast %97 : !llvm.ptr<i8> to !llvm.ptr<i32>
%99 = llvm.ptrtoint %98 : !llvm.ptr<i32> to i64
%100 = llvm.mlir.constant(1 : index) : i64
%101 = llvm.sub %95, %100 : i64
%102 = llvm.add %99, %101 : i64
%103 = llvm.urem %102, %95 : i64
%104 = llvm.sub %102, %103 : i64
%105 = llvm.inttoptr %104 : i64 to !llvm.ptr<i32>
%106 = llvm.mlir.undef : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%107 = llvm.insertvalue %98, %106[0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%108 = llvm.insertvalue %105, %107[1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%109 = llvm.mlir.constant(0 : index) : i64
%110 = llvm.insertvalue %109, %108[2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%111 = llvm.insertvalue %87, %110[3, 0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%112 = llvm.insertvalue %88, %111[3, 1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%113 = llvm.insertvalue %89, %112[3, 2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%114 = llvm.insertvalue %90, %113[3, 3] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%115 = llvm.insertvalue %88, %114[4, 0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%116 = llvm.insertvalue %89, %115[4, 1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%117 = llvm.insertvalue %90, %116[4, 2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%118 = llvm.insertvalue %91, %117[4, 3] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%119 = llvm.mlir.constant(0 : index) : i64
%120 = llvm.mlir.constant(1 : index) : i64
%121 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb1(%119 : i64)
^bb1(%122: i64): // 2 preds: ^bb0, ^bb11
%123 = llvm.icmp "slt" %122, %120 : i64
llvm.cond_br %123, ^bb2, ^bb12
^bb2: // pred: ^bb1
%124 = llvm.mlir.constant(0 : index) : i64
%125 = llvm.mlir.constant(1 : index) : i64
%126 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb3(%124 : i64)
^bb3(%127: i64): // 2 preds: ^bb2, ^bb10
%128 = llvm.icmp "slt" %127, %125 : i64
llvm.cond_br %128, ^bb4, ^bb11
^bb4: // pred: ^bb3
%129 = llvm.mlir.constant(0 : index) : i64
%130 = llvm.mlir.constant(1 : index) : i64
%131 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb5(%129 : i64)
^bb5(%132: i64): // 2 preds: ^bb4, ^bb9
%133 = llvm.icmp "slt" %132, %130 : i64
llvm.cond_br %133, ^bb6, ^bb10
^bb6: // pred: ^bb5
%134 = llvm.mlir.constant(0 : index) : i64
%135 = llvm.mlir.constant(1 : index) : i64
%136 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb7(%134 : i64)
^bb7(%137: i64): // 2 preds: ^bb6, ^bb8
%138 = llvm.icmp "slt" %137, %135 : i64
llvm.cond_br %138, ^bb8, ^bb9
^bb8: // pred: ^bb7
%139 = llvm.extractvalue %11[1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%140 = llvm.add %122, %127 : i64
%141 = llvm.add %140, %132 : i64
%142 = llvm.add %141, %137 : i64
%143 = llvm.getelementptr %139[%142] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32>
%144 = llvm.load %143 : !llvm.ptr<i32>
%145 = llvm.extractvalue %11[1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%146 = llvm.add %122, %127 : i64
%147 = llvm.add %146, %132 : i64
%148 = llvm.add %147, %137 : i64
%149 = llvm.getelementptr %145[%148] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32>
%150 = llvm.load %149 : !llvm.ptr<i32>
%151 = llvm.mul %144, %150 : i32
%152 = llvm.extractvalue %118[1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%153 = llvm.add %122, %127 : i64
%154 = llvm.add %153, %132 : i64
%155 = llvm.add %154, %137 : i64
%156 = llvm.getelementptr %152[%155] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32>
llvm.store %151, %156 : !llvm.ptr<i32>
%157 = llvm.add %137, %136 : i64
llvm.br ^bb7(%157 : i64)
^bb9: // pred: ^bb7
%158 = llvm.add %132, %131 : i64
llvm.br ^bb5(%158 : i64)
^bb10: // pred: ^bb5
%159 = llvm.add %127, %126 : i64
llvm.br ^bb3(%159 : i64)
^bb11: // pred: ^bb3
%160 = llvm.add %122, %121 : i64
llvm.br ^bb1(%160 : i64)
^bb12: // pred: ^bb1
%161 = llvm.mlir.constant(1 : index) : i64
%162 = llvm.mlir.constant(1 : index) : i64
%163 = llvm.mlir.constant(1 : index) : i64
%164 = llvm.mlir.constant(1 : index) : i64
%165 = llvm.mlir.constant(1 : index) : i64
%166 = llvm.mlir.null : !llvm.ptr<f32>
%167 = llvm.getelementptr %166[%161] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
%168 = llvm.ptrtoint %167 : !llvm.ptr<f32> to i64
%169 = llvm.mlir.constant(16 : index) : i64
%170 = llvm.add %168, %169 : i64
%171 = llvm.call @malloc(%170) : (i64) -> !llvm.ptr<i8>
%172 = llvm.bitcast %171 : !llvm.ptr<i8> to !llvm.ptr<f32>
%173 = llvm.ptrtoint %172 : !llvm.ptr<f32> to i64
%174 = llvm.mlir.constant(1 : index) : i64
%175 = llvm.sub %169, %174 : i64
%176 = llvm.add %173, %175 : i64
%177 = llvm.urem %176, %169 : i64
%178 = llvm.sub %176, %177 : i64
%179 = llvm.inttoptr %178 : i64 to !llvm.ptr<f32>
%180 = llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%181 = llvm.insertvalue %172, %180[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%182 = llvm.insertvalue %179, %181[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%183 = llvm.mlir.constant(0 : index) : i64
%184 = llvm.insertvalue %183, %182[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%185 = llvm.insertvalue %161, %184[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%186 = llvm.insertvalue %162, %185[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%187 = llvm.insertvalue %163, %186[3, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%188 = llvm.insertvalue %164, %187[3, 3] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%189 = llvm.insertvalue %162, %188[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%190 = llvm.insertvalue %163, %189[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%191 = llvm.insertvalue %164, %190[4, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%192 = llvm.insertvalue %165, %191[4, 3] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%193 = llvm.mlir.constant(0 : index) : i64
%194 = llvm.mlir.constant(1 : index) : i64
%195 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb13(%193 : i64)
^bb13(%196: i64): // 2 preds: ^bb12, ^bb23
%197 = llvm.icmp "slt" %196, %194 : i64
llvm.cond_br %197, ^bb14, ^bb24
^bb14: // pred: ^bb13
%198 = llvm.mlir.constant(0 : index) : i64
%199 = llvm.mlir.constant(1 : index) : i64
%200 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb15(%198 : i64)
^bb15(%201: i64): // 2 preds: ^bb14, ^bb22
%202 = llvm.icmp "slt" %201, %199 : i64
llvm.cond_br %202, ^bb16, ^bb23
^bb16: // pred: ^bb15
%203 = llvm.mlir.constant(0 : index) : i64
%204 = llvm.mlir.constant(1 : index) : i64
%205 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb17(%203 : i64)
^bb17(%206: i64): // 2 preds: ^bb16, ^bb21
%207 = llvm.icmp "slt" %206, %204 : i64
llvm.cond_br %207, ^bb18, ^bb22
^bb18: // pred: ^bb17
%208 = llvm.mlir.constant(0 : index) : i64
%209 = llvm.mlir.constant(1 : index) : i64
%210 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb19(%208 : i64)
^bb19(%211: i64): // 2 preds: ^bb18, ^bb20
%212 = llvm.icmp "slt" %211, %209 : i64
llvm.cond_br %212, ^bb20, ^bb21
^bb20: // pred: ^bb19
%213 = llvm.extractvalue %11[1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%214 = llvm.add %196, %201 : i64
%215 = llvm.add %214, %206 : i64
%216 = llvm.add %215, %211 : i64
%217 = llvm.getelementptr %213[%216] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32>
%218 = llvm.load %217 : !llvm.ptr<i32>
%219 = llvm.sitofp %218 : i32 to f32
%220 = llvm.extractvalue %192[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%221 = llvm.add %196, %201 : i64
%222 = llvm.add %221, %206 : i64
%223 = llvm.add %222, %211 : i64
%224 = llvm.getelementptr %220[%223] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
llvm.store %219, %224 : !llvm.ptr<f32>
%225 = llvm.add %211, %210 : i64
llvm.br ^bb19(%225 : i64)
^bb21: // pred: ^bb19
%226 = llvm.add %206, %205 : i64
llvm.br ^bb17(%226 : i64)
^bb22: // pred: ^bb17
%227 = llvm.add %201, %200 : i64
llvm.br ^bb15(%227 : i64)
^bb23: // pred: ^bb15
%228 = llvm.add %196, %195 : i64
llvm.br ^bb13(%228 : i64)
^bb24: // pred: ^bb13
%229 = llvm.mlir.constant(4 : index) : i64
%230 = llvm.mlir.constant(1 : index) : i64
%231 = llvm.mlir.null : !llvm.ptr<i64>
%232 = llvm.getelementptr %231[%229] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%233 = llvm.ptrtoint %232 : !llvm.ptr<i64> to i64
%234 = llvm.mlir.constant(16 : index) : i64
%235 = llvm.add %233, %234 : i64
%236 = llvm.call @malloc(%235) : (i64) -> !llvm.ptr<i8>
%237 = llvm.bitcast %236 : !llvm.ptr<i8> to !llvm.ptr<i64>
%238 = llvm.ptrtoint %237 : !llvm.ptr<i64> to i64
%239 = llvm.mlir.constant(1 : index) : i64
%240 = llvm.sub %234, %239 : i64
%241 = llvm.add %238, %240 : i64
%242 = llvm.urem %241, %234 : i64
%243 = llvm.sub %241, %242 : i64
%244 = llvm.inttoptr %243 : i64 to !llvm.ptr<i64>
%245 = llvm.mlir.undef : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%246 = llvm.insertvalue %237, %245[0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%247 = llvm.insertvalue %244, %246[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%248 = llvm.mlir.constant(0 : index) : i64
%249 = llvm.insertvalue %248, %247[2] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%250 = llvm.insertvalue %229, %249[3, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%251 = llvm.insertvalue %230, %250[4, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%252 = llvm.mlir.constant(0 : index) : i64
%253 = llvm.mlir.constant(4 : index) : i64
%254 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb25(%252 : i64)
^bb25(%255: i64): // 2 preds: ^bb24, ^bb26
%256 = llvm.icmp "slt" %255, %253 : i64
llvm.cond_br %256, ^bb26, ^bb27
^bb26: // pred: ^bb25
%257 = llvm.extractvalue %251[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%258 = llvm.getelementptr %257[%255] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %12, %258 : !llvm.ptr<i64>
%259 = llvm.add %255, %254 : i64
llvm.br ^bb25(%259 : i64)
^bb27: // pred: ^bb25
%260 = llvm.mlir.constant(4 : index) : i64
%261 = llvm.mlir.constant(1 : index) : i64
%262 = llvm.mlir.null : !llvm.ptr<i64>
%263 = llvm.getelementptr %262[%260] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%264 = llvm.ptrtoint %263 : !llvm.ptr<i64> to i64
%265 = llvm.mlir.constant(16 : index) : i64
%266 = llvm.add %264, %265 : i64
%267 = llvm.call @malloc(%266) : (i64) -> !llvm.ptr<i8>
%268 = llvm.bitcast %267 : !llvm.ptr<i8> to !llvm.ptr<i64>
%269 = llvm.ptrtoint %268 : !llvm.ptr<i64> to i64
%270 = llvm.mlir.constant(1 : index) : i64
%271 = llvm.sub %265, %270 : i64
%272 = llvm.add %269, %271 : i64
%273 = llvm.urem %272, %265 : i64
%274 = llvm.sub %272, %273 : i64
%275 = llvm.inttoptr %274 : i64 to !llvm.ptr<i64>
%276 = llvm.mlir.undef : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%277 = llvm.insertvalue %268, %276[0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%278 = llvm.insertvalue %275, %277[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%279 = llvm.mlir.constant(0 : index) : i64
%280 = llvm.insertvalue %279, %278[2] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%281 = llvm.insertvalue %260, %280[3, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%282 = llvm.insertvalue %261, %281[4, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%283 = llvm.mlir.constant(0 : index) : i64
%284 = llvm.mlir.constant(4 : index) : i64
%285 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb28(%283 : i64)
^bb28(%286: i64): // 2 preds: ^bb27, ^bb29
%287 = llvm.icmp "slt" %286, %284 : i64
llvm.cond_br %287, ^bb29, ^bb30
^bb29: // pred: ^bb28
%288 = llvm.extractvalue %251[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%289 = llvm.getelementptr %288[%286] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%290 = llvm.load %289 : !llvm.ptr<i64>
%291 = llvm.extractvalue %60[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64)>
%292 = llvm.load %291 : !llvm.ptr<i64>
%293 = llvm.mul %290, %292 : i64
%294 = llvm.extractvalue %282[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%295 = llvm.getelementptr %294[%286] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %293, %295 : !llvm.ptr<i64>
%296 = llvm.add %286, %285 : i64
llvm.br ^bb28(%296 : i64)
^bb30: // pred: ^bb28
%297 = llvm.mlir.constant(4 : index) : i64
%298 = llvm.mlir.constant(1 : index) : i64
%299 = llvm.mlir.null : !llvm.ptr<i1>
%300 = llvm.getelementptr %299[%297] : (!llvm.ptr<i1>, i64) -> !llvm.ptr<i1>
%301 = llvm.ptrtoint %300 : !llvm.ptr<i1> to i64
%302 = llvm.mlir.constant(16 : index) : i64
%303 = llvm.add %301, %302 : i64
%304 = llvm.call @malloc(%303) : (i64) -> !llvm.ptr<i8>
%305 = llvm.bitcast %304 : !llvm.ptr<i8> to !llvm.ptr<i1>
%306 = llvm.ptrtoint %305 : !llvm.ptr<i1> to i64
%307 = llvm.mlir.constant(1 : index) : i64
%308 = llvm.sub %302, %307 : i64
%309 = llvm.add %306, %308 : i64
%310 = llvm.urem %309, %302 : i64
%311 = llvm.sub %309, %310 : i64
%312 = llvm.inttoptr %311 : i64 to !llvm.ptr<i1>
%313 = llvm.mlir.undef : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%314 = llvm.insertvalue %305, %313[0] : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%315 = llvm.insertvalue %312, %314[1] : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%316 = llvm.mlir.constant(0 : index) : i64
%317 = llvm.insertvalue %316, %315[2] : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%318 = llvm.insertvalue %297, %317[3, 0] : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%319 = llvm.insertvalue %298, %318[4, 0] : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%320 = llvm.mlir.constant(0 : index) : i64
%321 = llvm.mlir.constant(4 : index) : i64
%322 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb31(%320 : i64)
^bb31(%323: i64): // 2 preds: ^bb30, ^bb32
%324 = llvm.icmp "slt" %323, %321 : i64
llvm.cond_br %324, ^bb32, ^bb33
^bb32: // pred: ^bb31
%325 = llvm.extractvalue %53[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%326 = llvm.getelementptr %325[%323] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%327 = llvm.load %326 : !llvm.ptr<i64>
%328 = llvm.extractvalue %282[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%329 = llvm.getelementptr %328[%323] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%330 = llvm.load %329 : !llvm.ptr<i64>
%331 = llvm.icmp "eq" %327, %330 : i64
%332 = llvm.extractvalue %319[1] : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%333 = llvm.getelementptr %332[%323] : (!llvm.ptr<i1>, i64) -> !llvm.ptr<i1>
llvm.store %331, %333 : !llvm.ptr<i1>
%334 = llvm.add %323, %322 : i64
llvm.br ^bb31(%334 : i64)
^bb33: // pred: ^bb31
%335 = llvm.mlir.constant(4 : index) : i64
%336 = llvm.mlir.constant(1 : index) : i64
%337 = llvm.mlir.null : !llvm.ptr<i64>
%338 = llvm.getelementptr %337[%335] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%339 = llvm.ptrtoint %338 : !llvm.ptr<i64> to i64
%340 = llvm.mlir.constant(16 : index) : i64
%341 = llvm.add %339, %340 : i64
%342 = llvm.call @malloc(%341) : (i64) -> !llvm.ptr<i8>
%343 = llvm.bitcast %342 : !llvm.ptr<i8> to !llvm.ptr<i64>
%344 = llvm.ptrtoint %343 : !llvm.ptr<i64> to i64
%345 = llvm.mlir.constant(1 : index) : i64
%346 = llvm.sub %340, %345 : i64
%347 = llvm.add %344, %346 : i64
%348 = llvm.urem %347, %340 : i64
%349 = llvm.sub %347, %348 : i64
%350 = llvm.inttoptr %349 : i64 to !llvm.ptr<i64>
%351 = llvm.mlir.undef : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%352 = llvm.insertvalue %343, %351[0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%353 = llvm.insertvalue %350, %352[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%354 = llvm.mlir.constant(0 : index) : i64
%355 = llvm.insertvalue %354, %353[2] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%356 = llvm.insertvalue %335, %355[3, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%357 = llvm.insertvalue %336, %356[4, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%358 = llvm.mlir.constant(0 : index) : i64
%359 = llvm.mlir.constant(4 : index) : i64
%360 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb34(%358 : i64)
^bb34(%361: i64): // 2 preds: ^bb33, ^bb35
%362 = llvm.icmp "slt" %361, %359 : i64
llvm.cond_br %362, ^bb35, ^bb36
^bb35: // pred: ^bb34
%363 = llvm.extractvalue %319[1] : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%364 = llvm.getelementptr %363[%361] : (!llvm.ptr<i1>, i64) -> !llvm.ptr<i1>
%365 = llvm.load %364 : !llvm.ptr<i1>
%366 = llvm.extractvalue %251[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%367 = llvm.getelementptr %366[%361] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%368 = llvm.load %367 : !llvm.ptr<i64>
%369 = llvm.extractvalue %71[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%370 = llvm.getelementptr %369[%361] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%371 = llvm.load %370 : !llvm.ptr<i64>
%372 = llvm.select %365, %368, %371 : i1, i64
%373 = llvm.extractvalue %357[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%374 = llvm.getelementptr %373[%361] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %372, %374 : !llvm.ptr<i64>
%375 = llvm.add %361, %360 : i64
llvm.br ^bb34(%375 : i64)
^bb36: // pred: ^bb34
%376 = llvm.mlir.constant(1 : index) : i64
%377 = llvm.mlir.constant(1 : index) : i64
%378 = llvm.mlir.constant(1 : index) : i64
%379 = llvm.mlir.constant(1 : index) : i64
%380 = llvm.mlir.constant(1 : index) : i64
%381 = llvm.mlir.null : !llvm.ptr<f32>
%382 = llvm.getelementptr %381[%376] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
%383 = llvm.ptrtoint %382 : !llvm.ptr<f32> to i64
%384 = llvm.mlir.constant(16 : index) : i64
%385 = llvm.add %383, %384 : i64
%386 = llvm.call @malloc(%385) : (i64) -> !llvm.ptr<i8>
%387 = llvm.bitcast %386 : !llvm.ptr<i8> to !llvm.ptr<f32>
%388 = llvm.ptrtoint %387 : !llvm.ptr<f32> to i64
%389 = llvm.mlir.constant(1 : index) : i64
%390 = llvm.sub %384, %389 : i64
%391 = llvm.add %388, %390 : i64
%392 = llvm.urem %391, %384 : i64
%393 = llvm.sub %391, %392 : i64
%394 = llvm.inttoptr %393 : i64 to !llvm.ptr<f32>
%395 = llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%396 = llvm.insertvalue %387, %395[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%397 = llvm.insertvalue %394, %396[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%398 = llvm.mlir.constant(0 : index) : i64
%399 = llvm.insertvalue %398, %397[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%400 = llvm.insertvalue %376, %399[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%401 = llvm.insertvalue %377, %400[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%402 = llvm.insertvalue %378, %401[3, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%403 = llvm.insertvalue %379, %402[3, 3] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%404 = llvm.insertvalue %377, %403[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%405 = llvm.insertvalue %378, %404[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%406 = llvm.insertvalue %379, %405[4, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%407 = llvm.insertvalue %380, %406[4, 3] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%408 = llvm.mlir.constant(0 : index) : i64
%409 = llvm.mlir.constant(1 : index) : i64
%410 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb37(%408 : i64)
^bb37(%411: i64): // 2 preds: ^bb36, ^bb47
%412 = llvm.icmp "slt" %411, %409 : i64
llvm.cond_br %412, ^bb38, ^bb48
^bb38: // pred: ^bb37
%413 = llvm.mlir.constant(0 : index) : i64
%414 = llvm.mlir.constant(1 : index) : i64
%415 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb39(%413 : i64)
^bb39(%416: i64): // 2 preds: ^bb38, ^bb46
%417 = llvm.icmp "slt" %416, %414 : i64
llvm.cond_br %417, ^bb40, ^bb47
^bb40: // pred: ^bb39
%418 = llvm.mlir.constant(0 : index) : i64
%419 = llvm.mlir.constant(1 : index) : i64
%420 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb41(%418 : i64)
^bb41(%421: i64): // 2 preds: ^bb40, ^bb45
%422 = llvm.icmp "slt" %421, %419 : i64
llvm.cond_br %422, ^bb42, ^bb46
^bb42: // pred: ^bb41
%423 = llvm.mlir.constant(0 : index) : i64
%424 = llvm.mlir.constant(1 : index) : i64
%425 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb43(%423 : i64)
^bb43(%426: i64): // 2 preds: ^bb42, ^bb44
%427 = llvm.icmp "slt" %426, %424 : i64
llvm.cond_br %427, ^bb44, ^bb45
^bb44: // pred: ^bb43
%428 = llvm.extractvalue %192[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%429 = llvm.add %13, %13 : i64
%430 = llvm.add %429, %13 : i64
%431 = llvm.add %430, %13 : i64
%432 = llvm.getelementptr %428[%431] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
%433 = llvm.load %432 : !llvm.ptr<f32>
%434 = llvm.extractvalue %407[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%435 = llvm.add %411, %416 : i64
%436 = llvm.add %435, %421 : i64
%437 = llvm.add %436, %426 : i64
%438 = llvm.getelementptr %434[%437] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
llvm.store %433, %438 : !llvm.ptr<f32>
%439 = llvm.add %426, %425 : i64
llvm.br ^bb43(%439 : i64)
^bb45: // pred: ^bb43
%440 = llvm.add %421, %420 : i64
llvm.br ^bb41(%440 : i64)
^bb46: // pred: ^bb41
%441 = llvm.add %416, %415 : i64
llvm.br ^bb39(%441 : i64)
^bb47: // pred: ^bb39
%442 = llvm.add %411, %410 : i64
llvm.br ^bb37(%442 : i64)
^bb48: // pred: ^bb37
%443 = llvm.mlir.constant(4 : index) : i64
%444 = llvm.mlir.constant(1 : index) : i64
%445 = llvm.mlir.null : !llvm.ptr<i64>
%446 = llvm.getelementptr %445[%443] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%447 = llvm.ptrtoint %446 : !llvm.ptr<i64> to i64
%448 = llvm.mlir.constant(16 : index) : i64
%449 = llvm.add %447, %448 : i64
%450 = llvm.call @malloc(%449) : (i64) -> !llvm.ptr<i8>
%451 = llvm.bitcast %450 : !llvm.ptr<i8> to !llvm.ptr<i64>
%452 = llvm.ptrtoint %451 : !llvm.ptr<i64> to i64
%453 = llvm.mlir.constant(1 : index) : i64
%454 = llvm.sub %448, %453 : i64
%455 = llvm.add %452, %454 : i64
%456 = llvm.urem %455, %448 : i64
%457 = llvm.sub %455, %456 : i64
%458 = llvm.inttoptr %457 : i64 to !llvm.ptr<i64>
%459 = llvm.mlir.undef : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%460 = llvm.insertvalue %451, %459[0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%461 = llvm.insertvalue %458, %460[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%462 = llvm.mlir.constant(0 : index) : i64
%463 = llvm.insertvalue %462, %461[2] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%464 = llvm.insertvalue %443, %463[3, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%465 = llvm.insertvalue %444, %464[4, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%466 = llvm.mlir.constant(0 : index) : i64
%467 = llvm.mlir.constant(4 : index) : i64
%468 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb49(%466 : i64)
^bb49(%469: i64): // 2 preds: ^bb48, ^bb50
%470 = llvm.icmp "slt" %469, %467 : i64
llvm.cond_br %470, ^bb50, ^bb51
^bb50: // pred: ^bb49
%471 = llvm.extractvalue %465[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%472 = llvm.getelementptr %471[%469] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %12, %472 : !llvm.ptr<i64>
%473 = llvm.add %469, %468 : i64
llvm.br ^bb49(%473 : i64)
^bb51: // pred: ^bb49
%474 = llvm.mlir.constant(4 : index) : i64
%475 = llvm.mlir.constant(1 : index) : i64
%476 = llvm.mlir.null : !llvm.ptr<i64>
%477 = llvm.getelementptr %476[%474] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%478 = llvm.ptrtoint %477 : !llvm.ptr<i64> to i64
%479 = llvm.mlir.constant(16 : index) : i64
%480 = llvm.add %478, %479 : i64
%481 = llvm.call @malloc(%480) : (i64) -> !llvm.ptr<i8>
%482 = llvm.bitcast %481 : !llvm.ptr<i8> to !llvm.ptr<i64>
%483 = llvm.ptrtoint %482 : !llvm.ptr<i64> to i64
%484 = llvm.mlir.constant(1 : index) : i64
%485 = llvm.sub %479, %484 : i64
%486 = llvm.add %483, %485 : i64
%487 = llvm.urem %486, %479 : i64
%488 = llvm.sub %486, %487 : i64
%489 = llvm.inttoptr %488 : i64 to !llvm.ptr<i64>
%490 = llvm.mlir.undef : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%491 = llvm.insertvalue %482, %490[0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%492 = llvm.insertvalue %489, %491[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%493 = llvm.mlir.constant(0 : index) : i64
%494 = llvm.insertvalue %493, %492[2] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%495 = llvm.insertvalue %474, %494[3, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%496 = llvm.insertvalue %475, %495[4, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%497 = llvm.mlir.constant(0 : index) : i64
%498 = llvm.mlir.constant(4 : index) : i64
%499 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb52(%497 : i64)
^bb52(%500: i64): // 2 preds: ^bb51, ^bb53
%501 = llvm.icmp "slt" %500, %498 : i64
llvm.cond_br %501, ^bb53, ^bb54
^bb53: // pred: ^bb52
%502 = llvm.extractvalue %465[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%503 = llvm.getelementptr %502[%500] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%504 = llvm.load %503 : !llvm.ptr<i64>
%505 = llvm.extractvalue %31[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64)>
%506 = llvm.load %505 : !llvm.ptr<i64>
%507 = llvm.mul %504, %506 : i64
%508 = llvm.extractvalue %496[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%509 = llvm.getelementptr %508[%500] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %507, %509 : !llvm.ptr<i64>
%510 = llvm.add %500, %499 : i64
llvm.br ^bb52(%510 : i64)
^bb54: // pred: ^bb52
%511 = llvm.mlir.constant(4 : index) : i64
%512 = llvm.mlir.constant(1 : index) : i64
%513 = llvm.mlir.null : !llvm.ptr<i1>
%514 = llvm.getelementptr %513[%511] : (!llvm.ptr<i1>, i64) -> !llvm.ptr<i1>
%515 = llvm.ptrtoint %514 : !llvm.ptr<i1> to i64
%516 = llvm.mlir.constant(16 : index) : i64
%517 = llvm.add %515, %516 : i64
%518 = llvm.call @malloc(%517) : (i64) -> !llvm.ptr<i8>
%519 = llvm.bitcast %518 : !llvm.ptr<i8> to !llvm.ptr<i1>
%520 = llvm.ptrtoint %519 : !llvm.ptr<i1> to i64
%521 = llvm.mlir.constant(1 : index) : i64
%522 = llvm.sub %516, %521 : i64
%523 = llvm.add %520, %522 : i64
%524 = llvm.urem %523, %516 : i64
%525 = llvm.sub %523, %524 : i64
%526 = llvm.inttoptr %525 : i64 to !llvm.ptr<i1>
%527 = llvm.mlir.undef : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%528 = llvm.insertvalue %519, %527[0] : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%529 = llvm.insertvalue %526, %528[1] : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%530 = llvm.mlir.constant(0 : index) : i64
%531 = llvm.insertvalue %530, %529[2] : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%532 = llvm.insertvalue %511, %531[3, 0] : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%533 = llvm.insertvalue %512, %532[4, 0] : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%534 = llvm.mlir.constant(0 : index) : i64
%535 = llvm.mlir.constant(4 : index) : i64
%536 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb55(%534 : i64)
^bb55(%537: i64): // 2 preds: ^bb54, ^bb56
%538 = llvm.icmp "slt" %537, %535 : i64
llvm.cond_br %538, ^bb56, ^bb57
^bb56: // pred: ^bb55
%539 = llvm.extractvalue %24[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%540 = llvm.getelementptr %539[%537] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%541 = llvm.load %540 : !llvm.ptr<i64>
%542 = llvm.extractvalue %496[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%543 = llvm.getelementptr %542[%537] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%544 = llvm.load %543 : !llvm.ptr<i64>
%545 = llvm.icmp "eq" %541, %544 : i64
%546 = llvm.extractvalue %533[1] : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%547 = llvm.getelementptr %546[%537] : (!llvm.ptr<i1>, i64) -> !llvm.ptr<i1>
llvm.store %545, %547 : !llvm.ptr<i1>
%548 = llvm.add %537, %536 : i64
llvm.br ^bb55(%548 : i64)
^bb57: // pred: ^bb55
%549 = llvm.mlir.constant(4 : index) : i64
%550 = llvm.mlir.constant(1 : index) : i64
%551 = llvm.mlir.null : !llvm.ptr<i64>
%552 = llvm.getelementptr %551[%549] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%553 = llvm.ptrtoint %552 : !llvm.ptr<i64> to i64
%554 = llvm.mlir.constant(16 : index) : i64
%555 = llvm.add %553, %554 : i64
%556 = llvm.call @malloc(%555) : (i64) -> !llvm.ptr<i8>
%557 = llvm.bitcast %556 : !llvm.ptr<i8> to !llvm.ptr<i64>
%558 = llvm.ptrtoint %557 : !llvm.ptr<i64> to i64
%559 = llvm.mlir.constant(1 : index) : i64
%560 = llvm.sub %554, %559 : i64
%561 = llvm.add %558, %560 : i64
%562 = llvm.urem %561, %554 : i64
%563 = llvm.sub %561, %562 : i64
%564 = llvm.inttoptr %563 : i64 to !llvm.ptr<i64>
%565 = llvm.mlir.undef : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%566 = llvm.insertvalue %557, %565[0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%567 = llvm.insertvalue %564, %566[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%568 = llvm.mlir.constant(0 : index) : i64
%569 = llvm.insertvalue %568, %567[2] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%570 = llvm.insertvalue %549, %569[3, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%571 = llvm.insertvalue %550, %570[4, 0] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%572 = llvm.mlir.constant(0 : index) : i64
%573 = llvm.mlir.constant(4 : index) : i64
%574 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb58(%572 : i64)
^bb58(%575: i64): // 2 preds: ^bb57, ^bb59
%576 = llvm.icmp "slt" %575, %573 : i64
llvm.cond_br %576, ^bb59, ^bb60
^bb59: // pred: ^bb58
%577 = llvm.extractvalue %533[1] : !llvm.struct<(ptr<i1>, ptr<i1>, i64, array<1 x i64>, array<1 x i64>)>
%578 = llvm.getelementptr %577[%575] : (!llvm.ptr<i1>, i64) -> !llvm.ptr<i1>
%579 = llvm.load %578 : !llvm.ptr<i1>
%580 = llvm.extractvalue %465[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%581 = llvm.getelementptr %580[%575] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%582 = llvm.load %581 : !llvm.ptr<i64>
%583 = llvm.extractvalue %42[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%584 = llvm.getelementptr %583[%575] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%585 = llvm.load %584 : !llvm.ptr<i64>
%586 = llvm.select %579, %582, %585 : i1, i64
%587 = llvm.extractvalue %571[1] : !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
%588 = llvm.getelementptr %587[%575] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %586, %588 : !llvm.ptr<i64>
%589 = llvm.add %575, %574 : i64
llvm.br ^bb58(%589 : i64)
^bb60: // pred: ^bb58
%590 = llvm.mlir.constant(1 : index) : i64
%591 = llvm.mlir.constant(1 : index) : i64
%592 = llvm.mlir.constant(1 : index) : i64
%593 = llvm.mlir.constant(1 : index) : i64
%594 = llvm.mlir.constant(1 : index) : i64
%595 = llvm.mlir.null : !llvm.ptr<f32>
%596 = llvm.getelementptr %595[%590] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
%597 = llvm.ptrtoint %596 : !llvm.ptr<f32> to i64
%598 = llvm.mlir.constant(16 : index) : i64
%599 = llvm.add %597, %598 : i64
%600 = llvm.call @malloc(%599) : (i64) -> !llvm.ptr<i8>
%601 = llvm.bitcast %600 : !llvm.ptr<i8> to !llvm.ptr<f32>
%602 = llvm.ptrtoint %601 : !llvm.ptr<f32> to i64
%603 = llvm.mlir.constant(1 : index) : i64
%604 = llvm.sub %598, %603 : i64
%605 = llvm.add %602, %604 : i64
%606 = llvm.urem %605, %598 : i64
%607 = llvm.sub %605, %606 : i64
%608 = llvm.inttoptr %607 : i64 to !llvm.ptr<f32>
%609 = llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%610 = llvm.insertvalue %601, %609[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%611 = llvm.insertvalue %608, %610[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%612 = llvm.mlir.constant(0 : index) : i64
%613 = llvm.insertvalue %612, %611[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%614 = llvm.insertvalue %590, %613[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%615 = llvm.insertvalue %591, %614[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%616 = llvm.insertvalue %592, %615[3, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%617 = llvm.insertvalue %593, %616[3, 3] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%618 = llvm.insertvalue %591, %617[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%619 = llvm.insertvalue %592, %618[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%620 = llvm.insertvalue %593, %619[4, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%621 = llvm.insertvalue %594, %620[4, 3] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%622 = llvm.mlir.constant(0 : index) : i64
%623 = llvm.mlir.constant(1 : index) : i64
%624 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb61(%622 : i64)
^bb61(%625: i64): // 2 preds: ^bb60, ^bb71
%626 = llvm.icmp "slt" %625, %623 : i64
llvm.cond_br %626, ^bb62, ^bb72
^bb62: // pred: ^bb61
%627 = llvm.mlir.constant(0 : index) : i64
%628 = llvm.mlir.constant(1 : index) : i64
%629 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb63(%627 : i64)
^bb63(%630: i64): // 2 preds: ^bb62, ^bb70
%631 = llvm.icmp "slt" %630, %628 : i64
llvm.cond_br %631, ^bb64, ^bb71
^bb64: // pred: ^bb63
%632 = llvm.mlir.constant(0 : index) : i64
%633 = llvm.mlir.constant(1 : index) : i64
%634 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb65(%632 : i64)
^bb65(%635: i64): // 2 preds: ^bb64, ^bb69
%636 = llvm.icmp "slt" %635, %633 : i64
llvm.cond_br %636, ^bb66, ^bb70
^bb66: // pred: ^bb65
%637 = llvm.mlir.constant(0 : index) : i64
%638 = llvm.mlir.constant(1 : index) : i64
%639 = llvm.mlir.constant(1 : index) : i64
llvm.br ^bb67(%637 : i64)
^bb67(%640: i64): // 2 preds: ^bb66, ^bb68
%641 = llvm.icmp "slt" %640, %638 : i64
llvm.cond_br %641, ^bb68, ^bb69
^bb68: // pred: ^bb67
%642 = llvm.extractvalue %192[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%643 = llvm.add %13, %13 : i64
%644 = llvm.add %643, %13 : i64
%645 = llvm.add %644, %13 : i64
%646 = llvm.getelementptr %642[%645] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
%647 = llvm.load %646 : !llvm.ptr<f32>
%648 = llvm.extractvalue %621[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%649 = llvm.add %625, %630 : i64
%650 = llvm.add %649, %635 : i64
%651 = llvm.add %650, %640 : i64
%652 = llvm.getelementptr %648[%651] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
llvm.store %647, %652 : !llvm.ptr<f32>
%653 = llvm.add %640, %639 : i64
llvm.br ^bb67(%653 : i64)
^bb69: // pred: ^bb67
%654 = llvm.add %635, %634 : i64
llvm.br ^bb65(%654 : i64)
^bb70: // pred: ^bb65
%655 = llvm.add %630, %629 : i64
llvm.br ^bb63(%655 : i64)
^bb71: // pred: ^bb63
%656 = llvm.add %625, %624 : i64
llvm.br ^bb61(%656 : i64)
^bb72: // pred: ^bb61
%657 = llvm.mlir.undef : !llvm.struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>
%658 = llvm.insertvalue %86, %657[0] : !llvm.struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>
%659 = llvm.insertvalue %118, %658[1] : !llvm.struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>
%660 = llvm.insertvalue %407, %659[2] : !llvm.struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>
%661 = llvm.insertvalue %621, %660[3] : !llvm.struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>
llvm.return %661 : !llvm.struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>
}
llvm.func @_mlir_ciface_main_graph(%arg0: !llvm.ptr<struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>>, %arg1: !llvm.ptr<struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>>) attributes {input_names = ["v0_0"], llvm.emit_c_interface, output_names = ["v5_0", "v3_0", "v4_0", "v2_0"]} {
%0 = llvm.load %arg1 : !llvm.ptr<struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>>
%1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%2 = llvm.extractvalue %0[1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%3 = llvm.extractvalue %0[2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%4 = llvm.extractvalue %0[3, 0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%5 = llvm.extractvalue %0[3, 1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%6 = llvm.extractvalue %0[3, 2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%7 = llvm.extractvalue %0[3, 3] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%8 = llvm.extractvalue %0[4, 0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%9 = llvm.extractvalue %0[4, 1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%10 = llvm.extractvalue %0[4, 2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%11 = llvm.extractvalue %0[4, 3] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%12 = llvm.call @main_graph(%1, %2, %3, %4, %5, %6, %7, %8, %9, %10, %11) : (!llvm.ptr<i32>, !llvm.ptr<i32>, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> !llvm.struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>
llvm.store %12, %arg0 : !llvm.ptr<struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>>
llvm.return
}
llvm.func @run_main_graph(%arg0: !llvm.ptr<i8>) -> !llvm.ptr<i8> {
%0 = llvm.call @omTensorListGetOmtArray(%arg0) : (!llvm.ptr<i8>) -> !llvm.ptr<ptr<i8>>
%1 = llvm.mlir.constant(1 : i64) : i64
%2 = llvm.alloca %1 x !llvm.struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)> : (i64) -> !llvm.ptr<struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>>
%3 = llvm.mlir.constant(0 : i64) : i64
%4 = llvm.getelementptr %0[%3] : (!llvm.ptr<ptr<i8>>, i64) -> !llvm.ptr<ptr<i8>>
%5 = llvm.load %4 : !llvm.ptr<ptr<i8>>
%6 = llvm.alloca %1 x !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)> : (i64) -> !llvm.ptr<struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>>
%7 = llvm.mlir.undef : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%8 = llvm.call @omTensorGetDataPtr(%5) : (!llvm.ptr<i8>) -> !llvm.ptr<i8>
%9 = llvm.bitcast %8 : !llvm.ptr<i8> to !llvm.ptr<i32>
%10 = llvm.insertvalue %9, %7[0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%11 = llvm.insertvalue %9, %10[1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%12 = llvm.mlir.constant(0 : i64) : i64
%13 = llvm.insertvalue %12, %11[2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%14 = llvm.call @omTensorGetShape(%5) : (!llvm.ptr<i8>) -> !llvm.ptr<i64>
%15 = llvm.call @omTensorGetStrides(%5) : (!llvm.ptr<i8>) -> !llvm.ptr<i64>
%16 = llvm.mlir.constant(0 : i64) : i64
%17 = llvm.getelementptr %14[%16] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%18 = llvm.load %17 : !llvm.ptr<i64>
%19 = llvm.insertvalue %18, %13[3, 0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%20 = llvm.getelementptr %15[%16] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%21 = llvm.load %20 : !llvm.ptr<i64>
%22 = llvm.insertvalue %21, %19[4, 0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%23 = llvm.mlir.constant(1 : i64) : i64
%24 = llvm.getelementptr %14[%23] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%25 = llvm.load %24 : !llvm.ptr<i64>
%26 = llvm.insertvalue %25, %22[3, 1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%27 = llvm.getelementptr %15[%23] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%28 = llvm.load %27 : !llvm.ptr<i64>
%29 = llvm.insertvalue %28, %26[4, 1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%30 = llvm.mlir.constant(2 : i64) : i64
%31 = llvm.getelementptr %14[%30] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%32 = llvm.load %31 : !llvm.ptr<i64>
%33 = llvm.insertvalue %32, %29[3, 2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%34 = llvm.getelementptr %15[%30] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%35 = llvm.load %34 : !llvm.ptr<i64>
%36 = llvm.insertvalue %35, %33[4, 2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%37 = llvm.mlir.constant(3 : i64) : i64
%38 = llvm.getelementptr %14[%37] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%39 = llvm.load %38 : !llvm.ptr<i64>
%40 = llvm.insertvalue %39, %36[3, 3] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%41 = llvm.getelementptr %15[%37] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
%42 = llvm.load %41 : !llvm.ptr<i64>
%43 = llvm.insertvalue %42, %40[4, 3] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
llvm.store %43, %6 : !llvm.ptr<struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>>
llvm.call @_mlir_ciface_main_graph(%2, %6) : (!llvm.ptr<struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>>, !llvm.ptr<struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>>) -> ()
%44 = llvm.load %2 : !llvm.ptr<struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>>
%45 = llvm.extractvalue %44[0] : !llvm.struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>
%46 = llvm.extractvalue %44[1] : !llvm.struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>
%47 = llvm.extractvalue %44[2] : !llvm.struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>
%48 = llvm.extractvalue %44[3] : !llvm.struct<(struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>, struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>)>
%49 = llvm.mlir.constant(4 : i64) : i64
%50 = llvm.mlir.constant(32 : i64) : i64
%51 = llvm.call @malloc(%50) : (i64) -> !llvm.ptr<i8>
%52 = llvm.bitcast %51 : !llvm.ptr<i8> to !llvm.ptr<ptr<i8>>
%53 = llvm.mlir.constant(2 : i64) : i64
%54 = llvm.call @omTensorCreateUntyped(%53) : (i64) -> !llvm.ptr<i8>
%55 = llvm.mlir.constant(0 : i64) : i64
%56 = llvm.extractvalue %45[0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>
%57 = llvm.bitcast %56 : !llvm.ptr<i32> to !llvm.ptr<i8>
%58 = llvm.extractvalue %45[1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>
%59 = llvm.bitcast %58 : !llvm.ptr<i32> to !llvm.ptr<i8>
llvm.call @omTensorSetDataPtr(%54, %55, %57, %59) : (!llvm.ptr<i8>, i64, !llvm.ptr<i8>, !llvm.ptr<i8>) -> ()
%60 = llvm.mlir.constant(6 : i64) : i64
llvm.call @omTensorSetDataType(%54, %60) : (!llvm.ptr<i8>, i64) -> ()
%61 = llvm.call @omTensorGetShape(%54) : (!llvm.ptr<i8>) -> !llvm.ptr<i64>
%62 = llvm.call @omTensorGetStrides(%54) : (!llvm.ptr<i8>) -> !llvm.ptr<i64>
%63 = llvm.mlir.constant(0 : i64) : i64
%64 = llvm.extractvalue %45[3, 0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>
%65 = llvm.getelementptr %61[%63] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %64, %65 : !llvm.ptr<i64>
%66 = llvm.extractvalue %45[4, 0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>
%67 = llvm.getelementptr %62[%63] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %66, %67 : !llvm.ptr<i64>
%68 = llvm.mlir.constant(1 : i64) : i64
%69 = llvm.extractvalue %45[3, 1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>
%70 = llvm.getelementptr %61[%68] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %69, %70 : !llvm.ptr<i64>
%71 = llvm.extractvalue %45[4, 1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<2 x i64>, array<2 x i64>)>
%72 = llvm.getelementptr %62[%68] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %71, %72 : !llvm.ptr<i64>
%73 = llvm.mlir.constant(0 : i64) : i64
%74 = llvm.getelementptr %52[%73] : (!llvm.ptr<ptr<i8>>, i64) -> !llvm.ptr<ptr<i8>>
llvm.store %54, %74 : !llvm.ptr<ptr<i8>>
%75 = llvm.mlir.constant(4 : i64) : i64
%76 = llvm.call @omTensorCreateUntyped(%75) : (i64) -> !llvm.ptr<i8>
%77 = llvm.mlir.constant(1 : i64) : i64
%78 = llvm.extractvalue %46[0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%79 = llvm.bitcast %78 : !llvm.ptr<i32> to !llvm.ptr<i8>
%80 = llvm.extractvalue %46[1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%81 = llvm.bitcast %80 : !llvm.ptr<i32> to !llvm.ptr<i8>
llvm.call @omTensorSetDataPtr(%76, %77, %79, %81) : (!llvm.ptr<i8>, i64, !llvm.ptr<i8>, !llvm.ptr<i8>) -> ()
%82 = llvm.mlir.constant(6 : i64) : i64
llvm.call @omTensorSetDataType(%76, %82) : (!llvm.ptr<i8>, i64) -> ()
%83 = llvm.call @omTensorGetShape(%76) : (!llvm.ptr<i8>) -> !llvm.ptr<i64>
%84 = llvm.call @omTensorGetStrides(%76) : (!llvm.ptr<i8>) -> !llvm.ptr<i64>
%85 = llvm.mlir.constant(0 : i64) : i64
%86 = llvm.extractvalue %46[3, 0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%87 = llvm.getelementptr %83[%85] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %86, %87 : !llvm.ptr<i64>
%88 = llvm.extractvalue %46[4, 0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%89 = llvm.getelementptr %84[%85] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %88, %89 : !llvm.ptr<i64>
%90 = llvm.mlir.constant(1 : i64) : i64
%91 = llvm.extractvalue %46[3, 1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%92 = llvm.getelementptr %83[%90] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %91, %92 : !llvm.ptr<i64>
%93 = llvm.extractvalue %46[4, 1] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%94 = llvm.getelementptr %84[%90] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %93, %94 : !llvm.ptr<i64>
%95 = llvm.mlir.constant(2 : i64) : i64
%96 = llvm.extractvalue %46[3, 2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%97 = llvm.getelementptr %83[%95] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %96, %97 : !llvm.ptr<i64>
%98 = llvm.extractvalue %46[4, 2] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%99 = llvm.getelementptr %84[%95] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %98, %99 : !llvm.ptr<i64>
%100 = llvm.mlir.constant(3 : i64) : i64
%101 = llvm.extractvalue %46[3, 3] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%102 = llvm.getelementptr %83[%100] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %101, %102 : !llvm.ptr<i64>
%103 = llvm.extractvalue %46[4, 3] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<4 x i64>, array<4 x i64>)>
%104 = llvm.getelementptr %84[%100] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %103, %104 : !llvm.ptr<i64>
%105 = llvm.mlir.constant(1 : i64) : i64
%106 = llvm.getelementptr %52[%105] : (!llvm.ptr<ptr<i8>>, i64) -> !llvm.ptr<ptr<i8>>
llvm.store %76, %106 : !llvm.ptr<ptr<i8>>
%107 = llvm.mlir.constant(4 : i64) : i64
%108 = llvm.call @omTensorCreateUntyped(%107) : (i64) -> !llvm.ptr<i8>
%109 = llvm.mlir.constant(1 : i64) : i64
%110 = llvm.extractvalue %47[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%111 = llvm.bitcast %110 : !llvm.ptr<f32> to !llvm.ptr<i8>
%112 = llvm.extractvalue %47[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%113 = llvm.bitcast %112 : !llvm.ptr<f32> to !llvm.ptr<i8>
llvm.call @omTensorSetDataPtr(%108, %109, %111, %113) : (!llvm.ptr<i8>, i64, !llvm.ptr<i8>, !llvm.ptr<i8>) -> ()
%114 = llvm.mlir.constant(1 : i64) : i64
llvm.call @omTensorSetDataType(%108, %114) : (!llvm.ptr<i8>, i64) -> ()
%115 = llvm.call @omTensorGetShape(%108) : (!llvm.ptr<i8>) -> !llvm.ptr<i64>
%116 = llvm.call @omTensorGetStrides(%108) : (!llvm.ptr<i8>) -> !llvm.ptr<i64>
%117 = llvm.mlir.constant(0 : i64) : i64
%118 = llvm.extractvalue %47[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%119 = llvm.getelementptr %115[%117] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %118, %119 : !llvm.ptr<i64>
%120 = llvm.extractvalue %47[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%121 = llvm.getelementptr %116[%117] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %120, %121 : !llvm.ptr<i64>
%122 = llvm.mlir.constant(1 : i64) : i64
%123 = llvm.extractvalue %47[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%124 = llvm.getelementptr %115[%122] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %123, %124 : !llvm.ptr<i64>
%125 = llvm.extractvalue %47[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%126 = llvm.getelementptr %116[%122] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %125, %126 : !llvm.ptr<i64>
%127 = llvm.mlir.constant(2 : i64) : i64
%128 = llvm.extractvalue %47[3, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%129 = llvm.getelementptr %115[%127] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %128, %129 : !llvm.ptr<i64>
%130 = llvm.extractvalue %47[4, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>
%131 = llvm.getelementptr %116[%127] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
llvm.store %130, %131 : !llvm.ptr<i64>
%132 = llvm.mlir.constant(3 : i64) : i64