1loops.frag
2WARNING: 0:14: varying deprecated in version 130; may be removed in future release
3
4Shader version: 130
50:? Sequence
60:53  Function Definition: main( ( global void)
70:53    Function Parameters:
80:55    Sequence
90:55      Sequence
100:55        move second child to first child ( temp 4-component vector of float)
110:55          'color' ( temp 4-component vector of float)
120:55          'BaseColor' ( smooth in 4-component vector of float)
130:58      Loop with condition tested first
140:58        Loop Condition
150:58        Constant:
160:58          true (const bool)
170:58        Loop Body
180:59        Sequence
190:59          Test condition and select ( temp void)
200:59            Condition
210:59            Compare Less Than ( temp bool)
220:59              direct index ( temp float)
230:59                'color' ( temp 4-component vector of float)
240:59                Constant:
250:59                  0 (const int)
260:59              Constant:
270:59                0.330000
280:59            true case
290:60            Sequence
300:60              add second child into first child ( temp 4-component vector of float)
310:60                'color' ( temp 4-component vector of float)
320:60                Constant:
330:60                  0.330000
340:60                  0.330000
350:60                  0.330000
360:60                  0.330000
370:61              Branch: Break
380:63          Test condition and select ( temp void)
390:63            Condition
400:63            Compare Less Than ( temp bool)
410:63              direct index ( temp float)
420:63                'color' ( temp 4-component vector of float)
430:63                Constant:
440:63                  0 (const int)
450:63              Constant:
460:63                0.660000
470:63            true case
480:64            Sequence
490:64              add second child into first child ( temp 4-component vector of float)
500:64                'color' ( temp 4-component vector of float)
510:64                Constant:
520:64                  0.660000
530:64                  0.660000
540:64                  0.660000
550:64                  0.660000
560:65              Branch: Break
570:68          add second child into first child ( temp 4-component vector of float)
580:68            'color' ( temp 4-component vector of float)
590:68            Constant:
600:68              0.330000
610:68              0.330000
620:68              0.330000
630:68              0.330000
640:69          Branch: Break
650:73      Loop with condition tested first
660:73        Loop Condition
670:73        Compare Less Than ( temp bool)
680:73          direct index ( temp float)
690:73            'color' ( temp 4-component vector of float)
700:73            Constant:
710:73              0 (const int)
720:73          'd' ( uniform float)
730:73        Loop Body
740:74        Sequence
750:74          add second child into first child ( temp 4-component vector of float)
760:74            'color' ( temp 4-component vector of float)
770:74            'bigColor' ( uniform 4-component vector of float)
780:78      Loop with condition tested first
790:78        Loop Condition
800:78        Compare Less Than ( temp bool)
810:78          direct index ( temp float)
820:78            'color' ( temp 4-component vector of float)
830:78            Constant:
840:78              2 (const int)
850:78          'd' ( uniform float)
860:78        Loop Body
870:79        Sequence
880:79          add second child into first child ( temp 4-component vector of float)
890:79            'color' ( temp 4-component vector of float)
900:79            'bigColor1_1' ( uniform 4-component vector of float)
910:80          Test condition and select ( temp void)
920:80            Condition
930:80            Compare Less Than ( temp bool)
940:80              direct index ( temp float)
950:80                'color' ( temp 4-component vector of float)
960:80                Constant:
970:80                  3 (const int)
980:80              'd' ( uniform float)
990:80            true case
1000:81            Branch: Continue
1010:83          add second child into first child ( temp 4-component vector of float)
1020:83            'color' ( temp 4-component vector of float)
1030:83            'bigColor1_1' ( uniform 4-component vector of float)
1040:87      Loop with condition tested first
1050:87        Loop Condition
1060:87        Compare Less Than ( temp bool)
1070:87          direct index ( temp float)
1080:87            'color' ( temp 4-component vector of float)
1090:87            Constant:
1100:87              0 (const int)
1110:87          Constant:
1120:87            42.000000
1130:87        Loop Body
1140:88        Sequence
1150:88          Pre-Increment ( temp 4-component vector of float)
1160:88            'color' ( temp 4-component vector of float)
1170:92      Loop with condition tested first
1180:92        Loop Condition
1190:92        logical-and ( temp bool)
1200:92          Compare Less Than ( temp bool)
1210:92            direct index ( temp float)
1220:92              'color' ( temp 4-component vector of float)
1230:92              Constant:
1240:92                3 (const int)
1250:92            'd2' ( uniform float)
1260:92          Compare Less Than ( temp bool)
1270:92            direct index ( temp float)
1280:92              'color' ( temp 4-component vector of float)
1290:92              Constant:
1300:92                1 (const int)
1310:92            'd3' ( uniform float)
1320:92        Loop Body
1330:93        Sequence
1340:93          add second child into first child ( temp 4-component vector of float)
1350:93            'color' ( temp 4-component vector of float)
1360:93            'bigColor1_2' ( uniform 4-component vector of float)
1370:97      Loop with condition tested first
1380:97        Loop Condition
1390:97        Compare Less Than ( temp bool)
1400:97          direct index ( temp float)
1410:97            'color' ( temp 4-component vector of float)
1420:97            Constant:
1430:97              2 (const int)
1440:97          'd3' ( uniform float)
1450:97        Loop Body
1460:98        Sequence
1470:98          add second child into first child ( temp 4-component vector of float)
1480:98            'color' ( temp 4-component vector of float)
1490:98            'bigColor1_3' ( uniform 4-component vector of float)
1500:99          Test condition and select ( temp void)
1510:99            Condition
1520:99            Compare Less Than ( temp bool)
1530:99              direct index ( temp float)
1540:99                'color' ( temp 4-component vector of float)
1550:99                Constant:
1560:99                  1 (const int)
1570:99              'd4' ( uniform float)
1580:99            true case
1590:100            Branch: Break
1600:101          add second child into first child ( temp 4-component vector of float)
1610:101            'color' ( temp 4-component vector of float)
1620:101            'bigColor1_3' ( uniform 4-component vector of float)
1630:105      Sequence
1640:105        Sequence
1650:105          move second child to first child ( temp int)
1660:105            'i' ( temp int)
1670:105            Constant:
1680:105              0 (const int)
1690:105        Loop with condition tested first
1700:105          Loop Condition
1710:105          Compare Less Than ( temp bool)
1720:105            'i' ( temp int)
1730:105            'Count' ( uniform int)
1740:105          Loop Body
1750:106          Sequence
1760:106            add second child into first child ( temp 4-component vector of float)
1770:106              'color' ( temp 4-component vector of float)
1780:106              'bigColor2' ( uniform 4-component vector of float)
1790:105          Loop Terminal Expression
1800:105          Pre-Increment ( temp int)
1810:105            'i' ( temp int)
1820:112      Loop with condition not tested first
1830:112        Loop Condition
1840:112        Compare Less Than ( temp bool)
1850:112          direct index ( temp float)
1860:112            'color' ( temp 4-component vector of float)
1870:112            Constant:
1880:112              0 (const int)
1890:112          'd2' ( uniform float)
1900:112        Loop Body
1910:111        Sequence
1920:111          add second child into first child ( temp 4-component vector of float)
1930:111            'color' ( temp 4-component vector of float)
1940:111            'bigColor3' ( uniform 4-component vector of float)
1950:115      Sequence
1960:115        Sequence
1970:115          move second child to first child ( temp int)
1980:115            'i' ( temp int)
1990:115            Constant:
2000:115              0 (const int)
2010:115        Loop with condition tested first
2020:115          Loop Condition
2030:115          Compare Less Than ( temp bool)
2040:115            'i' ( temp int)
2050:115            Constant:
2060:115              42 (const int)
2070:115          Loop Body
2080:116          Sequence
2090:116            add second child into first child ( temp float)
2100:116              direct index ( temp float)
2110:116                'color' ( temp 4-component vector of float)
2120:116                Constant:
2130:116                  2 (const int)
2140:116              'd3' ( uniform float)
2150:115          Loop Terminal Expression
2160:115          Pre-Increment ( temp int)
2170:115            'i' ( temp int)
2180:120      Sequence
2190:120        Sequence
2200:120          move second child to first child ( temp int)
2210:120            'i' ( temp int)
2220:120            Constant:
2230:120              0 (const int)
2240:120        Loop with condition tested first
2250:120          Loop Condition
2260:120          Compare Less Than ( temp bool)
2270:120            'i' ( temp int)
2280:120            Constant:
2290:120              100 (const int)
2300:120          Loop Body
2310:121          Sequence
2320:121            Test condition and select ( temp void)
2330:121              Condition
2340:121              Compare Less Than ( temp bool)
2350:121                direct index ( temp float)
2360:121                  'color' ( temp 4-component vector of float)
2370:121                  Constant:
2380:121                    2 (const int)
2390:121                Constant:
2400:121                  20.000000
2410:121              true case
2420:122              Post-Increment ( temp float)
2430:122                direct index ( temp float)
2440:122                  'color' ( temp 4-component vector of float)
2450:122                  Constant:
2460:122                    0 (const int)
2470:121              false case
2480:124              Post-Increment ( temp float)
2490:124                direct index ( temp float)
2500:124                  'color' ( temp 4-component vector of float)
2510:124                  Constant:
2520:124                    1 (const int)
2530:125            Test condition and select ( temp void)
2540:125              Condition
2550:125              Compare Less Than ( temp bool)
2560:125                direct index ( temp float)
2570:125                  'color' ( temp 4-component vector of float)
2580:125                  Constant:
2590:125                    3 (const int)
2600:125                Constant:
2610:125                  20.000000
2620:125              true case
2630:126              Test condition and select ( temp void)
2640:126                Condition
2650:126                Compare Greater Than ( temp bool)
2660:126                  direct index ( temp float)
2670:126                    'color' ( temp 4-component vector of float)
2680:126                    Constant:
2690:126                      2 (const int)
2700:126                  direct index ( temp float)
2710:126                    'color' ( temp 4-component vector of float)
2720:126                    Constant:
2730:126                      1 (const int)
2740:126                true case
2750:127                Constant:
2760:127                  0 (const int)
2770:120          Loop Terminal Expression
2780:120          Pre-Increment ( temp int)
2790:120            'i' ( temp int)
2800:131      Sequence
2810:131        Sequence
2820:131          move second child to first child ( temp int)
2830:131            'i' ( temp int)
2840:131            Constant:
2850:131              0 (const int)
2860:131        Loop with condition tested first
2870:131          Loop Condition
2880:131          Compare Less Than ( temp bool)
2890:131            'i' ( temp int)
2900:131            Constant:
2910:131              120 (const int)
2920:131          Loop Body
2930:132          Sequence
2940:132            Test condition and select ( temp void)
2950:132              Condition
2960:132              Compare Less Than ( temp bool)
2970:132                direct index ( temp float)
2980:132                  'color' ( temp 4-component vector of float)
2990:132                  Constant:
3000:132                    2 (const int)
3010:132                Constant:
3020:132                  20.000000
3030:132              true case
3040:133              Post-Increment ( temp float)
3050:133                direct index ( temp float)
3060:133                  'color' ( temp 4-component vector of float)
3070:133                  Constant:
3080:133                    0 (const int)
3090:132              false case
3100:135              Post-Increment ( temp float)
3110:135                direct index ( temp float)
3120:135                  'color' ( temp 4-component vector of float)
3130:135                  Constant:
3140:135                    1 (const int)
3150:131          Loop Terminal Expression
3160:131          Pre-Increment ( temp int)
3170:131            'i' ( temp int)
3180:139      Sequence
3190:139        Sequence
3200:139          move second child to first child ( temp int)
3210:139            'i' ( temp int)
3220:139            Constant:
3230:139              0 (const int)
3240:139        Loop with condition tested first
3250:139          Loop Condition
3260:139          Compare Less Than ( temp bool)
3270:139            'i' ( temp int)
3280:139            Constant:
3290:139              42 (const int)
3300:139          Loop Body
3310:140          Sequence
3320:140            add second child into first child ( temp float)
3330:140              direct index ( temp float)
3340:140                'color' ( temp 4-component vector of float)
3350:140                Constant:
3360:140                  2 (const int)
3370:140              'd3' ( uniform float)
3380:141            Test condition and select ( temp void)
3390:141              Condition
3400:141              Compare Less Than ( temp bool)
3410:141                direct index ( temp float)
3420:141                  'color' ( temp 4-component vector of float)
3430:141                  Constant:
3440:141                    0 (const int)
3450:141                'd4' ( uniform float)
3460:141              true case
3470:142              Branch: Continue
3480:143            Pre-Increment ( temp float)
3490:143              direct index ( temp float)
3500:143                'color' ( temp 4-component vector of float)
3510:143                Constant:
3520:143                  3 (const int)
3530:139          Loop Terminal Expression
3540:139          Pre-Increment ( temp int)
3550:139            'i' ( temp int)
3560:147      Sequence
3570:147        Sequence
3580:147          move second child to first child ( temp int)
3590:147            'i' ( temp int)
3600:147            Constant:
3610:147              0 (const int)
3620:147        Loop with condition tested first
3630:147          Loop Condition
3640:147          Compare Less Than ( temp bool)
3650:147            'i' ( temp int)
3660:147            Constant:
3670:147              42 (const int)
3680:147          Loop Body
3690:148          Sequence
3700:148            add second child into first child ( temp float)
3710:148              direct index ( temp float)
3720:148                'color' ( temp 4-component vector of float)
3730:148                Constant:
3740:148                  2 (const int)
3750:148              'd3' ( uniform float)
3760:149            Test condition and select ( temp void)
3770:149              Condition
3780:149              Compare Less Than ( temp bool)
3790:149                direct index ( temp float)
3800:149                  'color' ( temp 4-component vector of float)
3810:149                  Constant:
3820:149                    0 (const int)
3830:149                'd4' ( uniform float)
3840:149              true case
3850:150              Branch: Break
3860:151            Pre-Increment ( temp float)
3870:151              direct index ( temp float)
3880:151                'color' ( temp 4-component vector of float)
3890:151                Constant:
3900:151                  3 (const int)
3910:147          Loop Terminal Expression
3920:147          Pre-Increment ( temp int)
3930:147            'i' ( temp int)
3940:163      Loop with condition not tested first
3950:163        Loop Condition
3960:163        Compare Less Than ( temp bool)
3970:163          direct index ( temp float)
3980:163            'color' ( temp 4-component vector of float)
3990:163            Constant:
4000:163              2 (const int)
4010:163          'd4' ( uniform float)
4020:163        Loop Body
4030:156        Sequence
4040:156          add second child into first child ( temp 4-component vector of float)
4050:156            'color' ( temp 4-component vector of float)
4060:156            'bigColor4' ( uniform 4-component vector of float)
4070:157          Test condition and select ( temp void)
4080:157            Condition
4090:157            Compare Less Than ( temp bool)
4100:157              direct index ( temp float)
4110:157                'color' ( temp 4-component vector of float)
4120:157                Constant:
4130:157                  0 (const int)
4140:157              'd4' ( uniform float)
4150:157            true case
4160:158            Branch: Continue
4170:159          Test condition and select ( temp void)
4180:159            Condition
4190:159            Compare Less Than ( temp bool)
4200:159              direct index ( temp float)
4210:159                'color' ( temp 4-component vector of float)
4220:159                Constant:
4230:159                  1 (const int)
4240:159              'd4' ( uniform float)
4250:159            true case
4260:160            add second child into first child ( temp float)
4270:160              direct index ( temp float)
4280:160                'color' ( temp 4-component vector of float)
4290:160                Constant:
4300:160                  1 (const int)
4310:160              'd4' ( uniform float)
4320:159            false case
4330:162            add second child into first child ( temp float)
4340:162              direct index ( temp float)
4350:162                'color' ( temp 4-component vector of float)
4360:162                Constant:
4370:162                  0 (const int)
4380:162              'd4' ( uniform float)
4390:170      Loop with condition not tested first
4400:170        Loop Condition
4410:170        Compare Less Than ( temp bool)
4420:170          direct index ( temp float)
4430:170            'color' ( temp 4-component vector of float)
4440:170            Constant:
4450:170              0 (const int)
4460:170          'd5' ( uniform float)
4470:170        Loop Body
4480:167        Sequence
4490:167          add second child into first child ( temp 4-component vector of float)
4500:167            'color' ( temp 4-component vector of float)
4510:167            'bigColor5' ( uniform 4-component vector of float)
4520:168          Test condition and select ( temp void)
4530:168            Condition
4540:168            Compare Less Than ( temp bool)
4550:168              direct index ( temp float)
4560:168                'color' ( temp 4-component vector of float)
4570:168                Constant:
4580:168                  1 (const int)
4590:168              'd5' ( uniform float)
4600:168            true case
4610:169            add second child into first child ( temp float)
4620:169              direct index ( temp float)
4630:169                'color' ( temp 4-component vector of float)
4640:169                Constant:
4650:169                  1 (const int)
4660:169              'd5' ( uniform float)
4670:173      Test condition and select ( temp void)
4680:173        Condition
4690:173        Compare Less Than ( temp bool)
4700:173          direct index ( temp float)
4710:173            'color' ( temp 4-component vector of float)
4720:173            Constant:
4730:173              0 (const int)
4740:173          'd6' ( uniform float)
4750:173        true case
4760:174        Sequence
4770:174          Loop with condition tested first
4780:174            Loop Condition
4790:174            Compare Less Than ( temp bool)
4800:174              direct index ( temp float)
4810:174                'color' ( temp 4-component vector of float)
4820:174                Constant:
4830:174                  1 (const int)
4840:174              'd6' ( uniform float)
4850:174            Loop Body
4860:175            add second child into first child ( temp 4-component vector of float)
4870:175              'color' ( temp 4-component vector of float)
4880:175              'bigColor6' ( uniform 4-component vector of float)
4890:173        false case
4900:177        Sequence
4910:177          Loop with condition tested first
4920:177            Loop Condition
4930:177            Compare Less Than ( temp bool)
4940:177              direct index ( temp float)
4950:177                'color' ( temp 4-component vector of float)
4960:177                Constant:
4970:177                  2 (const int)
4980:177              'd6' ( uniform float)
4990:177            Loop Body
5000:178            add second child into first child ( temp float)
5010:178              direct index ( temp float)
5020:178                'color' ( temp 4-component vector of float)
5030:178                Constant:
5040:178                  2 (const int)
5050:178              direct index ( temp float)
5060:178                'bigColor6' ( uniform 4-component vector of float)
5070:178                Constant:
5080:178                  2 (const int)
5090:182      Test condition and select ( temp void)
5100:182        Condition
5110:182        Compare Less Than ( temp bool)
5120:182          direct index ( temp float)
5130:182            'color' ( temp 4-component vector of float)
5140:182            Constant:
5150:182              0 (const int)
5160:182          'd6' ( uniform float)
5170:182        true case
5180:183        Sequence
5190:183          Loop with condition tested first
5200:183            Loop Condition
5210:183            Compare Less Than ( temp bool)
5220:183              direct index ( temp float)
5230:183                'color' ( temp 4-component vector of float)
5240:183                Constant:
5250:183                  1 (const int)
5260:183              'd6' ( uniform float)
5270:183            Loop Body
5280:184            Sequence
5290:184              add second child into first child ( temp 4-component vector of float)
5300:184                'color' ( temp 4-component vector of float)
5310:184                'bigColor6' ( uniform 4-component vector of float)
5320:185              Test condition and select ( temp void)
5330:185                Condition
5340:185                Compare Less Than ( temp bool)
5350:185                  'd7' ( uniform float)
5360:185                  Constant:
5370:185                    1.000000
5380:185                true case
5390:186                Branch: Break
5400:182        false case
5410:190        Sequence
5420:190          Loop with condition tested first
5430:190            Loop Condition
5440:190            Compare Less Than ( temp bool)
5450:190              direct index ( temp float)
5460:190                'color' ( temp 4-component vector of float)
5470:190                Constant:
5480:190                  2 (const int)
5490:190              'd6' ( uniform float)
5500:190            Loop Body
5510:191            add second child into first child ( temp float)
5520:191              direct index ( temp float)
5530:191                'color' ( temp 4-component vector of float)
5540:191                Constant:
5550:191                  2 (const int)
5560:191              direct index ( temp float)
5570:191                'bigColor6' ( uniform 4-component vector of float)
5580:191                Constant:
5590:191                  2 (const int)
5600:209      Loop with condition not tested first
5610:209        Loop Condition
5620:209        Constant:
5630:209          true (const bool)
5640:209        Loop Body
5650:197        Sequence
5660:197          Test condition and select ( temp void)
5670:197            Condition
5680:197            Compare Less Than ( temp bool)
5690:197              'd7' ( uniform float)
5700:197              Constant:
5710:197                0.000000
5720:197            true case
5730:198            Branch: Break
5740:200          add second child into first child ( temp 4-component vector of float)
5750:200            'color' ( temp 4-component vector of float)
5760:200            'bigColor7' ( uniform 4-component vector of float)
5770:202          Test condition and select ( temp void)
5780:202            Condition
5790:202            Compare Less Than ( temp bool)
5800:202              'd7' ( uniform float)
5810:202              Constant:
5820:202                1.000000
5830:202            true case
5840:203            Sequence
5850:203              Post-Increment ( temp float)
5860:203                direct index ( temp float)
5870:203                  'color' ( temp 4-component vector of float)
5880:203                  Constant:
5890:203                    2 (const int)
5900:204              Branch: Break
5910:207          add second child into first child ( temp 4-component vector of float)
5920:207            'color' ( temp 4-component vector of float)
5930:207            'BaseColor' ( smooth in 4-component vector of float)
5940:234      Loop with condition not tested first
5950:234        Loop Condition
5960:234        Compare Less Than ( temp bool)
5970:234          direct index ( temp float)
5980:234            'color' ( temp 4-component vector of float)
5990:234            Constant:
6000:234              2 (const int)
6010:234          'd8' ( uniform float)
6020:234        Loop Body
6030:217        Sequence
6040:217          Test condition and select ( temp void)
6050:217            Condition
6060:217            Compare Less Than ( temp bool)
6070:217              'd8' ( uniform float)
6080:217              Constant:
6090:217                0.000000
6100:217            true case
6110:218            Branch: Break
6120:220          add second child into first child ( temp 4-component vector of float)
6130:220            'color' ( temp 4-component vector of float)
6140:220            'bigColor7' ( uniform 4-component vector of float)
6150:222          Test condition and select ( temp void)
6160:222            Condition
6170:222            Compare Less Than ( temp bool)
6180:222              'd8' ( uniform float)
6190:222              Constant:
6200:222                1.000000
6210:222            true case
6220:223            Sequence
6230:223              Post-Increment ( temp float)
6240:223                direct index ( temp float)
6250:223                  'color' ( temp 4-component vector of float)
6260:223                  Constant:
6270:223                    2 (const int)
6280:224              Test condition and select ( temp void)
6290:224                Condition
6300:224                Compare Less Than ( temp bool)
6310:224                  'd8' ( uniform float)
6320:224                  Constant:
6330:224                    2.000000
6340:224                true case
6350:225                Sequence
6360:225                  Post-Increment ( temp float)
6370:225                    direct index ( temp float)
6380:225                      'color' ( temp 4-component vector of float)
6390:225                      Constant:
6400:225                        1 (const int)
6410:224                false case
6420:227                Sequence
6430:227                  Post-Increment ( temp float)
6440:227                    direct index ( temp float)
6450:227                      'color' ( temp 4-component vector of float)
6460:227                      Constant:
6470:227                        0 (const int)
6480:229              Branch: Break
6490:232          add second child into first child ( temp 4-component vector of float)
6500:232            'color' ( temp 4-component vector of float)
6510:232            'BaseColor' ( smooth in 4-component vector of float)
6520:237      Loop with condition tested first
6530:237        Loop Condition
6540:237        Compare Less Than ( temp bool)
6550:237          direct index ( temp float)
6560:237            'color' ( temp 4-component vector of float)
6570:237            Constant:
6580:237              3 (const int)
6590:237          'd9' ( uniform float)
6600:237        Loop Body
6610:238        Sequence
6620:238          Test condition and select ( temp void)
6630:238            Condition
6640:238            Compare Greater Than ( temp bool)
6650:238              'd9' ( uniform float)
6660:238              'd8' ( uniform float)
6670:238            true case
6680:239            Sequence
6690:239              Test condition and select ( temp void)
6700:239                Condition
6710:239                Compare Less Than or Equal ( temp bool)
6720:239                  direct index ( temp float)
6730:239                    'color' ( temp 4-component vector of float)
6740:239                    Constant:
6750:239                      0 (const int)
6760:239                  'd7' ( uniform float)
6770:239                true case
6780:240                Sequence
6790:240                  Test condition and select ( temp void)
6800:240                    Condition
6810:240                    Compare Equal ( temp bool)
6820:240                      direct index ( temp float)
6830:240                        'color' ( temp 4-component vector of float)
6840:240                        Constant:
6850:240                          2 (const int)
6860:240                      Constant:
6870:240                        5.000000
6880:240                    true case
6890:241                    Post-Increment ( temp float)
6900:241                      direct index ( temp float)
6910:241                        'color' ( temp 4-component vector of float)
6920:241                        Constant:
6930:241                          3 (const int)
6940:240                    false case
6950:243                    Branch: Break
6960:250      Loop with condition tested first
6970:250        Loop Condition
6980:250        Compare Less Than ( temp bool)
6990:250          direct index ( temp float)
7000:250            'color' ( temp 4-component vector of float)
7010:250            Constant:
7020:250              2 (const int)
7030:250          'd10' ( uniform float)
7040:250        Loop Body
7050:251        Sequence
7060:251          Post-Increment ( temp float)
7070:251            direct index ( temp float)
7080:251              'color' ( temp 4-component vector of float)
7090:251              Constant:
7100:251                1 (const int)
7110:252          Test condition and select ( temp void)
7120:252            Condition
7130:252            Compare Less Than ( temp bool)
7140:252              direct index ( temp float)
7150:252                'color' ( temp 4-component vector of float)
7160:252                Constant:
7170:252                  1 (const int)
7180:252              'd11' ( uniform float)
7190:252            true case
7200:253            Sequence
7210:253              Post-Increment ( temp float)
7220:253                direct index ( temp float)
7230:253                  'color' ( temp 4-component vector of float)
7240:253                  Constant:
7250:253                    2 (const int)
7260:254              Test condition and select ( temp void)
7270:254                Condition
7280:254                Compare Less Than ( temp bool)
7290:254                  direct index ( temp float)
7300:254                    'color' ( temp 4-component vector of float)
7310:254                    Constant:
7320:254                      3 (const int)
7330:254                  'd12' ( uniform float)
7340:254                true case
7350:255                Post-Increment ( temp float)
7360:255                  direct index ( temp float)
7370:255                    'color' ( temp 4-component vector of float)
7380:255                    Constant:
7390:255                      3 (const int)
7400:254                false case
7410:257                Post-Increment ( temp float)
7420:257                  direct index ( temp float)
7430:257                    'color' ( temp 4-component vector of float)
7440:257                    Constant:
7450:257                      0 (const int)
7460:258              Branch: Continue
7470:261          Post-Increment ( temp 4-component vector of float)
7480:261            'color' ( temp 4-component vector of float)
7490:262          Branch: Break
7500:266      Loop with condition tested first
7510:266        Loop Condition
7520:266        Compare Less Than ( temp bool)
7530:266          direct index ( temp float)
7540:266            'color' ( temp 4-component vector of float)
7550:266            Constant:
7560:266              0 (const int)
7570:266          Constant:
7580:266            10.000000
7590:266        Loop Body
7600:267        Sequence
7610:267          add second child into first child ( temp 4-component vector of float)
7620:267            'color' ( temp 4-component vector of float)
7630:267            'bigColor8' ( uniform 4-component vector of float)
7640:269          Test condition and select ( temp void)
7650:269            Condition
7660:269            Compare Less Than ( temp bool)
7670:269              direct index ( temp float)
7680:269                'color' ( temp 4-component vector of float)
7690:269                Constant:
7700:269                  2 (const int)
7710:269              'd8' ( uniform float)
7720:269            true case
7730:270            Test condition and select ( temp void)
7740:270              Condition
7750:270              Compare Less Than ( temp bool)
7760:270                direct index ( temp float)
7770:270                  'color' ( temp 4-component vector of float)
7780:270                  Constant:
7790:270                    3 (const int)
7800:270                'd6' ( uniform float)
7810:270              true case
7820:271              Branch: Continue
7830:273          add second child into first child ( temp float)
7840:273            direct index ( temp float)
7850:273              'color' ( temp 4-component vector of float)
7860:273              Constant:
7870:273                1 (const int)
7880:273            direct index ( temp float)
7890:273              'bigColor8' ( uniform 4-component vector of float)
7900:273              Constant:
7910:273                0 (const int)
7920:276      Post-Increment ( temp 4-component vector of float)
7930:276        'color' ( temp 4-component vector of float)
7940:277      move second child to first child ( temp 4-component vector of float)
7950:277        'gl_FragColor' ( fragColor 4-component vector of float FragColor)
7960:277        'color' ( temp 4-component vector of float)
7970:280      Loop with condition tested first
7980:280        Loop Condition
7990:280        Compare Less Than ( temp bool)
8000:280          direct index ( temp float)
8010:280            'color' ( temp 4-component vector of float)
8020:280            Constant:
8030:280              0 (const int)
8040:280          'd14' ( uniform float)
8050:280        Loop Body
8060:281        Sequence
8070:281          Test condition and select ( temp void)
8080:281            Condition
8090:281            Compare Less Than ( temp bool)
8100:281              direct index ( temp float)
8110:281                'color' ( temp 4-component vector of float)
8120:281                Constant:
8130:281                  1 (const int)
8140:281              'd15' ( uniform float)
8150:281            true case
8160:282            Sequence
8170:282              Branch: Return
8180:281            false case
8190:285            Post-Increment ( temp 4-component vector of float)
8200:285              'color' ( temp 4-component vector of float)
8210:288      Post-Increment ( temp 4-component vector of float)
8220:288        'color' ( temp 4-component vector of float)
8230:290      Loop with condition tested first
8240:290        Loop Condition
8250:290        Compare Less Than ( temp bool)
8260:290          direct index ( temp float)
8270:290            'color' ( temp 4-component vector of float)
8280:290            Constant:
8290:290              3 (const int)
8300:290          'd16' ( uniform float)
8310:290        Loop Body
8320:291        Sequence
8330:291          Post-Increment ( temp float)
8340:291            direct index ( temp float)
8350:291              'color' ( temp 4-component vector of float)
8360:291              Constant:
8370:291                3 (const int)
8380:296      Loop with condition tested first
8390:296        Loop Condition
8400:296        logical-and ( temp bool)
8410:296          Compare Less Than ( temp bool)
8420:296            direct index ( temp float)
8430:296              'color' ( temp 4-component vector of float)
8440:296              Constant:
8450:296                3 (const int)
8460:296            'd2' ( uniform float)
8470:296          Compare Less Than ( temp bool)
8480:296            direct index ( temp float)
8490:296              'color' ( temp 4-component vector of float)
8500:296              Constant:
8510:296                1 (const int)
8520:296            'd3' ( uniform float)
8530:296        Loop Body
8540:297        Sequence
8550:297          add second child into first child ( temp 4-component vector of float)
8560:297            'color' ( temp 4-component vector of float)
8570:297            'bigColor1_2' ( uniform 4-component vector of float)
8580:298          Test condition and select ( temp void)
8590:298            Condition
8600:298            Compare Less Than ( temp bool)
8610:298              direct index ( temp float)
8620:298                'color' ( temp 4-component vector of float)
8630:298                Constant:
8640:298                  2 (const int)
8650:298              'd3' ( uniform float)
8660:298            true case
8670:299            Branch: Return
8680:307      Loop with condition not tested first
8690:307        Loop Condition
8700:307        Compare Less Than ( temp bool)
8710:307          direct index ( temp float)
8720:307            'color' ( temp 4-component vector of float)
8730:307            Constant:
8740:307              0 (const int)
8750:307          'd17' ( uniform float)
8760:307        Loop Body
8770:304        Sequence
8780:304          Test condition and select ( temp void)
8790:304            Condition
8800:304            Compare Less Than ( temp bool)
8810:304              direct index ( temp float)
8820:304                'color' ( temp 4-component vector of float)
8830:304                Constant:
8840:304                  1 (const int)
8850:304              'd18' ( uniform float)
8860:304            true case
8870:305            Branch: Return
8880:306          Post-Increment ( temp 4-component vector of float)
8890:306            'color' ( temp 4-component vector of float)
8900:310      Loop with condition tested first
8910:310        Loop Condition
8920:310        Compare Less Than ( temp bool)
8930:310          direct index ( temp float)
8940:310            'color' ( temp 4-component vector of float)
8950:310            Constant:
8960:310              1 (const int)
8970:310          'd16' ( uniform float)
8980:310        Loop Body
8990:311        Sequence
9000:311          Test condition and select ( temp void)
9010:311            Condition
9020:311            Compare Less Than ( temp bool)
9030:311              direct index ( temp float)
9040:311                'color' ( temp 4-component vector of float)
9050:311                Constant:
9060:311                  3 (const int)
9070:311              'd16' ( uniform float)
9080:311            true case
9090:312            Sequence
9100:312              Branch: Kill
9110:311            false case
9120:314            Post-Increment ( temp 4-component vector of float)
9130:314              'color' ( temp 4-component vector of float)
9140:317      Post-Increment ( temp 4-component vector of float)
9150:317        'color' ( temp 4-component vector of float)
9160:319      move second child to first child ( temp 4-component vector of float)
9170:319        'gl_FragColor' ( fragColor 4-component vector of float FragColor)
9180:319        'color' ( temp 4-component vector of float)
9190:?   Linker Objects
9200:?     'bigColor' ( uniform 4-component vector of float)
9210:?     'bigColor1_1' ( uniform 4-component vector of float)
9220:?     'bigColor1_2' ( uniform 4-component vector of float)
9230:?     'bigColor1_3' ( uniform 4-component vector of float)
9240:?     'bigColor2' ( uniform 4-component vector of float)
9250:?     'bigColor3' ( uniform 4-component vector of float)
9260:?     'bigColor4' ( uniform 4-component vector of float)
9270:?     'bigColor5' ( uniform 4-component vector of float)
9280:?     'bigColor6' ( uniform 4-component vector of float)
9290:?     'bigColor7' ( uniform 4-component vector of float)
9300:?     'bigColor8' ( uniform 4-component vector of float)
9310:?     'BaseColor' ( smooth in 4-component vector of float)
9320:?     'd' ( uniform float)
9330:?     'd2' ( uniform float)
9340:?     'd3' ( uniform float)
9350:?     'd4' ( uniform float)
9360:?     'd5' ( uniform float)
9370:?     'd6' ( uniform float)
9380:?     'd7' ( uniform float)
9390:?     'd8' ( uniform float)
9400:?     'd9' ( uniform float)
9410:?     'd10' ( uniform float)
9420:?     'd11' ( uniform float)
9430:?     'd12' ( uniform float)
9440:?     'd13' ( uniform float)
9450:?     'd14' ( uniform float)
9460:?     'd15' ( uniform float)
9470:?     'd16' ( uniform float)
9480:?     'd17' ( uniform float)
9490:?     'd18' ( uniform float)
9500:?     'd19' ( uniform float)
9510:?     'd20' ( uniform float)
9520:?     'd21' ( uniform float)
9530:?     'd22' ( uniform float)
9540:?     'd23' ( uniform float)
9550:?     'd24' ( uniform float)
9560:?     'd25' ( uniform float)
9570:?     'd26' ( uniform float)
9580:?     'd27' ( uniform float)
9590:?     'd28' ( uniform float)
9600:?     'd29' ( uniform float)
9610:?     'd30' ( uniform float)
9620:?     'd31' ( uniform float)
9630:?     'd32' ( uniform float)
9640:?     'd33' ( uniform float)
9650:?     'd34' ( uniform float)
9660:?     'Count' ( uniform int)
967
968
969Linked fragment stage:
970
971
972Shader version: 130
9730:? Sequence
9740:53  Function Definition: main( ( global void)
9750:53    Function Parameters:
9760:55    Sequence
9770:55      Sequence
9780:55        move second child to first child ( temp 4-component vector of float)
9790:55          'color' ( temp 4-component vector of float)
9800:55          'BaseColor' ( smooth in 4-component vector of float)
9810:58      Loop with condition tested first
9820:58        Loop Condition
9830:58        Constant:
9840:58          true (const bool)
9850:58        Loop Body
9860:59        Sequence
9870:59          Test condition and select ( temp void)
9880:59            Condition
9890:59            Compare Less Than ( temp bool)
9900:59              direct index ( temp float)
9910:59                'color' ( temp 4-component vector of float)
9920:59                Constant:
9930:59                  0 (const int)
9940:59              Constant:
9950:59                0.330000
9960:59            true case
9970:60            Sequence
9980:60              add second child into first child ( temp 4-component vector of float)
9990:60                'color' ( temp 4-component vector of float)
10000:60                Constant:
10010:60                  0.330000
10020:60                  0.330000
10030:60                  0.330000
10040:60                  0.330000
10050:61              Branch: Break
10060:63          Test condition and select ( temp void)
10070:63            Condition
10080:63            Compare Less Than ( temp bool)
10090:63              direct index ( temp float)
10100:63                'color' ( temp 4-component vector of float)
10110:63                Constant:
10120:63                  0 (const int)
10130:63              Constant:
10140:63                0.660000
10150:63            true case
10160:64            Sequence
10170:64              add second child into first child ( temp 4-component vector of float)
10180:64                'color' ( temp 4-component vector of float)
10190:64                Constant:
10200:64                  0.660000
10210:64                  0.660000
10220:64                  0.660000
10230:64                  0.660000
10240:65              Branch: Break
10250:68          add second child into first child ( temp 4-component vector of float)
10260:68            'color' ( temp 4-component vector of float)
10270:68            Constant:
10280:68              0.330000
10290:68              0.330000
10300:68              0.330000
10310:68              0.330000
10320:69          Branch: Break
10330:73      Loop with condition tested first
10340:73        Loop Condition
10350:73        Compare Less Than ( temp bool)
10360:73          direct index ( temp float)
10370:73            'color' ( temp 4-component vector of float)
10380:73            Constant:
10390:73              0 (const int)
10400:73          'd' ( uniform float)
10410:73        Loop Body
10420:74        Sequence
10430:74          add second child into first child ( temp 4-component vector of float)
10440:74            'color' ( temp 4-component vector of float)
10450:74            'bigColor' ( uniform 4-component vector of float)
10460:78      Loop with condition tested first
10470:78        Loop Condition
10480:78        Compare Less Than ( temp bool)
10490:78          direct index ( temp float)
10500:78            'color' ( temp 4-component vector of float)
10510:78            Constant:
10520:78              2 (const int)
10530:78          'd' ( uniform float)
10540:78        Loop Body
10550:79        Sequence
10560:79          add second child into first child ( temp 4-component vector of float)
10570:79            'color' ( temp 4-component vector of float)
10580:79            'bigColor1_1' ( uniform 4-component vector of float)
10590:80          Test condition and select ( temp void)
10600:80            Condition
10610:80            Compare Less Than ( temp bool)
10620:80              direct index ( temp float)
10630:80                'color' ( temp 4-component vector of float)
10640:80                Constant:
10650:80                  3 (const int)
10660:80              'd' ( uniform float)
10670:80            true case
10680:81            Branch: Continue
10690:83          add second child into first child ( temp 4-component vector of float)
10700:83            'color' ( temp 4-component vector of float)
10710:83            'bigColor1_1' ( uniform 4-component vector of float)
10720:87      Loop with condition tested first
10730:87        Loop Condition
10740:87        Compare Less Than ( temp bool)
10750:87          direct index ( temp float)
10760:87            'color' ( temp 4-component vector of float)
10770:87            Constant:
10780:87              0 (const int)
10790:87          Constant:
10800:87            42.000000
10810:87        Loop Body
10820:88        Sequence
10830:88          Pre-Increment ( temp 4-component vector of float)
10840:88            'color' ( temp 4-component vector of float)
10850:92      Loop with condition tested first
10860:92        Loop Condition
10870:92        logical-and ( temp bool)
10880:92          Compare Less Than ( temp bool)
10890:92            direct index ( temp float)
10900:92              'color' ( temp 4-component vector of float)
10910:92              Constant:
10920:92                3 (const int)
10930:92            'd2' ( uniform float)
10940:92          Compare Less Than ( temp bool)
10950:92            direct index ( temp float)
10960:92              'color' ( temp 4-component vector of float)
10970:92              Constant:
10980:92                1 (const int)
10990:92            'd3' ( uniform float)
11000:92        Loop Body
11010:93        Sequence
11020:93          add second child into first child ( temp 4-component vector of float)
11030:93            'color' ( temp 4-component vector of float)
11040:93            'bigColor1_2' ( uniform 4-component vector of float)
11050:97      Loop with condition tested first
11060:97        Loop Condition
11070:97        Compare Less Than ( temp bool)
11080:97          direct index ( temp float)
11090:97            'color' ( temp 4-component vector of float)
11100:97            Constant:
11110:97              2 (const int)
11120:97          'd3' ( uniform float)
11130:97        Loop Body
11140:98        Sequence
11150:98          add second child into first child ( temp 4-component vector of float)
11160:98            'color' ( temp 4-component vector of float)
11170:98            'bigColor1_3' ( uniform 4-component vector of float)
11180:99          Test condition and select ( temp void)
11190:99            Condition
11200:99            Compare Less Than ( temp bool)
11210:99              direct index ( temp float)
11220:99                'color' ( temp 4-component vector of float)
11230:99                Constant:
11240:99                  1 (const int)
11250:99              'd4' ( uniform float)
11260:99            true case
11270:100            Branch: Break
11280:101          add second child into first child ( temp 4-component vector of float)
11290:101            'color' ( temp 4-component vector of float)
11300:101            'bigColor1_3' ( uniform 4-component vector of float)
11310:105      Sequence
11320:105        Sequence
11330:105          move second child to first child ( temp int)
11340:105            'i' ( temp int)
11350:105            Constant:
11360:105              0 (const int)
11370:105        Loop with condition tested first
11380:105          Loop Condition
11390:105          Compare Less Than ( temp bool)
11400:105            'i' ( temp int)
11410:105            'Count' ( uniform int)
11420:105          Loop Body
11430:106          Sequence
11440:106            add second child into first child ( temp 4-component vector of float)
11450:106              'color' ( temp 4-component vector of float)
11460:106              'bigColor2' ( uniform 4-component vector of float)
11470:105          Loop Terminal Expression
11480:105          Pre-Increment ( temp int)
11490:105            'i' ( temp int)
11500:112      Loop with condition not tested first
11510:112        Loop Condition
11520:112        Compare Less Than ( temp bool)
11530:112          direct index ( temp float)
11540:112            'color' ( temp 4-component vector of float)
11550:112            Constant:
11560:112              0 (const int)
11570:112          'd2' ( uniform float)
11580:112        Loop Body
11590:111        Sequence
11600:111          add second child into first child ( temp 4-component vector of float)
11610:111            'color' ( temp 4-component vector of float)
11620:111            'bigColor3' ( uniform 4-component vector of float)
11630:115      Sequence
11640:115        Sequence
11650:115          move second child to first child ( temp int)
11660:115            'i' ( temp int)
11670:115            Constant:
11680:115              0 (const int)
11690:115        Loop with condition tested first
11700:115          Loop Condition
11710:115          Compare Less Than ( temp bool)
11720:115            'i' ( temp int)
11730:115            Constant:
11740:115              42 (const int)
11750:115          Loop Body
11760:116          Sequence
11770:116            add second child into first child ( temp float)
11780:116              direct index ( temp float)
11790:116                'color' ( temp 4-component vector of float)
11800:116                Constant:
11810:116                  2 (const int)
11820:116              'd3' ( uniform float)
11830:115          Loop Terminal Expression
11840:115          Pre-Increment ( temp int)
11850:115            'i' ( temp int)
11860:120      Sequence
11870:120        Sequence
11880:120          move second child to first child ( temp int)
11890:120            'i' ( temp int)
11900:120            Constant:
11910:120              0 (const int)
11920:120        Loop with condition tested first
11930:120          Loop Condition
11940:120          Compare Less Than ( temp bool)
11950:120            'i' ( temp int)
11960:120            Constant:
11970:120              100 (const int)
11980:120          Loop Body
11990:121          Sequence
12000:121            Test condition and select ( temp void)
12010:121              Condition
12020:121              Compare Less Than ( temp bool)
12030:121                direct index ( temp float)
12040:121                  'color' ( temp 4-component vector of float)
12050:121                  Constant:
12060:121                    2 (const int)
12070:121                Constant:
12080:121                  20.000000
12090:121              true case
12100:122              Post-Increment ( temp float)
12110:122                direct index ( temp float)
12120:122                  'color' ( temp 4-component vector of float)
12130:122                  Constant:
12140:122                    0 (const int)
12150:121              false case
12160:124              Post-Increment ( temp float)
12170:124                direct index ( temp float)
12180:124                  'color' ( temp 4-component vector of float)
12190:124                  Constant:
12200:124                    1 (const int)
12210:125            Test condition and select ( temp void)
12220:125              Condition
12230:125              Compare Less Than ( temp bool)
12240:125                direct index ( temp float)
12250:125                  'color' ( temp 4-component vector of float)
12260:125                  Constant:
12270:125                    3 (const int)
12280:125                Constant:
12290:125                  20.000000
12300:125              true case
12310:126              Test condition and select ( temp void)
12320:126                Condition
12330:126                Compare Greater Than ( temp bool)
12340:126                  direct index ( temp float)
12350:126                    'color' ( temp 4-component vector of float)
12360:126                    Constant:
12370:126                      2 (const int)
12380:126                  direct index ( temp float)
12390:126                    'color' ( temp 4-component vector of float)
12400:126                    Constant:
12410:126                      1 (const int)
12420:126                true case
12430:127                Constant:
12440:127                  0 (const int)
12450:120          Loop Terminal Expression
12460:120          Pre-Increment ( temp int)
12470:120            'i' ( temp int)
12480:131      Sequence
12490:131        Sequence
12500:131          move second child to first child ( temp int)
12510:131            'i' ( temp int)
12520:131            Constant:
12530:131              0 (const int)
12540:131        Loop with condition tested first
12550:131          Loop Condition
12560:131          Compare Less Than ( temp bool)
12570:131            'i' ( temp int)
12580:131            Constant:
12590:131              120 (const int)
12600:131          Loop Body
12610:132          Sequence
12620:132            Test condition and select ( temp void)
12630:132              Condition
12640:132              Compare Less Than ( temp bool)
12650:132                direct index ( temp float)
12660:132                  'color' ( temp 4-component vector of float)
12670:132                  Constant:
12680:132                    2 (const int)
12690:132                Constant:
12700:132                  20.000000
12710:132              true case
12720:133              Post-Increment ( temp float)
12730:133                direct index ( temp float)
12740:133                  'color' ( temp 4-component vector of float)
12750:133                  Constant:
12760:133                    0 (const int)
12770:132              false case
12780:135              Post-Increment ( temp float)
12790:135                direct index ( temp float)
12800:135                  'color' ( temp 4-component vector of float)
12810:135                  Constant:
12820:135                    1 (const int)
12830:131          Loop Terminal Expression
12840:131          Pre-Increment ( temp int)
12850:131            'i' ( temp int)
12860:139      Sequence
12870:139        Sequence
12880:139          move second child to first child ( temp int)
12890:139            'i' ( temp int)
12900:139            Constant:
12910:139              0 (const int)
12920:139        Loop with condition tested first
12930:139          Loop Condition
12940:139          Compare Less Than ( temp bool)
12950:139            'i' ( temp int)
12960:139            Constant:
12970:139              42 (const int)
12980:139          Loop Body
12990:140          Sequence
13000:140            add second child into first child ( temp float)
13010:140              direct index ( temp float)
13020:140                'color' ( temp 4-component vector of float)
13030:140                Constant:
13040:140                  2 (const int)
13050:140              'd3' ( uniform float)
13060:141            Test condition and select ( temp void)
13070:141              Condition
13080:141              Compare Less Than ( temp bool)
13090:141                direct index ( temp float)
13100:141                  'color' ( temp 4-component vector of float)
13110:141                  Constant:
13120:141                    0 (const int)
13130:141                'd4' ( uniform float)
13140:141              true case
13150:142              Branch: Continue
13160:143            Pre-Increment ( temp float)
13170:143              direct index ( temp float)
13180:143                'color' ( temp 4-component vector of float)
13190:143                Constant:
13200:143                  3 (const int)
13210:139          Loop Terminal Expression
13220:139          Pre-Increment ( temp int)
13230:139            'i' ( temp int)
13240:147      Sequence
13250:147        Sequence
13260:147          move second child to first child ( temp int)
13270:147            'i' ( temp int)
13280:147            Constant:
13290:147              0 (const int)
13300:147        Loop with condition tested first
13310:147          Loop Condition
13320:147          Compare Less Than ( temp bool)
13330:147            'i' ( temp int)
13340:147            Constant:
13350:147              42 (const int)
13360:147          Loop Body
13370:148          Sequence
13380:148            add second child into first child ( temp float)
13390:148              direct index ( temp float)
13400:148                'color' ( temp 4-component vector of float)
13410:148                Constant:
13420:148                  2 (const int)
13430:148              'd3' ( uniform float)
13440:149            Test condition and select ( temp void)
13450:149              Condition
13460:149              Compare Less Than ( temp bool)
13470:149                direct index ( temp float)
13480:149                  'color' ( temp 4-component vector of float)
13490:149                  Constant:
13500:149                    0 (const int)
13510:149                'd4' ( uniform float)
13520:149              true case
13530:150              Branch: Break
13540:151            Pre-Increment ( temp float)
13550:151              direct index ( temp float)
13560:151                'color' ( temp 4-component vector of float)
13570:151                Constant:
13580:151                  3 (const int)
13590:147          Loop Terminal Expression
13600:147          Pre-Increment ( temp int)
13610:147            'i' ( temp int)
13620:163      Loop with condition not tested first
13630:163        Loop Condition
13640:163        Compare Less Than ( temp bool)
13650:163          direct index ( temp float)
13660:163            'color' ( temp 4-component vector of float)
13670:163            Constant:
13680:163              2 (const int)
13690:163          'd4' ( uniform float)
13700:163        Loop Body
13710:156        Sequence
13720:156          add second child into first child ( temp 4-component vector of float)
13730:156            'color' ( temp 4-component vector of float)
13740:156            'bigColor4' ( uniform 4-component vector of float)
13750:157          Test condition and select ( temp void)
13760:157            Condition
13770:157            Compare Less Than ( temp bool)
13780:157              direct index ( temp float)
13790:157                'color' ( temp 4-component vector of float)
13800:157                Constant:
13810:157                  0 (const int)
13820:157              'd4' ( uniform float)
13830:157            true case
13840:158            Branch: Continue
13850:159          Test condition and select ( temp void)
13860:159            Condition
13870:159            Compare Less Than ( temp bool)
13880:159              direct index ( temp float)
13890:159                'color' ( temp 4-component vector of float)
13900:159                Constant:
13910:159                  1 (const int)
13920:159              'd4' ( uniform float)
13930:159            true case
13940:160            add second child into first child ( temp float)
13950:160              direct index ( temp float)
13960:160                'color' ( temp 4-component vector of float)
13970:160                Constant:
13980:160                  1 (const int)
13990:160              'd4' ( uniform float)
14000:159            false case
14010:162            add second child into first child ( temp float)
14020:162              direct index ( temp float)
14030:162                'color' ( temp 4-component vector of float)
14040:162                Constant:
14050:162                  0 (const int)
14060:162              'd4' ( uniform float)
14070:170      Loop with condition not tested first
14080:170        Loop Condition
14090:170        Compare Less Than ( temp bool)
14100:170          direct index ( temp float)
14110:170            'color' ( temp 4-component vector of float)
14120:170            Constant:
14130:170              0 (const int)
14140:170          'd5' ( uniform float)
14150:170        Loop Body
14160:167        Sequence
14170:167          add second child into first child ( temp 4-component vector of float)
14180:167            'color' ( temp 4-component vector of float)
14190:167            'bigColor5' ( uniform 4-component vector of float)
14200:168          Test condition and select ( temp void)
14210:168            Condition
14220:168            Compare Less Than ( temp bool)
14230:168              direct index ( temp float)
14240:168                'color' ( temp 4-component vector of float)
14250:168                Constant:
14260:168                  1 (const int)
14270:168              'd5' ( uniform float)
14280:168            true case
14290:169            add second child into first child ( temp float)
14300:169              direct index ( temp float)
14310:169                'color' ( temp 4-component vector of float)
14320:169                Constant:
14330:169                  1 (const int)
14340:169              'd5' ( uniform float)
14350:173      Test condition and select ( temp void)
14360:173        Condition
14370:173        Compare Less Than ( temp bool)
14380:173          direct index ( temp float)
14390:173            'color' ( temp 4-component vector of float)
14400:173            Constant:
14410:173              0 (const int)
14420:173          'd6' ( uniform float)
14430:173        true case
14440:174        Sequence
14450:174          Loop with condition tested first
14460:174            Loop Condition
14470:174            Compare Less Than ( temp bool)
14480:174              direct index ( temp float)
14490:174                'color' ( temp 4-component vector of float)
14500:174                Constant:
14510:174                  1 (const int)
14520:174              'd6' ( uniform float)
14530:174            Loop Body
14540:175            add second child into first child ( temp 4-component vector of float)
14550:175              'color' ( temp 4-component vector of float)
14560:175              'bigColor6' ( uniform 4-component vector of float)
14570:173        false case
14580:177        Sequence
14590:177          Loop with condition tested first
14600:177            Loop Condition
14610:177            Compare Less Than ( temp bool)
14620:177              direct index ( temp float)
14630:177                'color' ( temp 4-component vector of float)
14640:177                Constant:
14650:177                  2 (const int)
14660:177              'd6' ( uniform float)
14670:177            Loop Body
14680:178            add second child into first child ( temp float)
14690:178              direct index ( temp float)
14700:178                'color' ( temp 4-component vector of float)
14710:178                Constant:
14720:178                  2 (const int)
14730:178              direct index ( temp float)
14740:178                'bigColor6' ( uniform 4-component vector of float)
14750:178                Constant:
14760:178                  2 (const int)
14770:182      Test condition and select ( temp void)
14780:182        Condition
14790:182        Compare Less Than ( temp bool)
14800:182          direct index ( temp float)
14810:182            'color' ( temp 4-component vector of float)
14820:182            Constant:
14830:182              0 (const int)
14840:182          'd6' ( uniform float)
14850:182        true case
14860:183        Sequence
14870:183          Loop with condition tested first
14880:183            Loop Condition
14890:183            Compare Less Than ( temp bool)
14900:183              direct index ( temp float)
14910:183                'color' ( temp 4-component vector of float)
14920:183                Constant:
14930:183                  1 (const int)
14940:183              'd6' ( uniform float)
14950:183            Loop Body
14960:184            Sequence
14970:184              add second child into first child ( temp 4-component vector of float)
14980:184                'color' ( temp 4-component vector of float)
14990:184                'bigColor6' ( uniform 4-component vector of float)
15000:185              Test condition and select ( temp void)
15010:185                Condition
15020:185                Compare Less Than ( temp bool)
15030:185                  'd7' ( uniform float)
15040:185                  Constant:
15050:185                    1.000000
15060:185                true case
15070:186                Branch: Break
15080:182        false case
15090:190        Sequence
15100:190          Loop with condition tested first
15110:190            Loop Condition
15120:190            Compare Less Than ( temp bool)
15130:190              direct index ( temp float)
15140:190                'color' ( temp 4-component vector of float)
15150:190                Constant:
15160:190                  2 (const int)
15170:190              'd6' ( uniform float)
15180:190            Loop Body
15190:191            add second child into first child ( temp float)
15200:191              direct index ( temp float)
15210:191                'color' ( temp 4-component vector of float)
15220:191                Constant:
15230:191                  2 (const int)
15240:191              direct index ( temp float)
15250:191                'bigColor6' ( uniform 4-component vector of float)
15260:191                Constant:
15270:191                  2 (const int)
15280:209      Loop with condition not tested first
15290:209        Loop Condition
15300:209        Constant:
15310:209          true (const bool)
15320:209        Loop Body
15330:197        Sequence
15340:197          Test condition and select ( temp void)
15350:197            Condition
15360:197            Compare Less Than ( temp bool)
15370:197              'd7' ( uniform float)
15380:197              Constant:
15390:197                0.000000
15400:197            true case
15410:198            Branch: Break
15420:200          add second child into first child ( temp 4-component vector of float)
15430:200            'color' ( temp 4-component vector of float)
15440:200            'bigColor7' ( uniform 4-component vector of float)
15450:202          Test condition and select ( temp void)
15460:202            Condition
15470:202            Compare Less Than ( temp bool)
15480:202              'd7' ( uniform float)
15490:202              Constant:
15500:202                1.000000
15510:202            true case
15520:203            Sequence
15530:203              Post-Increment ( temp float)
15540:203                direct index ( temp float)
15550:203                  'color' ( temp 4-component vector of float)
15560:203                  Constant:
15570:203                    2 (const int)
15580:204              Branch: Break
15590:207          add second child into first child ( temp 4-component vector of float)
15600:207            'color' ( temp 4-component vector of float)
15610:207            'BaseColor' ( smooth in 4-component vector of float)
15620:234      Loop with condition not tested first
15630:234        Loop Condition
15640:234        Compare Less Than ( temp bool)
15650:234          direct index ( temp float)
15660:234            'color' ( temp 4-component vector of float)
15670:234            Constant:
15680:234              2 (const int)
15690:234          'd8' ( uniform float)
15700:234        Loop Body
15710:217        Sequence
15720:217          Test condition and select ( temp void)
15730:217            Condition
15740:217            Compare Less Than ( temp bool)
15750:217              'd8' ( uniform float)
15760:217              Constant:
15770:217                0.000000
15780:217            true case
15790:218            Branch: Break
15800:220          add second child into first child ( temp 4-component vector of float)
15810:220            'color' ( temp 4-component vector of float)
15820:220            'bigColor7' ( uniform 4-component vector of float)
15830:222          Test condition and select ( temp void)
15840:222            Condition
15850:222            Compare Less Than ( temp bool)
15860:222              'd8' ( uniform float)
15870:222              Constant:
15880:222                1.000000
15890:222            true case
15900:223            Sequence
15910:223              Post-Increment ( temp float)
15920:223                direct index ( temp float)
15930:223                  'color' ( temp 4-component vector of float)
15940:223                  Constant:
15950:223                    2 (const int)
15960:224              Test condition and select ( temp void)
15970:224                Condition
15980:224                Compare Less Than ( temp bool)
15990:224                  'd8' ( uniform float)
16000:224                  Constant:
16010:224                    2.000000
16020:224                true case
16030:225                Sequence
16040:225                  Post-Increment ( temp float)
16050:225                    direct index ( temp float)
16060:225                      'color' ( temp 4-component vector of float)
16070:225                      Constant:
16080:225                        1 (const int)
16090:224                false case
16100:227                Sequence
16110:227                  Post-Increment ( temp float)
16120:227                    direct index ( temp float)
16130:227                      'color' ( temp 4-component vector of float)
16140:227                      Constant:
16150:227                        0 (const int)
16160:229              Branch: Break
16170:232          add second child into first child ( temp 4-component vector of float)
16180:232            'color' ( temp 4-component vector of float)
16190:232            'BaseColor' ( smooth in 4-component vector of float)
16200:237      Loop with condition tested first
16210:237        Loop Condition
16220:237        Compare Less Than ( temp bool)
16230:237          direct index ( temp float)
16240:237            'color' ( temp 4-component vector of float)
16250:237            Constant:
16260:237              3 (const int)
16270:237          'd9' ( uniform float)
16280:237        Loop Body
16290:238        Sequence
16300:238          Test condition and select ( temp void)
16310:238            Condition
16320:238            Compare Greater Than ( temp bool)
16330:238              'd9' ( uniform float)
16340:238              'd8' ( uniform float)
16350:238            true case
16360:239            Sequence
16370:239              Test condition and select ( temp void)
16380:239                Condition
16390:239                Compare Less Than or Equal ( temp bool)
16400:239                  direct index ( temp float)
16410:239                    'color' ( temp 4-component vector of float)
16420:239                    Constant:
16430:239                      0 (const int)
16440:239                  'd7' ( uniform float)
16450:239                true case
16460:240                Sequence
16470:240                  Test condition and select ( temp void)
16480:240                    Condition
16490:240                    Compare Equal ( temp bool)
16500:240                      direct index ( temp float)
16510:240                        'color' ( temp 4-component vector of float)
16520:240                        Constant:
16530:240                          2 (const int)
16540:240                      Constant:
16550:240                        5.000000
16560:240                    true case
16570:241                    Post-Increment ( temp float)
16580:241                      direct index ( temp float)
16590:241                        'color' ( temp 4-component vector of float)
16600:241                        Constant:
16610:241                          3 (const int)
16620:240                    false case
16630:243                    Branch: Break
16640:250      Loop with condition tested first
16650:250        Loop Condition
16660:250        Compare Less Than ( temp bool)
16670:250          direct index ( temp float)
16680:250            'color' ( temp 4-component vector of float)
16690:250            Constant:
16700:250              2 (const int)
16710:250          'd10' ( uniform float)
16720:250        Loop Body
16730:251        Sequence
16740:251          Post-Increment ( temp float)
16750:251            direct index ( temp float)
16760:251              'color' ( temp 4-component vector of float)
16770:251              Constant:
16780:251                1 (const int)
16790:252          Test condition and select ( temp void)
16800:252            Condition
16810:252            Compare Less Than ( temp bool)
16820:252              direct index ( temp float)
16830:252                'color' ( temp 4-component vector of float)
16840:252                Constant:
16850:252                  1 (const int)
16860:252              'd11' ( uniform float)
16870:252            true case
16880:253            Sequence
16890:253              Post-Increment ( temp float)
16900:253                direct index ( temp float)
16910:253                  'color' ( temp 4-component vector of float)
16920:253                  Constant:
16930:253                    2 (const int)
16940:254              Test condition and select ( temp void)
16950:254                Condition
16960:254                Compare Less Than ( temp bool)
16970:254                  direct index ( temp float)
16980:254                    'color' ( temp 4-component vector of float)
16990:254                    Constant:
17000:254                      3 (const int)
17010:254                  'd12' ( uniform float)
17020:254                true case
17030:255                Post-Increment ( temp float)
17040:255                  direct index ( temp float)
17050:255                    'color' ( temp 4-component vector of float)
17060:255                    Constant:
17070:255                      3 (const int)
17080:254                false case
17090:257                Post-Increment ( temp float)
17100:257                  direct index ( temp float)
17110:257                    'color' ( temp 4-component vector of float)
17120:257                    Constant:
17130:257                      0 (const int)
17140:258              Branch: Continue
17150:261          Post-Increment ( temp 4-component vector of float)
17160:261            'color' ( temp 4-component vector of float)
17170:262          Branch: Break
17180:266      Loop with condition tested first
17190:266        Loop Condition
17200:266        Compare Less Than ( temp bool)
17210:266          direct index ( temp float)
17220:266            'color' ( temp 4-component vector of float)
17230:266            Constant:
17240:266              0 (const int)
17250:266          Constant:
17260:266            10.000000
17270:266        Loop Body
17280:267        Sequence
17290:267          add second child into first child ( temp 4-component vector of float)
17300:267            'color' ( temp 4-component vector of float)
17310:267            'bigColor8' ( uniform 4-component vector of float)
17320:269          Test condition and select ( temp void)
17330:269            Condition
17340:269            Compare Less Than ( temp bool)
17350:269              direct index ( temp float)
17360:269                'color' ( temp 4-component vector of float)
17370:269                Constant:
17380:269                  2 (const int)
17390:269              'd8' ( uniform float)
17400:269            true case
17410:270            Test condition and select ( temp void)
17420:270              Condition
17430:270              Compare Less Than ( temp bool)
17440:270                direct index ( temp float)
17450:270                  'color' ( temp 4-component vector of float)
17460:270                  Constant:
17470:270                    3 (const int)
17480:270                'd6' ( uniform float)
17490:270              true case
17500:271              Branch: Continue
17510:273          add second child into first child ( temp float)
17520:273            direct index ( temp float)
17530:273              'color' ( temp 4-component vector of float)
17540:273              Constant:
17550:273                1 (const int)
17560:273            direct index ( temp float)
17570:273              'bigColor8' ( uniform 4-component vector of float)
17580:273              Constant:
17590:273                0 (const int)
17600:276      Post-Increment ( temp 4-component vector of float)
17610:276        'color' ( temp 4-component vector of float)
17620:277      move second child to first child ( temp 4-component vector of float)
17630:277        'gl_FragColor' ( fragColor 4-component vector of float FragColor)
17640:277        'color' ( temp 4-component vector of float)
17650:280      Loop with condition tested first
17660:280        Loop Condition
17670:280        Compare Less Than ( temp bool)
17680:280          direct index ( temp float)
17690:280            'color' ( temp 4-component vector of float)
17700:280            Constant:
17710:280              0 (const int)
17720:280          'd14' ( uniform float)
17730:280        Loop Body
17740:281        Sequence
17750:281          Test condition and select ( temp void)
17760:281            Condition
17770:281            Compare Less Than ( temp bool)
17780:281              direct index ( temp float)
17790:281                'color' ( temp 4-component vector of float)
17800:281                Constant:
17810:281                  1 (const int)
17820:281              'd15' ( uniform float)
17830:281            true case
17840:282            Sequence
17850:282              Branch: Return
17860:281            false case
17870:285            Post-Increment ( temp 4-component vector of float)
17880:285              'color' ( temp 4-component vector of float)
17890:288      Post-Increment ( temp 4-component vector of float)
17900:288        'color' ( temp 4-component vector of float)
17910:290      Loop with condition tested first
17920:290        Loop Condition
17930:290        Compare Less Than ( temp bool)
17940:290          direct index ( temp float)
17950:290            'color' ( temp 4-component vector of float)
17960:290            Constant:
17970:290              3 (const int)
17980:290          'd16' ( uniform float)
17990:290        Loop Body
18000:291        Sequence
18010:291          Post-Increment ( temp float)
18020:291            direct index ( temp float)
18030:291              'color' ( temp 4-component vector of float)
18040:291              Constant:
18050:291                3 (const int)
18060:296      Loop with condition tested first
18070:296        Loop Condition
18080:296        logical-and ( temp bool)
18090:296          Compare Less Than ( temp bool)
18100:296            direct index ( temp float)
18110:296              'color' ( temp 4-component vector of float)
18120:296              Constant:
18130:296                3 (const int)
18140:296            'd2' ( uniform float)
18150:296          Compare Less Than ( temp bool)
18160:296            direct index ( temp float)
18170:296              'color' ( temp 4-component vector of float)
18180:296              Constant:
18190:296                1 (const int)
18200:296            'd3' ( uniform float)
18210:296        Loop Body
18220:297        Sequence
18230:297          add second child into first child ( temp 4-component vector of float)
18240:297            'color' ( temp 4-component vector of float)
18250:297            'bigColor1_2' ( uniform 4-component vector of float)
18260:298          Test condition and select ( temp void)
18270:298            Condition
18280:298            Compare Less Than ( temp bool)
18290:298              direct index ( temp float)
18300:298                'color' ( temp 4-component vector of float)
18310:298                Constant:
18320:298                  2 (const int)
18330:298              'd3' ( uniform float)
18340:298            true case
18350:299            Branch: Return
18360:307      Loop with condition not tested first
18370:307        Loop Condition
18380:307        Compare Less Than ( temp bool)
18390:307          direct index ( temp float)
18400:307            'color' ( temp 4-component vector of float)
18410:307            Constant:
18420:307              0 (const int)
18430:307          'd17' ( uniform float)
18440:307        Loop Body
18450:304        Sequence
18460:304          Test condition and select ( temp void)
18470:304            Condition
18480:304            Compare Less Than ( temp bool)
18490:304              direct index ( temp float)
18500:304                'color' ( temp 4-component vector of float)
18510:304                Constant:
18520:304                  1 (const int)
18530:304              'd18' ( uniform float)
18540:304            true case
18550:305            Branch: Return
18560:306          Post-Increment ( temp 4-component vector of float)
18570:306            'color' ( temp 4-component vector of float)
18580:310      Loop with condition tested first
18590:310        Loop Condition
18600:310        Compare Less Than ( temp bool)
18610:310          direct index ( temp float)
18620:310            'color' ( temp 4-component vector of float)
18630:310            Constant:
18640:310              1 (const int)
18650:310          'd16' ( uniform float)
18660:310        Loop Body
18670:311        Sequence
18680:311          Test condition and select ( temp void)
18690:311            Condition
18700:311            Compare Less Than ( temp bool)
18710:311              direct index ( temp float)
18720:311                'color' ( temp 4-component vector of float)
18730:311                Constant:
18740:311                  3 (const int)
18750:311              'd16' ( uniform float)
18760:311            true case
18770:312            Sequence
18780:312              Branch: Kill
18790:311            false case
18800:314            Post-Increment ( temp 4-component vector of float)
18810:314              'color' ( temp 4-component vector of float)
18820:317      Post-Increment ( temp 4-component vector of float)
18830:317        'color' ( temp 4-component vector of float)
18840:319      move second child to first child ( temp 4-component vector of float)
18850:319        'gl_FragColor' ( fragColor 4-component vector of float FragColor)
18860:319        'color' ( temp 4-component vector of float)
18870:?   Linker Objects
18880:?     'bigColor' ( uniform 4-component vector of float)
18890:?     'bigColor1_1' ( uniform 4-component vector of float)
18900:?     'bigColor1_2' ( uniform 4-component vector of float)
18910:?     'bigColor1_3' ( uniform 4-component vector of float)
18920:?     'bigColor2' ( uniform 4-component vector of float)
18930:?     'bigColor3' ( uniform 4-component vector of float)
18940:?     'bigColor4' ( uniform 4-component vector of float)
18950:?     'bigColor5' ( uniform 4-component vector of float)
18960:?     'bigColor6' ( uniform 4-component vector of float)
18970:?     'bigColor7' ( uniform 4-component vector of float)
18980:?     'bigColor8' ( uniform 4-component vector of float)
18990:?     'BaseColor' ( smooth in 4-component vector of float)
19000:?     'd' ( uniform float)
19010:?     'd2' ( uniform float)
19020:?     'd3' ( uniform float)
19030:?     'd4' ( uniform float)
19040:?     'd5' ( uniform float)
19050:?     'd6' ( uniform float)
19060:?     'd7' ( uniform float)
19070:?     'd8' ( uniform float)
19080:?     'd9' ( uniform float)
19090:?     'd10' ( uniform float)
19100:?     'd11' ( uniform float)
19110:?     'd12' ( uniform float)
19120:?     'd13' ( uniform float)
19130:?     'd14' ( uniform float)
19140:?     'd15' ( uniform float)
19150:?     'd16' ( uniform float)
19160:?     'd17' ( uniform float)
19170:?     'd18' ( uniform float)
19180:?     'd19' ( uniform float)
19190:?     'd20' ( uniform float)
19200:?     'd21' ( uniform float)
19210:?     'd22' ( uniform float)
19220:?     'd23' ( uniform float)
19230:?     'd24' ( uniform float)
19240:?     'd25' ( uniform float)
19250:?     'd26' ( uniform float)
19260:?     'd27' ( uniform float)
19270:?     'd28' ( uniform float)
19280:?     'd29' ( uniform float)
19290:?     'd30' ( uniform float)
19300:?     'd31' ( uniform float)
19310:?     'd32' ( uniform float)
19320:?     'd33' ( uniform float)
19330:?     'd34' ( uniform float)
19340:?     'Count' ( uniform int)
1935
1936