1(
2    types: [
3        (
4            name: None,
5            inner: Scalar(
6                kind: Uint,
7                width: 4,
8            ),
9        ),
10        (
11            name: None,
12            inner: Array(
13                base: 1,
14                size: Dynamic,
15                stride: 4,
16            ),
17        ),
18        (
19            name: Some("PrimeIndices"),
20            inner: Struct(
21                level: Root,
22                members: [
23                    (
24                        name: Some("data"),
25                        ty: 2,
26                        binding: None,
27                        offset: 0,
28                    ),
29                ],
30                span: 4,
31            ),
32        ),
33        (
34            name: None,
35            inner: Vector(
36                size: Tri,
37                kind: Uint,
38                width: 4,
39            ),
40        ),
41    ],
42    constants: [
43        (
44            name: None,
45            specialization: None,
46            inner: Scalar(
47                width: 4,
48                value: Uint(0),
49            ),
50        ),
51        (
52            name: None,
53            specialization: None,
54            inner: Scalar(
55                width: 4,
56                value: Uint(1),
57            ),
58        ),
59        (
60            name: None,
61            specialization: None,
62            inner: Scalar(
63                width: 4,
64                value: Uint(2),
65            ),
66        ),
67        (
68            name: None,
69            specialization: None,
70            inner: Scalar(
71                width: 4,
72                value: Uint(3),
73            ),
74        ),
75    ],
76    global_variables: [
77        (
78            name: Some("v_indices"),
79            class: Storage,
80            binding: Some((
81                group: 0,
82                binding: 0,
83            )),
84            ty: 3,
85            init: None,
86            storage_access: (
87                bits: 3,
88            ),
89        ),
90    ],
91    functions: [
92        (
93            name: Some("collatz_iterations"),
94            arguments: [
95                (
96                    name: Some("n_base"),
97                    ty: 1,
98                    binding: None,
99                ),
100            ],
101            result: Some((
102                ty: 1,
103                binding: None,
104            )),
105            local_variables: [
106                (
107                    name: Some("n"),
108                    ty: 1,
109                    init: None,
110                ),
111                (
112                    name: Some("i"),
113                    ty: 1,
114                    init: Some(1),
115                ),
116            ],
117            expressions: [
118                GlobalVariable(1),
119                FunctionArgument(0),
120                LocalVariable(1),
121                Constant(1),
122                LocalVariable(2),
123                Load(
124                    pointer: 3,
125                ),
126                Constant(2),
127                Binary(
128                    op: LessEqual,
129                    left: 6,
130                    right: 7,
131                ),
132                Load(
133                    pointer: 3,
134                ),
135                Constant(3),
136                Binary(
137                    op: Modulo,
138                    left: 9,
139                    right: 10,
140                ),
141                Constant(1),
142                Binary(
143                    op: Equal,
144                    left: 11,
145                    right: 12,
146                ),
147                Load(
148                    pointer: 3,
149                ),
150                Constant(3),
151                Binary(
152                    op: Divide,
153                    left: 14,
154                    right: 15,
155                ),
156                Constant(4),
157                Load(
158                    pointer: 3,
159                ),
160                Binary(
161                    op: Multiply,
162                    left: 17,
163                    right: 18,
164                ),
165                Constant(2),
166                Binary(
167                    op: Add,
168                    left: 19,
169                    right: 20,
170                ),
171                Load(
172                    pointer: 5,
173                ),
174                Constant(2),
175                Binary(
176                    op: Add,
177                    left: 22,
178                    right: 23,
179                ),
180                Load(
181                    pointer: 5,
182                ),
183            ],
184            body: [
185                Store(
186                    pointer: 3,
187                    value: 2,
188                ),
189                Loop(
190                    body: [
191                        Emit((
192                            start: 5,
193                            end: 6,
194                        )),
195                        Emit((
196                            start: 7,
197                            end: 8,
198                        )),
199                        If(
200                            condition: 8,
201                            accept: [
202                                Break,
203                            ],
204                            reject: [],
205                        ),
206                        Emit((
207                            start: 8,
208                            end: 9,
209                        )),
210                        Emit((
211                            start: 10,
212                            end: 11,
213                        )),
214                        Emit((
215                            start: 12,
216                            end: 13,
217                        )),
218                        If(
219                            condition: 13,
220                            accept: [
221                                Emit((
222                                    start: 13,
223                                    end: 14,
224                                )),
225                                Emit((
226                                    start: 15,
227                                    end: 16,
228                                )),
229                                Store(
230                                    pointer: 3,
231                                    value: 16,
232                                ),
233                            ],
234                            reject: [
235                                Emit((
236                                    start: 17,
237                                    end: 19,
238                                )),
239                                Emit((
240                                    start: 20,
241                                    end: 21,
242                                )),
243                                Store(
244                                    pointer: 3,
245                                    value: 21,
246                                ),
247                            ],
248                        ),
249                        Emit((
250                            start: 21,
251                            end: 22,
252                        )),
253                        Emit((
254                            start: 23,
255                            end: 24,
256                        )),
257                        Store(
258                            pointer: 5,
259                            value: 24,
260                        ),
261                    ],
262                    continuing: [],
263                ),
264                Emit((
265                    start: 24,
266                    end: 25,
267                )),
268                Return(
269                    value: Some(25),
270                ),
271            ],
272        ),
273    ],
274    entry_points: [
275        (
276            name: "main",
277            stage: Compute,
278            early_depth_test: None,
279            workgroup_size: (1, 1, 1),
280            function: (
281                name: Some("main"),
282                arguments: [
283                    (
284                        name: Some("global_id"),
285                        ty: 4,
286                        binding: Some(BuiltIn(GlobalInvocationId)),
287                    ),
288                ],
289                result: None,
290                local_variables: [],
291                expressions: [
292                    GlobalVariable(1),
293                    FunctionArgument(0),
294                    AccessIndex(
295                        base: 1,
296                        index: 0,
297                    ),
298                    AccessIndex(
299                        base: 2,
300                        index: 0,
301                    ),
302                    Access(
303                        base: 3,
304                        index: 4,
305                    ),
306                    AccessIndex(
307                        base: 1,
308                        index: 0,
309                    ),
310                    AccessIndex(
311                        base: 2,
312                        index: 0,
313                    ),
314                    Access(
315                        base: 6,
316                        index: 7,
317                    ),
318                    Load(
319                        pointer: 8,
320                    ),
321                    Call(1),
322                ],
323                body: [
324                    Emit((
325                        start: 2,
326                        end: 9,
327                    )),
328                    Call(
329                        function: 1,
330                        arguments: [
331                            9,
332                        ],
333                        result: Some(10),
334                    ),
335                    Store(
336                        pointer: 5,
337                        value: 10,
338                    ),
339                    Return(
340                        value: None,
341                    ),
342                ],
343            ),
344        ),
345    ],
346)