diff --git a/lib/AsmParser/Lexer.cpp.cvs b/lib/AsmParser/Lexer.cpp.cvs
index dae64fa..752ba01 100644
--- a/lib/AsmParser/Lexer.cpp.cvs
+++ b/lib/AsmParser/Lexer.cpp.cvs
@@ -349,7 +349,7 @@
 
 /* Begin user sect3 */
 
-#define llvmAsmwrap() 1
+#define llvmAsmwrap(n) 1
 #define YY_SKIP_YYWRAP
 
 typedef unsigned char YY_CHAR;
@@ -380,8 +380,8 @@
 	*yy_cp = '\0'; \
 	(yy_c_buf_p) = yy_cp;
 
-#define YY_NUM_RULES 136
-#define YY_END_OF_BUFFER 137
+#define YY_NUM_RULES 137
+#define YY_END_OF_BUFFER 138
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
@@ -389,68 +389,69 @@
 	flex_int32_t yy_verify;
 	flex_int32_t yy_nxt;
 	};
-static yyconst flex_int16_t yy_accept[550] =
+static yyconst flex_int16_t yy_accept[552] =
     {   0,
-        0,    0,  137,  135,  134,  134,  135,  135,  135,  135,
-      135,  135,  127,  127,    1,  135,  135,  135,  135,  135,
-      135,  135,  135,  135,  135,  135,  135,  135,  135,  135,
-      135,  135,  135,  135,  135,  135,  135,  135,    0,  125,
-        0,  123,  121,  130,    0,  128,    0,  132,  127,    0,
-        1,    0,  122,  131,    0,    0,    0,    0,    0,    0,
-        0,  107,    0,   36,    0,    0,    0,    0,    0,    0,
-       70,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,   52,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,   71,    0,    0,    0,    0,    0,    0,    0,   66,
+        0,    0,  138,  136,  135,  135,  136,  136,  136,  136,
+      136,  136,  128,  128,    1,  136,  136,  136,  136,  136,
+      136,  136,  136,  136,  136,  136,  136,  136,  136,  136,
+      136,  136,  136,  136,  136,  136,  136,  136,    0,  126,
+        0,  124,  122,  131,    0,  129,    0,  133,  128,    0,
+        1,    0,  123,  132,    0,    0,    0,    0,    0,    0,
+        0,  108,    0,   37,    0,    0,    0,    0,    0,    0,
+       71,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,   53,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,   72,    0,    0,    0,    0,    0,    0,    0,   67,
 
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,   24,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,  125,  121,  132,   21,  132,    0,  133,    0,
-      126,  122,   53,    0,    0,   65,    0,    0,   34,    0,
-        0,    0,   37,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,  126,  122,  133,   21,  133,    0,  134,    0,
+      127,  123,   54,    0,    0,   66,    0,    0,   35,    0,
+        0,    0,   38,    0,    0,    0,    0,    0,    0,    0,
         0,    3,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,   55,    0,    0,    0,   80,
-       85,   83,   84,   82,   81,    0,   86,   90,    0,  106,
+        0,    0,    0,    0,    0,   56,    0,    0,    0,   81,
+       86,   84,   85,   83,   82,    0,   87,   91,    0,  107,
 
-        0,    0,    0,    0,    0,   75,   73,   62,    0,    0,
-        0,   74,   72,    0,    0,   54,    0,    0,    0,    0,
-        0,    0,    0,    0,   88,   79,   77,    0,   78,   76,
-        0,   89,   87,    0,    0,    0,    0,    0,    0,    0,
-        0,   67,    0,    0,  124,  132,    0,    0,    0,  132,
-        0,    0,    0,   64,    0,    0,   91,    0,    0,    0,
+        0,    0,    0,    0,    0,   76,   74,   63,    0,    0,
+        0,   75,   73,    0,    0,   55,    0,    0,    0,    0,
+        0,    0,    0,    0,   89,   80,   78,    0,   79,   77,
+        0,   90,   88,    0,    0,    0,    0,    0,    0,    0,
+        0,   68,    0,    0,  125,  133,    0,    0,    0,  133,
+        0,    0,    0,    0,   65,    0,    0,   92,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-       69,   58,    0,    0,    0,    0,  114,   61,    0,    0,
-        0,   68,    0,    0,    0,    0,    0,    0,    0,  115,
-       63,    0,    0,    0,    0,   23,    0,    0,  129,   57,
+        0,   70,   59,    0,    0,    0,    0,  115,   62,    0,
+        0,    0,   69,    0,    0,    0,    0,    0,    0,    0,
+      116,   64,    0,    0,    0,    0,   23,    0,    0,  130,
 
-        0,    0,   94,    0,    0,    0,   60,   43,    0,    0,
-       25,    0,    0,    0,    4,    0,   50,   56,    0,    0,
-        0,    0,   59,    0,   46,    0,   12,    0,    0,   93,
-      132,   31,    0,    0,    2,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,    0,    5,    0,   47,
-       96,    0,    0,    0,    0,    0,    0,   42,    0,    0,
-        0,    0,   49,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,  116,    0,    0,    0,    0,
-       92,    0,   22,    0,    0,    0,    0,    0,    0,    0,
-      113,    0,    0,   39,    0,    0,    0,    7,    0,    0,
+       58,    0,    0,   95,    0,    0,    0,   61,   44,    0,
+        0,   25,    0,    0,    0,    4,    0,   51,   57,    0,
+        0,    0,    0,   60,    0,   47,    0,   12,    0,    0,
+       94,  133,   33,   31,    0,    0,    2,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    5,
+        0,   48,   97,    0,    0,    0,    0,    0,    0,   43,
+        0,    0,    0,    0,   50,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,  117,    0,    0,
+        0,    0,   93,    0,   22,    0,    0,    0,    0,    0,
+        0,    0,  114,    0,    0,   40,    0,    0,    0,    7,
 
-        0,   48,    0,    0,   38,  100,   99,    0,    0,    8,
-       16,    0,    0,    0,  109,    0,  112,   33,    0,    0,
-       51,    0,    0,  104,    0,    0,   98,  108,   26,    0,
-       27,   97,    0,  110,  105,    0,    0,    0,    0,    0,
-      103,    0,    0,    6,   28,    0,    0,    0,    0,    0,
-       95,    0,    0,    0,    0,    0,    0,    0,    0,   32,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    9,
-        0,    0,    0,    0,   18,    0,    0,    0,   10,  101,
-       11,   45,   44,  102,    0,    0,    0,    0,   30,    0,
-        0,    0,   13,    0,   15,   14,    0,    0,    0,    0,
+        0,    0,    0,   49,    0,    0,   39,  101,  100,    0,
+        0,    8,   16,    0,    0,    0,  110,    0,  113,   34,
+        0,    0,   52,    0,    0,  105,    0,    0,   99,  109,
+       26,    0,   27,   98,    0,  111,  106,    0,    0,    0,
+        0,    0,  104,    0,    0,    6,   28,    0,    0,    0,
+        0,    0,   96,    0,    0,    0,    0,    0,    0,    0,
+        0,   32,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    9,    0,    0,    0,    0,   18,    0,    0,    0,
+       10,  102,   11,   46,   45,  103,    0,    0,    0,    0,
+       30,    0,    0,    0,   13,    0,   15,   14,    0,    0,
 
-        0,    0,    0,    0,    0,    0,    0,   29,    0,    0,
-        0,    0,    0,   35,    0,    0,    0,    0,    0,   17,
-        0,    0,    0,    0,    0,  111,    0,    0,    0,    0,
-        0,    0,    0,   19,    0,    0,    0,    0,  117,  119,
-      120,    0,   40,    0,  118,   41,    0,   20,    0
+        0,    0,    0,    0,    0,    0,    0,    0,    0,   29,
+        0,    0,    0,    0,    0,   36,    0,    0,    0,    0,
+        0,   17,    0,    0,    0,    0,    0,  112,    0,    0,
+        0,    0,    0,    0,    0,   19,    0,    0,    0,    0,
+      118,  120,  121,    0,   41,    0,  119,   42,    0,   20,
+        0
     } ;
 
 static yyconst flex_int32_t yy_ec[256] =
@@ -494,137 +495,137 @@
         4,    4,    4,    4
     } ;
 
-static yyconst flex_int16_t yy_base[558] =
+static yyconst flex_int16_t yy_base[560] =
     {   0,
-        0,    0, 1197, 1198, 1198, 1198, 1192, 1181,   35,   39,
+        0,    0, 1201, 1202, 1202, 1202, 1196, 1185,   35,   39,
        43,   49,   55,   61,    0,   72,   64,   67,   66,   86,
        76,  106,   91,   65,  133,  121,  117,   99,  152,   95,
-       78,  179,  137,  211,  139,   90,  148,   93, 1190, 1198,
-     1179, 1198,    0,   49,  185,  217,  116,  238,  254,  259,
-        0, 1188,    0,  200,  125,  149,  146,  153,  177,   63,
-      154, 1177,  160,  161,  208,  185,  264,  171,  113,  210,
-     1176,  222,  260,  228,  186,  261,  271,  110,  273,  274,
+       78,  179,  137,  211,  139,   90,  148,   93, 1194, 1202,
+     1183, 1202,    0,   49,  185,  217,  116,  238,  254,  259,
+        0, 1192,    0,  200,  125,  149,  146,  153,  177,   63,
+      154, 1181,  160,  161,  208,  185,  264,  171,  113,  210,
+     1180,  222,  260,  228,  186,  261,  271,  110,  273,  274,
       230,  289,  277,  278,  240,  290,  292,  205,  291,  232,
-      296, 1175,  299,  303,  305,  306,  310,  313,  309,  318,
+      296, 1179,  299,  303,  305,  306,  310,  313,  309,  318,
 
       311,  314,  317,  322,  328,  329,  338,  331,  335,  339,
-      333,  332,  346,  340,  352,  355, 1174,  358,  360,  361,
+      333,  332,  346,  340,  352,  355, 1178,  358,  360,  361,
       364,  368,  365,  369,  381,  376,  382,  388,  367,  396,
-      384,  395, 1173,    0,  414, 1172,  429,  447,    0, 1181,
-     1198,    0, 1170,  231,  397, 1169,  399,  398, 1168,  401,
-      414,  405, 1167,  442,  407,  431,  419,  434,  436,  449,
-      450, 1166,  454,  432,  438,  453,  456,  460,  458,  461,
-      467,  465,  471,  470,  468,  481,  485,  487,  474,  489,
-      490,  492,  472,  496,  498, 1165,  500,  502,  503, 1164,
-     1163, 1162, 1161, 1160, 1159,  504, 1158, 1157,  506, 1156,
+      384,  395, 1177,    0,  414, 1176,  429,  447,    0, 1185,
+     1202,    0, 1174,  409,  397, 1173,  420,  414, 1172,  405,
+      399,  422, 1171,  442,  431,  449,  432,  450,  437,  452,
+      456, 1170,  457,  435,  459,  460,  461,  465,  370,  469,
+      468,  472,  470,  475,  473,  476,  489,  490,  492,  494,
+      481,  497,  495,  502,  498, 1169,  503,  501,  505, 1168,
+     1167, 1166, 1165, 1164, 1163,  507, 1162, 1161,  508, 1160,
 
-      535,  509,  513,  507,  516, 1155, 1154, 1153,  515,  508,
-      528, 1152, 1151,  536,  527, 1150,  524,  550,  551,  552,
-      554,  555,  557,  556, 1149, 1148, 1147,  558, 1146, 1145,
-      559, 1144, 1143,  561,  564,  568,  570,  572,  580,  514,
-      579, 1142,  575,  583, 1198,  591,  606,  612,  616,  621,
-      606,  622,  623, 1141,  625,  591, 1140,  626,  627,  628,
-      592,  629,  631,  632,  633,  636,  635,  640,  638,  653,
-     1139, 1138,  639,  642,  649,  637, 1137, 1136,  654,  658,
-      655, 1135,  656,  659,  667,  669,  671,  675,  673, 1134,
-     1133,  676,  677,  678,  679, 1132,  680,  682,    0, 1131,
+      537,  512,  515,  510,  525, 1159, 1158, 1157,  516,  542,
+      531, 1156, 1155,  537,  529, 1154,  553,  555,  231,  556,
+      558,  557,  559,  560, 1153, 1152, 1151,  562, 1150, 1149,
+      563, 1148, 1147,  564,  565,  509,  524,  576,  582,  568,
+      584, 1146,  572,  570, 1202,  599,  608,  614,  618,  623,
+      608,  624,  592,  625, 1145,  626,  587, 1144,  627,  628,
+      629,  630,  632,  633,  634,  637,  639,  638,  640,  580,
+      641, 1143, 1142,  648,  651,  653,  656, 1141, 1140,  657,
+      658,  659, 1139,  665,  661,  663,  667,  674,  666,  668,
+     1138, 1137,  671,  679,  670,  680, 1136,  684,  691,    0,
 
-      683,  690, 1130,  685,  684,  699, 1129, 1128,  703,  700,
-     1127,  704,  709,  707, 1126,  711, 1125, 1124,  716,  717,
-      712,  720, 1123,  721, 1122,  722, 1121,  724,  725, 1120,
-      733, 1119,  734,  733, 1118,  726,  736,  745,  748,  737,
-      750,  755,  741,  752,  753,  756,  757, 1117,  758, 1116,
-     1115,  764,  767,  768,  769,  771,  770, 1114,  773,  775,
-      776,  780, 1113,  777,  783,  782,  784,  785,  794,  789,
-      798,  800,  802,  801,  805, 1112,  806,  807,  811,  813,
-     1111,  808, 1110,  814,  821,  815,  826,  810,  829,  832,
-     1109,  833,  834, 1108,  836,  835,  838, 1107,  837,  842,
+     1135,  688,  692, 1134,  693,  696,  697, 1133, 1132,  701,
+      705, 1131,  712,  714,  699, 1130,  716, 1129, 1128,  717,
+      718,  719,  703, 1127,  723, 1126,  726, 1125,  730,  732,
+     1124,  737, 1123, 1122,  731,  738, 1121,  739,  740,  743,
+      751,  742,  744,  752,  755,  756,  758,  760,  761, 1120,
+      763, 1119, 1118,  765,  766,  767,  772,  770,  773, 1117,
+      774,  777,  781,  783, 1116,  784,  788,  787,  789,  790,
+      799,  792,  794,  800,  803,  805,  807, 1115,  808,  810,
+      811,  812, 1114,  815, 1113,  817,  823,  818,  826,  831,
+      828,  829, 1112,  836,  833, 1111,  838,  698,  839, 1110,
 
-      843, 1106,  839,  841, 1105, 1104, 1103,  849,  846, 1102,
-     1101,  856,  867,  851, 1100,  868, 1099, 1098,  852,  859,
-     1097,  869,  870, 1096,  871,  872, 1095, 1094, 1093,  879,
-     1092, 1091,  878, 1090, 1089,  880,  882,  885,  886,  889,
-     1088,  890,  892, 1087, 1076,  893,  895,  897,  902,  898,
-     1066,  899,  903,  904,  901,  906,  910,  912,  913, 1065,
-      922,  925,  926,  927,  929,  930,  932,  931,  934, 1064,
-      936,  938,  941,  943, 1061,  944,  945,  947, 1060, 1059,
-     1058, 1057, 1056, 1055,  949,  950,  951,  964, 1054,  966,
-      967,  968, 1048,  952, 1047, 1046,  969,  977,  956,  972,
+      841,  842,  843, 1109,  848,  844, 1108, 1107, 1106,  851,
+      846, 1105, 1104,  845,  860,  858, 1103,  865, 1102, 1101,
+      867,  869, 1100,  870,  872, 1099,  871,  874, 1098, 1097,
+     1096,  875, 1095, 1094,  878, 1093, 1092,  876,  877,  884,
+      883,  886, 1091,  879,  894, 1090, 1089,  895,  896,  898,
+      899,  901, 1088,  902,  905,  906,  907,  909,  908,  914,
+      910, 1087,  916,  920,  924,  927,  928,  931,  935,  932,
+      936, 1086,  937,  939,  941,  944, 1085,  945,  946,  947,
+     1074, 1064, 1063, 1062, 1061, 1060,  949,  950,  951,  953,
+     1059,  966,  967,  968, 1058,  952, 1057, 1056,  969,  971,
 
-      978,  979,  983,  981,  984,  985,  988,  855,  992,  993,
-      995,  996,  998,  687,  999, 1002, 1000, 1004, 1008,  596,
-     1009, 1011, 1013, 1014, 1018,  593, 1021, 1017, 1026, 1023,
-     1027, 1028, 1029,  522, 1030, 1036, 1032, 1039,  521,  469,
-      371, 1042,  370, 1043,  282,  279, 1045,  244, 1198, 1081,
-     1083,  212, 1088, 1091,  167, 1095,  108
+      972,  977,  978,  979,  980,  983,  984,  985,  987, 1055,
+      989,  991,  992,  995,  997, 1053, 1000, 1007,  998, 1002,
+     1009, 1049, 1010, 1011, 1013, 1015, 1016, 1046, 1022, 1019,
+     1023, 1024, 1026, 1028, 1029, 1045, 1033, 1036,  371, 1030,
+      599,  522,  474, 1039,  434, 1040,  282,  279, 1043,  244,
+     1202, 1079, 1081,  212, 1086, 1089,  167, 1093,  108
     } ;
 
-static yyconst flex_int16_t yy_def[558] =
+static yyconst flex_int16_t yy_def[560] =
     {   0,
-      549,    1,  549,  549,  549,  549,  550,  551,  552,  549,
-      551,  551,  551,  551,  553,  554,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  550,  549,
-      551,  549,  555,  549,  549,  551,  551,  551,  551,  551,
-      553,  556,  557,  549,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
+      551,    1,  551,  551,  551,  551,  552,  553,  554,  551,
+      553,  553,  553,  553,  555,  556,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  552,  551,
+      553,  551,  557,  551,  551,  553,  553,  553,  553,  553,
+      555,  558,  559,  551,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
 
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  549,  555,  549,  551,  551,  551,   50,  556,
-      549,  557,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  551,  557,  551,  553,  553,  553,   50,  558,
+      551,  559,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
 
-       50,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  549,  549,  549,  549,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  201,  551,
+       50,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  551,  551,  551,  551,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  201,
 
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      549,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  551,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
 
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
 
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
-      551,  551,  551,  551,  551,  551,  551,  551,    0,  549,
-      549,  549,  549,  549,  549,  549,  549
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
+        0,  551,  551,  551,  551,  551,  551,  551,  551
     } ;
 
-static yyconst flex_int16_t yy_nxt[1243] =
+static yyconst flex_int16_t yy_nxt[1247] =
     {   0,
         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
        14,   14,   14,    4,   15,   16,    8,    8,    8,   17,
@@ -653,7 +654,7 @@
       104,   42,  156,   42,   42,   48,   46,   46,   46,   46,
        42,  183,  162,  120,  121,   42,  122,  154,  123,  155,
       124,   42,  125,   42,   42,   42,  126,  137,  137,  137,
-      137,   42,  174,   42,  185,  138,  251,   42,  166,  163,
+      137,   42,  174,   42,  185,  138,  313,   42,  166,  163,
       180,  138,   48,   49,   49,   49,   49,   42,  139,  139,
       139,  139,   42,   42,   42,  139,  139,   42,  139,  139,
       139,  139,  139,  139,   42,  157,   42,   42,  158,  164,
@@ -671,81 +672,81 @@
       220,  226,  229,  223,   42,   42,  222,   42,  225,  236,
 
       237,   42,  228,  231,  232,  227,  230,  241,   42,   42,
-       42,   42,   42,  233,   42,  238,  234,  239,   42,  242,
-       42,  235,  253,  246,  246,  246,  246,   42,  255,  252,
-      243,  247,   42,  254,  257,  256,  244,  247,  137,  137,
-      137,  137,   42,  259,   42,   42,  138,   42,  261,   42,
-      260,   42,  138,  248,  249,   42,  250,  250,  250,  250,
-       42,  262,   42,   42,  258,  263,   42,   42,  269,   42,
-      266,   42,  264,   42,   42,  270,  265,  267,   42,  273,
-       42,   42,   42,   42,   42,   42,  271,   42,  279,  268,
-      277,  280,  281,  275,   42,  272,  276,  278,   42,  274,
+       42,  275,   42,  233,  546,  238,  234,  239,   42,  242,
+      257,  235,   42,  246,  246,  246,  246,   42,  251,  253,
+      243,  247,  256,   42,  252,   42,  244,  247,  137,  137,
+      137,  137,   42,  254,   42,   42,  138,   42,   42,  255,
+       42,  258,  138,  248,  249,   42,  250,  250,  250,  250,
+       42,  262,   42,   42,  259,   42,  264,  260,  261,   42,
+       42,  270,   42,   42,   42,  265,  267,  263,   42,  266,
+      268,   42,   42,   42,  274,   42,   42,   42,   42,   42,
+      281,  278,  269,  272,   42,  280,  271,  282,  279,  284,
 
-       42,  282,   42,   42,  283,   42,  287,  291,  284,   42,
-      285,   42,  288,   42,  290,   42,   42,   42,  289,   42,
-       42,   42,   42,  294,  286,  292,   42,   42,   42,   42,
-      302,  305,  296,  295,   42,   42,  293,   42,  297,  304,
-       42,   42,  327,  298,  299,  299,  299,  299,  300,   42,
-      301,  299,  299,  303,  299,  299,  299,  299,  299,  299,
-      306,  310,  309,   42,   42,   42,  307,   42,   42,   42,
-       42,   42,   42,  308,   42,  313,  312,   42,  315,  311,
-      317,   42,  320,   42,  321,   42,  316,  314,   42,  324,
-      319,  322,   42,   42,  325,  318,   42,  328,  323,  326,
+      273,  276,   42,   42,  277,   42,  283,   42,   42,  290,
+       42,   42,  285,  286,   42,   42,   42,  289,   42,  291,
+       42,   42,   42,   42,  288,   42,  295,  287,   42,   42,
+      292,  293,  296,  303,  297,   42,  294,   42,   42,  324,
+      305,  298,   42,  325,   42,  299,  300,  300,  300,  300,
+       42,  301,  302,  300,  300,   42,  300,  300,  300,  300,
+      300,  300,  304,  307,  310,  306,   42,  308,   42,   42,
+       42,   42,   42,   42,  309,   42,   42,   42,   42,  314,
+      316,   42,  318,   42,  312,   42,  321,  322,  317,   42,
+      311,  315,  323,   42,  320,   42,  328,   42,  326,  319,
 
-      246,  246,  246,  246,   42,   42,   42,  329,  247,   42,
-      336,  340,  248,  248,  247,  331,  331,  331,  331,   42,
-      330,  331,  331,  331,  331,  250,  250,  250,  250,   42,
-      250,  250,  250,  250,   42,   42,   42,  332,   42,   42,
-       42,   42,   42,  333,   42,   42,   42,  337,   42,   42,
-       42,   42,   42,   42,  334,   42,  335,  339,  342,  347,
-      341,  348,   42,  344,  338,  345,   42,   42,   42,   42,
-      346,   42,   42,  343,  349,  354,  350,  356,  357,  351,
-       42,  358,   42,  355,   42,  352,   42,  353,   42,   42,
-       42,   42,   42,   42,  359,   42,   42,   42,   42,  362,
+       42,  327,  329,  350,  330,   42,  338,  331,  246,  246,
+      246,  246,   42,  335,  248,  248,  247,  332,  332,  332,
+      332,   42,  247,  332,  332,  332,  332,  250,  250,  250,
+      250,   42,  250,  250,  250,  250,   42,   42,   42,   42,
+       42,   42,   42,   42,  333,   42,   42,   42,  339,  342,
+       42,   42,   42,   42,   42,  334,  336,  337,  341,  349,
+      344,   42,  351,  343,   42,  340,   42,  346,  347,   42,
+       42,   42,   42,  348,   42,  345,   42,  358,   42,   42,
+       42,   42,  359,   42,   42,  352,  357,   42,  353,  354,
+      360,  355,   42,   42,  356,  365,  361,   42,  362,  363,
 
-       42,  361,  360,   42,  363,  364,  366,  374,  365,  373,
-      371,  372,   42,   42,  370,  367,   42,   42,  369,  368,
-       42,  377,   42,  375,   42,   42,  376,  378,  379,   42,
-       42,  384,  381,   42,   42,   42,  380,   42,   42,   42,
-      382,  383,  331,  331,  331,  331,   42,   42,  388,   42,
-       42,  385,  390,  391,   42,  392,  386,  394,   42,  387,
-      389,   42,  393,   42,  395,   42,   42,  396,   42,   42,
-       42,   42,  397,  398,  400,  399,  402,   42,  404,  405,
-       42,   42,   42,   42,   42,  401,   42,  403,   42,   42,
-       42,  406,  409,   42,  407,   42,   42,   42,   42,  408,
+      366,   42,  364,  367,   42,   42,   42,  369,  368,   42,
+       42,   42,   42,  374,   42,  373,   42,  375,   42,  376,
+      370,  377,  371,  372,  378,   42,  379,   42,  382,   42,
+       42,   42,   42,  381,  387,  380,   42,  383,  386,   42,
+      445,  384,  385,   42,   42,   42,  332,  332,  332,  332,
+      393,   42,   42,   42,  390,   42,   42,   42,  388,  392,
+      394,  396,  397,  389,   42,   42,  391,  400,   42,   42,
+      398,   42,  401,   42,   42,  395,   42,  399,   42,   42,
+       42,  404,  406,   42,  407,   42,   42,   42,  402,  403,
+       42,  405,  408,  409,   42,  411,   42,   42,  410,  412,
 
-      410,  411,   42,  415,  417,  418,  413,   42,  416,  414,
-      412,   42,  420,   42,   42,   42,  422,  421,   42,   42,
-       42,   42,  419,   42,   42,  426,   42,   42,   42,  437,
-      423,  425,  428,  430,   42,  433,  431,  424,  427,   42,
-      435,  432,   42,  434,  429,   42,   42,   42,   42,   42,
-       42,   42,   42,  436,   42,   42,   42,  448,  449,   42,
-      440,  444,   42,  439,   42,   42,  438,  442,   42,   42,
-      451,  441,   42,  445,  446,  447,  452,  443,  450,  453,
-       42,   42,   42,   42,   42,   42,  454,  457,  455,  456,
-      458,   42,   42,   42,  461,   42,  462,  463,   42,   42,
+       42,   42,   42,   42,  413,   42,  417,   42,  415,  419,
+      420,  414,   42,   42,  416,  418,   42,  422,   42,  424,
+       42,   42,  423,   42,   42,   42,  425,  421,   42,  428,
+       42,   42,  427,  432,  430,  433,   42,  426,  435,   42,
+      429,   42,   42,  437,   42,  436,   42,  431,  434,   42,
+      439,   42,   42,  438,   42,   42,   42,   42,   42,   42,
+      441,   42,  446,  442,   42,  440,  450,  451,  455,  444,
+      443,   42,  453,   42,  448,  449,  454,  447,   42,  456,
+       42,  452,   42,   42,   42,   42,  458,   42,   42,   42,
+       42,   42,   42,  465,  463,  457,   42,   42,  464,   42,
 
-      459,  460,   42,   42,  464,   42,   42,  467,   42,  465,
-       42,   42,   42,  468,   42,   42,   42,   42,  466,   42,
-      469,  476,  477,   42,  471,   42,   42,  470,  472,  481,
-      473,  475,  478,  479,  483,   42,  480,  474,   42,   42,
-       42,  482,   42,   42,   42,   42,  488,   42,  486,   42,
-      484,   42,  489,  491,   42,  487,   42,   42,   42,  493,
-       42,  485,   42,   42,   42,   42,  497,  490,  492,   42,
-      500,  502,  501,  498,  494,  495,  499,   42,  496,   42,
-       42,   42,   42,  503,  504,   42,  506,  505,  509,  508,
-       42,   42,   42,  511,   42,  507,   42,   42,   42,  513,
+      460,  461,  459,  462,  466,  467,  469,   42,   42,   42,
+      470,   42,   42,  468,   42,   42,  472,  471,   42,   42,
+       42,   42,   42,   42,  478,  479,  473,   42,  477,   42,
+      474,  475,  483,   42,  480,  481,  485,   42,  476,  484,
+       42,   42,  482,  488,   42,   42,  490,  486,   42,   42,
+       42,  491,   42,  489,   42,  487,  493,   42,   42,   42,
+       42,  495,   42,   42,   42,   42,   42,  499,  492,  494,
+      502,  504,  503,  506,  500,  496,  497,  501,  498,   42,
+       42,   42,   42,  505,   42,   42,  508,  507,  511,  510,
+       42,   42,   42,   42,  512,  509,   42,   42,   42,  515,
 
-      510,   42,  512,  517,  515,   42,   42,  519,   42,   42,
-      516,   42,   42,   42,  518,   42,  514,   42,  525,  523,
-      520,   42,   42,  521,   42,  526,   42,   42,  522,  527,
-       42,   42,  530,  528,   42,  524,   42,  529,  536,   42,
-       42,   42,   42,   42,  532,   42,  533,  534,  531,   42,
-      535,  542,   42,  537,  538,   42,   42,  543,   42,   42,
-       42,   42,  539,  546,  541,  540,  547,   42,   42,   42,
-       42,   42,   42,   42,   42,  544,  545,   42,   42,   42,
-      548,   39,   39,   39,   39,   39,   41,   41,   51,   42,
-       51,   51,   51,   53,   53,  140,  140,  140,  140,  140,
+       42,  517,   42,  519,   42,   42,  521,  514,   42,  513,
+       42,   42,  518,   42,  520,   42,  516,  522,  525,  527,
+       42,  523,   42,   42,   42,  524,   42,  529,   42,   42,
+      528,  530,   42,  532,  526,   42,   42,   42,  531,   42,
+      538,   42,   42,   42,  534,  536,   42,  535,  533,   42,
+      539,  537,   42,   42,  544,  540,   42,  545,   42,   42,
+      548,  541,   42,  549,  543,  542,   42,  547,   42,   42,
+       42,   42,   42,   42,   42,   42,   42,   42,  550,   39,
+       39,   39,   39,   39,   41,   41,   51,   42,   51,   51,
+       51,   53,   53,  140,  140,  140,  140,  140,   42,   42,
 
        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
@@ -755,17 +756,17 @@
        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-       42,   42,   42,   42,  141,   42,  245,   42,   42,   42,
-       42,  141,   42,  133,   42,   40,  549,    3,  549,  549,
+       42,   42,   42,   42,   42,   42,   42,   42,  141,   42,
+      245,   42,   42,   42,   42,  141,   42,  133,   42,   40,
 
-      549,  549,  549,  549,  549,  549,  549,  549,  549,  549,
-      549,  549,  549,  549,  549,  549,  549,  549,  549,  549,
-      549,  549,  549,  549,  549,  549,  549,  549,  549,  549,
-      549,  549,  549,  549,  549,  549,  549,  549,  549,  549,
-      549,  549
+      551,    3,  551,  551,  551,  551,  551,  551,  551,  551,
+      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
+      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
+      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
+      551,  551,  551,  551,  551,  551
     } ;
 
-static yyconst flex_int16_t yy_chk[1243] =
+static yyconst flex_int16_t yy_chk[1247] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -779,26 +780,26 @@
        18,   31,   24,   17,   18,   17,   13,   17,   19,   20,
 
        17,   31,   18,   36,   23,   20,   38,   21,   30,   20,
-       21,  557,   28,   36,   23,   20,   38,   21,   20,   22,
+       21,  559,   28,   36,   23,   20,   38,   21,   20,   22,
        23,   30,   28,   78,   47,   22,   69,   22,   22,   47,
        27,   28,   30,   78,   26,   22,   27,   28,   55,   22,
        26,   22,   25,   25,   25,   25,   25,   55,   26,   27,
        33,   69,   35,   26,   25,   27,   33,   26,   35,   57,
        37,   37,   56,   33,   25,   29,   58,   61,   57,   33,
-      555,   35,   33,   63,   64,   29,   56,   29,   56,   33,
+      557,   35,   33,   63,   64,   29,   56,   29,   56,   33,
        37,   29,   64,   29,   68,   29,   58,   29,   32,   63,
        59,   61,   32,   45,   45,   45,   45,   45,   66,   75,
 
        68,   32,   32,   59,   32,   32,   32,   59,   32,   54,
-       54,   54,   54,   75,   32,  552,   32,   32,   88,   32,
+       54,   54,   54,   75,   32,  554,   32,   32,   88,   32,
        34,   65,   66,   70,   34,   46,   46,   46,   46,   46,
        46,   88,   70,   34,   34,   72,   34,   65,   34,   65,
-       34,   74,   34,   81,  144,   90,   34,   48,   48,   48,
-       48,   48,   81,   85,   90,   48,  144,  548,   74,   72,
+       34,   74,   34,   81,  219,   90,   34,   48,   48,   48,
+       48,   48,   81,   85,   90,   48,  219,  550,   74,   72,
        85,   48,   49,   49,   49,   49,   49,   49,   50,   50,
        50,   50,   50,   73,   76,   50,   50,   67,   50,   50,
        50,   50,   50,   50,   77,   67,   79,   80,   67,   73,
-       83,   84,  546,   76,   77,  545,   73,   67,   82,   82,
+       83,   84,  548,   76,   77,  547,   73,   67,   82,   82,
 
        82,   82,   82,   86,   89,   87,   80,   83,   77,   91,
        79,   87,   93,   84,   84,   84,   94,   84,   95,   96,
@@ -808,106 +809,106 @@
       106,  107,  110,  114,  103,  105,  111,  109,  106,  113,
       108,  107,  110,  104,  112,  115,  113,  114,  116,  108,
       106,  118,  109,  119,  120,  107,  110,  121,  123,  115,
-      129,  122,  124,  543,  541,  118,  129,  115,  120,  126,
+      129,  122,  124,  169,  539,  118,  129,  115,  120,  126,
       116,  122,  124,  119,  125,  127,  118,  131,  121,  126,
 
       127,  128,  123,  125,  125,  122,  124,  130,  132,  130,
-      145,  148,  147,  125,  150,  128,  125,  128,  152,  131,
-      155,  125,  147,  135,  135,  135,  135,  151,  150,  145,
-      132,  135,  157,  148,  152,  151,  132,  135,  137,  137,
-      137,  137,  137,  155,  156,  164,  137,  158,  157,  159,
-      156,  165,  137,  138,  138,  154,  138,  138,  138,  138,
-      138,  158,  160,  161,  154,  159,  166,  163,  164,  167,
-      161,  169,  160,  168,  170,  165,  160,  163,  172,  168,
-      171,  175,  540,  174,  173,  183,  166,  179,  172,  163,
-      171,  173,  174,  170,  176,  167,  170,  171,  177,  169,
+      145,  169,  151,  125,  539,  128,  125,  128,  150,  131,
+      151,  125,  144,  135,  135,  135,  135,  148,  144,  145,
+      132,  135,  150,  147,  144,  152,  132,  135,  137,  137,
+      137,  137,  137,  147,  155,  157,  137,  545,  164,  148,
+      159,  152,  137,  138,  138,  154,  138,  138,  138,  138,
+      138,  157,  156,  158,  154,  160,  159,  155,  156,  161,
+      163,  164,  165,  166,  167,  160,  161,  158,  168,  160,
+      163,  171,  170,  173,  168,  172,  175,  543,  174,  176,
+      173,  171,  163,  166,  181,  172,  165,  174,  171,  176,
 
-      178,  175,  180,  181,  176,  182,  179,  183,  177,  184,
-      178,  185,  180,  187,  182,  188,  189,  196,  181,  199,
-      204,  210,  202,  187,  178,  184,  203,  240,  209,  205,
-      204,  210,  189,  188,  539,  534,  185,  217,  196,  209,
-      215,  211,  240,  199,  201,  201,  201,  201,  202,  214,
-      203,  201,  201,  205,  201,  201,  201,  201,  201,  201,
-      211,  217,  215,  218,  219,  220,  214,  221,  222,  224,
-      223,  228,  231,  214,  234,  220,  219,  235,  222,  218,
-      223,  236,  231,  237,  234,  238,  222,  221,  243,  237,
-      228,  235,  241,  239,  238,  224,  244,  241,  236,  239,
+      167,  170,  177,  178,  170,  179,  175,  180,  183,  181,
+      182,  185,  177,  178,  188,  184,  187,  180,  189,  182,
+      196,  199,  236,  204,  179,  202,  187,  178,  203,  209,
+      183,  184,  188,  204,  189,  542,  185,  237,  205,  236,
+      209,  196,  215,  237,  211,  199,  201,  201,  201,  201,
+      214,  202,  203,  201,  201,  210,  201,  201,  201,  201,
+      201,  201,  205,  211,  215,  210,  217,  214,  218,  220,
+      222,  221,  223,  224,  214,  228,  231,  234,  235,  220,
+      222,  240,  223,  244,  218,  243,  231,  234,  222,  238,
+      217,  221,  235,  270,  228,  239,  240,  241,  238,  224,
 
-      246,  246,  246,  246,  256,  261,  526,  243,  246,  520,
-      256,  261,  247,  247,  246,  247,  247,  247,  247,  251,
-      244,  248,  248,  248,  248,  249,  249,  249,  249,  249,
-      250,  250,  250,  250,  250,  252,  253,  251,  255,  258,
-      259,  260,  262,  252,  263,  264,  265,  258,  267,  266,
-      276,  269,  273,  268,  253,  274,  255,  260,  263,  268,
-      262,  269,  275,  265,  259,  266,  270,  279,  281,  283,
-      267,  280,  284,  264,  270,  276,  273,  280,  281,  274,
-      285,  283,  286,  279,  287,  275,  289,  275,  288,  292,
-      293,  294,  295,  297,  284,  298,  301,  305,  304,  287,
+      257,  239,  241,  270,  243,  253,  257,  244,  246,  246,
+      246,  246,  541,  253,  247,  247,  246,  247,  247,  247,
+      247,  251,  246,  248,  248,  248,  248,  249,  249,  249,
+      249,  249,  250,  250,  250,  250,  250,  252,  254,  256,
+      259,  260,  261,  262,  251,  263,  264,  265,  259,  262,
+      266,  268,  267,  269,  271,  252,  254,  256,  261,  269,
+      264,  274,  271,  263,  275,  260,  276,  266,  267,  277,
+      280,  281,  282,  268,  285,  265,  286,  281,  284,  289,
+      287,  290,  282,  295,  293,  274,  280,  288,  275,  276,
+      284,  276,  294,  296,  277,  289,  285,  298,  286,  287,
 
-      514,  286,  285,  302,  288,  289,  293,  305,  292,  304,
-      301,  302,  306,  310,  298,  294,  309,  312,  297,  295,
-      314,  310,  313,  306,  316,  321,  309,  312,  313,  319,
-      320,  321,  316,  322,  324,  326,  314,  328,  329,  336,
-      319,  320,  331,  331,  331,  331,  334,  333,  328,  337,
-      340,  322,  329,  333,  343,  334,  324,  337,  338,  326,
-      328,  339,  336,  341,  338,  344,  345,  339,  342,  346,
-      347,  349,  340,  341,  343,  342,  345,  352,  347,  349,
-      353,  354,  355,  357,  356,  344,  359,  346,  360,  361,
-      364,  352,  355,  362,  353,  366,  365,  367,  368,  354,
+      290,  302,  288,  293,  299,  303,  305,  295,  294,  306,
+      307,  398,  315,  303,  310,  302,  323,  305,  311,  306,
+      296,  307,  298,  299,  310,  313,  311,  314,  315,  317,
+      320,  321,  322,  314,  323,  313,  325,  317,  322,  327,
+      398,  320,  321,  329,  335,  330,  332,  332,  332,  332,
+      335,  336,  338,  339,  329,  342,  340,  343,  325,  330,
+      336,  339,  340,  327,  341,  344,  329,  343,  345,  346,
+      341,  347,  344,  348,  349,  338,  351,  342,  354,  355,
+      356,  347,  349,  358,  351,  357,  359,  361,  345,  346,
+      362,  348,  354,  355,  363,  357,  364,  366,  356,  358,
 
-      356,  357,  370,  362,  365,  366,  360,  369,  364,  361,
-      359,  371,  368,  372,  374,  373,  370,  369,  375,  377,
-      378,  382,  367,  388,  379,  374,  380,  384,  386,  388,
-      371,  373,  377,  379,  385,  384,  380,  372,  375,  387,
-      386,  382,  389,  385,  378,  390,  392,  393,  396,  395,
-      399,  397,  403,  387,  404,  400,  401,  403,  403,  409,
-      392,  397,  408,  390,  414,  419,  389,  395,  508,  412,
-      408,  393,  420,  399,  400,  401,  409,  396,  404,  412,
-      413,  416,  422,  423,  425,  426,  413,  419,  414,  416,
-      420,  433,  430,  436,  425,  437,  426,  430,  438,  439,
+      368,  367,  369,  370,  359,  372,  364,  373,  362,  367,
+      368,  361,  371,  374,  363,  366,  375,  370,  376,  372,
+      377,  379,  371,  380,  381,  382,  373,  369,  384,  376,
+      386,  388,  375,  381,  379,  382,  387,  374,  386,  389,
+      377,  391,  392,  388,  390,  387,  395,  380,  384,  394,
+      390,  397,  399,  389,  401,  402,  403,  406,  414,  411,
+      392,  405,  399,  394,  410,  391,  405,  405,  414,  397,
+      395,  416,  410,  415,  402,  403,  411,  401,  418,  415,
+      421,  406,  422,  424,  427,  425,  418,  428,  432,  438,
+      439,  435,  444,  432,  427,  416,  441,  440,  428,  442,
 
-      422,  423,  440,  442,  433,  443,  446,  438,  447,  436,
-      448,  450,  452,  439,  455,  449,  453,  454,  437,  456,
-      440,  450,  452,  457,  443,  458,  459,  442,  446,  456,
-      447,  449,  453,  454,  458,  461,  455,  448,  462,  463,
-      464,  457,  465,  466,  468,  467,  464,  469,  462,  471,
-      459,  472,  465,  467,  473,  463,  474,  476,  477,  469,
-      478,  461,  485,  486,  487,  494,  474,  466,  468,  499,
-      478,  486,  485,  476,  471,  472,  477,  488,  473,  490,
-      491,  492,  497,  487,  488,  500,  491,  490,  497,  494,
-      498,  501,  502,  499,  504,  492,  503,  505,  506,  501,
+      422,  424,  421,  425,  435,  438,  440,  445,  448,  449,
+      441,  450,  451,  439,  452,  454,  444,  442,  455,  456,
+      457,  459,  458,  461,  452,  454,  445,  460,  451,  463,
+      448,  449,  458,  464,  455,  456,  460,  465,  450,  459,
+      466,  467,  457,  464,  468,  470,  466,  461,  469,  471,
+      473,  467,  474,  465,  475,  463,  469,  476,  478,  479,
+      480,  471,  487,  488,  489,  496,  490,  476,  468,  470,
+      480,  488,  487,  490,  478,  473,  474,  479,  475,  492,
+      493,  494,  499,  489,  500,  501,  493,  492,  499,  496,
+      502,  503,  504,  505,  500,  494,  506,  507,  508,  503,
 
-      498,  507,  500,  505,  503,  509,  510,  507,  511,  512,
-      504,  513,  515,  517,  506,  516,  502,  518,  515,  512,
-      509,  519,  521,  510,  522,  516,  523,  524,  511,  517,
-      528,  525,  521,  518,  527,  513,  530,  519,  528,  529,
-      531,  532,  533,  535,  523,  537,  524,  525,  522,  536,
-      527,  535,  538,  529,  530,  542,  544,  536,  547,  496,
-      495,  493,  531,  542,  533,  532,  544,  489,  484,  483,
-      482,  481,  480,  479,  475,  537,  538,  470,  460,  451,
-      547,  550,  550,  550,  550,  550,  551,  551,  553,  445,
-      553,  553,  553,  554,  554,  556,  556,  556,  556,  556,
+      509,  505,  511,  507,  512,  513,  509,  502,  514,  501,
+      515,  519,  506,  517,  508,  520,  504,  511,  514,  517,
+      518,  512,  521,  523,  524,  513,  525,  519,  526,  527,
+      518,  520,  530,  523,  515,  529,  531,  532,  521,  533,
+      530,  534,  535,  540,  525,  527,  537,  526,  524,  538,
+      531,  529,  544,  546,  537,  532,  549,  538,  536,  528,
+      544,  533,  522,  546,  535,  534,  516,  540,  510,  498,
+      497,  495,  491,  486,  485,  484,  483,  482,  549,  552,
+      552,  552,  552,  552,  553,  553,  555,  481,  555,  555,
+      555,  556,  556,  558,  558,  558,  558,  558,  477,  472,
 
-      444,  441,  435,  434,  432,  431,  429,  428,  427,  424,
-      421,  418,  417,  415,  411,  410,  407,  406,  405,  402,
-      398,  394,  391,  383,  381,  376,  363,  358,  351,  350,
-      348,  335,  332,  330,  327,  325,  323,  318,  317,  315,
-      311,  308,  307,  303,  300,  296,  291,  290,  282,  278,
-      277,  272,  271,  257,  254,  242,  233,  232,  230,  229,
-      227,  226,  225,  216,  213,  212,  208,  207,  206,  200,
-      198,  197,  195,  194,  193,  192,  191,  190,  186,  162,
-      153,  149,  146,  143,  140,  136,  133,  117,   92,   71,
-       62,   52,   41,   39,    8,    7,    3,  549,  549,  549,
+      462,  453,  447,  446,  443,  437,  436,  434,  433,  431,
+      430,  429,  426,  423,  420,  419,  417,  413,  412,  409,
+      408,  407,  404,  400,  396,  393,  385,  383,  378,  365,
+      360,  353,  352,  350,  337,  334,  333,  331,  328,  326,
+      324,  319,  318,  316,  312,  309,  308,  304,  301,  297,
+      292,  291,  283,  279,  278,  273,  272,  258,  255,  242,
+      233,  232,  230,  229,  227,  226,  225,  216,  213,  212,
+      208,  207,  206,  200,  198,  197,  195,  194,  193,  192,
+      191,  190,  186,  162,  153,  149,  146,  143,  140,  136,
+      133,  117,   92,   71,   62,   52,   41,   39,    8,    7,
 
-      549,  549,  549,  549,  549,  549,  549,  549,  549,  549,
-      549,  549,  549,  549,  549,  549,  549,  549,  549,  549,
-      549,  549,  549,  549,  549,  549,  549,  549,  549,  549,
-      549,  549,  549,  549,  549,  549,  549,  549,  549,  549,
-      549,  549
+        3,  551,  551,  551,  551,  551,  551,  551,  551,  551,
+      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
+      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
+      551,  551,  551,  551,  551,  551,  551,  551,  551,  551,
+      551,  551,  551,  551,  551,  551
     } ;
 
 /* Table of booleans, true if rule could match eol. */
-static yyconst flex_int32_t yy_rule_can_match_eol[137] =
+static yyconst flex_int32_t yy_rule_can_match_eol[138] =
     {   0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
@@ -915,7 +916,7 @@
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,     };
+    0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,     };
 
 static yy_state_type yy_last_accepting_state;
 static char *yy_last_accepting_cpos;
@@ -931,7 +932,7 @@
 #define YY_MORE_ADJ 0
 #define YY_RESTORE_YY_MORE_OFFSET
 char *llvmAsmtext;
-#line 1 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 1 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 /*===-- Lexer.l - Scanner for llvm assembly files --------------*- C++ -*--===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -944,7 +945,7 @@
 //  This file implements the flex scanner for LLVM assembly languages files.
 //
 //===----------------------------------------------------------------------===*/
-#line 28 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 28 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 #include "ParserInternals.h"
 #include "llvm/Module.h"
 #include <list>
@@ -1077,7 +1078,7 @@
 /* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing
  * it to deal with 64 bit numbers.
  */
-#line 1081 "Lexer.cpp"
+#line 1082 "Lexer.cpp"
 
 #define INITIAL 0
 
@@ -1230,10 +1231,10 @@
 	register char *yy_cp, *yy_bp;
 	register int yy_act;
     
-#line 190 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 190 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 
 
-#line 1237 "Lexer.cpp"
+#line 1238 "Lexer.cpp"
 
 	if ( !(yy_init) )
 		{
@@ -1286,13 +1287,13 @@
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 550 )
+				if ( yy_current_state >= 552 )
 					yy_c = yy_meta[(unsigned int) yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 			++yy_cp;
 			}
-		while ( yy_current_state != 549 );
+		while ( yy_current_state != 551 );
 		yy_cp = (yy_last_accepting_cpos);
 		yy_current_state = (yy_last_accepting_state);
 
@@ -1324,262 +1325,267 @@
 
 case 1:
 YY_RULE_SETUP
-#line 192 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 192 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { /* Ignore comments for now */ }
 	YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 194 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 194 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return BEGINTOK; }
 	YY_BREAK
 case 3:
 YY_RULE_SETUP
-#line 195 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 195 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return ENDTOK; }
 	YY_BREAK
 case 4:
 YY_RULE_SETUP
-#line 196 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 196 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return TRUETOK;  }
 	YY_BREAK
 case 5:
 YY_RULE_SETUP
-#line 197 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 197 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return FALSETOK; }
 	YY_BREAK
 case 6:
 YY_RULE_SETUP
-#line 198 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 198 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return DECLARE; }
 	YY_BREAK
 case 7:
 YY_RULE_SETUP
-#line 199 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 199 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return DEFINE; }
 	YY_BREAK
 case 8:
 YY_RULE_SETUP
-#line 200 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 200 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return GLOBAL; }
 	YY_BREAK
 case 9:
 YY_RULE_SETUP
-#line 201 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 201 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return CONSTANT; }
 	YY_BREAK
 case 10:
 YY_RULE_SETUP
-#line 202 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 202 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return INTERNAL; }
 	YY_BREAK
 case 11:
 YY_RULE_SETUP
-#line 203 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 203 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return LINKONCE; }
 	YY_BREAK
 case 12:
 YY_RULE_SETUP
-#line 204 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 204 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return WEAK; }
 	YY_BREAK
 case 13:
 YY_RULE_SETUP
-#line 205 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 205 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return APPENDING; }
 	YY_BREAK
 case 14:
 YY_RULE_SETUP
-#line 206 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 206 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return DLLIMPORT; }
 	YY_BREAK
 case 15:
 YY_RULE_SETUP
-#line 207 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 207 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return DLLEXPORT; }
 	YY_BREAK
 case 16:
 YY_RULE_SETUP
-#line 208 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 208 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return HIDDEN; }
 	YY_BREAK
 case 17:
 YY_RULE_SETUP
-#line 209 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 209 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return EXTERN_WEAK; }
 	YY_BREAK
 case 18:
 YY_RULE_SETUP
-#line 210 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 210 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return EXTERNAL; }
 	YY_BREAK
 case 19:
 YY_RULE_SETUP
-#line 211 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 211 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return THREAD_LOCAL; }
 	YY_BREAK
 case 20:
 YY_RULE_SETUP
-#line 212 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 212 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return ZEROINITIALIZER; }
 	YY_BREAK
 case 21:
 YY_RULE_SETUP
-#line 213 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 213 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return DOTDOTDOT; }
 	YY_BREAK
 case 22:
 YY_RULE_SETUP
-#line 214 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 214 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return UNDEF; }
 	YY_BREAK
 case 23:
 YY_RULE_SETUP
-#line 215 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 215 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return NULL_TOK; }
 	YY_BREAK
 case 24:
 YY_RULE_SETUP
-#line 216 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 216 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return TO; }
 	YY_BREAK
 case 25:
 YY_RULE_SETUP
-#line 217 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 217 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return TAIL; }
 	YY_BREAK
 case 26:
 YY_RULE_SETUP
-#line 218 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 218 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return TARGET; }
 	YY_BREAK
 case 27:
 YY_RULE_SETUP
-#line 219 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 219 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return TRIPLE; }
 	YY_BREAK
 case 28:
 YY_RULE_SETUP
-#line 220 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 220 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return DEPLIBS; }
 	YY_BREAK
 case 29:
 YY_RULE_SETUP
-#line 221 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 221 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return DATALAYOUT; }
 	YY_BREAK
 case 30:
 YY_RULE_SETUP
-#line 222 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 222 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return VOLATILE; }
 	YY_BREAK
 case 31:
 YY_RULE_SETUP
-#line 223 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 223 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return ALIGN;  }
 	YY_BREAK
 case 32:
 YY_RULE_SETUP
-#line 224 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 224 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { return SECTION; }
 	YY_BREAK
 case 33:
 YY_RULE_SETUP
-#line 225 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return MODULE; }
+#line 225 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return ALIAS; }
 	YY_BREAK
 case 34:
 YY_RULE_SETUP
-#line 226 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return ASM_TOK; }
+#line 226 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return MODULE; }
 	YY_BREAK
 case 35:
 YY_RULE_SETUP
-#line 227 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return SIDEEFFECT; }
+#line 227 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return ASM_TOK; }
 	YY_BREAK
 case 36:
 YY_RULE_SETUP
-#line 229 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return CC_TOK; }
+#line 228 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return SIDEEFFECT; }
 	YY_BREAK
 case 37:
 YY_RULE_SETUP
-#line 230 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return CCC_TOK; }
+#line 230 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return CC_TOK; }
 	YY_BREAK
 case 38:
 YY_RULE_SETUP
-#line 231 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return FASTCC_TOK; }
+#line 231 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return CCC_TOK; }
 	YY_BREAK
 case 39:
 YY_RULE_SETUP
-#line 232 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return COLDCC_TOK; }
+#line 232 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return FASTCC_TOK; }
 	YY_BREAK
 case 40:
 YY_RULE_SETUP
-#line 233 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return X86_STDCALLCC_TOK; }
+#line 233 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return COLDCC_TOK; }
 	YY_BREAK
 case 41:
 YY_RULE_SETUP
-#line 234 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return X86_FASTCALLCC_TOK; }
+#line 234 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return X86_STDCALLCC_TOK; }
 	YY_BREAK
 case 42:
 YY_RULE_SETUP
-#line 236 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return INREG; }
+#line 235 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return X86_FASTCALLCC_TOK; }
 	YY_BREAK
 case 43:
 YY_RULE_SETUP
-#line 237 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return SRET;  }
+#line 237 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return INREG; }
 	YY_BREAK
 case 44:
 YY_RULE_SETUP
-#line 238 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return NOUNWIND; }
+#line 238 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return SRET;  }
 	YY_BREAK
 case 45:
 YY_RULE_SETUP
-#line 239 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return NORETURN; }
+#line 239 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return NOUNWIND; }
 	YY_BREAK
 case 46:
 YY_RULE_SETUP
-#line 241 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TY(Type::VoidTy,  VOID);  }
+#line 240 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return NORETURN; }
 	YY_BREAK
 case 47:
 YY_RULE_SETUP
-#line 242 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TY(Type::FloatTy, FLOAT); }
+#line 242 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TY(Type::VoidTy,  VOID);  }
 	YY_BREAK
 case 48:
 YY_RULE_SETUP
-#line 243 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TY(Type::DoubleTy,DOUBLE);}
+#line 243 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TY(Type::FloatTy, FLOAT); }
 	YY_BREAK
 case 49:
 YY_RULE_SETUP
-#line 244 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TY(Type::LabelTy, LABEL); }
+#line 244 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TY(Type::DoubleTy,DOUBLE);}
 	YY_BREAK
 case 50:
 YY_RULE_SETUP
-#line 245 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return TYPE;   }
+#line 245 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TY(Type::LabelTy, LABEL); }
 	YY_BREAK
 case 51:
 YY_RULE_SETUP
-#line 246 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return OPAQUE; }
+#line 246 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return TYPE;   }
 	YY_BREAK
 case 52:
 YY_RULE_SETUP
-#line 247 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 247 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return OPAQUE; }
+	YY_BREAK
+case 53:
+YY_RULE_SETUP
+#line 248 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { uint64_t NumBits = atoull(llvmAsmtext+1);
                   if (NumBits < IntegerType::MIN_INT_BITS || 
                       NumBits > IntegerType::MAX_INT_BITS)
@@ -1588,367 +1594,367 @@
                   RET_TY(Ty, INTTYPE);
                 }
 	YY_BREAK
-case 53:
-YY_RULE_SETUP
-#line 255 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, Add, ADD); }
-	YY_BREAK
 case 54:
 YY_RULE_SETUP
-#line 256 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, Sub, SUB); }
+#line 256 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, Add, ADD); }
 	YY_BREAK
 case 55:
 YY_RULE_SETUP
-#line 257 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, Mul, MUL); }
+#line 257 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, Sub, SUB); }
 	YY_BREAK
 case 56:
 YY_RULE_SETUP
-#line 258 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, UDiv, UDIV); }
+#line 258 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, Mul, MUL); }
 	YY_BREAK
 case 57:
 YY_RULE_SETUP
-#line 259 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, SDiv, SDIV); }
+#line 259 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, UDiv, UDIV); }
 	YY_BREAK
 case 58:
 YY_RULE_SETUP
-#line 260 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, FDiv, FDIV); }
+#line 260 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, SDiv, SDIV); }
 	YY_BREAK
 case 59:
 YY_RULE_SETUP
-#line 261 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, URem, UREM); }
+#line 261 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, FDiv, FDIV); }
 	YY_BREAK
 case 60:
 YY_RULE_SETUP
-#line 262 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, SRem, SREM); }
+#line 262 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, URem, UREM); }
 	YY_BREAK
 case 61:
 YY_RULE_SETUP
-#line 263 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, FRem, FREM); }
+#line 263 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, SRem, SREM); }
 	YY_BREAK
 case 62:
 YY_RULE_SETUP
-#line 264 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, Shl, SHL); }
+#line 264 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, FRem, FREM); }
 	YY_BREAK
 case 63:
 YY_RULE_SETUP
-#line 265 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, LShr, LSHR); }
+#line 265 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, Shl, SHL); }
 	YY_BREAK
 case 64:
 YY_RULE_SETUP
-#line 266 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, AShr, ASHR); }
+#line 266 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, LShr, LSHR); }
 	YY_BREAK
 case 65:
 YY_RULE_SETUP
-#line 267 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, And, AND); }
+#line 267 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, AShr, ASHR); }
 	YY_BREAK
 case 66:
 YY_RULE_SETUP
-#line 268 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, Or , OR ); }
+#line 268 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, And, AND); }
 	YY_BREAK
 case 67:
 YY_RULE_SETUP
-#line 269 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(BinaryOpVal, Xor, XOR); }
+#line 269 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, Or , OR ); }
 	YY_BREAK
 case 68:
 YY_RULE_SETUP
-#line 270 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(OtherOpVal,  ICmp,  ICMP); }
+#line 270 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(BinaryOpVal, Xor, XOR); }
 	YY_BREAK
 case 69:
 YY_RULE_SETUP
-#line 271 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(OtherOpVal,  FCmp,  FCMP); }
+#line 271 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(OtherOpVal,  ICmp,  ICMP); }
 	YY_BREAK
 case 70:
 YY_RULE_SETUP
-#line 273 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return EQ;  }
+#line 272 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(OtherOpVal,  FCmp,  FCMP); }
 	YY_BREAK
 case 71:
 YY_RULE_SETUP
-#line 274 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return NE;  }
+#line 274 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return EQ;  }
 	YY_BREAK
 case 72:
 YY_RULE_SETUP
-#line 275 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return SLT; }
+#line 275 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return NE;  }
 	YY_BREAK
 case 73:
 YY_RULE_SETUP
-#line 276 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return SGT; }
+#line 276 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return SLT; }
 	YY_BREAK
 case 74:
 YY_RULE_SETUP
-#line 277 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return SLE; }
+#line 277 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return SGT; }
 	YY_BREAK
 case 75:
 YY_RULE_SETUP
-#line 278 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return SGE; }
+#line 278 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return SLE; }
 	YY_BREAK
 case 76:
 YY_RULE_SETUP
-#line 279 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return ULT; }
+#line 279 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return SGE; }
 	YY_BREAK
 case 77:
 YY_RULE_SETUP
-#line 280 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return UGT; }
+#line 280 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return ULT; }
 	YY_BREAK
 case 78:
 YY_RULE_SETUP
-#line 281 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return ULE; }
+#line 281 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return UGT; }
 	YY_BREAK
 case 79:
 YY_RULE_SETUP
-#line 282 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return UGE; }
+#line 282 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return ULE; }
 	YY_BREAK
 case 80:
 YY_RULE_SETUP
-#line 283 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return OEQ; }
+#line 283 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return UGE; }
 	YY_BREAK
 case 81:
 YY_RULE_SETUP
-#line 284 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return ONE; }
+#line 284 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return OEQ; }
 	YY_BREAK
 case 82:
 YY_RULE_SETUP
-#line 285 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return OLT; }
+#line 285 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return ONE; }
 	YY_BREAK
 case 83:
 YY_RULE_SETUP
-#line 286 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return OGT; }
+#line 286 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return OLT; }
 	YY_BREAK
 case 84:
 YY_RULE_SETUP
-#line 287 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return OLE; }
+#line 287 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return OGT; }
 	YY_BREAK
 case 85:
 YY_RULE_SETUP
-#line 288 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return OGE; }
+#line 288 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return OLE; }
 	YY_BREAK
 case 86:
 YY_RULE_SETUP
-#line 289 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return ORD; }
+#line 289 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return OGE; }
 	YY_BREAK
 case 87:
 YY_RULE_SETUP
-#line 290 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return UNO; }
+#line 290 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return ORD; }
 	YY_BREAK
 case 88:
 YY_RULE_SETUP
-#line 291 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return UEQ; }
+#line 291 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return UNO; }
 	YY_BREAK
 case 89:
 YY_RULE_SETUP
-#line 292 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return UNE; }
+#line 292 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return UEQ; }
 	YY_BREAK
 case 90:
 YY_RULE_SETUP
-#line 294 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(OtherOpVal, PHI, PHI_TOK); }
+#line 293 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return UNE; }
 	YY_BREAK
 case 91:
 YY_RULE_SETUP
-#line 295 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(OtherOpVal, Call, CALL); }
+#line 295 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(OtherOpVal, PHI, PHI_TOK); }
 	YY_BREAK
 case 92:
 YY_RULE_SETUP
-#line 296 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(CastOpVal, Trunc, TRUNC); }
+#line 296 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(OtherOpVal, Call, CALL); }
 	YY_BREAK
 case 93:
 YY_RULE_SETUP
-#line 297 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(CastOpVal, ZExt, ZEXT); }
+#line 297 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(CastOpVal, Trunc, TRUNC); }
 	YY_BREAK
 case 94:
 YY_RULE_SETUP
-#line 298 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(CastOpVal, SExt, SEXT); }
+#line 298 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(CastOpVal, ZExt, ZEXT); }
 	YY_BREAK
 case 95:
 YY_RULE_SETUP
-#line 299 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(CastOpVal, FPTrunc, FPTRUNC); }
+#line 299 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(CastOpVal, SExt, SEXT); }
 	YY_BREAK
 case 96:
 YY_RULE_SETUP
-#line 300 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(CastOpVal, FPExt, FPEXT); }
+#line 300 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(CastOpVal, FPTrunc, FPTRUNC); }
 	YY_BREAK
 case 97:
 YY_RULE_SETUP
-#line 301 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(CastOpVal, UIToFP, UITOFP); }
+#line 301 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(CastOpVal, FPExt, FPEXT); }
 	YY_BREAK
 case 98:
 YY_RULE_SETUP
-#line 302 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(CastOpVal, SIToFP, SITOFP); }
+#line 302 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(CastOpVal, UIToFP, UITOFP); }
 	YY_BREAK
 case 99:
 YY_RULE_SETUP
-#line 303 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(CastOpVal, FPToUI, FPTOUI); }
+#line 303 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(CastOpVal, SIToFP, SITOFP); }
 	YY_BREAK
 case 100:
 YY_RULE_SETUP
-#line 304 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(CastOpVal, FPToSI, FPTOSI); }
+#line 304 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(CastOpVal, FPToUI, FPTOUI); }
 	YY_BREAK
 case 101:
 YY_RULE_SETUP
-#line 305 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(CastOpVal, IntToPtr, INTTOPTR); }
+#line 305 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(CastOpVal, FPToSI, FPTOSI); }
 	YY_BREAK
 case 102:
 YY_RULE_SETUP
-#line 306 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(CastOpVal, PtrToInt, PTRTOINT); }
+#line 306 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(CastOpVal, IntToPtr, INTTOPTR); }
 	YY_BREAK
 case 103:
 YY_RULE_SETUP
-#line 307 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(CastOpVal, BitCast, BITCAST); }
+#line 307 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(CastOpVal, PtrToInt, PTRTOINT); }
 	YY_BREAK
 case 104:
 YY_RULE_SETUP
-#line 308 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(OtherOpVal, Select, SELECT); }
+#line 308 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(CastOpVal, BitCast, BITCAST); }
 	YY_BREAK
 case 105:
 YY_RULE_SETUP
-#line 309 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(OtherOpVal, VAArg , VAARG); }
+#line 309 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(OtherOpVal, Select, SELECT); }
 	YY_BREAK
 case 106:
 YY_RULE_SETUP
-#line 310 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(TermOpVal, Ret, RET); }
+#line 310 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(OtherOpVal, VAArg , VAARG); }
 	YY_BREAK
 case 107:
 YY_RULE_SETUP
-#line 311 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(TermOpVal, Br, BR); }
+#line 311 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(TermOpVal, Ret, RET); }
 	YY_BREAK
 case 108:
 YY_RULE_SETUP
-#line 312 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(TermOpVal, Switch, SWITCH); }
+#line 312 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(TermOpVal, Br, BR); }
 	YY_BREAK
 case 109:
 YY_RULE_SETUP
-#line 313 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(TermOpVal, Invoke, INVOKE); }
+#line 313 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(TermOpVal, Switch, SWITCH); }
 	YY_BREAK
 case 110:
 YY_RULE_SETUP
-#line 314 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(TermOpVal, Unwind, UNWIND); }
+#line 314 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(TermOpVal, Invoke, INVOKE); }
 	YY_BREAK
 case 111:
 YY_RULE_SETUP
-#line 315 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(TermOpVal, Unreachable, UNREACHABLE); }
+#line 315 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(TermOpVal, Unwind, UNWIND); }
 	YY_BREAK
 case 112:
 YY_RULE_SETUP
-#line 317 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(MemOpVal, Malloc, MALLOC); }
+#line 316 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(TermOpVal, Unreachable, UNREACHABLE); }
 	YY_BREAK
 case 113:
 YY_RULE_SETUP
-#line 318 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(MemOpVal, Alloca, ALLOCA); }
+#line 318 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(MemOpVal, Malloc, MALLOC); }
 	YY_BREAK
 case 114:
 YY_RULE_SETUP
-#line 319 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(MemOpVal, Free, FREE); }
+#line 319 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(MemOpVal, Alloca, ALLOCA); }
 	YY_BREAK
 case 115:
 YY_RULE_SETUP
-#line 320 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(MemOpVal, Load, LOAD); }
+#line 320 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(MemOpVal, Free, FREE); }
 	YY_BREAK
 case 116:
 YY_RULE_SETUP
-#line 321 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(MemOpVal, Store, STORE); }
+#line 321 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(MemOpVal, Load, LOAD); }
 	YY_BREAK
 case 117:
 YY_RULE_SETUP
-#line 322 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
+#line 322 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(MemOpVal, Store, STORE); }
 	YY_BREAK
 case 118:
 YY_RULE_SETUP
-#line 324 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); }
+#line 323 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
 	YY_BREAK
 case 119:
 YY_RULE_SETUP
-#line 325 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); }
+#line 325 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); }
 	YY_BREAK
 case 120:
 YY_RULE_SETUP
-#line 326 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
+#line 326 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); }
 	YY_BREAK
 case 121:
 YY_RULE_SETUP
-#line 329 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 327 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
+	YY_BREAK
+case 122:
+YY_RULE_SETUP
+#line 330 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 {
                   UnEscapeLexed(llvmAsmtext+1);
                   llvmAsmlval.StrVal = strdup(llvmAsmtext+1);             // Skip %
                   return LOCALVAR;
                 }
 	YY_BREAK
-case 122:
+case 123:
 YY_RULE_SETUP
-#line 334 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 335 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 {
                   UnEscapeLexed(llvmAsmtext+1);
                   llvmAsmlval.StrVal = strdup(llvmAsmtext+1);             // Skip @
                   return GLOBALVAR;
                 }
 	YY_BREAK
-case 123:
+case 124:
 YY_RULE_SETUP
-#line 339 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 340 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 {
                   llvmAsmtext[strlen(llvmAsmtext)-1] = 0;  // nuke colon
                   UnEscapeLexed(llvmAsmtext);
@@ -1956,10 +1962,10 @@
                   return LABELSTR;
                 }
 	YY_BREAK
-case 124:
-/* rule 124 can match eol */
+case 125:
+/* rule 125 can match eol */
 YY_RULE_SETUP
-#line 345 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 346 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 {
                   llvmAsmtext[strlen(llvmAsmtext)-2] = 0;  // nuke colon, end quote
                   UnEscapeLexed(llvmAsmtext+1);
@@ -1967,10 +1973,10 @@
                   return LABELSTR;
                 }
 	YY_BREAK
-case 125:
-/* rule 125 can match eol */
+case 126:
+/* rule 126 can match eol */
 YY_RULE_SETUP
-#line 352 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 353 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { // Note that we cannot unescape a string constant here!  The
                    // string constant might contain a \00 which would not be
                    // understood by the string stuff.  It is valid to make a
@@ -1981,19 +1987,19 @@
                    return STRINGCONSTANT;
                  }
 	YY_BREAK
-case 126:
-/* rule 126 can match eol */
+case 127:
+/* rule 127 can match eol */
 YY_RULE_SETUP
-#line 361 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 362 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 {
                      llvmAsmtext[strlen(llvmAsmtext)-1] = 0;           // nuke end quote
                      llvmAsmlval.StrVal = strdup(llvmAsmtext+2);  // Nuke @, quote
                      return ATSTRINGCONSTANT;
                    }
 	YY_BREAK
-case 127:
+case 128:
 YY_RULE_SETUP
-#line 367 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 368 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { int len = strlen(llvmAsmtext); 
                   uint32_t numBits = ((len * 64) / 19) + 1;
                   APInt Tmp(numBits, llvmAsmtext, len, 10);
@@ -2009,9 +2015,9 @@
                   }
                 }
 	YY_BREAK
-case 128:
+case 129:
 YY_RULE_SETUP
-#line 381 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 382 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { int len = strlen(llvmAsmtext); 
                   uint32_t numBits = (((len-1) * 64) / 19) + 2;
                   APInt Tmp(numBits, llvmAsmtext, len, 10);
@@ -2027,9 +2033,9 @@
                   }
                 }
 	YY_BREAK
-case 129:
+case 130:
 YY_RULE_SETUP
-#line 396 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 397 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { int len = strlen(llvmAsmtext+3) - 3;
                    uint32_t bits = len * 4;
                    APInt Tmp(bits, llvmAsmtext+3, len, 16);
@@ -2048,9 +2054,9 @@
                    }
                  }
 	YY_BREAK
-case 130:
+case 131:
 YY_RULE_SETUP
-#line 414 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 415 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 {
                   uint64_t Val = atoull(llvmAsmtext+1);
                   if ((unsigned)Val != Val)
@@ -2059,9 +2065,9 @@
                   return LOCALVAL_ID;
                 }
 	YY_BREAK
-case 131:
+case 132:
 YY_RULE_SETUP
-#line 421 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 422 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 {
                   uint64_t Val = atoull(llvmAsmtext+1);
                   if ((unsigned)Val != Val)
@@ -2070,18 +2076,18 @@
                   return GLOBALVAL_ID;
                 }
 	YY_BREAK
-case 132:
-YY_RULE_SETUP
-#line 429 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ llvmAsmlval.FPVal = atof(llvmAsmtext); return FPVAL; }
-	YY_BREAK
 case 133:
 YY_RULE_SETUP
-#line 430 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 430 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ llvmAsmlval.FPVal = atof(llvmAsmtext); return FPVAL; }
+	YY_BREAK
+case 134:
+YY_RULE_SETUP
+#line 431 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 { llvmAsmlval.FPVal = HexToFP(llvmAsmtext); return FPVAL; }
 	YY_BREAK
 case YY_STATE_EOF(INITIAL):
-#line 432 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 433 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 {
                   /* Make sure to free the internal buffers for flex when we are
                    * done reading our input!
@@ -2090,23 +2096,23 @@
                   return EOF;
                 }
 	YY_BREAK
-case 134:
-/* rule 134 can match eol */
-YY_RULE_SETUP
-#line 440 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ /* Ignore whitespace */ }
-	YY_BREAK
 case 135:
+/* rule 135 can match eol */
 YY_RULE_SETUP
-#line 441 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
-{ return llvmAsmtext[0]; }
+#line 441 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ /* Ignore whitespace */ }
 	YY_BREAK
 case 136:
 YY_RULE_SETUP
-#line 443 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 442 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
+{ return llvmAsmtext[0]; }
+	YY_BREAK
+case 137:
+YY_RULE_SETUP
+#line 444 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 2110 "Lexer.cpp"
+#line 2116 "Lexer.cpp"
 
 	case YY_END_OF_BUFFER:
 		{
@@ -2389,7 +2395,7 @@
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 550 )
+			if ( yy_current_state >= 552 )
 				yy_c = yy_meta[(unsigned int) yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
@@ -2417,11 +2423,11 @@
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 550 )
+		if ( yy_current_state >= 552 )
 			yy_c = yy_meta[(unsigned int) yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 549);
+	yy_is_jam = (yy_current_state == 551);
 
 	return yy_is_jam ? 0 : yy_current_state;
 }
@@ -2842,7 +2848,7 @@
 
 /** Setup the input buffer state to scan a string. The next call to llvmAsmlex() will
  * scan from a @e copy of @a str.
- * @param yystr a NUL-terminated string to scan
+ * @param str a NUL-terminated string to scan
  * 
  * @return the newly allocated buffer state object.
  * @note If you want to scan bytes that may contain NUL values, then use
@@ -3099,7 +3105,7 @@
 
 #define YYTABLES_NAME "yytables"
 
-#line 443 "/home/laurov/llvm/llvm/lib/AsmParser/Lexer.l"
+#line 444 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
 
 
 
diff --git a/lib/AsmParser/Lexer.l.cvs b/lib/AsmParser/Lexer.l.cvs
index d75d070..382ce24 100644
--- a/lib/AsmParser/Lexer.l.cvs
+++ b/lib/AsmParser/Lexer.l.cvs
@@ -222,6 +222,7 @@
 volatile        { return VOLATILE; }
 align           { return ALIGN;  }
 section         { return SECTION; }
+alias           { return ALIAS; }
 module          { return MODULE; }
 asm             { return ASM_TOK; }
 sideeffect      { return SIDEEFFECT; }
diff --git a/lib/AsmParser/llvmAsmParser.cpp.cvs b/lib/AsmParser/llvmAsmParser.cpp.cvs
index 6d79fb5..28061f8 100644
--- a/lib/AsmParser/llvmAsmParser.cpp.cvs
+++ b/lib/AsmParser/llvmAsmParser.cpp.cvs
@@ -1,150 +1,354 @@
+/* A Bison parser, made by GNU Bison 2.3.  */
 
-/*  A Bison parser, made from /Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y
-    by GNU Bison version 1.28  */
+/* Skeleton implementation for Bison's Yacc-like parsers in C
 
-#define YYBISON 1  /* Identify Bison output.  */
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.
 
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output.  */
+#define YYBISON 1
+
+/* Bison version.  */
+#define YYBISON_VERSION "2.3"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 0
+
+/* Using locations.  */
+#define YYLSP_NEEDED 0
+
+/* Substitute the variable and function names.  */
 #define yyparse llvmAsmparse
-#define yylex llvmAsmlex
+#define yylex   llvmAsmlex
 #define yyerror llvmAsmerror
-#define yylval llvmAsmlval
-#define yychar llvmAsmchar
+#define yylval  llvmAsmlval
+#define yychar  llvmAsmchar
 #define yydebug llvmAsmdebug
 #define yynerrs llvmAsmnerrs
-#define	ESINT64VAL	257
-#define	EUINT64VAL	258
-#define	ESAPINTVAL	259
-#define	EUAPINTVAL	260
-#define	LOCALVAL_ID	261
-#define	GLOBALVAL_ID	262
-#define	FPVAL	263
-#define	VOID	264
-#define	INTTYPE	265
-#define	FLOAT	266
-#define	DOUBLE	267
-#define	LABEL	268
-#define	TYPE	269
-#define	LOCALVAR	270
-#define	GLOBALVAR	271
-#define	LABELSTR	272
-#define	STRINGCONSTANT	273
-#define	ATSTRINGCONSTANT	274
-#define	ZEROINITIALIZER	275
-#define	TRUETOK	276
-#define	FALSETOK	277
-#define	BEGINTOK	278
-#define	ENDTOK	279
-#define	DECLARE	280
-#define	DEFINE	281
-#define	GLOBAL	282
-#define	CONSTANT	283
-#define	SECTION	284
-#define	VOLATILE	285
-#define	THREAD_LOCAL	286
-#define	TO	287
-#define	DOTDOTDOT	288
-#define	NULL_TOK	289
-#define	UNDEF	290
-#define	INTERNAL	291
-#define	LINKONCE	292
-#define	WEAK	293
-#define	APPENDING	294
-#define	DLLIMPORT	295
-#define	DLLEXPORT	296
-#define	EXTERN_WEAK	297
-#define	OPAQUE	298
-#define	EXTERNAL	299
-#define	TARGET	300
-#define	TRIPLE	301
-#define	ALIGN	302
-#define	DEPLIBS	303
-#define	CALL	304
-#define	TAIL	305
-#define	ASM_TOK	306
-#define	MODULE	307
-#define	SIDEEFFECT	308
-#define	CC_TOK	309
-#define	CCC_TOK	310
-#define	FASTCC_TOK	311
-#define	COLDCC_TOK	312
-#define	X86_STDCALLCC_TOK	313
-#define	X86_FASTCALLCC_TOK	314
-#define	DATALAYOUT	315
-#define	RET	316
-#define	BR	317
-#define	SWITCH	318
-#define	INVOKE	319
-#define	UNWIND	320
-#define	UNREACHABLE	321
-#define	ADD	322
-#define	SUB	323
-#define	MUL	324
-#define	UDIV	325
-#define	SDIV	326
-#define	FDIV	327
-#define	UREM	328
-#define	SREM	329
-#define	FREM	330
-#define	AND	331
-#define	OR	332
-#define	XOR	333
-#define	SHL	334
-#define	LSHR	335
-#define	ASHR	336
-#define	ICMP	337
-#define	FCMP	338
-#define	EQ	339
-#define	NE	340
-#define	SLT	341
-#define	SGT	342
-#define	SLE	343
-#define	SGE	344
-#define	ULT	345
-#define	UGT	346
-#define	ULE	347
-#define	UGE	348
-#define	OEQ	349
-#define	ONE	350
-#define	OLT	351
-#define	OGT	352
-#define	OLE	353
-#define	OGE	354
-#define	ORD	355
-#define	UNO	356
-#define	UEQ	357
-#define	UNE	358
-#define	MALLOC	359
-#define	ALLOCA	360
-#define	FREE	361
-#define	LOAD	362
-#define	STORE	363
-#define	GETELEMENTPTR	364
-#define	TRUNC	365
-#define	ZEXT	366
-#define	SEXT	367
-#define	FPTRUNC	368
-#define	FPEXT	369
-#define	BITCAST	370
-#define	UITOFP	371
-#define	SITOFP	372
-#define	FPTOUI	373
-#define	FPTOSI	374
-#define	INTTOPTR	375
-#define	PTRTOINT	376
-#define	PHI_TOK	377
-#define	SELECT	378
-#define	VAARG	379
-#define	EXTRACTELEMENT	380
-#define	INSERTELEMENT	381
-#define	SHUFFLEVECTOR	382
-#define	NORETURN	383
-#define	INREG	384
-#define	SRET	385
-#define	NOUNWIND	386
-#define	DEFAULT	387
-#define	HIDDEN	388
 
-#line 14 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     ESINT64VAL = 258,
+     EUINT64VAL = 259,
+     ESAPINTVAL = 260,
+     EUAPINTVAL = 261,
+     LOCALVAL_ID = 262,
+     GLOBALVAL_ID = 263,
+     FPVAL = 264,
+     VOID = 265,
+     INTTYPE = 266,
+     FLOAT = 267,
+     DOUBLE = 268,
+     LABEL = 269,
+     TYPE = 270,
+     LOCALVAR = 271,
+     GLOBALVAR = 272,
+     LABELSTR = 273,
+     STRINGCONSTANT = 274,
+     ATSTRINGCONSTANT = 275,
+     ZEROINITIALIZER = 276,
+     TRUETOK = 277,
+     FALSETOK = 278,
+     BEGINTOK = 279,
+     ENDTOK = 280,
+     DECLARE = 281,
+     DEFINE = 282,
+     GLOBAL = 283,
+     CONSTANT = 284,
+     SECTION = 285,
+     ALIAS = 286,
+     VOLATILE = 287,
+     THREAD_LOCAL = 288,
+     TO = 289,
+     DOTDOTDOT = 290,
+     NULL_TOK = 291,
+     UNDEF = 292,
+     INTERNAL = 293,
+     LINKONCE = 294,
+     WEAK = 295,
+     APPENDING = 296,
+     DLLIMPORT = 297,
+     DLLEXPORT = 298,
+     EXTERN_WEAK = 299,
+     OPAQUE = 300,
+     EXTERNAL = 301,
+     TARGET = 302,
+     TRIPLE = 303,
+     ALIGN = 304,
+     DEPLIBS = 305,
+     CALL = 306,
+     TAIL = 307,
+     ASM_TOK = 308,
+     MODULE = 309,
+     SIDEEFFECT = 310,
+     CC_TOK = 311,
+     CCC_TOK = 312,
+     FASTCC_TOK = 313,
+     COLDCC_TOK = 314,
+     X86_STDCALLCC_TOK = 315,
+     X86_FASTCALLCC_TOK = 316,
+     DATALAYOUT = 317,
+     RET = 318,
+     BR = 319,
+     SWITCH = 320,
+     INVOKE = 321,
+     UNWIND = 322,
+     UNREACHABLE = 323,
+     ADD = 324,
+     SUB = 325,
+     MUL = 326,
+     UDIV = 327,
+     SDIV = 328,
+     FDIV = 329,
+     UREM = 330,
+     SREM = 331,
+     FREM = 332,
+     AND = 333,
+     OR = 334,
+     XOR = 335,
+     SHL = 336,
+     LSHR = 337,
+     ASHR = 338,
+     ICMP = 339,
+     FCMP = 340,
+     EQ = 341,
+     NE = 342,
+     SLT = 343,
+     SGT = 344,
+     SLE = 345,
+     SGE = 346,
+     ULT = 347,
+     UGT = 348,
+     ULE = 349,
+     UGE = 350,
+     OEQ = 351,
+     ONE = 352,
+     OLT = 353,
+     OGT = 354,
+     OLE = 355,
+     OGE = 356,
+     ORD = 357,
+     UNO = 358,
+     UEQ = 359,
+     UNE = 360,
+     MALLOC = 361,
+     ALLOCA = 362,
+     FREE = 363,
+     LOAD = 364,
+     STORE = 365,
+     GETELEMENTPTR = 366,
+     TRUNC = 367,
+     ZEXT = 368,
+     SEXT = 369,
+     FPTRUNC = 370,
+     FPEXT = 371,
+     BITCAST = 372,
+     UITOFP = 373,
+     SITOFP = 374,
+     FPTOUI = 375,
+     FPTOSI = 376,
+     INTTOPTR = 377,
+     PTRTOINT = 378,
+     PHI_TOK = 379,
+     SELECT = 380,
+     VAARG = 381,
+     EXTRACTELEMENT = 382,
+     INSERTELEMENT = 383,
+     SHUFFLEVECTOR = 384,
+     NORETURN = 385,
+     INREG = 386,
+     SRET = 387,
+     NOUNWIND = 388,
+     DEFAULT = 389,
+     HIDDEN = 390
+   };
+#endif
+/* Tokens.  */
+#define ESINT64VAL 258
+#define EUINT64VAL 259
+#define ESAPINTVAL 260
+#define EUAPINTVAL 261
+#define LOCALVAL_ID 262
+#define GLOBALVAL_ID 263
+#define FPVAL 264
+#define VOID 265
+#define INTTYPE 266
+#define FLOAT 267
+#define DOUBLE 268
+#define LABEL 269
+#define TYPE 270
+#define LOCALVAR 271
+#define GLOBALVAR 272
+#define LABELSTR 273
+#define STRINGCONSTANT 274
+#define ATSTRINGCONSTANT 275
+#define ZEROINITIALIZER 276
+#define TRUETOK 277
+#define FALSETOK 278
+#define BEGINTOK 279
+#define ENDTOK 280
+#define DECLARE 281
+#define DEFINE 282
+#define GLOBAL 283
+#define CONSTANT 284
+#define SECTION 285
+#define ALIAS 286
+#define VOLATILE 287
+#define THREAD_LOCAL 288
+#define TO 289
+#define DOTDOTDOT 290
+#define NULL_TOK 291
+#define UNDEF 292
+#define INTERNAL 293
+#define LINKONCE 294
+#define WEAK 295
+#define APPENDING 296
+#define DLLIMPORT 297
+#define DLLEXPORT 298
+#define EXTERN_WEAK 299
+#define OPAQUE 300
+#define EXTERNAL 301
+#define TARGET 302
+#define TRIPLE 303
+#define ALIGN 304
+#define DEPLIBS 305
+#define CALL 306
+#define TAIL 307
+#define ASM_TOK 308
+#define MODULE 309
+#define SIDEEFFECT 310
+#define CC_TOK 311
+#define CCC_TOK 312
+#define FASTCC_TOK 313
+#define COLDCC_TOK 314
+#define X86_STDCALLCC_TOK 315
+#define X86_FASTCALLCC_TOK 316
+#define DATALAYOUT 317
+#define RET 318
+#define BR 319
+#define SWITCH 320
+#define INVOKE 321
+#define UNWIND 322
+#define UNREACHABLE 323
+#define ADD 324
+#define SUB 325
+#define MUL 326
+#define UDIV 327
+#define SDIV 328
+#define FDIV 329
+#define UREM 330
+#define SREM 331
+#define FREM 332
+#define AND 333
+#define OR 334
+#define XOR 335
+#define SHL 336
+#define LSHR 337
+#define ASHR 338
+#define ICMP 339
+#define FCMP 340
+#define EQ 341
+#define NE 342
+#define SLT 343
+#define SGT 344
+#define SLE 345
+#define SGE 346
+#define ULT 347
+#define UGT 348
+#define ULE 349
+#define UGE 350
+#define OEQ 351
+#define ONE 352
+#define OLT 353
+#define OGT 354
+#define OLE 355
+#define OGE 356
+#define ORD 357
+#define UNO 358
+#define UEQ 359
+#define UNE 360
+#define MALLOC 361
+#define ALLOCA 362
+#define FREE 363
+#define LOAD 364
+#define STORE 365
+#define GETELEMENTPTR 366
+#define TRUNC 367
+#define ZEXT 368
+#define SEXT 369
+#define FPTRUNC 370
+#define FPEXT 371
+#define BITCAST 372
+#define UITOFP 373
+#define SITOFP 374
+#define FPTOUI 375
+#define FPTOSI 376
+#define INTTOPTR 377
+#define PTRTOINT 378
+#define PHI_TOK 379
+#define SELECT 380
+#define VAARG 381
+#define EXTRACTELEMENT 382
+#define INSERTELEMENT 383
+#define SHUFFLEVECTOR 384
+#define NORETURN 385
+#define INREG 386
+#define SRET 387
+#define NOUNWIND 388
+#define DEFAULT 389
+#define HIDDEN 390
+
+
+
+
+/* Copy the first part of user declarations.  */
+#line 14 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
 
 #include "ParserInternals.h"
 #include "llvm/CallingConv.h"
@@ -1068,8 +1272,29 @@
 }
 
 
-#line 938 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-typedef union {
+
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
+#line 938 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+{
   llvm::Module                           *ModuleVal;
   llvm::Function                         *FunctionVal;
   llvm::BasicBlock                       *BasicBlockVal;
@@ -1114,1070 +1339,1756 @@
   llvm::Instruction::OtherOps       OtherOpVal;
   llvm::ICmpInst::Predicate         IPredicate;
   llvm::FCmpInst::Predicate         FPredicate;
-} YYSTYPE;
-#include <stdio.h>
-
-#ifndef __cplusplus
-#ifndef __STDC__
-#define const
-#endif
+}
+/* Line 187 of yacc.c.  */
+#line 1345 "llvmAsmParser.tab.c"
+	YYSTYPE;
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 
 
-#define	YYFINAL		565
-#define	YYFLAG		-32768
-#define	YYNTBASE	149
+/* Copy the second part of user declarations.  */
 
-#define YYTRANSLATE(x) ((unsigned)(x) <= 388 ? yytranslate[x] : 227)
 
-static const short yytranslate[] = {     0,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,   139,
-   140,   137,     2,   136,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,   144,
-   135,   145,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-   141,   138,   143,     2,     2,     2,     2,     2,   148,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,   142,
-     2,     2,   146,     2,   147,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
-     7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-    17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-    27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
-    37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
-    47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
-    57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
-    67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
-    77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-    87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
-    97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
-   107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-   117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
-   127,   128,   129,   130,   131,   132,   133,   134
-};
+/* Line 216 of yacc.c.  */
+#line 1358 "llvmAsmParser.tab.c"
 
-#if YYDEBUG != 0
-static const short yyprhs[] = {     0,
-     0,     2,     4,     6,     8,    10,    12,    14,    16,    18,
-    20,    22,    24,    26,    28,    30,    32,    34,    36,    38,
-    40,    42,    44,    46,    48,    50,    52,    54,    56,    58,
-    60,    62,    64,    66,    68,    70,    72,    74,    76,    78,
-    80,    82,    84,    86,    88,    90,    92,    94,    96,    98,
-   100,   102,   104,   106,   108,   110,   112,   114,   116,   118,
-   119,   122,   123,   125,   127,   130,   131,   133,   135,   137,
-   139,   141,   143,   145,   147,   148,   150,   151,   153,   155,
-   156,   158,   160,   162,   164,   165,   167,   169,   171,   173,
-   175,   178,   180,   182,   184,   186,   187,   190,   192,   194,
-   196,   197,   200,   201,   204,   205,   209,   212,   213,   215,
-   216,   220,   222,   225,   227,   229,   231,   233,   235,   237,
-   240,   242,   245,   251,   257,   263,   269,   273,   276,   282,
-   287,   290,   292,   294,   296,   300,   302,   306,   308,   309,
-   311,   315,   320,   324,   328,   333,   338,   342,   349,   355,
-   358,   361,   364,   367,   370,   373,   376,   379,   382,   385,
-   388,   391,   398,   404,   413,   420,   427,   435,   443,   450,
-   459,   468,   472,   474,   476,   478,   480,   481,   483,   484,
-   486,   489,   490,   494,   495,   499,   503,   507,   511,   512,
-   520,   521,   530,   531,   540,   543,   547,   549,   553,   557,
-   561,   565,   567,   568,   574,   578,   580,   584,   586,   587,
-   597,   599,   601,   606,   608,   610,   613,   617,   618,   620,
-   622,   624,   626,   628,   630,   632,   634,   636,   640,   642,
-   648,   650,   652,   654,   656,   658,   660,   663,   666,   669,
-   673,   676,   677,   679,   682,   685,   689,   699,   709,   718,
-   733,   735,   737,   744,   750,   753,   760,   768,   772,   778,
-   779,   780,   784,   787,   789,   795,   801,   808,   815,   820,
-   827,   832,   837,   844,   851,   854,   863,   865,   867,   868,
-   872,   879,   883,   890,   893,   899,   907
-};
-
-static const short yyrhs[] = {    68,
-     0,    69,     0,    70,     0,    71,     0,    72,     0,    73,
-     0,    74,     0,    75,     0,    76,     0,    80,     0,    81,
-     0,    82,     0,    77,     0,    78,     0,    79,     0,   111,
-     0,   112,     0,   113,     0,   114,     0,   115,     0,   116,
-     0,   117,     0,   118,     0,   119,     0,   120,     0,   121,
-     0,   122,     0,    85,     0,    86,     0,    87,     0,    88,
-     0,    89,     0,    90,     0,    91,     0,    92,     0,    93,
-     0,    94,     0,    95,     0,    96,     0,    97,     0,    98,
-     0,    99,     0,   100,     0,   101,     0,   102,     0,   103,
-     0,   104,     0,    91,     0,    92,     0,    93,     0,    94,
-     0,    22,     0,    23,     0,    11,     0,    12,     0,    13,
-     0,    16,     0,    19,     0,   156,     0,     0,   156,   135,
-     0,     0,    17,     0,    20,     0,   159,   135,     0,     0,
-    37,     0,    39,     0,    38,     0,    40,     0,    42,     0,
-    41,     0,    43,     0,    45,     0,     0,   134,     0,     0,
-    41,     0,    43,     0,     0,    37,     0,    38,     0,    39,
-     0,    42,     0,     0,    56,     0,    57,     0,    58,     0,
-    59,     0,    60,     0,    55,     4,     0,   112,     0,   113,
-     0,   130,     0,   131,     0,     0,   168,   167,     0,   129,
-     0,   132,     0,   167,     0,     0,   170,   169,     0,     0,
-    48,     4,     0,     0,   136,    48,     4,     0,    30,    19,
-     0,     0,   173,     0,     0,   136,   176,   175,     0,   173,
-     0,    48,     4,     0,    11,     0,    12,     0,    13,     0,
-    14,     0,    44,     0,   177,     0,   178,   137,     0,   211,
-     0,   138,     4,     0,   178,   139,   182,   140,   170,     0,
-    10,   139,   182,   140,   170,     0,   141,     4,   142,   178,
-   143,     0,   144,     4,   142,   178,   145,     0,   146,   183,
-   147,     0,   146,   147,     0,   144,   146,   183,   147,   145,
-     0,   144,   146,   147,   145,     0,   178,   168,     0,   178,
-     0,    10,     0,   179,     0,   181,   136,   179,     0,   181,
-     0,   181,   136,    34,     0,    34,     0,     0,   178,     0,
-   183,   136,   178,     0,   178,   141,   186,   143,     0,   178,
-   141,   143,     0,   178,   148,    19,     0,   178,   144,   186,
-   145,     0,   178,   146,   186,   147,     0,   178,   146,   147,
-     0,   178,   144,   146,   186,   147,   145,     0,   178,   144,
-   146,   147,   145,     0,   178,    35,     0,   178,    36,     0,
-   178,   211,     0,   178,   185,     0,   178,    21,     0,   154,
-     3,     0,   154,     5,     0,   154,     4,     0,   154,     6,
-     0,    11,    22,     0,    11,    23,     0,   155,     9,     0,
-   151,   139,   184,    33,   178,   140,     0,   110,   139,   184,
-   222,   140,     0,   124,   139,   184,   136,   184,   136,   184,
-   140,     0,   149,   139,   184,   136,   184,   140,     0,   150,
-   139,   184,   136,   184,   140,     0,    83,   152,   139,   184,
-   136,   184,   140,     0,    84,   153,   139,   184,   136,   184,
-   140,     0,   126,   139,   184,   136,   184,   140,     0,   127,
-   139,   184,   136,   184,   136,   184,   140,     0,   128,   139,
-   184,   136,   184,   136,   184,   140,     0,   186,   136,   184,
-     0,   184,     0,    28,     0,    29,     0,    32,     0,     0,
-   190,     0,     0,   191,     0,   190,   191,     0,     0,    27,
-   192,   207,     0,     0,    26,   193,   208,     0,    53,    52,
-   197,     0,   158,    15,   178,     0,   158,    15,    10,     0,
-     0,   160,   163,   188,   187,   184,   194,   175,     0,     0,
-   160,   161,   163,   188,   187,   184,   195,   175,     0,     0,
-   160,   162,   163,   188,   187,   178,   196,   175,     0,    46,
-   198,     0,    49,   135,   199,     0,    19,     0,    47,   135,
-    19,     0,    61,   135,    19,     0,   141,   200,   143,     0,
-   200,   136,    19,     0,    19,     0,     0,   201,   136,   178,
-   168,   157,     0,   178,   168,   157,     0,   201,     0,   201,
-   136,    34,     0,    34,     0,     0,   166,   180,   159,   139,
-   202,   140,   170,   174,   171,     0,    24,     0,   146,     0,
-   165,   163,   203,   204,     0,    25,     0,   147,     0,   214,
-   206,     0,   164,   163,   203,     0,     0,    54,     0,     3,
-     0,     4,     0,     9,     0,    22,     0,    23,     0,    35,
-     0,    36,     0,    21,     0,   144,   186,   145,     0,   185,
-     0,    52,   209,    19,   136,    19,     0,     7,     0,     8,
-     0,   156,     0,   159,     0,   211,     0,   210,     0,   178,
-   212,     0,   214,   215,     0,   205,   215,     0,   216,   158,
-   217,     0,   216,   219,     0,     0,    18,     0,    62,   213,
-     0,    62,    10,     0,    63,    14,   212,     0,    63,    11,
-   212,   136,    14,   212,   136,    14,   212,     0,    64,   154,
-   212,   136,    14,   212,   141,   218,   143,     0,    64,   154,
-   212,   136,    14,   212,   141,   143,     0,    65,   166,   180,
-   212,   139,   221,   140,   170,    33,    14,   212,    66,    14,
-   212,     0,    66,     0,    67,     0,   218,   154,   210,   136,
-    14,   212,     0,   154,   210,   136,    14,   212,     0,   158,
-   224,     0,   178,   141,   212,   136,   212,   143,     0,   220,
-   136,   141,   212,   136,   212,   143,     0,   178,   212,   168,
-     0,   221,   136,   178,   212,   168,     0,     0,     0,   222,
-   136,   213,     0,    51,    50,     0,    50,     0,   149,   178,
-   212,   136,   212,     0,   150,   178,   212,   136,   212,     0,
-    83,   152,   178,   212,   136,   212,     0,    84,   153,   178,
-   212,   136,   212,     0,   151,   213,    33,   178,     0,   124,
-   213,   136,   213,   136,   213,     0,   125,   213,   136,   178,
-     0,   126,   213,   136,   213,     0,   127,   213,   136,   213,
-   136,   213,     0,   128,   213,   136,   213,   136,   213,     0,
-   123,   220,     0,   223,   166,   180,   212,   139,   221,   140,
-   170,     0,   226,     0,    31,     0,     0,   105,   178,   172,
-     0,   105,   178,   136,    11,   212,   172,     0,   106,   178,
-   172,     0,   106,   178,   136,    11,   212,   172,     0,   107,
-   213,     0,   225,   108,   178,   212,   172,     0,   225,   109,
-   213,   136,   178,   212,   172,     0,   110,   178,   212,   222,
-     0
-};
-
+#ifdef short
+# undef short
 #endif
 
-#if YYDEBUG != 0
-static const short yyrline[] = { 0,
-  1093,  1093,  1093,  1093,  1093,  1093,  1093,  1093,  1093,  1094,
-  1094,  1094,  1094,  1094,  1094,  1095,  1095,  1095,  1095,  1095,
-  1095,  1095,  1096,  1096,  1096,  1096,  1096,  1099,  1099,  1100,
-  1100,  1101,  1101,  1102,  1102,  1103,  1103,  1107,  1107,  1108,
-  1108,  1109,  1109,  1110,  1110,  1111,  1111,  1112,  1112,  1113,
-  1113,  1114,  1115,  1120,  1121,  1121,  1123,  1123,  1124,  1124,
-  1128,  1132,  1137,  1137,  1139,  1143,  1149,  1150,  1151,  1152,
-  1153,  1157,  1158,  1159,  1163,  1164,  1168,  1169,  1170,  1174,
-  1175,  1176,  1177,  1178,  1181,  1181,  1182,  1183,  1184,  1185,
-  1186,  1194,  1195,  1196,  1197,  1200,  1201,  1206,  1207,  1208,
-  1211,  1212,  1219,  1219,  1226,  1226,  1235,  1243,  1243,  1249,
-  1249,  1251,  1256,  1269,  1269,  1269,  1269,  1272,  1276,  1280,
-  1287,  1292,  1300,  1330,  1361,  1366,  1378,  1388,  1392,  1402,
-  1409,  1416,  1423,  1428,  1433,  1440,  1441,  1448,  1455,  1463,
-  1469,  1481,  1509,  1525,  1554,  1582,  1607,  1626,  1652,  1672,
-  1684,  1691,  1757,  1767,  1777,  1783,  1793,  1799,  1809,  1814,
-  1819,  1827,  1839,  1861,  1869,  1875,  1886,  1891,  1896,  1902,
-  1908,  1917,  1921,  1929,  1929,  1932,  1932,  1943,  1948,  1956,
-  1957,  1961,  1961,  1965,  1965,  1968,  1971,  1995,  2006,  2013,
-  2016,  2021,  2024,  2030,  2034,  2037,  2043,  2056,  2060,  2065,
-  2067,  2072,  2077,  2086,  2096,  2107,  2111,  2120,  2129,  2134,
-  2256,  2256,  2258,  2267,  2267,  2269,  2274,  2286,  2290,  2295,
-  2299,  2303,  2307,  2311,  2315,  2319,  2323,  2327,  2352,  2356,
-  2370,  2374,  2378,  2382,  2388,  2388,  2394,  2403,  2407,  2416,
-  2425,  2434,  2438,  2443,  2447,  2451,  2456,  2466,  2485,  2494,
-  2574,  2578,  2585,  2596,  2609,  2619,  2630,  2640,  2649,  2658,
-  2661,  2662,  2669,  2673,  2678,  2699,  2716,  2730,  2744,  2756,
-  2764,  2771,  2777,  2783,  2789,  2804,  2889,  2894,  2898,  2905,
-  2912,  2920,  2927,  2935,  2943,  2957,  2974
-};
-#endif
-
-
-#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
-
-static const char * const yytname[] = {   "$","error","$undefined.","ESINT64VAL",
-"EUINT64VAL","ESAPINTVAL","EUAPINTVAL","LOCALVAL_ID","GLOBALVAL_ID","FPVAL",
-"VOID","INTTYPE","FLOAT","DOUBLE","LABEL","TYPE","LOCALVAR","GLOBALVAR","LABELSTR",
-"STRINGCONSTANT","ATSTRINGCONSTANT","ZEROINITIALIZER","TRUETOK","FALSETOK","BEGINTOK",
-"ENDTOK","DECLARE","DEFINE","GLOBAL","CONSTANT","SECTION","VOLATILE","THREAD_LOCAL",
-"TO","DOTDOTDOT","NULL_TOK","UNDEF","INTERNAL","LINKONCE","WEAK","APPENDING",
-"DLLIMPORT","DLLEXPORT","EXTERN_WEAK","OPAQUE","EXTERNAL","TARGET","TRIPLE",
-"ALIGN","DEPLIBS","CALL","TAIL","ASM_TOK","MODULE","SIDEEFFECT","CC_TOK","CCC_TOK",
-"FASTCC_TOK","COLDCC_TOK","X86_STDCALLCC_TOK","X86_FASTCALLCC_TOK","DATALAYOUT",
-"RET","BR","SWITCH","INVOKE","UNWIND","UNREACHABLE","ADD","SUB","MUL","UDIV",
-"SDIV","FDIV","UREM","SREM","FREM","AND","OR","XOR","SHL","LSHR","ASHR","ICMP",
-"FCMP","EQ","NE","SLT","SGT","SLE","SGE","ULT","UGT","ULE","UGE","OEQ","ONE",
-"OLT","OGT","OLE","OGE","ORD","UNO","UEQ","UNE","MALLOC","ALLOCA","FREE","LOAD",
-"STORE","GETELEMENTPTR","TRUNC","ZEXT","SEXT","FPTRUNC","FPEXT","BITCAST","UITOFP",
-"SITOFP","FPTOUI","FPTOSI","INTTOPTR","PTRTOINT","PHI_TOK","SELECT","VAARG",
-"EXTRACTELEMENT","INSERTELEMENT","SHUFFLEVECTOR","NORETURN","INREG","SRET","NOUNWIND",
-"DEFAULT","HIDDEN","'='","','","'*'","'\\\\'","'('","')'","'['","'x'","']'",
-"'<'","'>'","'{'","'}'","'c'","ArithmeticOps","LogicalOps","CastOps","IPredicates",
-"FPredicates","IntType","FPType","LocalName","OptLocalName","OptLocalAssign",
-"GlobalName","OptGlobalAssign","GVInternalLinkage","GVExternalLinkage","GVVisibilityStyle",
-"FunctionDeclareLinkage","FunctionDefineLinkage","OptCallingConv","ParamAttr",
-"OptParamAttrs","FuncAttr","OptFuncAttrs","OptAlign","OptCAlign","SectionString",
-"OptSection","GlobalVarAttributes","GlobalVarAttribute","PrimType","Types","ArgType",
-"ResultTypes","ArgTypeList","ArgTypeListI","TypeListI","ConstVal","ConstExpr",
-"ConstVector","GlobalType","ThreadLocal","Module","DefinitionList","Definition",
-"@1","@2","@3","@4","@5","AsmBlock","TargetDefinition","LibrariesDefinition",
-"LibList","ArgListH","ArgList","FunctionHeaderH","BEGIN","FunctionHeader","END",
-"Function","FunctionProto","OptSideEffect","ConstValueRef","SymbolicValueRef",
-"ValueRef","ResolvedVal","BasicBlockList","BasicBlock","InstructionList","BBTerminatorInst",
-"JumpTable","Inst","PHIList","ValueRefList","IndexList","OptTailCall","InstVal",
-"OptVolatile","MemoryInst", NULL
-};
-#endif
-
-static const short yyr1[] = {     0,
-   149,   149,   149,   149,   149,   149,   149,   149,   149,   150,
-   150,   150,   150,   150,   150,   151,   151,   151,   151,   151,
-   151,   151,   151,   151,   151,   151,   151,   152,   152,   152,
-   152,   152,   152,   152,   152,   152,   152,   153,   153,   153,
-   153,   153,   153,   153,   153,   153,   153,   153,   153,   153,
-   153,   153,   153,   154,   155,   155,   156,   156,   157,   157,
-   158,   158,   159,   159,   160,   160,   161,   161,   161,   161,
-   161,   162,   162,   162,   163,   163,   164,   164,   164,   165,
-   165,   165,   165,   165,   166,   166,   166,   166,   166,   166,
-   166,   167,   167,   167,   167,   168,   168,   169,   169,   169,
-   170,   170,   171,   171,   172,   172,   173,   174,   174,   175,
-   175,   176,   176,   177,   177,   177,   177,   178,   178,   178,
-   178,   178,   178,   178,   178,   178,   178,   178,   178,   178,
-   179,   180,   180,   181,   181,   182,   182,   182,   182,   183,
-   183,   184,   184,   184,   184,   184,   184,   184,   184,   184,
-   184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
-   184,   185,   185,   185,   185,   185,   185,   185,   185,   185,
-   185,   186,   186,   187,   187,   188,   188,   189,   189,   190,
-   190,   192,   191,   193,   191,   191,   191,   191,   194,   191,
-   195,   191,   196,   191,   191,   191,   197,   198,   198,   199,
-   200,   200,   200,   201,   201,   202,   202,   202,   202,   203,
-   204,   204,   205,   206,   206,   207,   208,   209,   209,   210,
-   210,   210,   210,   210,   210,   210,   210,   210,   210,   210,
-   211,   211,   211,   211,   212,   212,   213,   214,   214,   215,
-   216,   216,   216,   217,   217,   217,   217,   217,   217,   217,
-   217,   217,   218,   218,   219,   220,   220,   221,   221,   221,
-   222,   222,   223,   223,   224,   224,   224,   224,   224,   224,
-   224,   224,   224,   224,   224,   224,   224,   225,   225,   226,
-   226,   226,   226,   226,   226,   226,   226
-};
-
-static const short yyr2[] = {     0,
-     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-     1,     1,     1,     1,     1,     1,     1,     1,     1,     0,
-     2,     0,     1,     1,     2,     0,     1,     1,     1,     1,
-     1,     1,     1,     1,     0,     1,     0,     1,     1,     0,
-     1,     1,     1,     1,     0,     1,     1,     1,     1,     1,
-     2,     1,     1,     1,     1,     0,     2,     1,     1,     1,
-     0,     2,     0,     2,     0,     3,     2,     0,     1,     0,
-     3,     1,     2,     1,     1,     1,     1,     1,     1,     2,
-     1,     2,     5,     5,     5,     5,     3,     2,     5,     4,
-     2,     1,     1,     1,     3,     1,     3,     1,     0,     1,
-     3,     4,     3,     3,     4,     4,     3,     6,     5,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     6,     5,     8,     6,     6,     7,     7,     6,     8,
-     8,     3,     1,     1,     1,     1,     0,     1,     0,     1,
-     2,     0,     3,     0,     3,     3,     3,     3,     0,     7,
-     0,     8,     0,     8,     2,     3,     1,     3,     3,     3,
-     3,     1,     0,     5,     3,     1,     3,     1,     0,     9,
-     1,     1,     4,     1,     1,     2,     3,     0,     1,     1,
-     1,     1,     1,     1,     1,     1,     1,     3,     1,     5,
-     1,     1,     1,     1,     1,     1,     2,     2,     2,     3,
-     2,     0,     1,     2,     2,     3,     9,     9,     8,    14,
-     1,     1,     6,     5,     2,     6,     7,     3,     5,     0,
-     0,     3,     2,     1,     5,     5,     6,     6,     4,     6,
-     4,     4,     6,     6,     2,     8,     1,     1,     0,     3,
-     6,     3,     6,     2,     5,     7,     4
-};
-
-static const short yydefact[] = {    66,
-    57,    63,    58,    64,   184,   182,     0,     0,     0,     0,
-     0,     0,    75,    66,   180,    77,    80,     0,     0,   195,
-     0,     0,    61,     0,    65,    67,    69,    68,    70,    72,
-    71,    73,    74,    76,    75,    75,   177,   181,    78,    79,
-    75,   185,    81,    82,    83,    84,    75,   242,   183,   242,
-     0,     0,   203,   196,   197,   186,   231,   232,   188,   114,
-   115,   116,   117,   118,     0,     0,     0,     0,   233,   234,
-   119,   187,   121,   177,   177,   176,     0,    85,    85,   243,
-   239,    62,   214,   215,   216,   238,   198,   199,   202,     0,
-   139,   122,     0,     0,     0,     0,   128,   140,     0,   120,
-   139,     0,     0,   174,   175,     0,     0,    86,    87,    88,
-    89,    90,     0,   217,     0,   279,   241,     0,   200,   138,
-    96,   134,   136,     0,     0,     0,     0,     0,     0,   127,
-     0,     0,     0,   114,   115,   116,     0,     0,     0,   189,
-    91,   133,   132,     0,   211,   212,   213,   278,   264,     0,
-     0,     0,     0,    85,   251,   252,     1,     2,     3,     4,
-     5,     6,     7,     8,     9,    13,    14,    15,    10,    11,
-    12,     0,     0,     0,     0,     0,     0,    16,    17,    18,
-    19,    20,    21,    22,    23,    24,    25,    26,    27,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,   240,    85,
-   255,     0,   277,   201,   131,     0,   101,     0,     0,   130,
-     0,   141,   101,   191,   193,   159,   160,   155,   157,   156,
-   158,   161,   154,   150,   151,     0,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,   153,
-   152,   110,     0,   263,   245,     0,   244,     0,     0,    54,
-     0,     0,    28,    29,    30,    31,    32,    33,    34,    35,
-    36,    37,     0,    52,    53,    48,    49,    50,    51,    38,
-    39,    40,    41,    42,    43,    44,    45,    46,    47,     0,
-   105,   105,   284,     0,     0,   275,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,    92,    93,    94,
-    95,    97,   137,   135,   124,   125,   126,   129,   123,   110,
-   110,     0,     0,     0,     0,     0,     0,     0,   143,   173,
-     0,     0,     0,   147,     0,   144,     0,     0,     0,     0,
-   190,   209,   220,   221,   222,   227,   223,   224,   225,   226,
-   218,     0,   229,   236,   235,   237,     0,   246,     0,     0,
-     0,     0,     0,   280,     0,   282,   261,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    98,    99,   100,   102,   192,   194,     0,     0,   261,     0,
-     0,     0,     0,     0,   142,   128,   140,     0,   145,   146,
-     0,     0,     0,     0,     0,   112,   110,   208,    96,   206,
-     0,   219,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,   287,     0,     0,     0,   271,   272,     0,     0,
-     0,     0,   269,     0,   105,     0,     0,     0,     0,     0,
-     0,     0,     0,   172,   149,     0,     0,     0,     0,   107,
-   113,   111,    60,     0,   101,     0,   228,     0,     0,   260,
-     0,     0,   105,   106,   105,     0,     0,     0,     0,     0,
-     0,   265,   266,   260,     0,   285,     0,     0,     0,   163,
-     0,     0,     0,     0,   148,     0,     0,     0,    59,   205,
-   207,    96,   108,     0,     0,     0,     0,     0,   267,   268,
-   281,   283,   262,     0,     0,   270,   273,   274,     0,   105,
-     0,     0,     0,   169,     0,     0,   165,   166,   162,    60,
-   109,   103,   230,     0,     0,    96,     0,   101,   256,     0,
-   101,   286,   167,   168,     0,     0,     0,   204,     0,   210,
-     0,   249,     0,     0,   258,     0,     0,   257,   276,   164,
-   170,   171,   104,   247,     0,   248,     0,    96,     0,     0,
-     0,   259,     0,     0,     0,     0,   254,     0,     0,   253,
-     0,   250,     0,     0,     0
-};
-
-static const short yydefgoto[] = {   237,
-   238,   239,   263,   280,   137,   138,    69,   480,    11,    70,
-    13,    35,    36,    37,    41,    47,   113,   302,   205,   374,
-   305,   530,   354,   396,   512,   331,   397,    71,   139,   122,
-   144,   123,   124,    99,   320,   343,   321,   106,    77,   563,
-    14,    15,    17,    16,   242,   310,   311,    56,    20,    54,
-    90,   400,   401,   114,   147,    48,    85,    49,    42,   403,
-   344,    73,   346,   247,    50,    81,    82,   199,   534,   117,
-   286,   488,   413,   200,   201,   202,   203
-};
-
-static const short yypact[] = {   593,
--32768,-32768,-32768,-32768,-32768,-32768,    -1,   -87,    11,   -41,
-    89,   -13,    46,  1408,-32768,   185,    82,    13,    55,-32768,
-    81,   211,-32768,  1122,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,    98,    98,   206,-32768,-32768,-32768,
-    98,-32768,-32768,-32768,-32768,-32768,    98,   235,-32768,     8,
-   242,   251,   252,-32768,-32768,-32768,-32768,-32768,   128,-32768,
--32768,-32768,-32768,-32768,   272,   274,     4,   122,-32768,-32768,
--32768,    61,-32768,   206,   206,-32768,   183,   290,   290,-32768,
--32768,   121,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   -92,
-   979,-32768,   137,   139,   284,   128,-32768,    61,   -70,-32768,
-   979,   183,   183,-32768,-32768,  1136,   278,-32768,-32768,-32768,
--32768,-32768,  1178,-32768,   -15,  1277,-32768,   264,-32768,-32768,
-    61,-32768,   148,   153,  1192,  1192,   160,   -66,  1192,-32768,
-   162,  1136,  1192,    32,   297,   298,   215,   301,   761,-32768,
--32768,   128,    61,   145,-32768,-32768,-32768,-32768,-32768,   262,
-  1234,   248,   304,   290,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,   157,   422,  1192,  1192,  1192,  1192,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,  1192,
-  1192,  1192,  1192,  1192,  1192,  1192,  1192,  1192,-32768,   290,
--32768,   -34,-32768,-32768,   -33,  1019,-32768,    71,   -22,-32768,
-   173,    61,-32768,-32768,    61,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,-32768,   157,   422,   180,   181,   182,
-   184,   186,  1038,  1276,   448,   305,   187,   188,   191,-32768,
--32768,   193,   192,-32768,   128,   614,-32768,   740,   740,-32768,
-   740,  1178,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,  1192,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,  1192,
-    88,   119,-32768,   614,    62,   197,   198,   199,   200,   207,
-   217,   614,   614,   309,  1178,  1192,  1192,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,   -73,-32768,-32768,-32768,   -73,   193,
-   193,   212,   216,  1136,  1136,  1136,  1136,  1136,-32768,-32768,
-   -44,   933,   -69,-32768,   -40,-32768,  1136,  1136,  1136,    -5,
--32768,  1077,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-   300,  1136,-32768,-32768,-32768,-32768,   220,-32768,   221,   740,
-   614,   614,    17,-32768,    23,-32768,-32768,   740,   218,  1192,
-  1192,  1192,  1192,  1192,   222,   225,  1192,   740,   614,   226,
--32768,-32768,-32768,-32768,-32768,-32768,  1136,  1136,-32768,   227,
-   229,   230,   231,  1136,-32768,   228,   761,   -35,-32768,-32768,
-   234,   236,   341,   356,   372,-32768,   193,-32768,    61,   241,
-   238,-32768,   360,   -36,   366,   367,   243,   253,   254,   740,
-   387,   740,   256,   257,   740,   258,    61,-32768,   259,   266,
-   740,   740,    61,   261,   269,  1192,   270,   271,   -67,  1136,
-  1136,  1136,  1136,-32768,-32768,   263,  1136,  1136,  1192,-32768,
--32768,-32768,    33,  1093,-32768,   273,-32768,   740,   740,  1192,
-   740,   740,   269,-32768,   269,  1192,   740,   275,  1192,  1192,
-  1192,-32768,-32768,  1192,   362,-32768,   614,  1136,  1136,-32768,
-   279,   277,   288,   293,-32768,   280,   292,    42,-32768,-32768,
--32768,    61,    65,   395,   299,   308,   614,     7,-32768,-32768,
--32768,-32768,-32768,   291,   740,-32768,-32768,-32768,    73,   269,
-   302,   306,  1136,-32768,  1136,  1136,-32768,-32768,-32768,    33,
--32768,   391,-32768,   426,     1,-32768,  1192,-32768,-32768,   307,
--32768,-32768,-32768,-32768,   311,   312,   313,-32768,   453,-32768,
-   740,-32768,   890,    18,   -33,   614,    75,-32768,   -73,-32768,
--32768,-32768,-32768,-32768,   327,-32768,   890,-32768,   452,   455,
-   337,   -33,   740,   740,   460,   409,-32768,   740,   462,-32768,
-   740,-32768,   477,   479,-32768
-};
-
-static const short yypgoto[] = {   364,
-   365,   368,   260,   255,  -151,-32768,     0,   -27,   403,    16,
--32768,-32768,-32768,     6,-32768,-32768,  -139,  -298,  -389,-32768,
-  -210,-32768,  -269,    10,-32768,  -279,-32768,-32768,   -23,   281,
-  -233,-32768,   389,   396,    70,  -133,  -217,   134,   190,-32768,
--32768,   481,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,   417,-32768,-32768,-32768,-32768,-32768,-32768,
-  -483,  -135,   120,  -171,-32768,   447,-32768,-32768,-32768,-32768,
--32768,    34,   125,-32768,-32768,-32768,-32768
-};
-
-
-#define	YYLAST		1461
-
-
-static const short yytable[] = {    10,
-    72,   251,   309,   241,   283,   240,   373,    94,   145,   443,
-   373,   250,   356,    10,   252,    12,   323,   325,   350,   287,
-   288,   289,   290,   291,   394,    80,   294,   410,   250,    12,
-   375,   376,    83,   412,   -54,   -54,   -54,   -54,   298,   299,
-    74,    75,   395,   118,    98,    18,    78,    21,     1,   545,
-   119,     3,    79,   216,   217,   371,   300,   301,   372,    19,
-   295,   368,    22,   551,   411,   129,   384,   121,   456,   129,
-   411,    98,   470,   296,   297,   389,   130,   121,   298,   299,
-   211,    10,    26,    27,    28,    29,    30,    31,    32,   143,
-    33,   384,   510,    23,   394,   384,   300,   301,   385,   384,
-   384,   208,   209,    24,   388,   212,   390,   549,   447,   215,
-   345,   436,   345,   345,   100,   345,   101,   442,    43,    44,
-    45,    25,   307,    46,   404,   370,   535,   246,    57,    58,
-   146,    96,    60,    61,    62,    63,     1,     1,     2,     3,
-     3,     4,   517,   532,   298,   299,   518,    51,   345,    95,
-   281,   282,   246,   284,    84,   466,   345,   345,   552,   243,
-   546,     2,   300,   301,     4,    64,   285,   246,   246,   246,
-   246,   246,   292,   293,   246,   140,   298,   299,   100,    34,
-   101,   509,   121,   491,   373,   492,   298,   299,   416,    52,
-   418,   419,   420,   371,   300,   301,   372,   100,   100,   101,
-   101,   214,   358,   371,   300,   301,   372,   100,   517,   101,
-   104,   105,   521,   306,   345,   345,   345,   218,   219,   220,
-   221,    53,   345,   353,   100,    39,   101,    40,   143,    55,
-   522,    34,   345,   345,   483,   132,   133,    76,   373,   351,
-   373,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-   262,   241,    80,   240,   355,   100,   352,   101,   248,    65,
-    87,   249,    66,   102,   103,    67,    91,    68,    97,    88,
-    89,   143,   369,   246,   345,    92,   345,    93,   125,   345,
-   126,   141,   204,   206,   493,   345,   345,   496,   497,   498,
-    57,    58,   207,    96,    60,    61,    62,    63,   387,     1,
-     2,   213,     3,     4,   210,   -55,   -56,   537,   399,   222,
-   539,   244,   345,   345,   250,   345,   345,   308,   314,   315,
-   316,   345,   317,   326,   318,   327,   328,    64,   330,   329,
-   332,   345,   359,   360,   361,   362,   246,   417,   246,   246,
-   246,   367,   363,   423,   107,   108,   109,   110,   111,   112,
-   377,   345,   364,   402,   378,   405,   406,   421,   415,   345,
-   422,   426,   430,   533,   431,   432,   433,   347,   348,   437,
-   349,   438,   435,   439,   440,   441,   444,   445,   446,   448,
-   449,   450,   547,   379,   380,   381,   382,   383,   451,   452,
-   454,   456,   457,   459,   460,   345,   391,   392,   393,   464,
-   345,   461,   467,   357,   465,   468,   469,   475,   484,   411,
-   495,   365,   366,   513,   503,   478,   504,   345,   345,   507,
-   482,    65,   345,   505,    66,   345,   487,    67,   506,    68,
-   127,   508,   246,   519,   514,   246,   246,   246,   529,   531,
-   487,   523,   479,   264,   265,   524,   427,   428,   515,   538,
-   540,   541,   542,   434,    57,    58,   543,    96,   134,   135,
-   136,    63,   550,     1,     2,   553,     3,     4,   554,   407,
-   408,   409,   555,   558,   559,   561,   564,   414,   565,   196,
-   197,   313,   528,   198,   116,   312,   304,   424,   425,   131,
-   128,    64,   511,   536,    38,   115,    86,   499,     0,   471,
-   472,   473,   474,   429,     0,     0,   476,   477,     0,   479,
-     0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
-   274,   275,   276,   277,   278,   279,     0,     0,     0,   453,
-     0,   455,     0,     0,   458,     0,     0,   501,   502,     0,
-   462,   463,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,   485,   486,     0,
-   489,   490,   525,     0,   526,   527,   494,     0,     0,     0,
-     0,     0,     0,     0,     0,    65,   500,     0,    66,     0,
-     0,    67,  -179,    68,   324,     0,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,   516,   -62,     1,     2,
-     0,     3,     4,     0,   520,     0,   333,   334,     5,     6,
-    57,    58,   335,     0,     0,     0,     0,     0,     0,     1,
-     2,     0,     3,     4,   336,   337,   338,     0,     7,     0,
-     0,     8,     0,     0,     0,     9,     0,     0,   339,   340,
-   544,     0,     0,     0,     0,   548,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,   341,     0,     0,     0,     0,
-     0,     0,   556,   557,     0,     0,     0,   560,     0,     0,
-   562,   157,   158,   159,   160,   161,   162,   163,   164,   165,
-   166,   167,   168,   169,   170,   171,   226,   227,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,     0,   228,   178,   179,   180,   181,   182,   183,
-   184,   185,   186,   187,   188,   189,     0,   229,     0,   230,
-   231,   232,   333,   334,     0,     0,    57,    58,   335,     0,
-   100,     0,   101,     0,     0,     1,     2,   342,     3,     4,
-   336,   337,   338,     0,     0,     0,     0,    57,    58,     0,
-     0,     0,     0,     0,   339,   340,     1,     2,     0,     3,
-     4,   223,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,   341,     0,     0,     0,   224,   225,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,   157,   158,   159,
-   160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
-   170,   171,   226,   227,     0,     0,     0,     0,   157,   158,
-   159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
-   169,   170,   171,   226,   227,     0,     0,     0,     0,   228,
-   178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
-   188,   189,     0,   229,     0,   230,   231,   232,     0,     0,
-   228,   178,   179,   180,   181,   182,   183,   184,   185,   186,
-   187,   188,   189,   342,   229,     0,   230,   231,   232,     0,
-     0,     0,   333,   334,     0,     0,     0,   100,   335,   101,
-     0,   233,     0,     0,   234,     0,   235,     0,   236,     0,
-   336,   337,   338,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,     0,     0,   339,   340,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,    57,
-    58,   341,    96,   134,   135,   136,    63,     0,     1,     2,
-     0,     3,     4,     0,     0,     0,     0,   157,   158,   159,
-   160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
-   170,   171,   226,   227,     0,     0,    64,     0,     0,     0,
-     0,     0,     0,     0,     0,    57,    58,     0,    96,    60,
-    61,    62,    63,     0,     1,     2,     0,     3,     4,   228,
-   178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
-   188,   189,   120,   229,     0,   230,   231,   232,     0,     0,
-     0,     0,    64,     0,     0,    57,    58,     0,    96,    60,
-    61,    62,    63,   342,     1,     2,     0,     3,     4,     0,
-     0,     0,     0,     0,    57,    58,     0,    96,   134,   135,
-   136,    63,   303,     1,     2,     0,     3,     4,     0,     0,
-     0,     0,    64,     0,     0,     0,     0,     0,     0,     0,
-    65,     0,     0,    66,     0,     0,    67,     0,    68,   386,
-     0,    64,     0,    57,    58,     0,    96,    60,    61,    62,
-    63,     0,     1,     2,     0,     3,     4,     0,     0,    57,
-    58,     0,    96,    60,    61,    62,    63,     0,     1,     2,
-   398,     3,     4,     0,     0,     0,    65,     0,     0,    66,
-    64,     0,    67,     0,    68,     0,   481,     0,    57,    58,
-     0,    59,    60,    61,    62,    63,    64,     1,     2,     0,
-     3,     4,    57,    58,     0,    96,   134,   135,   136,    63,
-     0,     1,     2,     0,     3,     4,    65,     0,     0,    66,
-     0,     0,    67,     0,    68,    64,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,    65,     0,     0,    66,    64,
-   319,    67,     0,    68,    57,    58,     0,   142,    60,    61,
-    62,    63,     0,     1,     2,     0,     3,     4,    57,    58,
-     0,    96,    60,    61,    62,    63,     0,     1,     2,     0,
-     3,     4,     0,     0,    65,     0,     0,    66,     0,     0,
-    67,    64,    68,     0,     0,     0,     0,     0,     0,     0,
-    65,     0,     0,    66,     0,    64,    67,     0,    68,     0,
-    57,    58,     0,   245,    60,    61,    62,    63,     0,     1,
-     2,     0,     3,     4,     0,     0,     0,     0,     0,    65,
-     0,     0,    66,     0,     0,    67,     0,    68,     0,     0,
-     0,     0,     0,    65,     0,     0,    66,    64,     0,    67,
-     0,    68,    57,    58,     0,    96,   134,   135,   136,    63,
-     0,     1,     2,     0,     3,     4,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,   148,     0,     0,
-     0,     0,     0,     0,     0,    65,     0,     0,    66,    64,
-     0,    67,     0,    68,     0,     0,   149,   150,     0,    65,
-     0,     0,    66,     0,     0,    67,     0,    68,   151,   152,
-   153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
-   163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-   173,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,    65,     0,     0,    66,     0,     0,    67,     0,    68,
-     0,   174,   175,   176,     0,     0,   177,   178,   179,   180,
-   181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-   191,   192,   193,   194,   195,     0,     0,  -178,     0,     0,
-     0,     0,     0,    65,     0,     0,    66,     0,     0,    67,
-     0,   322,   -62,     1,     2,     0,     3,     4,     0,     0,
-     0,     0,     0,     5,     6,     0,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,     0,     7,     0,     0,     8,     0,     0,     0,
-     9
-};
-
-static const short yycheck[] = {     0,
-    24,   153,   213,   139,   176,   139,   305,     4,    24,   399,
-   309,    11,   282,    14,   154,     0,   234,   235,   252,   191,
-   192,   193,   194,   195,    30,    18,   198,    11,    11,    14,
-   310,   311,    25,    11,     3,     4,     5,     6,   112,   113,
-    35,    36,    48,   136,    68,    47,    41,   135,    16,   533,
-   143,    19,    47,    22,    23,   129,   130,   131,   132,    61,
-   200,   295,    52,   547,    48,   136,   136,    91,   136,   136,
-    48,    95,   140,   108,   109,   145,   147,   101,   112,   113,
-   147,    82,    37,    38,    39,    40,    41,    42,    43,   113,
-    45,   136,   482,   135,    30,   136,   130,   131,   143,   136,
-   136,   125,   126,    15,   322,   129,   147,    33,   145,   133,
-   246,   147,   248,   249,   137,   251,   139,   397,    37,    38,
-    39,   135,   145,    42,   342,   297,   516,   151,     7,     8,
-   146,    10,    11,    12,    13,    14,    16,    16,    17,    19,
-    19,    20,   136,   143,   112,   113,   140,   135,   284,   146,
-   174,   175,   176,   177,   147,   425,   292,   293,   548,   144,
-   143,    17,   130,   131,    20,    44,   190,   191,   192,   193,
-   194,   195,   196,   197,   198,   106,   112,   113,   137,   134,
-   139,   140,   206,   453,   483,   455,   112,   113,   360,   135,
-   362,   363,   364,   129,   130,   131,   132,   137,   137,   139,
-   139,   132,   141,   129,   130,   131,   132,   137,   136,   139,
-    28,    29,   140,   143,   350,   351,   352,     3,     4,     5,
-     6,   141,   358,   136,   137,    41,   139,    43,   252,    19,
-   500,   134,   368,   369,   445,   102,   103,    32,   537,   263,
-   539,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-    94,   387,    18,   387,   136,   137,   280,   139,    11,   138,
-    19,    14,   141,    74,    75,   144,   139,   146,   147,    19,
-    19,   295,   296,   297,   410,     4,   412,     4,   142,   415,
-   142,     4,    19,   136,   456,   421,   422,   459,   460,   461,
-     7,     8,   140,    10,    11,    12,    13,    14,   322,    16,
-    17,   140,    19,    20,   145,     9,     9,   518,   332,     9,
-   521,    50,   448,   449,    11,   451,   452,   145,   139,   139,
-   139,   457,   139,    19,   139,   139,   139,    44,   136,   139,
-   139,   467,   136,   136,   136,   136,   360,   361,   362,   363,
-   364,    33,   136,   367,    55,    56,    57,    58,    59,    60,
-   139,   487,   136,    54,   139,   136,   136,   136,   141,   495,
-   136,   136,   136,   515,   136,   136,   136,   248,   249,   136,
-   251,   136,   145,    33,    19,     4,   136,   140,    19,    14,
-    14,   139,   534,   314,   315,   316,   317,   318,   136,   136,
-     4,   136,   136,   136,   136,   531,   327,   328,   329,   139,
-   536,   136,   426,   284,   136,   136,   136,   145,   136,    48,
-   136,   292,   293,    19,   136,   439,   140,   553,   554,   140,
-   444,   138,   558,   136,   141,   561,   450,   144,   136,   146,
-   147,   140,   456,   143,   136,   459,   460,   461,    48,    14,
-   464,   140,   443,    22,    23,   140,   377,   378,   141,   143,
-   140,   140,   140,   384,     7,     8,     4,    10,    11,    12,
-    13,    14,   136,    16,    17,    14,    19,    20,    14,   350,
-   351,   352,   136,    14,    66,    14,     0,   358,     0,   116,
-   116,   227,   510,   116,    82,   226,   206,   368,   369,   101,
-    95,    44,   483,   517,    14,    79,    50,   464,    -1,   430,
-   431,   432,   433,   379,    -1,    -1,   437,   438,    -1,   510,
-    -1,    -1,    91,    92,    93,    94,    95,    96,    97,    98,
-    99,   100,   101,   102,   103,   104,    -1,    -1,    -1,   410,
-    -1,   412,    -1,    -1,   415,    -1,    -1,   468,   469,    -1,
-   421,   422,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,   448,   449,    -1,
-   451,   452,   503,    -1,   505,   506,   457,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,   138,   467,    -1,   141,    -1,
-    -1,   144,     0,   146,   147,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,   487,    15,    16,    17,
-    -1,    19,    20,    -1,   495,    -1,     3,     4,    26,    27,
-     7,     8,     9,    -1,    -1,    -1,    -1,    -1,    -1,    16,
-    17,    -1,    19,    20,    21,    22,    23,    -1,    46,    -1,
-    -1,    49,    -1,    -1,    -1,    53,    -1,    -1,    35,    36,
-   531,    -1,    -1,    -1,    -1,   536,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    52,    -1,    -1,    -1,    -1,
-    -1,    -1,   553,   554,    -1,    -1,    -1,   558,    -1,    -1,
-   561,    68,    69,    70,    71,    72,    73,    74,    75,    76,
-    77,    78,    79,    80,    81,    82,    83,    84,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,   110,   111,   112,   113,   114,   115,   116,
-   117,   118,   119,   120,   121,   122,    -1,   124,    -1,   126,
-   127,   128,     3,     4,    -1,    -1,     7,     8,     9,    -1,
-   137,    -1,   139,    -1,    -1,    16,    17,   144,    19,    20,
-    21,    22,    23,    -1,    -1,    -1,    -1,     7,     8,    -1,
-    -1,    -1,    -1,    -1,    35,    36,    16,    17,    -1,    19,
-    20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    52,    -1,    -1,    -1,    35,    36,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,
-    71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-    81,    82,    83,    84,    -1,    -1,    -1,    -1,    68,    69,
-    70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
-    80,    81,    82,    83,    84,    -1,    -1,    -1,    -1,   110,
-   111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
-   121,   122,    -1,   124,    -1,   126,   127,   128,    -1,    -1,
-   110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
-   120,   121,   122,   144,   124,    -1,   126,   127,   128,    -1,
-    -1,    -1,     3,     4,    -1,    -1,    -1,   137,     9,   139,
-    -1,   141,    -1,    -1,   144,    -1,   146,    -1,   148,    -1,
-    21,    22,    23,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    35,    36,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     7,
-     8,    52,    10,    11,    12,    13,    14,    -1,    16,    17,
-    -1,    19,    20,    -1,    -1,    -1,    -1,    68,    69,    70,
-    71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-    81,    82,    83,    84,    -1,    -1,    44,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,     7,     8,    -1,    10,    11,
-    12,    13,    14,    -1,    16,    17,    -1,    19,    20,   110,
-   111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
-   121,   122,    34,   124,    -1,   126,   127,   128,    -1,    -1,
-    -1,    -1,    44,    -1,    -1,     7,     8,    -1,    10,    11,
-    12,    13,    14,   144,    16,    17,    -1,    19,    20,    -1,
-    -1,    -1,    -1,    -1,     7,     8,    -1,    10,    11,    12,
-    13,    14,    34,    16,    17,    -1,    19,    20,    -1,    -1,
-    -1,    -1,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-   138,    -1,    -1,   141,    -1,    -1,   144,    -1,   146,   147,
-    -1,    44,    -1,     7,     8,    -1,    10,    11,    12,    13,
-    14,    -1,    16,    17,    -1,    19,    20,    -1,    -1,     7,
-     8,    -1,    10,    11,    12,    13,    14,    -1,    16,    17,
-    34,    19,    20,    -1,    -1,    -1,   138,    -1,    -1,   141,
-    44,    -1,   144,    -1,   146,    -1,    34,    -1,     7,     8,
-    -1,    10,    11,    12,    13,    14,    44,    16,    17,    -1,
-    19,    20,     7,     8,    -1,    10,    11,    12,    13,    14,
-    -1,    16,    17,    -1,    19,    20,   138,    -1,    -1,   141,
-    -1,    -1,   144,    -1,   146,    44,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,   138,    -1,    -1,   141,    44,
-   143,   144,    -1,   146,     7,     8,    -1,    10,    11,    12,
-    13,    14,    -1,    16,    17,    -1,    19,    20,     7,     8,
-    -1,    10,    11,    12,    13,    14,    -1,    16,    17,    -1,
-    19,    20,    -1,    -1,   138,    -1,    -1,   141,    -1,    -1,
-   144,    44,   146,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-   138,    -1,    -1,   141,    -1,    44,   144,    -1,   146,    -1,
-     7,     8,    -1,    10,    11,    12,    13,    14,    -1,    16,
-    17,    -1,    19,    20,    -1,    -1,    -1,    -1,    -1,   138,
-    -1,    -1,   141,    -1,    -1,   144,    -1,   146,    -1,    -1,
-    -1,    -1,    -1,   138,    -1,    -1,   141,    44,    -1,   144,
-    -1,   146,     7,     8,    -1,    10,    11,    12,    13,    14,
-    -1,    16,    17,    -1,    19,    20,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    31,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,   138,    -1,    -1,   141,    44,
-    -1,   144,    -1,   146,    -1,    -1,    50,    51,    -1,   138,
-    -1,    -1,   141,    -1,    -1,   144,    -1,   146,    62,    63,
-    64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
-    74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
-    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,   138,    -1,    -1,   141,    -1,    -1,   144,    -1,   146,
-    -1,   105,   106,   107,    -1,    -1,   110,   111,   112,   113,
-   114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
-   124,   125,   126,   127,   128,    -1,    -1,     0,    -1,    -1,
-    -1,    -1,    -1,   138,    -1,    -1,   141,    -1,    -1,   144,
-    -1,   146,    15,    16,    17,    -1,    19,    20,    -1,    -1,
-    -1,    -1,    -1,    26,    27,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    46,    -1,    -1,    49,    -1,    -1,    -1,
-    53
-};
-/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
-#line 3 "/usr/share/bison.simple"
-/* This file comes from bison-1.28.  */
-
-/* Skeleton output parser for bison,
-   Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-/* As a special exception, when this file is copied by Bison into a
-   Bison output file, you may use that output file without restriction.
-   This special exception was added by the Free Software Foundation
-   in version 1.24 of Bison.  */
-
-/* This is the parser code that is written into each bison parser
-  when the %semantic_parser declaration is not specified in the grammar.
-  It was written by Richard Stallman by simplifying the hairy parser
-  used when %semantic_parser is specified.  */
-
-#ifndef YYSTACK_USE_ALLOCA
-#ifdef alloca
-#define YYSTACK_USE_ALLOCA
-#else /* alloca not defined */
-#ifdef __GNUC__
-#define YYSTACK_USE_ALLOCA
-#define alloca __builtin_alloca
-#else /* not GNU C.  */
-#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
-#define YYSTACK_USE_ALLOCA
-#include <alloca.h>
-#else /* not sparc */
-/* We think this test detects Watcom and Microsoft C.  */
-/* This used to test MSDOS, but that is a bad idea
-   since that symbol is in the user namespace.  */
-#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
-#if 0 /* No need for malloc.h, which pollutes the namespace;
-	 instead, just don't use alloca.  */
-#include <malloc.h>
-#endif
-#else /* not MSDOS, or __TURBOC__ */
-#if defined(_AIX)
-/* I don't know what this was needed for, but it pollutes the namespace.
-   So I turned it off.   rms, 2 May 1997.  */
-/* #include <malloc.h>  */
- #pragma alloca
-#define YYSTACK_USE_ALLOCA
-#else /* not MSDOS, or __TURBOC__, or _AIX */
-#if 0
-#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
-		 and on HPUX 10.  Eventually we can turn this on.  */
-#define YYSTACK_USE_ALLOCA
-#define alloca __builtin_alloca
-#endif /* __hpux */
-#endif
-#endif /* not _AIX */
-#endif /* not MSDOS, or __TURBOC__ */
-#endif /* not sparc */
-#endif /* not GNU C */
-#endif /* alloca not defined */
-#endif /* YYSTACK_USE_ALLOCA not defined */
-
-#ifdef YYSTACK_USE_ALLOCA
-#define YYSTACK_ALLOC alloca
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
 #else
-#define YYSTACK_ALLOC malloc
+typedef unsigned char yytype_uint8;
 #endif
 
-/* Note: there must be only one dollar sign in this file.
-   It is replaced by the list of actions, each action
-   as one case of the switch.  */
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#elif (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+typedef signed char yytype_int8;
+#else
+typedef short int yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(msgid) msgid
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(e) ((void) (e))
+#else
+# define YYUSE(e) /* empty */
+#endif
+
+/* Identity function, used to suppress warnings about constant conditions.  */
+#ifndef lint
+# define YYID(n) (n)
+#else
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static int
+YYID (int i)
+#else
+static int
+YYID (i)
+    int i;
+#endif
+{
+  return i;
+}
+#endif
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#     ifndef _STDLIB_H
+#      define _STDLIB_H 1
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's `empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined _STDLIB_H \
+       && ! ((defined YYMALLOC || defined malloc) \
+	     && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef _STDLIB_H
+#    define _STDLIB_H 1
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+	 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  yytype_int16 yyss;
+  YYSTYPE yyvs;
+  };
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+      + YYSTACK_GAP_MAXIMUM)
+
+/* Copy COUNT objects from FROM to TO.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(To, From, Count) \
+      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+#  else
+#   define YYCOPY(To, From, Count)		\
+      do					\
+	{					\
+	  YYSIZE_T yyi;				\
+	  for (yyi = 0; yyi < (Count); yyi++)	\
+	    (To)[yyi] = (From)[yyi];		\
+	}					\
+      while (YYID (0))
+#  endif
+# endif
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack)					\
+    do									\
+      {									\
+	YYSIZE_T yynewbytes;						\
+	YYCOPY (&yyptr->Stack, Stack, yysize);				\
+	Stack = &yyptr->Stack;						\
+	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+	yyptr += yynewbytes / sizeof (*yyptr);				\
+      }									\
+    while (YYID (0))
+
+#endif
+
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  41
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   1455
+
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  150
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  81
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  294
+/* YYNRULES -- Number of states.  */
+#define YYNSTATES  573
+
+/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
+#define YYUNDEFTOK  2
+#define YYMAXUTOK   390
+
+#define YYTRANSLATE(YYX)						\
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
+static const yytype_uint8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     140,   141,   138,     2,   137,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     145,   136,   146,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,   142,   139,   144,     2,     2,     2,     2,     2,   149,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     143,     2,     2,   147,     2,   148,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
+      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
+      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
+      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
+      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
+      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
+     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
+     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
+     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
+     135
+};
+
+#if YYDEBUG
+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
+   YYRHS.  */
+static const yytype_uint16 yyprhs[] =
+{
+       0,     0,     3,     5,     7,     9,    11,    13,    15,    17,
+      19,    21,    23,    25,    27,    29,    31,    33,    35,    37,
+      39,    41,    43,    45,    47,    49,    51,    53,    55,    57,
+      59,    61,    63,    65,    67,    69,    71,    73,    75,    77,
+      79,    81,    83,    85,    87,    89,    91,    93,    95,    97,
+      99,   101,   103,   105,   107,   109,   111,   113,   115,   117,
+     119,   121,   122,   125,   126,   128,   130,   132,   133,   136,
+     138,   140,   142,   144,   146,   148,   150,   152,   153,   155,
+     157,   158,   160,   162,   163,   165,   167,   169,   171,   172,
+     174,   176,   177,   179,   181,   183,   185,   187,   190,   192,
+     194,   196,   198,   199,   202,   204,   206,   208,   209,   212,
+     213,   216,   217,   221,   224,   225,   227,   228,   232,   234,
+     237,   239,   241,   243,   245,   247,   249,   252,   254,   257,
+     263,   269,   275,   281,   285,   288,   294,   299,   302,   304,
+     306,   308,   312,   314,   318,   320,   321,   323,   327,   332,
+     336,   340,   345,   350,   354,   361,   367,   370,   373,   376,
+     379,   382,   385,   388,   391,   394,   397,   400,   403,   410,
+     416,   425,   432,   439,   447,   455,   462,   471,   480,   484,
+     486,   488,   490,   492,   493,   495,   496,   498,   501,   502,
+     506,   507,   511,   515,   519,   523,   524,   532,   533,   542,
+     543,   552,   559,   562,   566,   568,   572,   576,   580,   584,
+     586,   587,   593,   597,   599,   603,   605,   606,   616,   618,
+     620,   625,   627,   629,   632,   636,   637,   639,   641,   643,
+     645,   647,   649,   651,   653,   655,   659,   661,   667,   669,
+     671,   673,   675,   677,   679,   682,   685,   688,   692,   695,
+     696,   698,   701,   704,   708,   718,   728,   737,   752,   754,
+     756,   763,   769,   772,   779,   787,   791,   797,   798,   799,
+     803,   806,   808,   814,   820,   827,   834,   839,   846,   851,
+     856,   863,   870,   873,   882,   884,   886,   887,   891,   898,
+     902,   909,   912,   918,   926
+};
+
+/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
+static const yytype_int16 yyrhs[] =
+{
+     193,     0,    -1,    69,    -1,    70,    -1,    71,    -1,    72,
+      -1,    73,    -1,    74,    -1,    75,    -1,    76,    -1,    77,
+      -1,    81,    -1,    82,    -1,    83,    -1,    78,    -1,    79,
+      -1,    80,    -1,   112,    -1,   113,    -1,   114,    -1,   115,
+      -1,   116,    -1,   117,    -1,   118,    -1,   119,    -1,   120,
+      -1,   121,    -1,   122,    -1,   123,    -1,    86,    -1,    87,
+      -1,    88,    -1,    89,    -1,    90,    -1,    91,    -1,    92,
+      -1,    93,    -1,    94,    -1,    95,    -1,    96,    -1,    97,
+      -1,    98,    -1,    99,    -1,   100,    -1,   101,    -1,   102,
+      -1,   103,    -1,   104,    -1,   105,    -1,    92,    -1,    93,
+      -1,    94,    -1,    95,    -1,    22,    -1,    23,    -1,    11,
+      -1,    12,    -1,    13,    -1,    16,    -1,    19,    -1,   158,
+      -1,    -1,   158,   136,    -1,    -1,    17,    -1,    20,    -1,
+     163,    -1,    -1,   161,   136,    -1,    38,    -1,    40,    -1,
+      39,    -1,    41,    -1,    43,    -1,    42,    -1,    44,    -1,
+      46,    -1,    -1,   134,    -1,   135,    -1,    -1,    42,    -1,
+      44,    -1,    -1,    38,    -1,    39,    -1,    40,    -1,    43,
+      -1,    -1,    40,    -1,    38,    -1,    -1,    57,    -1,    58,
+      -1,    59,    -1,    60,    -1,    61,    -1,    56,     4,    -1,
+     113,    -1,   114,    -1,   131,    -1,   132,    -1,    -1,   172,
+     171,    -1,   130,    -1,   133,    -1,   171,    -1,    -1,   174,
+     173,    -1,    -1,    49,     4,    -1,    -1,   137,    49,     4,
+      -1,    30,    19,    -1,    -1,   177,    -1,    -1,   137,   180,
+     179,    -1,   177,    -1,    49,     4,    -1,    11,    -1,    12,
+      -1,    13,    -1,    14,    -1,    45,    -1,   181,    -1,   182,
+     138,    -1,   215,    -1,   139,     4,    -1,   182,   140,   186,
+     141,   174,    -1,    10,   140,   186,   141,   174,    -1,   142,
+       4,   143,   182,   144,    -1,   145,     4,   143,   182,   146,
+      -1,   147,   187,   148,    -1,   147,   148,    -1,   145,   147,
+     187,   148,   146,    -1,   145,   147,   148,   146,    -1,   182,
+     172,    -1,   182,    -1,    10,    -1,   183,    -1,   185,   137,
+     183,    -1,   185,    -1,   185,   137,    35,    -1,    35,    -1,
+      -1,   182,    -1,   187,   137,   182,    -1,   182,   142,   190,
+     144,    -1,   182,   142,   144,    -1,   182,   149,    19,    -1,
+     182,   145,   190,   146,    -1,   182,   147,   190,   148,    -1,
+     182,   147,   148,    -1,   182,   145,   147,   190,   148,   146,
+      -1,   182,   145,   147,   148,   146,    -1,   182,    36,    -1,
+     182,    37,    -1,   182,   215,    -1,   182,   189,    -1,   182,
+      21,    -1,   156,     3,    -1,   156,     5,    -1,   156,     4,
+      -1,   156,     6,    -1,    11,    22,    -1,    11,    23,    -1,
+     157,     9,    -1,   153,   140,   188,    34,   182,   141,    -1,
+     111,   140,   188,   226,   141,    -1,   125,   140,   188,   137,
+     188,   137,   188,   141,    -1,   151,   140,   188,   137,   188,
+     141,    -1,   152,   140,   188,   137,   188,   141,    -1,    84,
+     154,   140,   188,   137,   188,   141,    -1,    85,   155,   140,
+     188,   137,   188,   141,    -1,   127,   140,   188,   137,   188,
+     141,    -1,   128,   140,   188,   137,   188,   137,   188,   141,
+      -1,   129,   140,   188,   137,   188,   137,   188,   141,    -1,
+     190,   137,   188,    -1,   188,    -1,    28,    -1,    29,    -1,
+      33,    -1,    -1,   194,    -1,    -1,   195,    -1,   194,   195,
+      -1,    -1,    27,   196,   211,    -1,    -1,    26,   197,   212,
+      -1,    54,    53,   201,    -1,   160,    15,   182,    -1,   160,
+      15,    10,    -1,    -1,   162,   166,   192,   191,   188,   198,
+     179,    -1,    -1,   162,   164,   166,   192,   191,   188,   199,
+     179,    -1,    -1,   162,   165,   166,   192,   191,   182,   200,
+     179,    -1,   162,   166,    31,   169,   184,   215,    -1,    47,
+     202,    -1,    50,   136,   203,    -1,    19,    -1,    48,   136,
+      19,    -1,    62,   136,    19,    -1,   142,   204,   144,    -1,
+     204,   137,    19,    -1,    19,    -1,    -1,   205,   137,   182,
+     172,   159,    -1,   182,   172,   159,    -1,   205,    -1,   205,
+     137,    35,    -1,    35,    -1,    -1,   170,   184,   161,   140,
+     206,   141,   174,   178,   175,    -1,    24,    -1,   147,    -1,
+     168,   166,   207,   208,    -1,    25,    -1,   148,    -1,   218,
+     210,    -1,   167,   166,   207,    -1,    -1,    55,    -1,     3,
+      -1,     4,    -1,     9,    -1,    22,    -1,    23,    -1,    36,
+      -1,    37,    -1,    21,    -1,   145,   190,   146,    -1,   189,
+      -1,    53,   213,    19,   137,    19,    -1,     7,    -1,     8,
+      -1,   158,    -1,   161,    -1,   215,    -1,   214,    -1,   182,
+     216,    -1,   218,   219,    -1,   209,   219,    -1,   220,   160,
+     221,    -1,   220,   223,    -1,    -1,    18,    -1,    63,   217,
+      -1,    63,    10,    -1,    64,    14,   216,    -1,    64,    11,
+     216,   137,    14,   216,   137,    14,   216,    -1,    65,   156,
+     216,   137,    14,   216,   142,   222,   144,    -1,    65,   156,
+     216,   137,    14,   216,   142,   144,    -1,    66,   170,   184,
+     216,   140,   225,   141,   174,    34,    14,   216,    67,    14,
+     216,    -1,    67,    -1,    68,    -1,   222,   156,   214,   137,
+      14,   216,    -1,   156,   214,   137,    14,   216,    -1,   160,
+     228,    -1,   182,   142,   216,   137,   216,   144,    -1,   224,
+     137,   142,   216,   137,   216,   144,    -1,   182,   216,   172,
+      -1,   225,   137,   182,   216,   172,    -1,    -1,    -1,   226,
+     137,   217,    -1,    52,    51,    -1,    51,    -1,   151,   182,
+     216,   137,   216,    -1,   152,   182,   216,   137,   216,    -1,
+      84,   154,   182,   216,   137,   216,    -1,    85,   155,   182,
+     216,   137,   216,    -1,   153,   217,    34,   182,    -1,   125,
+     217,   137,   217,   137,   217,    -1,   126,   217,   137,   182,
+      -1,   127,   217,   137,   217,    -1,   128,   217,   137,   217,
+     137,   217,    -1,   129,   217,   137,   217,   137,   217,    -1,
+     124,   224,    -1,   227,   170,   184,   216,   140,   225,   141,
+     174,    -1,   230,    -1,    32,    -1,    -1,   106,   182,   176,
+      -1,   106,   182,   137,    11,   216,   176,    -1,   107,   182,
+     176,    -1,   107,   182,   137,    11,   216,   176,    -1,   108,
+     217,    -1,   229,   109,   182,   216,   176,    -1,   229,   110,
+     217,   137,   182,   216,   176,    -1,   111,   182,   216,   226,
+      -1
+};
+
+/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
+static const yytype_uint16 yyrline[] =
+{
+       0,  1094,  1094,  1094,  1094,  1094,  1094,  1094,  1094,  1094,
+    1094,  1095,  1095,  1095,  1095,  1095,  1095,  1096,  1096,  1096,
+    1096,  1096,  1096,  1097,  1097,  1097,  1097,  1097,  1097,  1100,
+    1100,  1101,  1101,  1102,  1102,  1103,  1103,  1104,  1104,  1108,
+    1108,  1109,  1109,  1110,  1110,  1111,  1111,  1112,  1112,  1113,
+    1113,  1114,  1114,  1115,  1116,  1121,  1122,  1122,  1124,  1124,
+    1125,  1125,  1129,  1133,  1138,  1138,  1140,  1141,  1146,  1152,
+    1153,  1154,  1155,  1156,  1160,  1161,  1162,  1166,  1167,  1168,
+    1172,  1173,  1174,  1178,  1179,  1180,  1181,  1182,  1186,  1187,
+    1188,  1191,  1192,  1193,  1194,  1195,  1196,  1197,  1204,  1205,
+    1206,  1207,  1210,  1211,  1216,  1217,  1218,  1221,  1222,  1229,
+    1230,  1236,  1237,  1245,  1253,  1254,  1259,  1260,  1261,  1266,
+    1279,  1279,  1279,  1279,  1282,  1286,  1290,  1297,  1302,  1310,
+    1340,  1371,  1376,  1388,  1398,  1402,  1412,  1419,  1426,  1433,
+    1438,  1443,  1450,  1451,  1458,  1465,  1473,  1479,  1491,  1519,
+    1535,  1564,  1592,  1617,  1636,  1662,  1682,  1694,  1701,  1767,
+    1777,  1787,  1793,  1803,  1809,  1819,  1824,  1829,  1837,  1849,
+    1871,  1879,  1885,  1896,  1901,  1906,  1912,  1918,  1927,  1931,
+    1939,  1939,  1942,  1942,  1953,  1958,  1966,  1967,  1971,  1971,
+    1975,  1975,  1978,  1981,  2005,  2016,  2016,  2026,  2026,  2034,
+    2034,  2044,  2072,  2075,  2081,  2094,  2098,  2103,  2105,  2110,
+    2115,  2124,  2134,  2145,  2149,  2158,  2167,  2172,  2294,  2294,
+    2296,  2305,  2305,  2307,  2312,  2324,  2328,  2333,  2337,  2341,
+    2345,  2349,  2353,  2357,  2361,  2365,  2390,  2394,  2408,  2412,
+    2416,  2420,  2426,  2426,  2432,  2441,  2445,  2454,  2463,  2472,
+    2476,  2481,  2485,  2489,  2494,  2504,  2523,  2532,  2612,  2616,
+    2623,  2634,  2647,  2657,  2668,  2678,  2687,  2696,  2699,  2700,
+    2707,  2711,  2716,  2737,  2754,  2768,  2782,  2794,  2802,  2809,
+    2815,  2821,  2827,  2842,  2927,  2932,  2936,  2943,  2950,  2958,
+    2965,  2973,  2981,  2995,  3012
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =
+{
+  "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "ESAPINTVAL",
+  "EUAPINTVAL", "LOCALVAL_ID", "GLOBALVAL_ID", "FPVAL", "VOID", "INTTYPE",
+  "FLOAT", "DOUBLE", "LABEL", "TYPE", "LOCALVAR", "GLOBALVAR", "LABELSTR",
+  "STRINGCONSTANT", "ATSTRINGCONSTANT", "ZEROINITIALIZER", "TRUETOK",
+  "FALSETOK", "BEGINTOK", "ENDTOK", "DECLARE", "DEFINE", "GLOBAL",
+  "CONSTANT", "SECTION", "ALIAS", "VOLATILE", "THREAD_LOCAL", "TO",
+  "DOTDOTDOT", "NULL_TOK", "UNDEF", "INTERNAL", "LINKONCE", "WEAK",
+  "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE",
+  "EXTERNAL", "TARGET", "TRIPLE", "ALIGN", "DEPLIBS", "CALL", "TAIL",
+  "ASM_TOK", "MODULE", "SIDEEFFECT", "CC_TOK", "CCC_TOK", "FASTCC_TOK",
+  "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT",
+  "RET", "BR", "SWITCH", "INVOKE", "UNWIND", "UNREACHABLE", "ADD", "SUB",
+  "MUL", "UDIV", "SDIV", "FDIV", "UREM", "SREM", "FREM", "AND", "OR",
+  "XOR", "SHL", "LSHR", "ASHR", "ICMP", "FCMP", "EQ", "NE", "SLT", "SGT",
+  "SLE", "SGE", "ULT", "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT",
+  "OLE", "OGE", "ORD", "UNO", "UEQ", "UNE", "MALLOC", "ALLOCA", "FREE",
+  "LOAD", "STORE", "GETELEMENTPTR", "TRUNC", "ZEXT", "SEXT", "FPTRUNC",
+  "FPEXT", "BITCAST", "UITOFP", "SITOFP", "FPTOUI", "FPTOSI", "INTTOPTR",
+  "PTRTOINT", "PHI_TOK", "SELECT", "VAARG", "EXTRACTELEMENT",
+  "INSERTELEMENT", "SHUFFLEVECTOR", "NORETURN", "INREG", "SRET",
+  "NOUNWIND", "DEFAULT", "HIDDEN", "'='", "','", "'*'", "'\\\\'", "'('",
+  "')'", "'['", "'x'", "']'", "'<'", "'>'", "'{'", "'}'", "'c'", "$accept",
+  "ArithmeticOps", "LogicalOps", "CastOps", "IPredicates", "FPredicates",
+  "IntType", "FPType", "LocalName", "OptLocalName", "OptLocalAssign",
+  "GlobalName", "OptGlobalAssign", "GlobalAssign", "GVInternalLinkage",
+  "GVExternalLinkage", "GVVisibilityStyle", "FunctionDeclareLinkage",
+  "FunctionDefineLinkage", "AliasLinkage", "OptCallingConv", "ParamAttr",
+  "OptParamAttrs", "FuncAttr", "OptFuncAttrs", "OptAlign", "OptCAlign",
+  "SectionString", "OptSection", "GlobalVarAttributes",
+  "GlobalVarAttribute", "PrimType", "Types", "ArgType", "ResultTypes",
+  "ArgTypeList", "ArgTypeListI", "TypeListI", "ConstVal", "ConstExpr",
+  "ConstVector", "GlobalType", "ThreadLocal", "Module", "DefinitionList",
+  "Definition", "@1", "@2", "@3", "@4", "@5", "AsmBlock",
+  "TargetDefinition", "LibrariesDefinition", "LibList", "ArgListH",
+  "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader", "END",
+  "Function", "FunctionProto", "OptSideEffect", "ConstValueRef",
+  "SymbolicValueRef", "ValueRef", "ResolvedVal", "BasicBlockList",
+  "BasicBlock", "InstructionList", "BBTerminatorInst", "JumpTable", "Inst",
+  "PHIList", "ValueRefList", "IndexList", "OptTailCall", "InstVal",
+  "OptVolatile", "MemoryInst", 0
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
+   token YYLEX-NUM.  */
+static const yytype_uint16 yytoknum[] =
+{
+       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
+     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
+     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
+     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
+     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
+     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
+     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
+     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
+     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
+     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
+     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
+     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
+     385,   386,   387,   388,   389,   390,    61,    44,    42,    92,
+      40,    41,    91,   120,    93,    60,    62,   123,   125,    99
+};
+# endif
+
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const yytype_uint8 yyr1[] =
+{
+       0,   150,   151,   151,   151,   151,   151,   151,   151,   151,
+     151,   152,   152,   152,   152,   152,   152,   153,   153,   153,
+     153,   153,   153,   153,   153,   153,   153,   153,   153,   154,
+     154,   154,   154,   154,   154,   154,   154,   154,   154,   155,
+     155,   155,   155,   155,   155,   155,   155,   155,   155,   155,
+     155,   155,   155,   155,   155,   156,   157,   157,   158,   158,
+     159,   159,   160,   160,   161,   161,   162,   162,   163,   164,
+     164,   164,   164,   164,   165,   165,   165,   166,   166,   166,
+     167,   167,   167,   168,   168,   168,   168,   168,   169,   169,
+     169,   170,   170,   170,   170,   170,   170,   170,   171,   171,
+     171,   171,   172,   172,   173,   173,   173,   174,   174,   175,
+     175,   176,   176,   177,   178,   178,   179,   179,   180,   180,
+     181,   181,   181,   181,   182,   182,   182,   182,   182,   182,
+     182,   182,   182,   182,   182,   182,   182,   183,   184,   184,
+     185,   185,   186,   186,   186,   186,   187,   187,   188,   188,
+     188,   188,   188,   188,   188,   188,   188,   188,   188,   188,
+     188,   188,   188,   188,   188,   188,   188,   188,   189,   189,
+     189,   189,   189,   189,   189,   189,   189,   189,   190,   190,
+     191,   191,   192,   192,   193,   193,   194,   194,   196,   195,
+     197,   195,   195,   195,   195,   198,   195,   199,   195,   200,
+     195,   195,   195,   195,   201,   202,   202,   203,   204,   204,
+     204,   205,   205,   206,   206,   206,   206,   207,   208,   208,
+     209,   210,   210,   211,   212,   213,   213,   214,   214,   214,
+     214,   214,   214,   214,   214,   214,   214,   214,   215,   215,
+     215,   215,   216,   216,   217,   218,   218,   219,   220,   220,
+     220,   221,   221,   221,   221,   221,   221,   221,   221,   221,
+     222,   222,   223,   224,   224,   225,   225,   225,   226,   226,
+     227,   227,   228,   228,   228,   228,   228,   228,   228,   228,
+     228,   228,   228,   228,   228,   229,   229,   230,   230,   230,
+     230,   230,   230,   230,   230
+};
+
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+static const yytype_uint8 yyr2[] =
+{
+       0,     2,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     0,     2,     0,     1,     1,     1,     0,     2,     1,
+       1,     1,     1,     1,     1,     1,     1,     0,     1,     1,
+       0,     1,     1,     0,     1,     1,     1,     1,     0,     1,
+       1,     0,     1,     1,     1,     1,     1,     2,     1,     1,
+       1,     1,     0,     2,     1,     1,     1,     0,     2,     0,
+       2,     0,     3,     2,     0,     1,     0,     3,     1,     2,
+       1,     1,     1,     1,     1,     1,     2,     1,     2,     5,
+       5,     5,     5,     3,     2,     5,     4,     2,     1,     1,
+       1,     3,     1,     3,     1,     0,     1,     3,     4,     3,
+       3,     4,     4,     3,     6,     5,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     6,     5,
+       8,     6,     6,     7,     7,     6,     8,     8,     3,     1,
+       1,     1,     1,     0,     1,     0,     1,     2,     0,     3,
+       0,     3,     3,     3,     3,     0,     7,     0,     8,     0,
+       8,     6,     2,     3,     1,     3,     3,     3,     3,     1,
+       0,     5,     3,     1,     3,     1,     0,     9,     1,     1,
+       4,     1,     1,     2,     3,     0,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     3,     1,     5,     1,     1,
+       1,     1,     1,     1,     2,     2,     2,     3,     2,     0,
+       1,     2,     2,     3,     9,     9,     8,    14,     1,     1,
+       6,     5,     2,     6,     7,     3,     5,     0,     0,     3,
+       2,     1,     5,     5,     6,     6,     4,     6,     4,     4,
+       6,     6,     2,     8,     1,     1,     0,     3,     6,     3,
+       6,     2,     5,     7,     4
+};
+
+/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
+   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
+   means the default is an error.  */
+static const yytype_uint16 yydefact[] =
+{
+      67,    58,    64,    59,    65,   190,   188,     0,     0,     0,
+       0,     0,     0,    77,    66,     0,    67,   186,    80,    83,
+       0,     0,   202,     0,     0,    62,     0,    68,    69,    71,
+      70,    72,    74,    73,    75,    76,    78,    79,    77,    77,
+     183,     1,   187,    81,    82,    77,   191,    84,    85,    86,
+      87,    77,   249,   189,   249,     0,     0,   210,   203,   204,
+     192,   238,   239,   194,   120,   121,   122,   123,   124,     0,
+       0,     0,     0,   240,   241,   125,   193,   127,   183,   183,
+      88,   182,     0,    91,    91,   250,   246,    63,   221,   222,
+     223,   245,   205,   206,   209,     0,   145,   128,     0,     0,
+       0,     0,   134,   146,     0,   126,   145,     0,     0,    90,
+      89,     0,   180,   181,     0,     0,    92,    93,    94,    95,
+      96,     0,   224,     0,   286,   248,     0,   207,   144,   102,
+     140,   142,     0,     0,     0,     0,     0,     0,   133,     0,
+       0,     0,   139,   138,     0,   120,   121,   122,     0,     0,
+       0,   195,    97,     0,   218,   219,   220,   285,   271,     0,
+       0,     0,     0,    91,   258,   259,     2,     3,     4,     5,
+       6,     7,     8,     9,    10,    14,    15,    16,    11,    12,
+      13,     0,     0,     0,     0,     0,     0,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   247,    91,
+     262,     0,   284,   208,   137,     0,   107,     0,     0,   136,
+       0,   147,   107,   197,   199,   201,   165,   166,   161,   163,
+     162,   164,   167,   160,   156,   157,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     159,   158,   116,     0,   270,   252,     0,   251,     0,     0,
+      55,     0,     0,    29,    30,    31,    32,    33,    34,    35,
+      36,    37,    38,     0,    53,    54,    49,    50,    51,    52,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+       0,   111,   111,   291,     0,     0,   282,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    98,    99,
+     100,   101,   103,   143,   141,   130,   131,   132,   135,   129,
+     116,   116,     0,     0,     0,     0,     0,     0,     0,   149,
+     179,     0,     0,     0,   153,     0,   150,     0,     0,     0,
+       0,   196,   216,   227,   228,   229,   234,   230,   231,   232,
+     233,   225,     0,   236,   243,   242,   244,     0,   253,     0,
+       0,     0,     0,     0,   287,     0,   289,   268,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   104,   105,   106,   108,   198,   200,     0,     0,   268,
+       0,     0,     0,     0,     0,   148,   134,   146,     0,   151,
+     152,     0,     0,     0,     0,     0,   118,   116,   215,   102,
+     213,     0,   226,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   294,     0,     0,     0,   278,   279,     0,
+       0,     0,     0,   276,     0,   111,     0,     0,     0,     0,
+       0,     0,     0,     0,   178,   155,     0,     0,     0,     0,
+     113,   119,   117,    61,     0,   107,     0,   235,     0,     0,
+     267,     0,     0,   111,   112,   111,     0,     0,     0,     0,
+       0,     0,   272,   273,   267,     0,   292,     0,     0,     0,
+     169,     0,     0,     0,     0,   154,     0,     0,     0,    60,
+     212,   214,   102,   114,     0,     0,     0,     0,     0,   274,
+     275,   288,   290,   269,     0,     0,   277,   280,   281,     0,
+     111,     0,     0,     0,   175,     0,     0,   171,   172,   168,
+      61,   115,   109,   237,     0,     0,   102,     0,   107,   263,
+       0,   107,   293,   173,   174,     0,     0,     0,   211,     0,
+     217,     0,   256,     0,     0,   265,     0,     0,   264,   283,
+     170,   176,   177,   110,   254,     0,   255,     0,   102,     0,
+       0,     0,   266,     0,     0,     0,     0,   261,     0,     0,
+     260,     0,   257
+};
+
+/* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int16 yydefgoto[] =
+{
+      -1,   247,   248,   249,   273,   290,   148,   149,    73,   490,
+      11,    74,    13,    14,    38,    39,    40,    45,    51,   111,
+     121,   312,   214,   384,   315,   540,   364,   406,   522,   341,
+     407,    75,   150,   130,   144,   131,   132,   104,   330,   353,
+     331,   114,    82,    15,    16,    17,    19,    18,   252,   320,
+     321,    60,    22,    58,    95,   410,   411,   122,   156,    52,
+      90,    53,    46,   413,   354,    77,   356,   257,    54,    86,
+      87,   208,   544,   125,   296,   498,   423,   209,   210,   211,
+     212
+};
+
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+   STATE-NUM.  */
+#define YYPACT_NINF -467
+static const yytype_int16 yypact[] =
+{
+     601,  -467,  -467,  -467,  -467,  -467,  -467,    28,   -64,    41,
+     -37,    98,    10,    16,  -467,   139,   856,  -467,    36,   170,
+      18,    26,  -467,    31,   148,  -467,  1069,  -467,  -467,  -467,
+    -467,  -467,  -467,  -467,  -467,  -467,  -467,  -467,    81,    81,
+     107,  -467,  -467,  -467,  -467,    81,  -467,  -467,  -467,  -467,
+    -467,    81,   179,  -467,     8,   209,   220,   226,  -467,  -467,
+    -467,  -467,  -467,   118,  -467,  -467,  -467,  -467,  -467,   269,
+     275,     1,   541,  -467,  -467,  -467,   100,  -467,   251,   251,
+     229,  -467,   204,   196,   196,  -467,  -467,   104,  -467,  -467,
+    -467,  -467,  -467,  -467,  -467,  -100,   981,  -467,   143,   146,
+     754,   118,  -467,   100,   -96,  -467,   981,   204,   204,  -467,
+    -467,  1086,  -467,  -467,  1137,   289,  -467,  -467,  -467,  -467,
+    -467,  1086,  -467,   -15,  1326,  -467,   277,  -467,  -467,   100,
+    -467,   162,   163,  1181,  1181,   167,   -95,  1181,  -467,   173,
+    1137,  1181,   118,   100,   227,    45,   299,   306,   216,   309,
+     712,  -467,  -467,    23,  -467,  -467,  -467,  -467,  -467,   268,
+    1227,   200,   312,   196,  -467,  -467,  -467,  -467,  -467,  -467,
+    -467,  -467,  -467,  -467,  -467,  -467,  -467,  -467,  -467,  -467,
+    -467,   303,  1195,  1181,  1181,  1181,  1181,  -467,  -467,  -467,
+    -467,  -467,  -467,  -467,  -467,  -467,  -467,  -467,  -467,  1181,
+    1181,  1181,  1181,  1181,  1181,  1181,  1181,  1181,  -467,   196,
+    -467,   140,  -467,  -467,   -68,   995,  -467,    58,    -9,  -467,
+     174,   100,  -467,  -467,   100,  -467,  -467,  -467,  -467,  -467,
+    -467,  -467,  -467,  -467,  -467,  -467,   303,  1195,   186,   187,
+     188,   189,   191,   633,  1241,   793,   313,   193,   194,   195,
+    -467,  -467,   201,   197,  -467,   118,   462,  -467,   589,   589,
+    -467,   589,  1086,  -467,  -467,  -467,  -467,  -467,  -467,  -467,
+    -467,  -467,  -467,  1181,  -467,  -467,  -467,  -467,  -467,  -467,
+    -467,  -467,  -467,  -467,  -467,  -467,  -467,  -467,  -467,  -467,
+    1181,    89,   165,  -467,   462,   134,   202,   205,   206,   213,
+     214,   217,   462,   462,   307,  1086,  1181,  1181,  -467,  -467,
+    -467,  -467,  -467,  -467,  -467,   -48,  -467,  -467,  -467,   -48,
+     201,   201,   215,   218,  1137,  1137,  1137,  1137,  1137,  -467,
+    -467,   -26,   965,   -67,  -467,   -45,  -467,  1137,  1137,  1137,
+     -10,  -467,  1025,  -467,  -467,  -467,  -467,  -467,  -467,  -467,
+    -467,   298,  1137,  -467,  -467,  -467,  -467,   219,  -467,   222,
+     589,   462,   462,    24,  -467,    25,  -467,  -467,   589,   221,
+    1181,  1181,  1181,  1181,  1181,   224,   225,  1181,   589,   462,
+     230,  -467,  -467,  -467,  -467,  -467,  -467,  1137,  1137,  -467,
+     233,   234,   235,   241,  1137,  -467,   211,   712,   -44,  -467,
+    -467,   242,   244,   330,   347,   365,  -467,   201,  -467,   100,
+     245,   258,  -467,   364,   -31,   386,   387,   265,   271,   276,
+     589,   402,   589,   278,   279,   589,   280,   100,  -467,   281,
+     282,   589,   589,   100,   272,   283,  1181,   284,   285,   -27,
+    1137,  1137,  1137,  1137,  -467,  -467,   286,  1137,  1137,  1181,
+    -467,  -467,  -467,    13,  1039,  -467,   288,  -467,   589,   589,
+    1181,   589,   589,   283,  -467,   283,  1181,   589,   291,  1181,
+    1181,  1181,  -467,  -467,  1181,   374,  -467,   462,  1137,  1137,
+    -467,   293,   273,   296,   301,  -467,   310,   311,   137,  -467,
+    -467,  -467,   100,    39,   420,   305,   308,   462,    -7,  -467,
+    -467,  -467,  -467,  -467,   304,   589,  -467,  -467,  -467,    47,
+     283,   314,   315,  1137,  -467,  1137,  1137,  -467,  -467,  -467,
+      13,  -467,   391,  -467,   433,    -1,  -467,  1181,  -467,  -467,
+     316,  -467,  -467,  -467,  -467,   317,   318,   320,  -467,   450,
+    -467,   589,  -467,   842,     3,   -68,   462,    73,  -467,   -48,
+    -467,  -467,  -467,  -467,  -467,   325,  -467,   842,  -467,   443,
+     449,   327,   -68,   589,   589,   453,   401,  -467,   589,   458,
+    -467,   589,  -467
+};
+
+/* YYPGOTO[NTERM-NUM].  */
+static const yytype_int16 yypgoto[] =
+{
+    -467,   349,   350,   351,   240,   243,  -160,  -467,     0,   -43,
+     399,    11,  -467,  -467,  -467,  -467,    50,  -467,  -467,  -467,
+    -148,  -281,  -390,  -467,  -219,  -467,  -280,    -6,  -467,  -290,
+    -467,  -467,   -25,   290,  -113,  -467,   382,   393,    49,  -146,
+    -227,   155,   232,  -467,  -467,   478,  -467,  -467,  -467,  -467,
+    -467,  -467,  -467,  -467,  -467,  -467,  -467,   411,  -467,  -467,
+    -467,  -467,  -467,  -467,  -466,  -137,  -161,  -179,  -467,   446,
+    -467,  -467,  -467,  -467,  -467,    27,   114,  -467,  -467,  -467,
+    -467
+};
+
+/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
+   positive, shift that token.  If negative, reduce the rule which
+   number is the opposite.  If zero, do what YYDEFACT says.
+   If YYTABLE_NINF, syntax error.  */
+#define YYTABLE_NINF -186
+static const yytype_int16 yytable[] =
+{
+      10,    76,   261,   319,   250,    99,   293,   225,   153,   154,
+     260,    12,   366,   251,   260,   262,    10,   333,   335,   453,
+     404,   297,   298,   299,   300,   301,    85,    12,   304,     1,
+     385,   386,     3,    88,   383,   420,   422,   126,   383,   405,
+       2,   137,   137,     4,   127,   308,   309,   103,   -55,   -55,
+     -55,   -55,   138,   220,    28,    29,    30,    31,    32,    33,
+      34,   305,    35,   310,   311,   308,   309,   226,   227,   404,
+     394,   129,    23,   421,   421,   103,    20,   555,    43,   399,
+      44,   129,   381,   310,   311,   382,   143,    10,    78,    79,
+      21,   561,   394,   394,    24,    83,   143,   357,   358,    25,
+     359,    84,   520,   400,   446,   398,   394,   559,   217,   218,
+     466,   394,   221,    26,   480,   457,   224,   452,   395,   355,
+       1,   355,   355,     3,   355,   414,   308,   309,   380,   105,
+     527,   106,   155,   367,   528,   256,   545,   317,    80,    41,
+      81,   375,   376,   542,   310,   311,    27,   556,   100,   360,
+      36,    37,   308,   309,    55,   476,    89,   355,   291,   292,
+     256,   294,    56,   151,   253,   355,   355,    59,   562,   381,
+     310,   311,   382,    57,   295,   256,   256,   256,   256,   256,
+     302,   303,   256,   501,   527,   502,   308,   309,   531,   223,
+     129,   426,   378,   428,   429,   430,   105,    85,   106,   417,
+     418,   419,   316,   381,   310,   311,   382,   424,    47,    48,
+      49,   258,   383,    50,   259,    36,    37,   434,   435,   228,
+     229,   230,   231,   355,   355,   355,   363,   105,    92,   106,
+     532,   355,   112,   113,    61,    62,   493,   143,   105,    93,
+     106,   355,   355,     1,     2,    94,     3,     4,   361,   306,
+     307,   250,   115,   116,   117,   118,   119,   120,    96,   463,
+     251,   465,   140,   141,   468,   362,   383,   109,   383,   110,
+     472,   473,   105,    97,   106,   105,   368,   106,   519,    98,
+     143,   379,   256,   355,    81,   355,   133,   503,   355,   134,
+     506,   507,   508,   152,   355,   355,   213,   495,   496,   215,
+     499,   500,   365,   105,   216,   106,   504,   397,   -56,   547,
+     107,   108,   549,   219,   222,   -57,   510,   409,   232,   254,
+     318,   355,   355,   260,   355,   355,   324,   325,   326,   327,
+     355,   328,   336,   337,   338,   339,   526,   342,   340,   369,
+     355,   377,   370,   371,   530,   256,   427,   256,   256,   256,
+     372,   373,   433,   412,   374,   387,   415,   445,   388,   416,
+     355,   431,   432,   425,   449,   543,   450,   436,   355,   451,
+     440,   441,   442,   389,   390,   391,   392,   393,   443,   447,
+     554,   448,   454,   456,   557,   558,   401,   402,   403,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   455,
+     458,   459,   566,   567,   355,   460,   464,   570,   461,   355,
+     572,   477,   474,   462,   514,   466,   467,   469,   470,   471,
+     475,   478,   479,   421,   488,   494,   355,   355,   505,   492,
+     513,   355,   485,   515,   355,   497,   437,   438,   516,   523,
+     539,   256,   524,   444,   256,   256,   256,   541,   529,   497,
+     525,   517,   518,   489,   553,   533,   534,   563,   550,   551,
+     548,   552,   560,   564,   565,   343,   344,   568,   569,    61,
+      62,   345,   571,   205,   206,   207,   322,   538,     1,     2,
+     323,     3,     4,   346,   347,   348,   124,   521,   139,   481,
+     482,   483,   484,   136,    42,   123,   486,   487,   349,   350,
+      91,   509,   546,   439,     0,   314,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   351,     0,     0,     0,     0,
+     489,     0,     0,     0,     0,     0,     0,   511,   512,     0,
+       0,   166,   167,   168,   169,   170,   171,   172,   173,   174,
+     175,   176,   177,   178,   179,   180,   236,   237,    61,    62,
+       0,   101,    64,    65,    66,    67,     0,     1,     2,     0,
+       3,     4,   535,     0,   536,   537,     0,     0,     0,     0,
+       0,     0,     0,   238,   187,   188,   189,   190,   191,   192,
+     193,   194,   195,   196,   197,   198,    68,   239,     0,   240,
+     241,   242,   343,   344,     0,     0,    61,    62,   345,     0,
+     105,  -185,   106,     0,     0,     1,     2,   352,     3,     4,
+     346,   347,   348,     0,     0,     0,   -63,     1,     2,     0,
+       3,     4,     0,     0,     0,   349,   350,     5,     6,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      61,    62,   351,   101,   145,   146,   147,    67,     7,     1,
+       2,     8,     3,     4,     0,     9,     0,     0,   166,   167,
+     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+     178,   179,   180,   236,   237,     0,     0,     0,    68,     0,
+      69,     0,     0,    70,     0,     0,    71,     0,    72,   102,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     238,   187,   188,   189,   190,   191,   192,   193,   194,   195,
+     196,   197,   198,     0,   239,     0,   240,   241,   242,    61,
+      62,     0,     0,     0,     0,     0,     0,     0,     1,     2,
+       0,     3,     4,   233,   352,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   234,   235,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    61,    62,     0,   101,    64,    65,    66,    67,     0,
+       1,     2,    69,     3,     4,    70,     0,   329,    71,     0,
+      72,   166,   167,   168,   169,   170,   171,   172,   173,   174,
+     175,   176,   177,   178,   179,   180,   236,   237,     0,    68,
+      61,    62,     0,   101,   145,   146,   147,    67,     0,     1,
+       2,     0,     3,     4,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   238,   187,   188,   189,   190,   191,   192,
+     193,   194,   195,   196,   197,   198,     0,   239,    68,   240,
+     241,   242,     0,     0,     0,   343,   344,     0,     0,     0,
+     105,   345,   106,     0,   243,     0,  -184,   244,     0,   245,
+       0,   246,     0,   346,   347,   348,     0,     0,     0,     0,
+       0,   -63,     1,     2,     0,     3,     4,     0,   349,   350,
+       0,     0,     5,     6,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    69,     0,   351,    70,     0,     0,    71,
+       0,    72,   135,     7,     0,     0,     8,     0,     0,     0,
+       9,   166,   167,   168,   169,   170,   171,   172,   173,   174,
+     175,   176,   177,   178,   179,   180,   236,   237,     0,     0,
+       0,     0,    69,     0,     0,    70,     0,     0,    71,     0,
+      72,   334,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   238,   187,   188,   189,   190,   191,   192,
+     193,   194,   195,   196,   197,   198,     0,   239,     0,   240,
+     241,   242,    61,    62,     0,   101,   145,   146,   147,    67,
+       0,     1,     2,     0,     3,     4,     0,   352,    61,    62,
+       0,   101,    64,    65,    66,    67,     0,     1,     2,     0,
+       3,     4,    61,    62,     0,   101,    64,    65,    66,    67,
+      68,     1,     2,     0,     3,     4,   128,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    68,     0,     0,     0,
+     313,     0,    61,    62,     0,   101,    64,    65,    66,    67,
+      68,     1,     2,     0,     3,     4,    61,    62,     0,   101,
+      64,    65,    66,    67,     0,     1,     2,     0,     3,     4,
+     408,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      68,     0,     0,     0,   491,     0,    61,    62,     0,    63,
+      64,    65,    66,    67,    68,     1,     2,     0,     3,     4,
+       0,     0,     0,    61,    62,     0,   142,    64,    65,    66,
+      67,     0,     1,     2,    69,     3,     4,    70,     0,     0,
+      71,     0,    72,   396,    68,     0,     0,     0,     0,     0,
+      69,     0,     0,    70,     0,     0,    71,     0,    72,     0,
+       0,    68,     0,     0,    69,     0,     0,    70,     0,     0,
+      71,     0,    72,     0,    61,    62,     0,   101,   145,   146,
+     147,    67,     0,     1,     2,     0,     3,     4,     0,     0,
+       0,     0,     0,     0,    69,     0,     0,    70,     0,     0,
+      71,     0,    72,     0,     0,     0,     0,     0,    69,     0,
+       0,    70,    68,     0,    71,     0,    72,     0,    61,    62,
+       0,   101,    64,    65,    66,    67,     0,     1,     2,     0,
+       3,     4,     0,     0,     0,     0,     0,     0,    69,     0,
+       0,    70,     0,     0,    71,     0,    72,   274,   275,     0,
+       0,     0,     0,     0,     0,    69,    68,     0,    70,     0,
+       0,    71,     0,    72,    61,    62,     0,   255,    64,    65,
+      66,    67,     0,     1,     2,     0,     3,     4,    61,    62,
+       0,   101,   145,   146,   147,    67,     0,     1,     2,     0,
+       3,     4,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    68,     0,     0,     0,    69,     0,     0,    70,
+       0,     0,    71,     0,    72,     0,    68,   276,   277,   278,
+     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
+     289,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      69,     0,     0,    70,     0,     0,    71,     0,    72,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   157,     0,
+       0,     0,     0,     0,     0,     0,    69,     0,     0,    70,
+       0,     0,    71,     0,    72,     0,     0,   158,   159,     0,
+      69,     0,     0,    70,     0,     0,    71,     0,   332,   160,
+     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
+     171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
+     181,   182,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   183,   184,   185,     0,     0,   186,   187,   188,
+     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
+     199,   200,   201,   202,   203,   204
+};
+
+static const yytype_int16 yycheck[] =
+{
+       0,    26,   162,   222,   150,     4,   185,   144,   121,    24,
+      11,     0,   292,   150,    11,   163,    16,   244,   245,   409,
+      30,   200,   201,   202,   203,   204,    18,    16,   207,    16,
+     320,   321,    19,    25,   315,    11,    11,   137,   319,    49,
+      17,   137,   137,    20,   144,   113,   114,    72,     3,     4,
+       5,     6,   148,   148,    38,    39,    40,    41,    42,    43,
+      44,   209,    46,   131,   132,   113,   114,    22,    23,    30,
+     137,    96,   136,    49,    49,   100,    48,   543,    42,   146,
+      44,   106,   130,   131,   132,   133,   111,    87,    38,    39,
+      62,   557,   137,   137,    53,    45,   121,   258,   259,   136,
+     261,    51,   492,   148,   148,   332,   137,    34,   133,   134,
+     137,   137,   137,    15,   141,   146,   141,   407,   144,   256,
+      16,   258,   259,    19,   261,   352,   113,   114,   307,   138,
+     137,   140,   147,   294,   141,   160,   526,   146,    31,     0,
+      33,   302,   303,   144,   131,   132,   136,   144,   147,   262,
+     134,   135,   113,   114,   136,   435,   148,   294,   183,   184,
+     185,   186,   136,   114,   153,   302,   303,    19,   558,   130,
+     131,   132,   133,   142,   199,   200,   201,   202,   203,   204,
+     205,   206,   207,   463,   137,   465,   113,   114,   141,   140,
+     215,   370,   305,   372,   373,   374,   138,    18,   140,   360,
+     361,   362,   144,   130,   131,   132,   133,   368,    38,    39,
+      40,    11,   493,    43,    14,   134,   135,   378,   379,     3,
+       4,     5,     6,   360,   361,   362,   137,   138,    19,   140,
+     510,   368,    28,    29,     7,     8,   455,   262,   138,    19,
+     140,   378,   379,    16,    17,    19,    19,    20,   273,   109,
+     110,   397,    56,    57,    58,    59,    60,    61,   140,   420,
+     397,   422,   107,   108,   425,   290,   547,    38,   549,    40,
+     431,   432,   138,     4,   140,   138,   142,   140,   141,     4,
+     305,   306,   307,   420,    33,   422,   143,   466,   425,   143,
+     469,   470,   471,     4,   431,   432,    19,   458,   459,   137,
+     461,   462,   137,   138,   141,   140,   467,   332,     9,   528,
+      78,    79,   531,   146,   141,     9,   477,   342,     9,    51,
+     146,   458,   459,    11,   461,   462,   140,   140,   140,   140,
+     467,   140,    19,   140,   140,   140,   497,   140,   137,   137,
+     477,    34,   137,   137,   505,   370,   371,   372,   373,   374,
+     137,   137,   377,    55,   137,   140,   137,   146,   140,   137,
+     497,   137,   137,   142,    34,   525,    19,   137,   505,     4,
+     137,   137,   137,   324,   325,   326,   327,   328,   137,   137,
+     541,   137,   137,    19,   544,   546,   337,   338,   339,    86,
+      87,    88,    89,    90,    91,    92,    93,    94,    95,   141,
+      14,    14,   563,   564,   541,   140,     4,   568,   137,   546,
+     571,   436,   140,   137,   141,   137,   137,   137,   137,   137,
+     137,   137,   137,    49,   449,   137,   563,   564,   137,   454,
+     137,   568,   146,   137,   571,   460,   387,   388,   137,    19,
+      49,   466,   137,   394,   469,   470,   471,    14,   144,   474,
+     142,   141,   141,   453,     4,   141,   141,    14,   141,   141,
+     144,   141,   137,    14,   137,     3,     4,    14,    67,     7,
+       8,     9,    14,   124,   124,   124,   236,   520,    16,    17,
+     237,    19,    20,    21,    22,    23,    87,   493,   106,   440,
+     441,   442,   443,   100,    16,    84,   447,   448,    36,    37,
+      54,   474,   527,   389,    -1,   215,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    53,    -1,    -1,    -1,    -1,
+     520,    -1,    -1,    -1,    -1,    -1,    -1,   478,   479,    -1,
+      -1,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    85,     7,     8,
+      -1,    10,    11,    12,    13,    14,    -1,    16,    17,    -1,
+      19,    20,   513,    -1,   515,   516,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,   122,   123,    45,   125,    -1,   127,
+     128,   129,     3,     4,    -1,    -1,     7,     8,     9,    -1,
+     138,     0,   140,    -1,    -1,    16,    17,   145,    19,    20,
+      21,    22,    23,    -1,    -1,    -1,    15,    16,    17,    -1,
+      19,    20,    -1,    -1,    -1,    36,    37,    26,    27,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+       7,     8,    53,    10,    11,    12,    13,    14,    47,    16,
+      17,    50,    19,    20,    -1,    54,    -1,    -1,    69,    70,
+      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
+      81,    82,    83,    84,    85,    -1,    -1,    -1,    45,    -1,
+     139,    -1,    -1,   142,    -1,    -1,   145,    -1,   147,   148,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
+     121,   122,   123,    -1,   125,    -1,   127,   128,   129,     7,
+       8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    16,    17,
+      -1,    19,    20,    21,   145,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    36,    37,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,     7,     8,    -1,    10,    11,    12,    13,    14,    -1,
+      16,    17,   139,    19,    20,   142,    -1,   144,   145,    -1,
+     147,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    85,    -1,    45,
+       7,     8,    -1,    10,    11,    12,    13,    14,    -1,    16,
+      17,    -1,    19,    20,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,   122,   123,    -1,   125,    45,   127,
+     128,   129,    -1,    -1,    -1,     3,     4,    -1,    -1,    -1,
+     138,     9,   140,    -1,   142,    -1,     0,   145,    -1,   147,
+      -1,   149,    -1,    21,    22,    23,    -1,    -1,    -1,    -1,
+      -1,    15,    16,    17,    -1,    19,    20,    -1,    36,    37,
+      -1,    -1,    26,    27,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   139,    -1,    53,   142,    -1,    -1,   145,
+      -1,   147,   148,    47,    -1,    -1,    50,    -1,    -1,    -1,
+      54,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    85,    -1,    -1,
+      -1,    -1,   139,    -1,    -1,   142,    -1,    -1,   145,    -1,
+     147,   148,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,   122,   123,    -1,   125,    -1,   127,
+     128,   129,     7,     8,    -1,    10,    11,    12,    13,    14,
+      -1,    16,    17,    -1,    19,    20,    -1,   145,     7,     8,
+      -1,    10,    11,    12,    13,    14,    -1,    16,    17,    -1,
+      19,    20,     7,     8,    -1,    10,    11,    12,    13,    14,
+      45,    16,    17,    -1,    19,    20,    35,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    45,    -1,    -1,    -1,
+      35,    -1,     7,     8,    -1,    10,    11,    12,    13,    14,
+      45,    16,    17,    -1,    19,    20,     7,     8,    -1,    10,
+      11,    12,    13,    14,    -1,    16,    17,    -1,    19,    20,
+      35,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      45,    -1,    -1,    -1,    35,    -1,     7,     8,    -1,    10,
+      11,    12,    13,    14,    45,    16,    17,    -1,    19,    20,
+      -1,    -1,    -1,     7,     8,    -1,    10,    11,    12,    13,
+      14,    -1,    16,    17,   139,    19,    20,   142,    -1,    -1,
+     145,    -1,   147,   148,    45,    -1,    -1,    -1,    -1,    -1,
+     139,    -1,    -1,   142,    -1,    -1,   145,    -1,   147,    -1,
+      -1,    45,    -1,    -1,   139,    -1,    -1,   142,    -1,    -1,
+     145,    -1,   147,    -1,     7,     8,    -1,    10,    11,    12,
+      13,    14,    -1,    16,    17,    -1,    19,    20,    -1,    -1,
+      -1,    -1,    -1,    -1,   139,    -1,    -1,   142,    -1,    -1,
+     145,    -1,   147,    -1,    -1,    -1,    -1,    -1,   139,    -1,
+      -1,   142,    45,    -1,   145,    -1,   147,    -1,     7,     8,
+      -1,    10,    11,    12,    13,    14,    -1,    16,    17,    -1,
+      19,    20,    -1,    -1,    -1,    -1,    -1,    -1,   139,    -1,
+      -1,   142,    -1,    -1,   145,    -1,   147,    22,    23,    -1,
+      -1,    -1,    -1,    -1,    -1,   139,    45,    -1,   142,    -1,
+      -1,   145,    -1,   147,     7,     8,    -1,    10,    11,    12,
+      13,    14,    -1,    16,    17,    -1,    19,    20,     7,     8,
+      -1,    10,    11,    12,    13,    14,    -1,    16,    17,    -1,
+      19,    20,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    45,    -1,    -1,    -1,   139,    -1,    -1,   142,
+      -1,    -1,   145,    -1,   147,    -1,    45,    92,    93,    94,
+      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
+     105,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     139,    -1,    -1,   142,    -1,    -1,   145,    -1,   147,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    32,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   139,    -1,    -1,   142,
+      -1,    -1,   145,    -1,   147,    -1,    -1,    51,    52,    -1,
+     139,    -1,    -1,   142,    -1,    -1,   145,    -1,   147,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   106,   107,   108,    -1,    -1,   111,   112,   113,
+     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129
+};
+
+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+   symbol of state STATE-NUM.  */
+static const yytype_uint8 yystos[] =
+{
+       0,    16,    17,    19,    20,    26,    27,    47,    50,    54,
+     158,   160,   161,   162,   163,   193,   194,   195,   197,   196,
+      48,    62,   202,   136,    53,   136,    15,   136,    38,    39,
+      40,    41,    42,    43,    44,    46,   134,   135,   164,   165,
+     166,     0,   195,    42,    44,   167,   212,    38,    39,    40,
+      43,   168,   209,   211,   218,   136,   136,   142,   203,    19,
+     201,     7,     8,    10,    11,    12,    13,    14,    45,   139,
+     142,   145,   147,   158,   161,   181,   182,   215,   166,   166,
+      31,    33,   192,   166,   166,    18,   219,   220,    25,   148,
+     210,   219,    19,    19,    19,   204,   140,     4,     4,     4,
+     147,    10,   148,   182,   187,   138,   140,   192,   192,    38,
+      40,   169,    28,    29,   191,    56,    57,    58,    59,    60,
+      61,   170,   207,   207,   160,   223,   137,   144,    35,   182,
+     183,   185,   186,   143,   143,   148,   187,   137,   148,   186,
+     191,   191,    10,   182,   184,    11,    12,    13,   156,   157,
+     182,   188,     4,   184,    24,   147,   208,    32,    51,    52,
+      63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
+      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
+      83,    84,    85,   106,   107,   108,   111,   112,   113,   114,
+     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
+     125,   126,   127,   128,   129,   151,   152,   153,   221,   227,
+     228,   229,   230,    19,   172,   137,   141,   182,   182,   146,
+     148,   182,   141,   188,   182,   215,    22,    23,     3,     4,
+       5,     6,     9,    21,    36,    37,    84,    85,   111,   125,
+     127,   128,   129,   142,   145,   147,   149,   151,   152,   153,
+     189,   215,   198,   161,    51,    10,   182,   217,    11,    14,
+      11,   156,   170,    86,    87,    88,    89,    90,    91,    92,
+      93,    94,    95,   154,    22,    23,    92,    93,    94,    95,
+      96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
+     155,   182,   182,   217,   182,   182,   224,   217,   217,   217,
+     217,   217,   182,   182,   217,   170,   109,   110,   113,   114,
+     131,   132,   171,    35,   183,   174,   144,   146,   146,   174,
+     199,   200,   154,   155,   140,   140,   140,   140,   140,   144,
+     188,   190,   147,   190,   148,   190,    19,   140,   140,   140,
+     137,   179,   140,     3,     4,     9,    21,    22,    23,    36,
+      37,    53,   145,   189,   214,   215,   216,   216,   216,   216,
+     184,   182,   182,   137,   176,   137,   176,   216,   142,   137,
+     137,   137,   137,   137,   137,   216,   216,    34,   184,   182,
+     217,   130,   133,   171,   173,   179,   179,   140,   140,   188,
+     188,   188,   188,   188,   137,   144,   148,   182,   190,   146,
+     148,   188,   188,   188,    30,    49,   177,   180,    35,   182,
+     205,   206,    55,   213,   190,   137,   137,   216,   216,   216,
+      11,    49,    11,   226,   216,   142,   217,   182,   217,   217,
+     217,   137,   137,   182,   216,   216,   137,   188,   188,   226,
+     137,   137,   137,   137,   188,   146,   148,   137,   137,    34,
+      19,     4,   179,   172,   137,   141,    19,   146,    14,    14,
+     140,   137,   137,   216,     4,   216,   137,   137,   216,   137,
+     137,   137,   216,   216,   140,   137,   176,   182,   137,   137,
+     141,   188,   188,   188,   188,   146,   188,   188,   182,   158,
+     159,    35,   182,   174,   137,   216,   216,   182,   225,   216,
+     216,   176,   176,   217,   216,   137,   217,   217,   217,   225,
+     216,   188,   188,   137,   141,   137,   137,   141,   141,   141,
+     172,   177,   178,    19,   137,   142,   216,   137,   141,   144,
+     216,   141,   176,   141,   141,   188,   188,   188,   159,    49,
+     175,    14,   144,   156,   222,   172,   182,   174,   144,   174,
+     141,   141,   141,     4,   216,   214,   144,   156,   216,    34,
+     137,   214,   172,    14,    14,   137,   216,   216,    14,    67,
+     216,    14,   216
+};
 
 #define yyerrok		(yyerrstatus = 0)
 #define yyclearin	(yychar = YYEMPTY)
-#define YYEMPTY		-2
+#define YYEMPTY		(-2)
 #define YYEOF		0
+
 #define YYACCEPT	goto yyacceptlab
-#define YYABORT 	goto yyabortlab
-#define YYERROR		goto yyerrlab1
-/* Like YYERROR except do call yyerror.
-   This remains here temporarily to ease the
-   transition to the new meaning of YYERROR, for GCC.
+#define YYABORT		goto yyabortlab
+#define YYERROR		goto yyerrorlab
+
+
+/* Like YYERROR except do call yyerror.  This remains here temporarily
+   to ease the transition to the new meaning of YYERROR, for GCC.
    Once GCC version 2 has supplanted version 1, this can go.  */
+
 #define YYFAIL		goto yyerrlab
+
 #define YYRECOVERING()  (!!yyerrstatus)
-#define YYBACKUP(token, value) \
+
+#define YYBACKUP(Token, Value)					\
 do								\
   if (yychar == YYEMPTY && yylen == 1)				\
-    { yychar = (token), yylval = (value);			\
-      yychar1 = YYTRANSLATE (yychar);				\
-      YYPOPSTACK;						\
+    {								\
+      yychar = (Token);						\
+      yylval = (Value);						\
+      yytoken = YYTRANSLATE (yychar);				\
+      YYPOPSTACK (1);						\
       goto yybackup;						\
     }								\
   else								\
-    { yyerror ("syntax error: cannot back up"); YYERROR; }	\
-while (0)
+    {								\
+      yyerror (YY_("syntax error: cannot back up")); \
+      YYERROR;							\
+    }								\
+while (YYID (0))
+
 
 #define YYTERROR	1
 #define YYERRCODE	256
 
-#ifndef YYPURE
-#define YYLEX		yylex()
+
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N)				\
+    do									\
+      if (YYID (N))                                                    \
+	{								\
+	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
+	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
+	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
+	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
+	}								\
+      else								\
+	{								\
+	  (Current).first_line   = (Current).last_line   =		\
+	    YYRHSLOC (Rhs, 0).last_line;				\
+	  (Current).first_column = (Current).last_column =		\
+	    YYRHSLOC (Rhs, 0).last_column;				\
+	}								\
+    while (YYID (0))
 #endif
 
-#ifdef YYPURE
-#ifdef YYLSP_NEEDED
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+#ifndef YY_LOCATION_PRINT
+# if YYLTYPE_IS_TRIVIAL
+#  define YY_LOCATION_PRINT(File, Loc)			\
+     fprintf (File, "%d.%d-%d.%d",			\
+	      (Loc).first_line, (Loc).first_column,	\
+	      (Loc).last_line,  (Loc).last_column)
+# else
+#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
+#endif
+
+
+/* YYLEX -- calling `yylex' with the right arguments.  */
+
 #ifdef YYLEX_PARAM
-#define YYLEX		yylex(&yylval, &yylloc, YYLEX_PARAM)
+# define YYLEX yylex (YYLEX_PARAM)
 #else
-#define YYLEX		yylex(&yylval, &yylloc)
+# define YYLEX yylex ()
 #endif
-#else /* not YYLSP_NEEDED */
-#ifdef YYLEX_PARAM
-#define YYLEX		yylex(&yylval, YYLEX_PARAM)
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)			\
+do {						\
+  if (yydebug)					\
+    YYFPRINTF Args;				\
+} while (YYID (0))
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
+do {									  \
+  if (yydebug)								  \
+    {									  \
+      YYFPRINTF (stderr, "%s ", Title);					  \
+      yy_symbol_print (stderr,						  \
+		  Type, Value); \
+      YYFPRINTF (stderr, "\n");						  \
+    }									  \
+} while (YYID (0))
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
 #else
-#define YYLEX		yylex(&yylval)
+static void
+yy_symbol_value_print (yyoutput, yytype, yyvaluep)
+    FILE *yyoutput;
+    int yytype;
+    YYSTYPE const * const yyvaluep;
 #endif
-#endif /* not YYLSP_NEEDED */
+{
+  if (!yyvaluep)
+    return;
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# else
+  YYUSE (yyoutput);
+# endif
+  switch (yytype)
+    {
+      default:
+	break;
+    }
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+#else
+static void
+yy_symbol_print (yyoutput, yytype, yyvaluep)
+    FILE *yyoutput;
+    int yytype;
+    YYSTYPE const * const yyvaluep;
 #endif
+{
+  if (yytype < YYNTOKENS)
+    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+  else
+    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 
-/* If nonreentrant, generate the variables here */
+  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
+  YYFPRINTF (yyoutput, ")");
+}
 
-#ifndef YYPURE
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
 
-int	yychar;			/*  the lookahead symbol		*/
-YYSTYPE	yylval;			/*  the semantic value of the		*/
-				/*  lookahead symbol			*/
-
-#ifdef YYLSP_NEEDED
-YYLTYPE yylloc;			/*  location data for the lookahead	*/
-				/*  symbol				*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
+#else
+static void
+yy_stack_print (bottom, top)
+    yytype_int16 *bottom;
+    yytype_int16 *top;
 #endif
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; bottom <= top; ++bottom)
+    YYFPRINTF (stderr, " %d", *bottom);
+  YYFPRINTF (stderr, "\n");
+}
 
-int yynerrs;			/*  number of parse errors so far       */
-#endif  /* not YYPURE */
+# define YY_STACK_PRINT(Bottom, Top)				\
+do {								\
+  if (yydebug)							\
+    yy_stack_print ((Bottom), (Top));				\
+} while (YYID (0))
 
-#if YYDEBUG != 0
-int yydebug;			/*  nonzero means print parse trace	*/
-/* Since this is uninitialized, it does not stop multiple parsers
-   from coexisting.  */
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
+#else
+static void
+yy_reduce_print (yyvsp, yyrule)
+    YYSTYPE *yyvsp;
+    int yyrule;
 #endif
+{
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  unsigned long int yylno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+	     yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      fprintf (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
+		       &(yyvsp[(yyi + 1) - (yynrhs)])
+		       		       );
+      fprintf (stderr, "\n");
+    }
+}
 
-/*  YYINITDEPTH indicates the initial size of the parser's stacks	*/
+# define YY_REDUCE_PRINT(Rule)		\
+do {					\
+  if (yydebug)				\
+    yy_reduce_print (yyvsp, Rule); \
+} while (YYID (0))
 
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef	YYINITDEPTH
-#define YYINITDEPTH 200
+# define YYINITDEPTH 200
 #endif
 
-/*  YYMAXDEPTH is the maximum size the stacks can grow to
-    (effective only if the built-in stack extension method is used).  */
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
 
-#if YYMAXDEPTH == 0
-#undef YYMAXDEPTH
-#endif
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
 
 #ifndef YYMAXDEPTH
-#define YYMAXDEPTH 10000
+# define YYMAXDEPTH 10000
 #endif
+
 
-/* Define __yy_memcpy.  Note that the size argument
-   should be passed with type unsigned int, because that is what the non-GCC
-   definitions require.  With GCC, __builtin_memcpy takes an arg
-   of type size_t, but it can handle unsigned int.  */
 
-#if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */
-#define __yy_memcpy(TO,FROM,COUNT)	__builtin_memcpy(TO,FROM,COUNT)
-#else				/* not GNU C or C++ */
-#ifndef __cplusplus
+#if YYERROR_VERBOSE
 
-/* This is the most reliable way to avoid incompatibilities
-   in available built-in functions on various systems.  */
-static void
-__yy_memcpy (to, from, count)
-     char *to;
-     char *from;
-     unsigned int count;
-{
-  register char *f = from;
-  register char *t = to;
-  register int i = count;
-
-  while (i-- > 0)
-    *t++ = *f++;
-}
-
-#else /* __cplusplus */
-
-/* This is the most reliable way to avoid incompatibilities
-   in available built-in functions on various systems.  */
-static void
-__yy_memcpy (char *to, char *from, unsigned int count)
-{
-  register char *t = to;
-  register char *f = from;
-  register int i = count;
-
-  while (i-- > 0)
-    *t++ = *f++;
-}
-
-#endif
-#endif
-
-#line 217 "/usr/share/bison.simple"
-
-/* The user can define YYPARSE_PARAM as the name of an argument to be passed
-   into yyparse.  The argument should have type void *.
-   It should actually point to an object.
-   Grammar actions can access the variable by casting it
-   to the proper pointer type.  */
-
-#ifdef YYPARSE_PARAM
-#ifdef __cplusplus
-#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
-#define YYPARSE_PARAM_DECL
-#else /* not __cplusplus */
-#define YYPARSE_PARAM_ARG YYPARSE_PARAM
-#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
-#endif /* not __cplusplus */
-#else /* not YYPARSE_PARAM */
-#define YYPARSE_PARAM_ARG
-#define YYPARSE_PARAM_DECL
-#endif /* not YYPARSE_PARAM */
-
-/* Prevent warning if -Wstrict-prototypes.  */
-#ifdef __GNUC__
-#ifdef YYPARSE_PARAM
-int yyparse (void *);
+# ifndef yystrlen
+#  if defined __GLIBC__ && defined _STRING_H
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static YYSIZE_T
+yystrlen (const char *yystr)
 #else
+static YYSIZE_T
+yystrlen (yystr)
+    const char *yystr;
+#endif
+{
+  YYSIZE_T yylen;
+  for (yylen = 0; yystr[yylen]; yylen++)
+    continue;
+  return yylen;
+}
+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+#else
+static char *
+yystpcpy (yydest, yysrc)
+    char *yydest;
+    const char *yysrc;
+#endif
+{
+  char *yyd = yydest;
+  const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      YYSIZE_T yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+	switch (*++yyp)
+	  {
+	  case '\'':
+	  case ',':
+	    goto do_not_strip_quotes;
+
+	  case '\\':
+	    if (*++yyp != '\\')
+	      goto do_not_strip_quotes;
+	    /* Fall through.  */
+	  default:
+	    if (yyres)
+	      yyres[yyn] = *yyp;
+	    yyn++;
+	    break;
+
+	  case '"':
+	    if (yyres)
+	      yyres[yyn] = '\0';
+	    return yyn;
+	  }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return yystrlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into YYRESULT an error message about the unexpected token
+   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
+   including the terminating null byte.  If YYRESULT is null, do not
+   copy anything; just return the number of bytes that would be
+   copied.  As a special case, return 0 if an ordinary "syntax error"
+   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
+   size calculation.  */
+static YYSIZE_T
+yysyntax_error (char *yyresult, int yystate, int yychar)
+{
+  int yyn = yypact[yystate];
+
+  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
+    return 0;
+  else
+    {
+      int yytype = YYTRANSLATE (yychar);
+      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
+      YYSIZE_T yysize = yysize0;
+      YYSIZE_T yysize1;
+      int yysize_overflow = 0;
+      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+      int yyx;
+
+# if 0
+      /* This is so xgettext sees the translatable formats that are
+	 constructed on the fly.  */
+      YY_("syntax error, unexpected %s");
+      YY_("syntax error, unexpected %s, expecting %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
+# endif
+      char *yyfmt;
+      char const *yyf;
+      static char const yyunexpected[] = "syntax error, unexpected %s";
+      static char const yyexpecting[] = ", expecting %s";
+      static char const yyor[] = " or %s";
+      char yyformat[sizeof yyunexpected
+		    + sizeof yyexpecting - 1
+		    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
+		       * (sizeof yyor - 1))];
+      char const *yyprefix = yyexpecting;
+
+      /* Start YYX at -YYN if negative to avoid negative indexes in
+	 YYCHECK.  */
+      int yyxbegin = yyn < 0 ? -yyn : 0;
+
+      /* Stay within bounds of both yycheck and yytname.  */
+      int yychecklim = YYLAST - yyn + 1;
+      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+      int yycount = 1;
+
+      yyarg[0] = yytname[yytype];
+      yyfmt = yystpcpy (yyformat, yyunexpected);
+
+      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+	  {
+	    if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+	      {
+		yycount = 1;
+		yysize = yysize0;
+		yyformat[sizeof yyunexpected - 1] = '\0';
+		break;
+	      }
+	    yyarg[yycount++] = yytname[yyx];
+	    yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+	    yysize_overflow |= (yysize1 < yysize);
+	    yysize = yysize1;
+	    yyfmt = yystpcpy (yyfmt, yyprefix);
+	    yyprefix = yyor;
+	  }
+
+      yyf = YY_(yyformat);
+      yysize1 = yysize + yystrlen (yyf);
+      yysize_overflow |= (yysize1 < yysize);
+      yysize = yysize1;
+
+      if (yysize_overflow)
+	return YYSIZE_MAXIMUM;
+
+      if (yyresult)
+	{
+	  /* Avoid sprintf, as that infringes on the user's name space.
+	     Don't have undefined behavior even if the translation
+	     produced a string with the wrong number of "%s"s.  */
+	  char *yyp = yyresult;
+	  int yyi = 0;
+	  while ((*yyp = *yyf) != '\0')
+	    {
+	      if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+		{
+		  yyp += yytnamerr (yyp, yyarg[yyi++]);
+		  yyf += 2;
+		}
+	      else
+		{
+		  yyp++;
+		  yyf++;
+		}
+	    }
+	}
+      return yysize;
+    }
+}
+#endif /* YYERROR_VERBOSE */
+
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
+#else
+static void
+yydestruct (yymsg, yytype, yyvaluep)
+    const char *yymsg;
+    int yytype;
+    YYSTYPE *yyvaluep;
+#endif
+{
+  YYUSE (yyvaluep);
+
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+  switch (yytype)
+    {
+
+      default:
+	break;
+    }
+}
+
+
+/* Prevent warnings from -Wmissing-prototypes.  */
+
+#ifdef YYPARSE_PARAM
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void *YYPARSE_PARAM);
+#else
+int yyparse ();
+#endif
+#else /* ! YYPARSE_PARAM */
+#if defined __STDC__ || defined __cplusplus
 int yyparse (void);
-#endif
-#endif
-
-int
-yyparse(YYPARSE_PARAM_ARG)
-     YYPARSE_PARAM_DECL
-{
-  register int yystate;
-  register int yyn;
-  register short *yyssp;
-  register YYSTYPE *yyvsp;
-  int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
-  int yychar1 = 0;		/*  lookahead token as an internal (translated) token number */
-
-  short	yyssa[YYINITDEPTH];	/*  the state stack			*/
-  YYSTYPE yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/
-
-  short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */
-  YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */
-
-#ifdef YYLSP_NEEDED
-  YYLTYPE yylsa[YYINITDEPTH];	/*  the location stack			*/
-  YYLTYPE *yyls = yylsa;
-  YYLTYPE *yylsp;
-
-#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 #else
-#define YYPOPSTACK   (yyvsp--, yyssp--)
+int yyparse ();
 #endif
+#endif /* ! YYPARSE_PARAM */
 
-  int yystacksize = YYINITDEPTH;
-  int yyfree_stacks = 0;
 
-#ifdef YYPURE
-  int yychar;
-  YYSTYPE yylval;
-  int yynerrs;
-#ifdef YYLSP_NEEDED
-  YYLTYPE yylloc;
+
+/* The look-ahead symbol.  */
+int yychar;
+
+/* The semantic value of the look-ahead symbol.  */
+YYSTYPE yylval;
+
+/* Number of syntax errors so far.  */
+int yynerrs;
+
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+#ifdef YYPARSE_PARAM
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (void *YYPARSE_PARAM)
+#else
+int
+yyparse (YYPARSE_PARAM)
+    void *YYPARSE_PARAM;
+#endif
+#else /* ! YYPARSE_PARAM */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (void)
+#else
+int
+yyparse ()
+
 #endif
 #endif
-
-  YYSTYPE yyval;		/*  the variable used to return		*/
-				/*  semantic values from the action	*/
-				/*  routines				*/
-
-  int yylen;
-
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Starting parse\n");
+{
+  
+  int yystate;
+  int yyn;
+  int yyresult;
+  /* Number of tokens to shift before error messages enabled.  */
+  int yyerrstatus;
+  /* Look-ahead token as an internal (translated) token number.  */
+  int yytoken = 0;
+#if YYERROR_VERBOSE
+  /* Buffer for error messages, and its allocated size.  */
+  char yymsgbuf[128];
+  char *yymsg = yymsgbuf;
+  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
 #endif
 
+  /* Three stacks and their tools:
+     `yyss': related to states,
+     `yyvs': related to semantic values,
+     `yyls': related to locations.
+
+     Refer to the stacks thru separate pointers, to allow yyoverflow
+     to reallocate them elsewhere.  */
+
+  /* The state stack.  */
+  yytype_int16 yyssa[YYINITDEPTH];
+  yytype_int16 *yyss = yyssa;
+  yytype_int16 *yyssp;
+
+  /* The semantic value stack.  */
+  YYSTYPE yyvsa[YYINITDEPTH];
+  YYSTYPE *yyvs = yyvsa;
+  YYSTYPE *yyvsp;
+
+
+
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
+
+  YYSIZE_T yystacksize = YYINITDEPTH;
+
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+
+
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
   yystate = 0;
   yyerrstatus = 0;
   yynerrs = 0;
@@ -2188,652 +3099,700 @@
      so that they stay on the same level as the state stack.
      The wasted elements are never initialized.  */
 
-  yyssp = yyss - 1;
+  yyssp = yyss;
   yyvsp = yyvs;
-#ifdef YYLSP_NEEDED
-  yylsp = yyls;
-#endif
 
-/* Push a new state, which is found in  yystate  .  */
-/* In all cases, when you get here, the value and location stacks
-   have just been pushed. so pushing a state here evens the stacks.  */
-yynewstate:
+  goto yysetstate;
 
-  *++yyssp = yystate;
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed.  So pushing a state here evens the stacks.  */
+  yyssp++;
 
-  if (yyssp >= yyss + yystacksize - 1)
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyss + yystacksize - 1 <= yyssp)
     {
-      /* Give user a chance to reallocate the stack */
-      /* Use copies of these so that the &'s don't force the real ones into memory. */
-      YYSTYPE *yyvs1 = yyvs;
-      short *yyss1 = yyss;
-#ifdef YYLSP_NEEDED
-      YYLTYPE *yyls1 = yyls;
-#endif
-
       /* Get the current used size of the three stacks, in elements.  */
-      int size = yyssp - yyss + 1;
+      YYSIZE_T yysize = yyssp - yyss + 1;
 
 #ifdef yyoverflow
-      /* Each stack pointer address is followed by the size of
-	 the data in use in that stack, in bytes.  */
-#ifdef YYLSP_NEEDED
-      /* This used to be a conditional around just the two extra args,
-	 but that might be undefined if yyoverflow is a macro.  */
-      yyoverflow("parser stack overflow",
-		 &yyss1, size * sizeof (*yyssp),
-		 &yyvs1, size * sizeof (*yyvsp),
-		 &yyls1, size * sizeof (*yylsp),
-		 &yystacksize);
-#else
-      yyoverflow("parser stack overflow",
-		 &yyss1, size * sizeof (*yyssp),
-		 &yyvs1, size * sizeof (*yyvsp),
-		 &yystacksize);
-#endif
+      {
+	/* Give user a chance to reallocate the stack.  Use copies of
+	   these so that the &'s don't force the real ones into
+	   memory.  */
+	YYSTYPE *yyvs1 = yyvs;
+	yytype_int16 *yyss1 = yyss;
 
-      yyss = yyss1; yyvs = yyvs1;
-#ifdef YYLSP_NEEDED
-      yyls = yyls1;
-#endif
+
+	/* Each stack pointer address is followed by the size of the
+	   data in use in that stack, in bytes.  This used to be a
+	   conditional around just the two extra args, but that might
+	   be undefined if yyoverflow is a macro.  */
+	yyoverflow (YY_("memory exhausted"),
+		    &yyss1, yysize * sizeof (*yyssp),
+		    &yyvs1, yysize * sizeof (*yyvsp),
+
+		    &yystacksize);
+
+	yyss = yyss1;
+	yyvs = yyvs1;
+      }
 #else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyexhaustedlab;
+# else
       /* Extend the stack our own way.  */
-      if (yystacksize >= YYMAXDEPTH)
-	{
-	  yyerror("parser stack overflow");
-	  if (yyfree_stacks)
-	    {
-	      free (yyss);
-	      free (yyvs);
-#ifdef YYLSP_NEEDED
-	      free (yyls);
-#endif
-	    }
-	  return 2;
-	}
+      if (YYMAXDEPTH <= yystacksize)
+	goto yyexhaustedlab;
       yystacksize *= 2;
-      if (yystacksize > YYMAXDEPTH)
+      if (YYMAXDEPTH < yystacksize)
 	yystacksize = YYMAXDEPTH;
-#ifndef YYSTACK_USE_ALLOCA
-      yyfree_stacks = 1;
-#endif
-      yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
-      __yy_memcpy ((char *)yyss, (char *)yyss1,
-		   size * (unsigned int) sizeof (*yyssp));
-      yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
-      __yy_memcpy ((char *)yyvs, (char *)yyvs1,
-		   size * (unsigned int) sizeof (*yyvsp));
-#ifdef YYLSP_NEEDED
-      yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
-      __yy_memcpy ((char *)yyls, (char *)yyls1,
-		   size * (unsigned int) sizeof (*yylsp));
-#endif
+
+      {
+	yytype_int16 *yyss1 = yyss;
+	union yyalloc *yyptr =
+	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+	if (! yyptr)
+	  goto yyexhaustedlab;
+	YYSTACK_RELOCATE (yyss);
+	YYSTACK_RELOCATE (yyvs);
+
+#  undef YYSTACK_RELOCATE
+	if (yyss1 != yyssa)
+	  YYSTACK_FREE (yyss1);
+      }
+# endif
 #endif /* no yyoverflow */
 
-      yyssp = yyss + size - 1;
-      yyvsp = yyvs + size - 1;
-#ifdef YYLSP_NEEDED
-      yylsp = yyls + size - 1;
-#endif
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
 
-#if YYDEBUG != 0
-      if (yydebug)
-	fprintf(stderr, "Stack size increased to %d\n", yystacksize);
-#endif
 
-      if (yyssp >= yyss + yystacksize - 1)
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+		  (unsigned long int) yystacksize));
+
+      if (yyss + yystacksize - 1 <= yyssp)
 	YYABORT;
     }
 
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Entering state %d\n", yystate);
-#endif
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 
   goto yybackup;
- yybackup:
 
-/* Do appropriate processing given the current state.  */
-/* Read a lookahead token if we need one and don't already have one.  */
-/* yyresume: */
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
 
-  /* First try to decide what to do without reference to lookahead token.  */
+  /* Do appropriate processing given the current state.  Read a
+     look-ahead token if we need one and don't already have one.  */
 
+  /* First try to decide what to do without reference to look-ahead token.  */
   yyn = yypact[yystate];
-  if (yyn == YYFLAG)
+  if (yyn == YYPACT_NINF)
     goto yydefault;
 
-  /* Not known => get a lookahead token if don't already have one.  */
+  /* Not known => get a look-ahead token if don't already have one.  */
 
-  /* yychar is either YYEMPTY or YYEOF
-     or a valid token in external form.  */
-
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
   if (yychar == YYEMPTY)
     {
-#if YYDEBUG != 0
-      if (yydebug)
-	fprintf(stderr, "Reading a token: ");
-#endif
+      YYDPRINTF ((stderr, "Reading a token: "));
       yychar = YYLEX;
     }
 
-  /* Convert token to internal form (in yychar1) for indexing tables with */
-
-  if (yychar <= 0)		/* This means end of input. */
+  if (yychar <= YYEOF)
     {
-      yychar1 = 0;
-      yychar = YYEOF;		/* Don't call YYLEX any more */
-
-#if YYDEBUG != 0
-      if (yydebug)
-	fprintf(stderr, "Now at end of input.\n");
-#endif
+      yychar = yytoken = YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
   else
     {
-      yychar1 = YYTRANSLATE(yychar);
-
-#if YYDEBUG != 0
-      if (yydebug)
-	{
-	  fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
-	  /* Give the individual parser a way to print the precise meaning
-	     of a token, for further debugging info.  */
-#ifdef YYPRINT
-	  YYPRINT (stderr, yychar, yylval);
-#endif
-	  fprintf (stderr, ")\n");
-	}
-#endif
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
     }
 
-  yyn += yychar1;
-  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
     goto yydefault;
-
   yyn = yytable[yyn];
-
-  /* yyn is what to do for this token type in this state.
-     Negative => reduce, -yyn is rule number.
-     Positive => shift, yyn is new state.
-       New state is final state => don't bother to shift,
-       just return success.
-     0, or most negative number => error.  */
-
-  if (yyn < 0)
+  if (yyn <= 0)
     {
-      if (yyn == YYFLAG)
+      if (yyn == 0 || yyn == YYTABLE_NINF)
 	goto yyerrlab;
       yyn = -yyn;
       goto yyreduce;
     }
-  else if (yyn == 0)
-    goto yyerrlab;
 
   if (yyn == YYFINAL)
     YYACCEPT;
 
-  /* Shift the lookahead token.  */
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
 
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
-#endif
+  /* Shift the look-ahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
-  /* Discard the token being shifted unless it is eof.  */
+  /* Discard the shifted token unless it is eof.  */
   if (yychar != YYEOF)
     yychar = YYEMPTY;
 
-  *++yyvsp = yylval;
-#ifdef YYLSP_NEEDED
-  *++yylsp = yylloc;
-#endif
-
-  /* count tokens shifted since error; after three, turn off error status.  */
-  if (yyerrstatus) yyerrstatus--;
-
   yystate = yyn;
+  *++yyvsp = yylval;
+
   goto yynewstate;
 
-/* Do the default action for the current state.  */
-yydefault:
 
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
   yyn = yydefact[yystate];
   if (yyn == 0)
     goto yyerrlab;
+  goto yyreduce;
 
-/* Do a reduction.  yyn is the number of a rule to reduce with.  */
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
 yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
   yylen = yyr2[yyn];
-  if (yylen > 0)
-    yyval = yyvsp[1-yylen]; /* implement default value of the action */
 
-#if YYDEBUG != 0
-  if (yydebug)
+  /* If YYLEN is nonzero, implement the default value of the action:
+     `$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
     {
-      int i;
+        case 29:
+#line 1100 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_EQ; ;}
+    break;
 
-      fprintf (stderr, "Reducing via rule %d (line %d), ",
-	       yyn, yyrline[yyn]);
+  case 30:
+#line 1100 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_NE; ;}
+    break;
 
-      /* Print the symbols being reduced, and their result.  */
-      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
-	fprintf (stderr, "%s ", yytname[yyrhs[i]]);
-      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
-    }
-#endif
+  case 31:
+#line 1101 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_SLT; ;}
+    break;
 
+  case 32:
+#line 1101 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_SGT; ;}
+    break;
 
-  switch (yyn) {
+  case 33:
+#line 1102 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_SLE; ;}
+    break;
 
-case 28:
-#line 1099 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.IPredicate = ICmpInst::ICMP_EQ; ;
-    break;}
-case 29:
-#line 1099 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.IPredicate = ICmpInst::ICMP_NE; ;
-    break;}
-case 30:
-#line 1100 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.IPredicate = ICmpInst::ICMP_SLT; ;
-    break;}
-case 31:
-#line 1100 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.IPredicate = ICmpInst::ICMP_SGT; ;
-    break;}
-case 32:
-#line 1101 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.IPredicate = ICmpInst::ICMP_SLE; ;
-    break;}
-case 33:
-#line 1101 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.IPredicate = ICmpInst::ICMP_SGE; ;
-    break;}
-case 34:
-#line 1102 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.IPredicate = ICmpInst::ICMP_ULT; ;
-    break;}
-case 35:
-#line 1102 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.IPredicate = ICmpInst::ICMP_UGT; ;
-    break;}
-case 36:
-#line 1103 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.IPredicate = ICmpInst::ICMP_ULE; ;
-    break;}
-case 37:
-#line 1103 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.IPredicate = ICmpInst::ICMP_UGE; ;
-    break;}
-case 38:
-#line 1107 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_OEQ; ;
-    break;}
-case 39:
-#line 1107 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_ONE; ;
-    break;}
-case 40:
-#line 1108 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_OLT; ;
-    break;}
-case 41:
-#line 1108 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_OGT; ;
-    break;}
-case 42:
-#line 1109 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_OLE; ;
-    break;}
-case 43:
-#line 1109 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_OGE; ;
-    break;}
-case 44:
-#line 1110 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_ORD; ;
-    break;}
-case 45:
-#line 1110 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_UNO; ;
-    break;}
-case 46:
-#line 1111 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_UEQ; ;
-    break;}
-case 47:
-#line 1111 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_UNE; ;
-    break;}
-case 48:
-#line 1112 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_ULT; ;
-    break;}
-case 49:
-#line 1112 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_UGT; ;
-    break;}
-case 50:
-#line 1113 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_ULE; ;
-    break;}
-case 51:
-#line 1113 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_UGE; ;
-    break;}
-case 52:
-#line 1114 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_TRUE; ;
-    break;}
-case 53:
-#line 1115 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.FPredicate = FCmpInst::FCMP_FALSE; ;
-    break;}
-case 60:
-#line 1124 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.StrVal = 0; ;
-    break;}
-case 61:
-#line 1128 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.StrVal = yyvsp[-1].StrVal;
+  case 34:
+#line 1102 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_SGE; ;}
+    break;
+
+  case 35:
+#line 1103 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_ULT; ;}
+    break;
+
+  case 36:
+#line 1103 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_UGT; ;}
+    break;
+
+  case 37:
+#line 1104 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_ULE; ;}
+    break;
+
+  case 38:
+#line 1104 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_UGE; ;}
+    break;
+
+  case 39:
+#line 1108 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_OEQ; ;}
+    break;
+
+  case 40:
+#line 1108 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_ONE; ;}
+    break;
+
+  case 41:
+#line 1109 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_OLT; ;}
+    break;
+
+  case 42:
+#line 1109 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_OGT; ;}
+    break;
+
+  case 43:
+#line 1110 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_OLE; ;}
+    break;
+
+  case 44:
+#line 1110 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_OGE; ;}
+    break;
+
+  case 45:
+#line 1111 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_ORD; ;}
+    break;
+
+  case 46:
+#line 1111 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_UNO; ;}
+    break;
+
+  case 47:
+#line 1112 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_UEQ; ;}
+    break;
+
+  case 48:
+#line 1112 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_UNE; ;}
+    break;
+
+  case 49:
+#line 1113 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_ULT; ;}
+    break;
+
+  case 50:
+#line 1113 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_UGT; ;}
+    break;
+
+  case 51:
+#line 1114 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_ULE; ;}
+    break;
+
+  case 52:
+#line 1114 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_UGE; ;}
+    break;
+
+  case 53:
+#line 1115 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_TRUE; ;}
+    break;
+
+  case 54:
+#line 1116 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_FALSE; ;}
+    break;
+
+  case 61:
+#line 1125 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.StrVal) = 0; ;}
+    break;
+
+  case 62:
+#line 1129 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.StrVal) = (yyvsp[(1) - (2)].StrVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 62:
-#line 1132 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.StrVal = 0;
+  ;}
+    break;
+
+  case 63:
+#line 1133 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.StrVal) = 0;
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 65:
-#line 1139 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.StrVal = yyvsp[-1].StrVal;
+  ;}
+    break;
+
+  case 67:
+#line 1141 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.StrVal) = 0;
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 66:
-#line 1143 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.StrVal = 0;
+  ;}
+    break;
+
+  case 68:
+#line 1146 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.StrVal) = (yyvsp[(1) - (2)].StrVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 67:
-#line 1149 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::InternalLinkage; ;
-    break;}
-case 68:
-#line 1150 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::WeakLinkage; ;
-    break;}
-case 69:
-#line 1151 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::LinkOnceLinkage; ;
-    break;}
-case 70:
-#line 1152 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::AppendingLinkage; ;
-    break;}
-case 71:
-#line 1153 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::DLLExportLinkage; ;
-    break;}
-case 72:
-#line 1157 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::DLLImportLinkage; ;
-    break;}
-case 73:
-#line 1158 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::ExternalWeakLinkage; ;
-    break;}
-case 74:
-#line 1159 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::ExternalLinkage; ;
-    break;}
-case 75:
-#line 1163 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Visibility = GlobalValue::DefaultVisibility; ;
-    break;}
-case 76:
-#line 1164 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Visibility = GlobalValue::HiddenVisibility;  ;
-    break;}
-case 77:
-#line 1168 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::ExternalLinkage; ;
-    break;}
-case 78:
-#line 1169 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::DLLImportLinkage; ;
-    break;}
-case 79:
-#line 1170 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::ExternalWeakLinkage; ;
-    break;}
-case 80:
-#line 1174 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::ExternalLinkage; ;
-    break;}
-case 81:
-#line 1175 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::InternalLinkage; ;
-    break;}
-case 82:
-#line 1176 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::LinkOnceLinkage; ;
-    break;}
-case 83:
-#line 1177 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::WeakLinkage; ;
-    break;}
-case 84:
-#line 1178 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.Linkage = GlobalValue::DLLExportLinkage; ;
-    break;}
-case 85:
-#line 1181 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.UIntVal = CallingConv::C; ;
-    break;}
-case 86:
-#line 1182 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.UIntVal = CallingConv::C; ;
-    break;}
-case 87:
-#line 1183 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.UIntVal = CallingConv::Fast; ;
-    break;}
-case 88:
-#line 1184 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.UIntVal = CallingConv::Cold; ;
-    break;}
-case 89:
-#line 1185 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.UIntVal = CallingConv::X86_StdCall; ;
-    break;}
-case 90:
-#line 1186 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.UIntVal = CallingConv::X86_FastCall; ;
-    break;}
-case 91:
-#line 1187 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-                   if ((unsigned)yyvsp[0].UInt64Val != yyvsp[0].UInt64Val)
+  ;}
+    break;
+
+  case 69:
+#line 1152 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
+    break;
+
+  case 70:
+#line 1153 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
+    break;
+
+  case 71:
+#line 1154 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
+    break;
+
+  case 72:
+#line 1155 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;}
+    break;
+
+  case 73:
+#line 1156 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
+    break;
+
+  case 74:
+#line 1160 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
+    break;
+
+  case 75:
+#line 1161 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
+    break;
+
+  case 76:
+#line 1162 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
+    break;
+
+  case 77:
+#line 1166 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Visibility) = GlobalValue::DefaultVisibility; ;}
+    break;
+
+  case 78:
+#line 1167 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Visibility) = GlobalValue::DefaultVisibility; ;}
+    break;
+
+  case 79:
+#line 1168 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Visibility) = GlobalValue::HiddenVisibility;  ;}
+    break;
+
+  case 80:
+#line 1172 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
+    break;
+
+  case 81:
+#line 1173 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
+    break;
+
+  case 82:
+#line 1174 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
+    break;
+
+  case 83:
+#line 1178 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
+    break;
+
+  case 84:
+#line 1179 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
+    break;
+
+  case 85:
+#line 1180 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
+    break;
+
+  case 86:
+#line 1181 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
+    break;
+
+  case 87:
+#line 1182 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
+    break;
+
+  case 88:
+#line 1186 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
+    break;
+
+  case 89:
+#line 1187 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
+    break;
+
+  case 90:
+#line 1188 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
+    break;
+
+  case 91:
+#line 1191 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = CallingConv::C; ;}
+    break;
+
+  case 92:
+#line 1192 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = CallingConv::C; ;}
+    break;
+
+  case 93:
+#line 1193 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = CallingConv::Fast; ;}
+    break;
+
+  case 94:
+#line 1194 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = CallingConv::Cold; ;}
+    break;
+
+  case 95:
+#line 1195 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = CallingConv::X86_StdCall; ;}
+    break;
+
+  case 96:
+#line 1196 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = CallingConv::X86_FastCall; ;}
+    break;
+
+  case 97:
+#line 1197 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+                   if ((unsigned)(yyvsp[(2) - (2)].UInt64Val) != (yyvsp[(2) - (2)].UInt64Val))
                      GEN_ERROR("Calling conv too large");
-                   yyval.UIntVal = yyvsp[0].UInt64Val;
+                   (yyval.UIntVal) = (yyvsp[(2) - (2)].UInt64Val);
                   CHECK_FOR_ERROR
-                 ;
-    break;}
-case 92:
-#line 1194 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.ParamAttrs = ParamAttr::ZExt;      ;
-    break;}
-case 93:
-#line 1195 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.ParamAttrs = ParamAttr::SExt;      ;
-    break;}
-case 94:
-#line 1196 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.ParamAttrs = ParamAttr::InReg;     ;
-    break;}
-case 95:
-#line 1197 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.ParamAttrs = ParamAttr::StructRet; ;
-    break;}
-case 96:
-#line 1200 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.ParamAttrs = ParamAttr::None; ;
-    break;}
-case 97:
-#line 1201 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-                yyval.ParamAttrs = yyvsp[-1].ParamAttrs | yyvsp[0].ParamAttrs;
-              ;
-    break;}
-case 98:
-#line 1206 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.ParamAttrs = ParamAttr::NoReturn; ;
-    break;}
-case 99:
-#line 1207 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.ParamAttrs = ParamAttr::NoUnwind; ;
-    break;}
-case 101:
-#line 1211 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.ParamAttrs = ParamAttr::None; ;
-    break;}
-case 102:
-#line 1212 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-                yyval.ParamAttrs = yyvsp[-1].ParamAttrs | yyvsp[0].ParamAttrs;
-              ;
-    break;}
-case 103:
-#line 1219 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.UIntVal = 0; ;
-    break;}
-case 104:
-#line 1220 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-  yyval.UIntVal = yyvsp[0].UInt64Val;
-  if (yyval.UIntVal != 0 && !isPowerOf2_32(yyval.UIntVal))
+                 ;}
+    break;
+
+  case 98:
+#line 1204 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ParamAttrs) = ParamAttr::ZExt;      ;}
+    break;
+
+  case 99:
+#line 1205 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ParamAttrs) = ParamAttr::SExt;      ;}
+    break;
+
+  case 100:
+#line 1206 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ParamAttrs) = ParamAttr::InReg;     ;}
+    break;
+
+  case 101:
+#line 1207 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ParamAttrs) = ParamAttr::StructRet; ;}
+    break;
+
+  case 102:
+#line 1210 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ParamAttrs) = ParamAttr::None; ;}
+    break;
+
+  case 103:
+#line 1211 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+                (yyval.ParamAttrs) = (yyvsp[(1) - (2)].ParamAttrs) | (yyvsp[(2) - (2)].ParamAttrs);
+              ;}
+    break;
+
+  case 104:
+#line 1216 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ParamAttrs) = ParamAttr::NoReturn; ;}
+    break;
+
+  case 105:
+#line 1217 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ParamAttrs) = ParamAttr::NoUnwind; ;}
+    break;
+
+  case 107:
+#line 1221 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ParamAttrs) = ParamAttr::None; ;}
+    break;
+
+  case 108:
+#line 1222 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+                (yyval.ParamAttrs) = (yyvsp[(1) - (2)].ParamAttrs) | (yyvsp[(2) - (2)].ParamAttrs);
+              ;}
+    break;
+
+  case 109:
+#line 1229 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = 0; ;}
+    break;
+
+  case 110:
+#line 1230 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+  (yyval.UIntVal) = (yyvsp[(2) - (2)].UInt64Val);
+  if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
     GEN_ERROR("Alignment must be a power of two");
   CHECK_FOR_ERROR
-;
-    break;}
-case 105:
-#line 1226 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.UIntVal = 0; ;
-    break;}
-case 106:
-#line 1227 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-  yyval.UIntVal = yyvsp[0].UInt64Val;
-  if (yyval.UIntVal != 0 && !isPowerOf2_32(yyval.UIntVal))
+;}
+    break;
+
+  case 111:
+#line 1236 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = 0; ;}
+    break;
+
+  case 112:
+#line 1237 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+  (yyval.UIntVal) = (yyvsp[(3) - (3)].UInt64Val);
+  if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
     GEN_ERROR("Alignment must be a power of two");
   CHECK_FOR_ERROR
-;
-    break;}
-case 107:
-#line 1235 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-  for (unsigned i = 0, e = strlen(yyvsp[0].StrVal); i != e; ++i)
-    if (yyvsp[0].StrVal[i] == '"' || yyvsp[0].StrVal[i] == '\\')
+;}
+    break;
+
+  case 113:
+#line 1245 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+  for (unsigned i = 0, e = strlen((yyvsp[(2) - (2)].StrVal)); i != e; ++i)
+    if ((yyvsp[(2) - (2)].StrVal)[i] == '"' || (yyvsp[(2) - (2)].StrVal)[i] == '\\')
       GEN_ERROR("Invalid character in section name");
-  yyval.StrVal = yyvsp[0].StrVal;
+  (yyval.StrVal) = (yyvsp[(2) - (2)].StrVal);
   CHECK_FOR_ERROR
-;
-    break;}
-case 108:
-#line 1243 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.StrVal = 0; ;
-    break;}
-case 109:
-#line 1244 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.StrVal = yyvsp[0].StrVal; ;
-    break;}
-case 110:
-#line 1249 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{;
-    break;}
-case 111:
-#line 1250 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{;
-    break;}
-case 112:
-#line 1251 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    CurGV->setSection(yyvsp[0].StrVal);
-    free(yyvsp[0].StrVal);
+;}
+    break;
+
+  case 114:
+#line 1253 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.StrVal) = 0; ;}
+    break;
+
+  case 115:
+#line 1254 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.StrVal) = (yyvsp[(1) - (1)].StrVal); ;}
+    break;
+
+  case 116:
+#line 1259 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {;}
+    break;
+
+  case 117:
+#line 1260 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {;}
+    break;
+
+  case 118:
+#line 1261 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    CurGV->setSection((yyvsp[(1) - (1)].StrVal));
+    free((yyvsp[(1) - (1)].StrVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 113:
-#line 1256 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (yyvsp[0].UInt64Val != 0 && !isPowerOf2_32(yyvsp[0].UInt64Val))
+  ;}
+    break;
+
+  case 119:
+#line 1266 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if ((yyvsp[(2) - (2)].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[(2) - (2)].UInt64Val)))
       GEN_ERROR("Alignment must be a power of two");
-    CurGV->setAlignment(yyvsp[0].UInt64Val);
+    CurGV->setAlignment((yyvsp[(2) - (2)].UInt64Val));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 118:
-#line 1272 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.TypeVal = new PATypeHolder(OpaqueType::get());
+  ;}
+    break;
+
+  case 124:
+#line 1282 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.TypeVal) = new PATypeHolder(OpaqueType::get());
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 119:
-#line 1276 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.TypeVal = new PATypeHolder(yyvsp[0].PrimType);
+  ;}
+    break;
+
+  case 125:
+#line 1286 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.TypeVal) = new PATypeHolder((yyvsp[(1) - (1)].PrimType));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 120:
-#line 1280 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{                             // Pointer type?
-    if (*yyvsp[-1].TypeVal == Type::LabelTy)
+  ;}
+    break;
+
+  case 126:
+#line 1290 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {                             // Pointer type?
+    if (*(yyvsp[(1) - (2)].TypeVal) == Type::LabelTy)
       GEN_ERROR("Cannot form a pointer to a basic block");
-    yyval.TypeVal = new PATypeHolder(HandleUpRefs(PointerType::get(*yyvsp[-1].TypeVal)));
-    delete yyvsp[-1].TypeVal;
+    (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(PointerType::get(*(yyvsp[(1) - (2)].TypeVal))));
+    delete (yyvsp[(1) - (2)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 121:
-#line 1287 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{            // Named types are also simple types...
-    const Type* tmp = getTypeVal(yyvsp[0].ValIDVal);
+  ;}
+    break;
+
+  case 127:
+#line 1297 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {            // Named types are also simple types...
+    const Type* tmp = getTypeVal((yyvsp[(1) - (1)].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.TypeVal = new PATypeHolder(tmp);
-  ;
-    break;}
-case 122:
-#line 1292 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{                   // Type UpReference
-    if (yyvsp[0].UInt64Val > (uint64_t)~0U) GEN_ERROR("Value out of range");
+    (yyval.TypeVal) = new PATypeHolder(tmp);
+  ;}
+    break;
+
+  case 128:
+#line 1302 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {                   // Type UpReference
+    if ((yyvsp[(2) - (2)].UInt64Val) > (uint64_t)~0U) GEN_ERROR("Value out of range");
     OpaqueType *OT = OpaqueType::get();        // Use temporary placeholder
-    UpRefs.push_back(UpRefRecord((unsigned)yyvsp[0].UInt64Val, OT));  // Add to vector...
-    yyval.TypeVal = new PATypeHolder(OT);
+    UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[(2) - (2)].UInt64Val), OT));  // Add to vector...
+    (yyval.TypeVal) = new PATypeHolder(OT);
     UR_OUT("New Upreference!\n");
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 123:
-#line 1300 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 129:
+#line 1310 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     std::vector<const Type*> Params;
     ParamAttrsVector Attrs;
-    if (yyvsp[0].ParamAttrs != ParamAttr::None) {
-      ParamAttrsWithIndex X; X.index = 0; X.attrs = yyvsp[0].ParamAttrs;
+    if ((yyvsp[(5) - (5)].ParamAttrs) != ParamAttr::None) {
+      ParamAttrsWithIndex X; X.index = 0; X.attrs = (yyvsp[(5) - (5)].ParamAttrs);
       Attrs.push_back(X);
     }
     unsigned index = 1;
-    TypeWithAttrsList::iterator I = yyvsp[-2].TypeWithAttrsList->begin(), E = yyvsp[-2].TypeWithAttrsList->end();
+    TypeWithAttrsList::iterator I = (yyvsp[(3) - (5)].TypeWithAttrsList)->begin(), E = (yyvsp[(3) - (5)].TypeWithAttrsList)->end();
     for (; I != E; ++I, ++index) {
       const Type *Ty = I->Ty->get();
       Params.push_back(Ty);
@@ -2849,23 +3808,24 @@
     ParamAttrsList *ActualAttrs = 0;
     if (!Attrs.empty())
       ActualAttrs = ParamAttrsList::get(Attrs);
-    FunctionType *FT = FunctionType::get(*yyvsp[-4].TypeVal, Params, isVarArg, ActualAttrs);
-    delete yyvsp[-2].TypeWithAttrsList;   // Delete the argument list
-    delete yyvsp[-4].TypeVal;   // Delete the return type handle
-    yyval.TypeVal = new PATypeHolder(HandleUpRefs(FT)); 
+    FunctionType *FT = FunctionType::get(*(yyvsp[(1) - (5)].TypeVal), Params, isVarArg, ActualAttrs);
+    delete (yyvsp[(3) - (5)].TypeWithAttrsList);   // Delete the argument list
+    delete (yyvsp[(1) - (5)].TypeVal);   // Delete the return type handle
+    (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(FT)); 
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 124:
-#line 1330 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 130:
+#line 1340 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     std::vector<const Type*> Params;
     ParamAttrsVector Attrs;
-    if (yyvsp[0].ParamAttrs != ParamAttr::None) {
-      ParamAttrsWithIndex X; X.index = 0; X.attrs = yyvsp[0].ParamAttrs;
+    if ((yyvsp[(5) - (5)].ParamAttrs) != ParamAttr::None) {
+      ParamAttrsWithIndex X; X.index = 0; X.attrs = (yyvsp[(5) - (5)].ParamAttrs);
       Attrs.push_back(X);
     }
-    TypeWithAttrsList::iterator I = yyvsp[-2].TypeWithAttrsList->begin(), E = yyvsp[-2].TypeWithAttrsList->end();
+    TypeWithAttrsList::iterator I = (yyvsp[(3) - (5)].TypeWithAttrsList)->begin(), E = (yyvsp[(3) - (5)].TypeWithAttrsList)->end();
     unsigned index = 1;
     for ( ; I != E; ++I, ++index) {
       const Type* Ty = I->Ty->get();
@@ -2883,284 +3843,305 @@
     if (!Attrs.empty())
       ActualAttrs = ParamAttrsList::get(Attrs);
 
-    FunctionType *FT = FunctionType::get(yyvsp[-4].PrimType, Params, isVarArg, ActualAttrs);
-    delete yyvsp[-2].TypeWithAttrsList;      // Delete the argument list
-    yyval.TypeVal = new PATypeHolder(HandleUpRefs(FT)); 
+    FunctionType *FT = FunctionType::get((yyvsp[(1) - (5)].PrimType), Params, isVarArg, ActualAttrs);
+    delete (yyvsp[(3) - (5)].TypeWithAttrsList);      // Delete the argument list
+    (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(FT)); 
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 125:
-#line 1361 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{          // Sized array type?
-    yyval.TypeVal = new PATypeHolder(HandleUpRefs(ArrayType::get(*yyvsp[-1].TypeVal, (unsigned)yyvsp[-3].UInt64Val)));
-    delete yyvsp[-1].TypeVal;
+  ;}
+    break;
+
+  case 131:
+#line 1371 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {          // Sized array type?
+    (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(ArrayType::get(*(yyvsp[(4) - (5)].TypeVal), (unsigned)(yyvsp[(2) - (5)].UInt64Val))));
+    delete (yyvsp[(4) - (5)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 126:
-#line 1366 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{          // Vector type?
-     const llvm::Type* ElemTy = yyvsp[-1].TypeVal->get();
-     if ((unsigned)yyvsp[-3].UInt64Val != yyvsp[-3].UInt64Val)
+  ;}
+    break;
+
+  case 132:
+#line 1376 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {          // Vector type?
+     const llvm::Type* ElemTy = (yyvsp[(4) - (5)].TypeVal)->get();
+     if ((unsigned)(yyvsp[(2) - (5)].UInt64Val) != (yyvsp[(2) - (5)].UInt64Val))
         GEN_ERROR("Unsigned result not equal to signed result");
      if (!ElemTy->isFloatingPoint() && !ElemTy->isInteger())
         GEN_ERROR("Element type of a VectorType must be primitive");
-     if (!isPowerOf2_32(yyvsp[-3].UInt64Val))
+     if (!isPowerOf2_32((yyvsp[(2) - (5)].UInt64Val)))
        GEN_ERROR("Vector length should be a power of 2");
-     yyval.TypeVal = new PATypeHolder(HandleUpRefs(VectorType::get(*yyvsp[-1].TypeVal, (unsigned)yyvsp[-3].UInt64Val)));
-     delete yyvsp[-1].TypeVal;
+     (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(VectorType::get(*(yyvsp[(4) - (5)].TypeVal), (unsigned)(yyvsp[(2) - (5)].UInt64Val))));
+     delete (yyvsp[(4) - (5)].TypeVal);
      CHECK_FOR_ERROR
-  ;
-    break;}
-case 127:
-#line 1378 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{                        // Structure type?
+  ;}
+    break;
+
+  case 133:
+#line 1388 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {                        // Structure type?
     std::vector<const Type*> Elements;
-    for (std::list<llvm::PATypeHolder>::iterator I = yyvsp[-1].TypeList->begin(),
-           E = yyvsp[-1].TypeList->end(); I != E; ++I)
+    for (std::list<llvm::PATypeHolder>::iterator I = (yyvsp[(2) - (3)].TypeList)->begin(),
+           E = (yyvsp[(2) - (3)].TypeList)->end(); I != E; ++I)
       Elements.push_back(*I);
 
-    yyval.TypeVal = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
-    delete yyvsp[-1].TypeList;
+    (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
+    delete (yyvsp[(2) - (3)].TypeList);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 128:
-#line 1388 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{                                  // Empty structure type?
-    yyval.TypeVal = new PATypeHolder(StructType::get(std::vector<const Type*>()));
+  ;}
+    break;
+
+  case 134:
+#line 1398 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {                                  // Empty structure type?
+    (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector<const Type*>()));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 129:
-#line 1392 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 135:
+#line 1402 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     std::vector<const Type*> Elements;
-    for (std::list<llvm::PATypeHolder>::iterator I = yyvsp[-2].TypeList->begin(),
-           E = yyvsp[-2].TypeList->end(); I != E; ++I)
+    for (std::list<llvm::PATypeHolder>::iterator I = (yyvsp[(3) - (5)].TypeList)->begin(),
+           E = (yyvsp[(3) - (5)].TypeList)->end(); I != E; ++I)
       Elements.push_back(*I);
 
-    yyval.TypeVal = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
-    delete yyvsp[-2].TypeList;
+    (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
+    delete (yyvsp[(3) - (5)].TypeList);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 130:
-#line 1402 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{                         // Empty structure type?
-    yyval.TypeVal = new PATypeHolder(StructType::get(std::vector<const Type*>(), true));
+  ;}
+    break;
+
+  case 136:
+#line 1412 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {                         // Empty structure type?
+    (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector<const Type*>(), true));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 131:
-#line 1409 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ 
-    yyval.TypeWithAttrs.Ty = yyvsp[-1].TypeVal; 
-    yyval.TypeWithAttrs.Attrs = yyvsp[0].ParamAttrs; 
-  ;
-    break;}
-case 132:
-#line 1416 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 137:
+#line 1419 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { 
+    (yyval.TypeWithAttrs).Ty = (yyvsp[(1) - (2)].TypeVal); 
+    (yyval.TypeWithAttrs).Attrs = (yyvsp[(2) - (2)].ParamAttrs); 
+  ;}
+    break;
+
+  case 138:
+#line 1426 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
-    if (!(*yyvsp[0].TypeVal)->isFirstClassType())
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (1)].TypeVal))->getDescription());
+    if (!(*(yyvsp[(1) - (1)].TypeVal))->isFirstClassType())
       GEN_ERROR("LLVM functions cannot return aggregate types");
-    yyval.TypeVal = yyvsp[0].TypeVal;
-  ;
-    break;}
-case 133:
-#line 1423 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.TypeVal = new PATypeHolder(Type::VoidTy);
-  ;
-    break;}
-case 134:
-#line 1428 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.TypeWithAttrsList = new TypeWithAttrsList();
-    yyval.TypeWithAttrsList->push_back(yyvsp[0].TypeWithAttrs);
+    (yyval.TypeVal) = (yyvsp[(1) - (1)].TypeVal);
+  ;}
+    break;
+
+  case 139:
+#line 1433 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.TypeVal) = new PATypeHolder(Type::VoidTy);
+  ;}
+    break;
+
+  case 140:
+#line 1438 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.TypeWithAttrsList) = new TypeWithAttrsList();
+    (yyval.TypeWithAttrsList)->push_back((yyvsp[(1) - (1)].TypeWithAttrs));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 135:
-#line 1433 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    (yyval.TypeWithAttrsList=yyvsp[-2].TypeWithAttrsList)->push_back(yyvsp[0].TypeWithAttrs);
+  ;}
+    break;
+
+  case 141:
+#line 1443 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    ((yyval.TypeWithAttrsList)=(yyvsp[(1) - (3)].TypeWithAttrsList))->push_back((yyvsp[(3) - (3)].TypeWithAttrs));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 137:
-#line 1441 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.TypeWithAttrsList=yyvsp[-2].TypeWithAttrsList;
+  ;}
+    break;
+
+  case 143:
+#line 1451 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.TypeWithAttrsList)=(yyvsp[(1) - (3)].TypeWithAttrsList);
     TypeWithAttrs TWA; TWA.Attrs = ParamAttr::None;
     TWA.Ty = new PATypeHolder(Type::VoidTy);
-    yyval.TypeWithAttrsList->push_back(TWA);
+    (yyval.TypeWithAttrsList)->push_back(TWA);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 138:
-#line 1448 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.TypeWithAttrsList = new TypeWithAttrsList;
+  ;}
+    break;
+
+  case 144:
+#line 1458 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.TypeWithAttrsList) = new TypeWithAttrsList;
     TypeWithAttrs TWA; TWA.Attrs = ParamAttr::None;
     TWA.Ty = new PATypeHolder(Type::VoidTy);
-    yyval.TypeWithAttrsList->push_back(TWA);
+    (yyval.TypeWithAttrsList)->push_back(TWA);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 139:
-#line 1455 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.TypeWithAttrsList = new TypeWithAttrsList();
+  ;}
+    break;
+
+  case 145:
+#line 1465 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.TypeWithAttrsList) = new TypeWithAttrsList();
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 140:
-#line 1463 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.TypeList = new std::list<PATypeHolder>();
-    yyval.TypeList->push_back(*yyvsp[0].TypeVal); 
-    delete yyvsp[0].TypeVal;
+  ;}
+    break;
+
+  case 146:
+#line 1473 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.TypeList) = new std::list<PATypeHolder>();
+    (yyval.TypeList)->push_back(*(yyvsp[(1) - (1)].TypeVal)); 
+    delete (yyvsp[(1) - (1)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 141:
-#line 1469 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    (yyval.TypeList=yyvsp[-2].TypeList)->push_back(*yyvsp[0].TypeVal); 
-    delete yyvsp[0].TypeVal;
+  ;}
+    break;
+
+  case 147:
+#line 1479 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    ((yyval.TypeList)=(yyvsp[(1) - (3)].TypeList))->push_back(*(yyvsp[(3) - (3)].TypeVal)); 
+    delete (yyvsp[(3) - (3)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 142:
-#line 1481 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ // Nonempty unsized arr
+  ;}
+    break;
+
+  case 148:
+#line 1491 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { // Nonempty unsized arr
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
-    const ArrayType *ATy = dyn_cast<ArrayType>(yyvsp[-3].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (4)].TypeVal))->getDescription());
+    const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[(1) - (4)].TypeVal)->get());
     if (ATy == 0)
       GEN_ERROR("Cannot make array constant with type: '" + 
-                     (*yyvsp[-3].TypeVal)->getDescription() + "'");
+                     (*(yyvsp[(1) - (4)].TypeVal))->getDescription() + "'");
     const Type *ETy = ATy->getElementType();
     int NumElements = ATy->getNumElements();
 
     // Verify that we have the correct size...
-    if (NumElements != -1 && NumElements != (int)yyvsp[-1].ConstVector->size())
+    if (NumElements != -1 && NumElements != (int)(yyvsp[(3) - (4)].ConstVector)->size())
       GEN_ERROR("Type mismatch: constant sized array initialized with " +
-                     utostr(yyvsp[-1].ConstVector->size()) +  " arguments, but has size of " + 
+                     utostr((yyvsp[(3) - (4)].ConstVector)->size()) +  " arguments, but has size of " + 
                      itostr(NumElements) + "");
 
     // Verify all elements are correct type!
-    for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) {
-      if (ETy != (*yyvsp[-1].ConstVector)[i]->getType())
+    for (unsigned i = 0; i < (yyvsp[(3) - (4)].ConstVector)->size(); i++) {
+      if (ETy != (*(yyvsp[(3) - (4)].ConstVector))[i]->getType())
         GEN_ERROR("Element #" + utostr(i) + " is not of type '" + 
                        ETy->getDescription() +"' as required!\nIt is of type '"+
-                       (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'.");
+                       (*(yyvsp[(3) - (4)].ConstVector))[i]->getType()->getDescription() + "'.");
     }
 
-    yyval.ConstVal = ConstantArray::get(ATy, *yyvsp[-1].ConstVector);
-    delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
+    (yyval.ConstVal) = ConstantArray::get(ATy, *(yyvsp[(3) - (4)].ConstVector));
+    delete (yyvsp[(1) - (4)].TypeVal); delete (yyvsp[(3) - (4)].ConstVector);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 143:
-#line 1509 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 149:
+#line 1519 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    const ArrayType *ATy = dyn_cast<ArrayType>(yyvsp[-2].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription());
+    const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[(1) - (3)].TypeVal)->get());
     if (ATy == 0)
       GEN_ERROR("Cannot make array constant with type: '" + 
-                     (*yyvsp[-2].TypeVal)->getDescription() + "'");
+                     (*(yyvsp[(1) - (3)].TypeVal))->getDescription() + "'");
 
     int NumElements = ATy->getNumElements();
     if (NumElements != -1 && NumElements != 0) 
       GEN_ERROR("Type mismatch: constant sized array initialized with 0"
                      " arguments, but has size of " + itostr(NumElements) +"");
-    yyval.ConstVal = ConstantArray::get(ATy, std::vector<Constant*>());
-    delete yyvsp[-2].TypeVal;
+    (yyval.ConstVal) = ConstantArray::get(ATy, std::vector<Constant*>());
+    delete (yyvsp[(1) - (3)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 144:
-#line 1525 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 150:
+#line 1535 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    const ArrayType *ATy = dyn_cast<ArrayType>(yyvsp[-2].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription());
+    const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[(1) - (3)].TypeVal)->get());
     if (ATy == 0)
       GEN_ERROR("Cannot make array constant with type: '" + 
-                     (*yyvsp[-2].TypeVal)->getDescription() + "'");
+                     (*(yyvsp[(1) - (3)].TypeVal))->getDescription() + "'");
 
     int NumElements = ATy->getNumElements();
     const Type *ETy = ATy->getElementType();
-    char *EndStr = UnEscapeLexed(yyvsp[0].StrVal, true);
-    if (NumElements != -1 && NumElements != (EndStr-yyvsp[0].StrVal))
+    char *EndStr = UnEscapeLexed((yyvsp[(3) - (3)].StrVal), true);
+    if (NumElements != -1 && NumElements != (EndStr-(yyvsp[(3) - (3)].StrVal)))
       GEN_ERROR("Can't build string constant of size " + 
-                     itostr((int)(EndStr-yyvsp[0].StrVal)) +
+                     itostr((int)(EndStr-(yyvsp[(3) - (3)].StrVal))) +
                      " when array has size " + itostr(NumElements) + "");
     std::vector<Constant*> Vals;
     if (ETy == Type::Int8Ty) {
-      for (unsigned char *C = (unsigned char *)yyvsp[0].StrVal; 
+      for (unsigned char *C = (unsigned char *)(yyvsp[(3) - (3)].StrVal); 
         C != (unsigned char*)EndStr; ++C)
       Vals.push_back(ConstantInt::get(ETy, *C));
     } else {
-      free(yyvsp[0].StrVal);
+      free((yyvsp[(3) - (3)].StrVal));
       GEN_ERROR("Cannot build string arrays of non byte sized elements");
     }
-    free(yyvsp[0].StrVal);
-    yyval.ConstVal = ConstantArray::get(ATy, Vals);
-    delete yyvsp[-2].TypeVal;
+    free((yyvsp[(3) - (3)].StrVal));
+    (yyval.ConstVal) = ConstantArray::get(ATy, Vals);
+    delete (yyvsp[(1) - (3)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 145:
-#line 1554 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ // Nonempty unsized arr
+  ;}
+    break;
+
+  case 151:
+#line 1564 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { // Nonempty unsized arr
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
-    const VectorType *PTy = dyn_cast<VectorType>(yyvsp[-3].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (4)].TypeVal))->getDescription());
+    const VectorType *PTy = dyn_cast<VectorType>((yyvsp[(1) - (4)].TypeVal)->get());
     if (PTy == 0)
       GEN_ERROR("Cannot make packed constant with type: '" + 
-                     (*yyvsp[-3].TypeVal)->getDescription() + "'");
+                     (*(yyvsp[(1) - (4)].TypeVal))->getDescription() + "'");
     const Type *ETy = PTy->getElementType();
     int NumElements = PTy->getNumElements();
 
     // Verify that we have the correct size...
-    if (NumElements != -1 && NumElements != (int)yyvsp[-1].ConstVector->size())
+    if (NumElements != -1 && NumElements != (int)(yyvsp[(3) - (4)].ConstVector)->size())
       GEN_ERROR("Type mismatch: constant sized packed initialized with " +
-                     utostr(yyvsp[-1].ConstVector->size()) +  " arguments, but has size of " + 
+                     utostr((yyvsp[(3) - (4)].ConstVector)->size()) +  " arguments, but has size of " + 
                      itostr(NumElements) + "");
 
     // Verify all elements are correct type!
-    for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) {
-      if (ETy != (*yyvsp[-1].ConstVector)[i]->getType())
+    for (unsigned i = 0; i < (yyvsp[(3) - (4)].ConstVector)->size(); i++) {
+      if (ETy != (*(yyvsp[(3) - (4)].ConstVector))[i]->getType())
         GEN_ERROR("Element #" + utostr(i) + " is not of type '" + 
            ETy->getDescription() +"' as required!\nIt is of type '"+
-           (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'.");
+           (*(yyvsp[(3) - (4)].ConstVector))[i]->getType()->getDescription() + "'.");
     }
 
-    yyval.ConstVal = ConstantVector::get(PTy, *yyvsp[-1].ConstVector);
-    delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
+    (yyval.ConstVal) = ConstantVector::get(PTy, *(yyvsp[(3) - (4)].ConstVector));
+    delete (yyvsp[(1) - (4)].TypeVal); delete (yyvsp[(3) - (4)].ConstVector);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 146:
-#line 1582 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    const StructType *STy = dyn_cast<StructType>(yyvsp[-3].TypeVal->get());
+  ;}
+    break;
+
+  case 152:
+#line 1592 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    const StructType *STy = dyn_cast<StructType>((yyvsp[(1) - (4)].TypeVal)->get());
     if (STy == 0)
       GEN_ERROR("Cannot make struct constant with type: '" + 
-                     (*yyvsp[-3].TypeVal)->getDescription() + "'");
+                     (*(yyvsp[(1) - (4)].TypeVal))->getDescription() + "'");
 
-    if (yyvsp[-1].ConstVector->size() != STy->getNumContainedTypes())
+    if ((yyvsp[(3) - (4)].ConstVector)->size() != STy->getNumContainedTypes())
       GEN_ERROR("Illegal number of initializers for structure type");
 
     // Check to ensure that constants are compatible with the type initializer!
-    for (unsigned i = 0, e = yyvsp[-1].ConstVector->size(); i != e; ++i)
-      if ((*yyvsp[-1].ConstVector)[i]->getType() != STy->getElementType(i))
+    for (unsigned i = 0, e = (yyvsp[(3) - (4)].ConstVector)->size(); i != e; ++i)
+      if ((*(yyvsp[(3) - (4)].ConstVector))[i]->getType() != STy->getElementType(i))
         GEN_ERROR("Expected type '" +
                        STy->getElementType(i)->getDescription() +
                        "' for element #" + utostr(i) +
@@ -3170,20 +4151,21 @@
     if (STy->isPacked())
       GEN_ERROR("Unpacked Initializer to vector type '" + STy->getDescription() + "'");
 
-    yyval.ConstVal = ConstantStruct::get(STy, *yyvsp[-1].ConstVector);
-    delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
+    (yyval.ConstVal) = ConstantStruct::get(STy, *(yyvsp[(3) - (4)].ConstVector));
+    delete (yyvsp[(1) - (4)].TypeVal); delete (yyvsp[(3) - (4)].ConstVector);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 147:
-#line 1607 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 153:
+#line 1617 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    const StructType *STy = dyn_cast<StructType>(yyvsp[-2].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription());
+    const StructType *STy = dyn_cast<StructType>((yyvsp[(1) - (3)].TypeVal)->get());
     if (STy == 0)
       GEN_ERROR("Cannot make struct constant with type: '" + 
-                     (*yyvsp[-2].TypeVal)->getDescription() + "'");
+                     (*(yyvsp[(1) - (3)].TypeVal))->getDescription() + "'");
 
     if (STy->getNumContainedTypes() != 0)
       GEN_ERROR("Illegal number of initializers for structure type");
@@ -3192,25 +4174,26 @@
     if (STy->isPacked())
       GEN_ERROR("Unpacked Initializer to vector type '" + STy->getDescription() + "'");
 
-    yyval.ConstVal = ConstantStruct::get(STy, std::vector<Constant*>());
-    delete yyvsp[-2].TypeVal;
+    (yyval.ConstVal) = ConstantStruct::get(STy, std::vector<Constant*>());
+    delete (yyvsp[(1) - (3)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 148:
-#line 1626 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    const StructType *STy = dyn_cast<StructType>(yyvsp[-5].TypeVal->get());
+  ;}
+    break;
+
+  case 154:
+#line 1636 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    const StructType *STy = dyn_cast<StructType>((yyvsp[(1) - (6)].TypeVal)->get());
     if (STy == 0)
       GEN_ERROR("Cannot make struct constant with type: '" + 
-                     (*yyvsp[-5].TypeVal)->getDescription() + "'");
+                     (*(yyvsp[(1) - (6)].TypeVal))->getDescription() + "'");
 
-    if (yyvsp[-2].ConstVector->size() != STy->getNumContainedTypes())
+    if ((yyvsp[(4) - (6)].ConstVector)->size() != STy->getNumContainedTypes())
       GEN_ERROR("Illegal number of initializers for structure type");
 
     // Check to ensure that constants are compatible with the type initializer!
-    for (unsigned i = 0, e = yyvsp[-2].ConstVector->size(); i != e; ++i)
-      if ((*yyvsp[-2].ConstVector)[i]->getType() != STy->getElementType(i))
+    for (unsigned i = 0, e = (yyvsp[(4) - (6)].ConstVector)->size(); i != e; ++i)
+      if ((*(yyvsp[(4) - (6)].ConstVector))[i]->getType() != STy->getElementType(i))
         GEN_ERROR("Expected type '" +
                        STy->getElementType(i)->getDescription() +
                        "' for element #" + utostr(i) +
@@ -3221,20 +4204,21 @@
       GEN_ERROR("Vector initializer to non-vector type '" + 
                 STy->getDescription() + "'");
 
-    yyval.ConstVal = ConstantStruct::get(STy, *yyvsp[-2].ConstVector);
-    delete yyvsp[-5].TypeVal; delete yyvsp[-2].ConstVector;
+    (yyval.ConstVal) = ConstantStruct::get(STy, *(yyvsp[(4) - (6)].ConstVector));
+    delete (yyvsp[(1) - (6)].TypeVal); delete (yyvsp[(4) - (6)].ConstVector);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 149:
-#line 1652 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 155:
+#line 1662 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
-    const StructType *STy = dyn_cast<StructType>(yyvsp[-4].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (5)].TypeVal))->getDescription());
+    const StructType *STy = dyn_cast<StructType>((yyvsp[(1) - (5)].TypeVal)->get());
     if (STy == 0)
       GEN_ERROR("Cannot make struct constant with type: '" + 
-                     (*yyvsp[-4].TypeVal)->getDescription() + "'");
+                     (*(yyvsp[(1) - (5)].TypeVal))->getDescription() + "'");
 
     if (STy->getNumContainedTypes() != 0)
       GEN_ERROR("Illegal number of initializers for structure type");
@@ -3244,42 +4228,45 @@
       GEN_ERROR("Vector initializer to non-vector type '" + 
                 STy->getDescription() + "'");
 
-    yyval.ConstVal = ConstantStruct::get(STy, std::vector<Constant*>());
-    delete yyvsp[-4].TypeVal;
+    (yyval.ConstVal) = ConstantStruct::get(STy, std::vector<Constant*>());
+    delete (yyvsp[(1) - (5)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 150:
-#line 1672 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 156:
+#line 1682 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    const PointerType *PTy = dyn_cast<PointerType>(yyvsp[-1].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
+    const PointerType *PTy = dyn_cast<PointerType>((yyvsp[(1) - (2)].TypeVal)->get());
     if (PTy == 0)
       GEN_ERROR("Cannot make null pointer constant with type: '" + 
-                     (*yyvsp[-1].TypeVal)->getDescription() + "'");
+                     (*(yyvsp[(1) - (2)].TypeVal))->getDescription() + "'");
 
-    yyval.ConstVal = ConstantPointerNull::get(PTy);
-    delete yyvsp[-1].TypeVal;
+    (yyval.ConstVal) = ConstantPointerNull::get(PTy);
+    delete (yyvsp[(1) - (2)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 151:
-#line 1684 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 157:
+#line 1694 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    yyval.ConstVal = UndefValue::get(yyvsp[-1].TypeVal->get());
-    delete yyvsp[-1].TypeVal;
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
+    (yyval.ConstVal) = UndefValue::get((yyvsp[(1) - (2)].TypeVal)->get());
+    delete (yyvsp[(1) - (2)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 152:
-#line 1691 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 158:
+#line 1701 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    const PointerType *Ty = dyn_cast<PointerType>(yyvsp[-1].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
+    const PointerType *Ty = dyn_cast<PointerType>((yyvsp[(1) - (2)].TypeVal)->get());
     if (Ty == 0)
       GEN_ERROR("Global const reference must be a pointer type");
 
@@ -3293,7 +4280,7 @@
     Function *SavedCurFn = CurFun.CurrentFunction;
     CurFun.CurrentFunction = 0;
 
-    Value *V = getExistingVal(Ty, yyvsp[0].ValIDVal);
+    Value *V = getExistingVal(Ty, (yyvsp[(2) - (2)].ValIDVal));
     CHECK_FOR_ERROR
 
     CurFun.CurrentFunction = SavedCurFn;
@@ -3308,16 +4295,16 @@
 
       // First check to see if the forward references value is already created!
       PerModuleInfo::GlobalRefsType::iterator I =
-        CurModule.GlobalRefs.find(std::make_pair(PT, yyvsp[0].ValIDVal));
+        CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[(2) - (2)].ValIDVal)));
     
       if (I != CurModule.GlobalRefs.end()) {
         V = I->second;             // Placeholder already exists, use it...
-        yyvsp[0].ValIDVal.destroy();
+        (yyvsp[(2) - (2)].ValIDVal).destroy();
       } else {
         std::string Name;
-        if (yyvsp[0].ValIDVal.Type == ValID::GlobalName)
-          Name = yyvsp[0].ValIDVal.Name;
-        else if (yyvsp[0].ValIDVal.Type != ValID::GlobalID)
+        if ((yyvsp[(2) - (2)].ValIDVal).Type == ValID::GlobalName)
+          Name = (yyvsp[(2) - (2)].ValIDVal).Name;
+        else if ((yyvsp[(2) - (2)].ValIDVal).Type != ValID::GlobalID)
           GEN_ERROR("Invalid reference to global");
 
         // Create the forward referenced global.
@@ -3333,307 +4320,340 @@
         }
 
         // Keep track of the fact that we have a forward ref to recycle it
-        CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, yyvsp[0].ValIDVal), GV));
+        CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[(2) - (2)].ValIDVal)), GV));
         V = GV;
       }
     }
 
-    yyval.ConstVal = cast<GlobalValue>(V);
-    delete yyvsp[-1].TypeVal;            // Free the type handle
+    (yyval.ConstVal) = cast<GlobalValue>(V);
+    delete (yyvsp[(1) - (2)].TypeVal);            // Free the type handle
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 153:
-#line 1757 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 159:
+#line 1767 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    if (yyvsp[-1].TypeVal->get() != yyvsp[0].ConstVal->getType())
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
+    if ((yyvsp[(1) - (2)].TypeVal)->get() != (yyvsp[(2) - (2)].ConstVal)->getType())
       GEN_ERROR("Mismatched types for constant expression: " + 
-        (*yyvsp[-1].TypeVal)->getDescription() + " and " + yyvsp[0].ConstVal->getType()->getDescription());
-    yyval.ConstVal = yyvsp[0].ConstVal;
-    delete yyvsp[-1].TypeVal;
+        (*(yyvsp[(1) - (2)].TypeVal))->getDescription() + " and " + (yyvsp[(2) - (2)].ConstVal)->getType()->getDescription());
+    (yyval.ConstVal) = (yyvsp[(2) - (2)].ConstVal);
+    delete (yyvsp[(1) - (2)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 154:
-#line 1767 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 160:
+#line 1777 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    const Type *Ty = yyvsp[-1].TypeVal->get();
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
+    const Type *Ty = (yyvsp[(1) - (2)].TypeVal)->get();
     if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
       GEN_ERROR("Cannot create a null initialized value of this type");
-    yyval.ConstVal = Constant::getNullValue(Ty);
-    delete yyvsp[-1].TypeVal;
+    (yyval.ConstVal) = Constant::getNullValue(Ty);
+    delete (yyvsp[(1) - (2)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 155:
-#line 1777 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{      // integral constants
-    if (!ConstantInt::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].SInt64Val))
+  ;}
+    break;
+
+  case 161:
+#line 1787 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {      // integral constants
+    if (!ConstantInt::isValueValidForType((yyvsp[(1) - (2)].PrimType), (yyvsp[(2) - (2)].SInt64Val)))
       GEN_ERROR("Constant value doesn't fit in type");
-    yyval.ConstVal = ConstantInt::get(yyvsp[-1].PrimType, yyvsp[0].SInt64Val, true);
+    (yyval.ConstVal) = ConstantInt::get((yyvsp[(1) - (2)].PrimType), (yyvsp[(2) - (2)].SInt64Val), true);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 156:
-#line 1783 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{      // arbitrary precision integer constants
-    uint32_t BitWidth = cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth();
-    if (yyvsp[0].APIntVal->getBitWidth() > BitWidth) {
+  ;}
+    break;
+
+  case 162:
+#line 1793 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {      // arbitrary precision integer constants
+    uint32_t BitWidth = cast<IntegerType>((yyvsp[(1) - (2)].PrimType))->getBitWidth();
+    if ((yyvsp[(2) - (2)].APIntVal)->getBitWidth() > BitWidth) {
       GEN_ERROR("Constant value does not fit in type");
     }
-    yyvsp[0].APIntVal->sextOrTrunc(BitWidth);
-    yyval.ConstVal = ConstantInt::get(*yyvsp[0].APIntVal);
-    delete yyvsp[0].APIntVal;
+    (yyvsp[(2) - (2)].APIntVal)->sextOrTrunc(BitWidth);
+    (yyval.ConstVal) = ConstantInt::get(*(yyvsp[(2) - (2)].APIntVal));
+    delete (yyvsp[(2) - (2)].APIntVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 157:
-#line 1793 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{      // integral constants
-    if (!ConstantInt::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].UInt64Val))
+  ;}
+    break;
+
+  case 163:
+#line 1803 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {      // integral constants
+    if (!ConstantInt::isValueValidForType((yyvsp[(1) - (2)].PrimType), (yyvsp[(2) - (2)].UInt64Val)))
       GEN_ERROR("Constant value doesn't fit in type");
-    yyval.ConstVal = ConstantInt::get(yyvsp[-1].PrimType, yyvsp[0].UInt64Val, false);
+    (yyval.ConstVal) = ConstantInt::get((yyvsp[(1) - (2)].PrimType), (yyvsp[(2) - (2)].UInt64Val), false);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 158:
-#line 1799 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{      // arbitrary precision integer constants
-    uint32_t BitWidth = cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth();
-    if (yyvsp[0].APIntVal->getBitWidth() > BitWidth) {
+  ;}
+    break;
+
+  case 164:
+#line 1809 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {      // arbitrary precision integer constants
+    uint32_t BitWidth = cast<IntegerType>((yyvsp[(1) - (2)].PrimType))->getBitWidth();
+    if ((yyvsp[(2) - (2)].APIntVal)->getBitWidth() > BitWidth) {
       GEN_ERROR("Constant value does not fit in type");
     } 
-    yyvsp[0].APIntVal->zextOrTrunc(BitWidth);
-    yyval.ConstVal = ConstantInt::get(*yyvsp[0].APIntVal);
-    delete yyvsp[0].APIntVal;
+    (yyvsp[(2) - (2)].APIntVal)->zextOrTrunc(BitWidth);
+    (yyval.ConstVal) = ConstantInt::get(*(yyvsp[(2) - (2)].APIntVal));
+    delete (yyvsp[(2) - (2)].APIntVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 159:
-#line 1809 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{                      // Boolean constants
-    assert(cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth() == 1 && "Not Bool?");
-    yyval.ConstVal = ConstantInt::getTrue();
+  ;}
+    break;
+
+  case 165:
+#line 1819 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {                      // Boolean constants
+    assert(cast<IntegerType>((yyvsp[(1) - (2)].PrimType))->getBitWidth() == 1 && "Not Bool?");
+    (yyval.ConstVal) = ConstantInt::getTrue();
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 160:
-#line 1814 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{                     // Boolean constants
-    assert(cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth() == 1 && "Not Bool?");
-    yyval.ConstVal = ConstantInt::getFalse();
+  ;}
+    break;
+
+  case 166:
+#line 1824 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {                     // Boolean constants
+    assert(cast<IntegerType>((yyvsp[(1) - (2)].PrimType))->getBitWidth() == 1 && "Not Bool?");
+    (yyval.ConstVal) = ConstantInt::getFalse();
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 161:
-#line 1819 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{                   // Float & Double constants
-    if (!ConstantFP::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].FPVal))
+  ;}
+    break;
+
+  case 167:
+#line 1829 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {                   // Float & Double constants
+    if (!ConstantFP::isValueValidForType((yyvsp[(1) - (2)].PrimType), (yyvsp[(2) - (2)].FPVal)))
       GEN_ERROR("Floating point constant invalid for type");
-    yyval.ConstVal = ConstantFP::get(yyvsp[-1].PrimType, yyvsp[0].FPVal);
+    (yyval.ConstVal) = ConstantFP::get((yyvsp[(1) - (2)].PrimType), (yyvsp[(2) - (2)].FPVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 162:
-#line 1827 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 168:
+#line 1837 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    Constant *Val = yyvsp[-3].ConstVal;
-    const Type *DestTy = yyvsp[-1].TypeVal->get();
-    if (!CastInst::castIsValid(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy))
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(5) - (6)].TypeVal))->getDescription());
+    Constant *Val = (yyvsp[(3) - (6)].ConstVal);
+    const Type *DestTy = (yyvsp[(5) - (6)].TypeVal)->get();
+    if (!CastInst::castIsValid((yyvsp[(1) - (6)].CastOpVal), (yyvsp[(3) - (6)].ConstVal), DestTy))
       GEN_ERROR("invalid cast opcode for cast from '" +
                 Val->getType()->getDescription() + "' to '" +
                 DestTy->getDescription() + "'"); 
-    yyval.ConstVal = ConstantExpr::getCast(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy);
-    delete yyvsp[-1].TypeVal;
-  ;
-    break;}
-case 163:
-#line 1839 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (!isa<PointerType>(yyvsp[-2].ConstVal->getType()))
+    (yyval.ConstVal) = ConstantExpr::getCast((yyvsp[(1) - (6)].CastOpVal), (yyvsp[(3) - (6)].ConstVal), DestTy);
+    delete (yyvsp[(5) - (6)].TypeVal);
+  ;}
+    break;
+
+  case 169:
+#line 1849 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if (!isa<PointerType>((yyvsp[(3) - (5)].ConstVal)->getType()))
       GEN_ERROR("GetElementPtr requires a pointer operand");
 
     const Type *IdxTy =
-      GetElementPtrInst::getIndexedType(yyvsp[-2].ConstVal->getType(), &(*yyvsp[-1].ValueList)[0], yyvsp[-1].ValueList->size(),
+      GetElementPtrInst::getIndexedType((yyvsp[(3) - (5)].ConstVal)->getType(), &(*(yyvsp[(4) - (5)].ValueList))[0], (yyvsp[(4) - (5)].ValueList)->size(),
                                         true);
     if (!IdxTy)
       GEN_ERROR("Index list invalid for constant getelementptr");
 
     SmallVector<Constant*, 8> IdxVec;
-    for (unsigned i = 0, e = yyvsp[-1].ValueList->size(); i != e; ++i)
-      if (Constant *C = dyn_cast<Constant>((*yyvsp[-1].ValueList)[i]))
+    for (unsigned i = 0, e = (yyvsp[(4) - (5)].ValueList)->size(); i != e; ++i)
+      if (Constant *C = dyn_cast<Constant>((*(yyvsp[(4) - (5)].ValueList))[i]))
         IdxVec.push_back(C);
       else
         GEN_ERROR("Indices to constant getelementptr must be constants");
 
-    delete yyvsp[-1].ValueList;
+    delete (yyvsp[(4) - (5)].ValueList);
 
-    yyval.ConstVal = ConstantExpr::getGetElementPtr(yyvsp[-2].ConstVal, &IdxVec[0], IdxVec.size());
+    (yyval.ConstVal) = ConstantExpr::getGetElementPtr((yyvsp[(3) - (5)].ConstVal), &IdxVec[0], IdxVec.size());
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 164:
-#line 1861 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (yyvsp[-5].ConstVal->getType() != Type::Int1Ty)
+  ;}
+    break;
+
+  case 170:
+#line 1871 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if ((yyvsp[(3) - (8)].ConstVal)->getType() != Type::Int1Ty)
       GEN_ERROR("Select condition must be of boolean type");
-    if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
+    if ((yyvsp[(5) - (8)].ConstVal)->getType() != (yyvsp[(7) - (8)].ConstVal)->getType())
       GEN_ERROR("Select operand types must match");
-    yyval.ConstVal = ConstantExpr::getSelect(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
+    (yyval.ConstVal) = ConstantExpr::getSelect((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 165:
-#line 1869 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
+  ;}
+    break;
+
+  case 171:
+#line 1879 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if ((yyvsp[(3) - (6)].ConstVal)->getType() != (yyvsp[(5) - (6)].ConstVal)->getType())
       GEN_ERROR("Binary operator types must match");
     CHECK_FOR_ERROR;
-    yyval.ConstVal = ConstantExpr::get(yyvsp[-5].BinaryOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
-  ;
-    break;}
-case 166:
-#line 1875 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
+    (yyval.ConstVal) = ConstantExpr::get((yyvsp[(1) - (6)].BinaryOpVal), (yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal));
+  ;}
+    break;
+
+  case 172:
+#line 1885 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if ((yyvsp[(3) - (6)].ConstVal)->getType() != (yyvsp[(5) - (6)].ConstVal)->getType())
       GEN_ERROR("Logical operator types must match");
-    if (!yyvsp[-3].ConstVal->getType()->isInteger()) {
-      if (Instruction::isShift(yyvsp[-5].BinaryOpVal) || !isa<VectorType>(yyvsp[-3].ConstVal->getType()) || 
-          !cast<VectorType>(yyvsp[-3].ConstVal->getType())->getElementType()->isInteger())
+    if (!(yyvsp[(3) - (6)].ConstVal)->getType()->isInteger()) {
+      if (Instruction::isShift((yyvsp[(1) - (6)].BinaryOpVal)) || !isa<VectorType>((yyvsp[(3) - (6)].ConstVal)->getType()) || 
+          !cast<VectorType>((yyvsp[(3) - (6)].ConstVal)->getType())->getElementType()->isInteger())
         GEN_ERROR("Logical operator requires integral operands");
     }
-    yyval.ConstVal = ConstantExpr::get(yyvsp[-5].BinaryOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
+    (yyval.ConstVal) = ConstantExpr::get((yyvsp[(1) - (6)].BinaryOpVal), (yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 167:
-#line 1886 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
+  ;}
+    break;
+
+  case 173:
+#line 1896 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType())
       GEN_ERROR("icmp operand types must match");
-    yyval.ConstVal = ConstantExpr::getICmp(yyvsp[-5].IPredicate, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
-  ;
-    break;}
-case 168:
-#line 1891 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
+    (yyval.ConstVal) = ConstantExpr::getICmp((yyvsp[(2) - (7)].IPredicate), (yyvsp[(4) - (7)].ConstVal), (yyvsp[(6) - (7)].ConstVal));
+  ;}
+    break;
+
+  case 174:
+#line 1901 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType())
       GEN_ERROR("fcmp operand types must match");
-    yyval.ConstVal = ConstantExpr::getFCmp(yyvsp[-5].FPredicate, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
-  ;
-    break;}
-case 169:
-#line 1896 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (!ExtractElementInst::isValidOperands(yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
+    (yyval.ConstVal) = ConstantExpr::getFCmp((yyvsp[(2) - (7)].FPredicate), (yyvsp[(4) - (7)].ConstVal), (yyvsp[(6) - (7)].ConstVal));
+  ;}
+    break;
+
+  case 175:
+#line 1906 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if (!ExtractElementInst::isValidOperands((yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal)))
       GEN_ERROR("Invalid extractelement operands");
-    yyval.ConstVal = ConstantExpr::getExtractElement(yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
+    (yyval.ConstVal) = ConstantExpr::getExtractElement((yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 170:
-#line 1902 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (!InsertElementInst::isValidOperands(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
+  ;}
+    break;
+
+  case 176:
+#line 1912 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if (!InsertElementInst::isValidOperands((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal)))
       GEN_ERROR("Invalid insertelement operands");
-    yyval.ConstVal = ConstantExpr::getInsertElement(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
+    (yyval.ConstVal) = ConstantExpr::getInsertElement((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 171:
-#line 1908 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (!ShuffleVectorInst::isValidOperands(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
+  ;}
+    break;
+
+  case 177:
+#line 1918 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if (!ShuffleVectorInst::isValidOperands((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal)))
       GEN_ERROR("Invalid shufflevector operands");
-    yyval.ConstVal = ConstantExpr::getShuffleVector(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
+    (yyval.ConstVal) = ConstantExpr::getShuffleVector((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 172:
-#line 1917 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    (yyval.ConstVector = yyvsp[-2].ConstVector)->push_back(yyvsp[0].ConstVal);
+  ;}
+    break;
+
+  case 178:
+#line 1927 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    ((yyval.ConstVector) = (yyvsp[(1) - (3)].ConstVector))->push_back((yyvsp[(3) - (3)].ConstVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 173:
-#line 1921 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ConstVector = new std::vector<Constant*>();
-    yyval.ConstVector->push_back(yyvsp[0].ConstVal);
+  ;}
+    break;
+
+  case 179:
+#line 1931 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ConstVector) = new std::vector<Constant*>();
+    (yyval.ConstVector)->push_back((yyvsp[(1) - (1)].ConstVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 174:
-#line 1929 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.BoolVal = false; ;
-    break;}
-case 175:
-#line 1929 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.BoolVal = true; ;
-    break;}
-case 176:
-#line 1932 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.BoolVal = true; ;
-    break;}
-case 177:
-#line 1932 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.BoolVal = false; ;
-    break;}
-case 178:
-#line 1943 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ModuleVal = ParserResult = CurModule.CurrentModule;
+  ;}
+    break;
+
+  case 180:
+#line 1939 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.BoolVal) = false; ;}
+    break;
+
+  case 181:
+#line 1939 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.BoolVal) = true; ;}
+    break;
+
+  case 182:
+#line 1942 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.BoolVal) = true; ;}
+    break;
+
+  case 183:
+#line 1942 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.BoolVal) = false; ;}
+    break;
+
+  case 184:
+#line 1953 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule;
     CurModule.ModuleDone();
     CHECK_FOR_ERROR;
-  ;
-    break;}
-case 179:
-#line 1948 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ModuleVal = ParserResult = CurModule.CurrentModule;
+  ;}
+    break;
+
+  case 185:
+#line 1958 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule;
     CurModule.ModuleDone();
     CHECK_FOR_ERROR;
-  ;
-    break;}
-case 182:
-#line 1961 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ CurFun.isDeclare = false; ;
-    break;}
-case 183:
-#line 1961 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 188:
+#line 1971 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { CurFun.isDeclare = false; ;}
+    break;
+
+  case 189:
+#line 1971 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     CurFun.FunctionDone();
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 184:
-#line 1965 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ CurFun.isDeclare = true; ;
-    break;}
-case 185:
-#line 1965 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 190:
+#line 1975 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { CurFun.isDeclare = true; ;}
+    break;
+
+  case 191:
+#line 1975 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 186:
-#line 1968 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 192:
+#line 1978 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 187:
-#line 1971 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 193:
+#line 1981 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (3)].TypeVal))->getDescription());
     // Eagerly resolve types.  This is not an optimization, this is a
     // requirement that is due to the fact that we could have this:
     //
@@ -3643,230 +4663,284 @@
     // If types are not resolved eagerly, then the two types will not be
     // determined to be the same type!
     //
-    ResolveTypeTo(yyvsp[-2].StrVal, *yyvsp[0].TypeVal);
+    ResolveTypeTo((yyvsp[(1) - (3)].StrVal), *(yyvsp[(3) - (3)].TypeVal));
 
-    if (!setTypeName(*yyvsp[0].TypeVal, yyvsp[-2].StrVal) && !yyvsp[-2].StrVal) {
+    if (!setTypeName(*(yyvsp[(3) - (3)].TypeVal), (yyvsp[(1) - (3)].StrVal)) && !(yyvsp[(1) - (3)].StrVal)) {
       CHECK_FOR_ERROR
       // If this is a named type that is not a redefinition, add it to the slot
       // table.
-      CurModule.Types.push_back(*yyvsp[0].TypeVal);
+      CurModule.Types.push_back(*(yyvsp[(3) - (3)].TypeVal));
     }
 
-    delete yyvsp[0].TypeVal;
+    delete (yyvsp[(3) - (3)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 188:
-#line 1995 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    ResolveTypeTo(yyvsp[-2].StrVal, yyvsp[0].PrimType);
+  ;}
+    break;
 
-    if (!setTypeName(yyvsp[0].PrimType, yyvsp[-2].StrVal) && !yyvsp[-2].StrVal) {
+  case 194:
+#line 2005 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    ResolveTypeTo((yyvsp[(1) - (3)].StrVal), (yyvsp[(3) - (3)].PrimType));
+
+    if (!setTypeName((yyvsp[(3) - (3)].PrimType), (yyvsp[(1) - (3)].StrVal)) && !(yyvsp[(1) - (3)].StrVal)) {
       CHECK_FOR_ERROR
       // If this is a named type that is not a redefinition, add it to the slot
       // table.
-      CurModule.Types.push_back(yyvsp[0].PrimType);
+      CurModule.Types.push_back((yyvsp[(3) - (3)].PrimType));
     }
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 189:
-#line 2006 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ 
+  ;}
+    break;
+
+  case 195:
+#line 2016 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { 
     /* "Externally Visible" Linkage */
-    if (yyvsp[0].ConstVal == 0) 
+    if ((yyvsp[(5) - (5)].ConstVal) == 0) 
       GEN_ERROR("Global value initializer is not a constant");
-    CurGV = ParseGlobalVariable(yyvsp[-4].StrVal, GlobalValue::ExternalLinkage,
-                                yyvsp[-3].Visibility, yyvsp[-1].BoolVal, yyvsp[0].ConstVal->getType(), yyvsp[0].ConstVal, yyvsp[-2].BoolVal);
+    CurGV = ParseGlobalVariable((yyvsp[(1) - (5)].StrVal), GlobalValue::ExternalLinkage,
+                                (yyvsp[(2) - (5)].Visibility), (yyvsp[(4) - (5)].BoolVal), (yyvsp[(5) - (5)].ConstVal)->getType(), (yyvsp[(5) - (5)].ConstVal), (yyvsp[(3) - (5)].BoolVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 190:
-#line 2013 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 196:
+#line 2023 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     CurGV = 0;
-  ;
-    break;}
-case 191:
-#line 2016 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (yyvsp[0].ConstVal == 0) 
+  ;}
+    break;
+
+  case 197:
+#line 2026 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if ((yyvsp[(6) - (6)].ConstVal) == 0) 
       GEN_ERROR("Global value initializer is not a constant");
-    CurGV = ParseGlobalVariable(yyvsp[-5].StrVal, yyvsp[-4].Linkage, yyvsp[-3].Visibility, yyvsp[-1].BoolVal, yyvsp[0].ConstVal->getType(), yyvsp[0].ConstVal, yyvsp[-2].BoolVal);
+    CurGV = ParseGlobalVariable((yyvsp[(1) - (6)].StrVal), (yyvsp[(2) - (6)].Linkage), (yyvsp[(3) - (6)].Visibility), (yyvsp[(5) - (6)].BoolVal), (yyvsp[(6) - (6)].ConstVal)->getType(), (yyvsp[(6) - (6)].ConstVal), (yyvsp[(4) - (6)].BoolVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 192:
-#line 2021 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 198:
+#line 2031 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     CurGV = 0;
-  ;
-    break;}
-case 193:
-#line 2024 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 199:
+#line 2034 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
-    CurGV = ParseGlobalVariable(yyvsp[-5].StrVal, yyvsp[-4].Linkage, yyvsp[-3].Visibility, yyvsp[-1].BoolVal, *yyvsp[0].TypeVal, 0, yyvsp[-2].BoolVal);
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(6) - (6)].TypeVal))->getDescription());
+    CurGV = ParseGlobalVariable((yyvsp[(1) - (6)].StrVal), (yyvsp[(2) - (6)].Linkage), (yyvsp[(3) - (6)].Visibility), (yyvsp[(5) - (6)].BoolVal), *(yyvsp[(6) - (6)].TypeVal), 0, (yyvsp[(4) - (6)].BoolVal));
     CHECK_FOR_ERROR
-    delete yyvsp[0].TypeVal;
-  ;
-    break;}
-case 194:
-#line 2030 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+    delete (yyvsp[(6) - (6)].TypeVal);
+  ;}
+    break;
+
+  case 200:
+#line 2040 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     CurGV = 0;
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 195:
-#line 2034 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ 
+  ;}
+    break;
+
+  case 201:
+#line 2044 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    std::string Name((yyvsp[(1) - (6)].StrVal));
+    if (Name.empty())
+      GEN_ERROR("Alias name cannot be empty")
+    const PointerType *PFTy = 0;
+    const FunctionType *Ty = 0;
+    Value* V = 0;
+    const Type* VTy = 0;
+    if (!(PFTy = dyn_cast<PointerType>((yyvsp[(5) - (6)].TypeVal)->get())) ||
+        !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
+      VTy = (yyvsp[(5) - (6)].TypeVal)->get();
+      V = getExistingVal(VTy, (yyvsp[(6) - (6)].ValIDVal));
+    } else {
+      VTy = PFTy;
+      V = getExistingVal(PFTy, (yyvsp[(6) - (6)].ValIDVal));
+    }
+    if (V == 0)
+      GEN_ERROR(std::string("Invalid aliasee for alias: ") + (yyvsp[(1) - (6)].StrVal));
+    GlobalValue* Aliasee;
+    if (Aliasee = dyn_cast<GlobalValue>(V)) {
+      GlobalAlias* GA = new GlobalAlias(VTy, (yyvsp[(4) - (6)].Linkage), Name, Aliasee, CurModule.CurrentModule);
+      GA->setVisibility((yyvsp[(2) - (6)].Visibility));
+      InsertValue(GA, CurModule.Values);
+    } else
+      GEN_ERROR("Aliases can be created only to global values");
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 196:
-#line 2037 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+    delete (yyvsp[(5) - (6)].TypeVal);
+  ;}
+    break;
+
+  case 202:
+#line 2072 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { 
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 197:
-#line 2043 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 203:
+#line 2075 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    CHECK_FOR_ERROR
+  ;}
+    break;
+
+  case 204:
+#line 2081 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
   const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
-  char *EndStr = UnEscapeLexed(yyvsp[0].StrVal, true);
-  std::string NewAsm(yyvsp[0].StrVal, EndStr);
-  free(yyvsp[0].StrVal);
+  char *EndStr = UnEscapeLexed((yyvsp[(1) - (1)].StrVal), true);
+  std::string NewAsm((yyvsp[(1) - (1)].StrVal), EndStr);
+  free((yyvsp[(1) - (1)].StrVal));
 
   if (AsmSoFar.empty())
     CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
   else
     CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
   CHECK_FOR_ERROR
-;
-    break;}
-case 198:
-#line 2056 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    CurModule.CurrentModule->setTargetTriple(yyvsp[0].StrVal);
-    free(yyvsp[0].StrVal);
-  ;
-    break;}
-case 199:
-#line 2060 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    CurModule.CurrentModule->setDataLayout(yyvsp[0].StrVal);
-    free(yyvsp[0].StrVal);
-  ;
-    break;}
-case 201:
-#line 2067 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-          CurModule.CurrentModule->addLibrary(yyvsp[0].StrVal);
-          free(yyvsp[0].StrVal);
+;}
+    break;
+
+  case 205:
+#line 2094 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    CurModule.CurrentModule->setTargetTriple((yyvsp[(3) - (3)].StrVal));
+    free((yyvsp[(3) - (3)].StrVal));
+  ;}
+    break;
+
+  case 206:
+#line 2098 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    CurModule.CurrentModule->setDataLayout((yyvsp[(3) - (3)].StrVal));
+    free((yyvsp[(3) - (3)].StrVal));
+  ;}
+    break;
+
+  case 208:
+#line 2105 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+          CurModule.CurrentModule->addLibrary((yyvsp[(3) - (3)].StrVal));
+          free((yyvsp[(3) - (3)].StrVal));
           CHECK_FOR_ERROR
-        ;
-    break;}
-case 202:
-#line 2072 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-          CurModule.CurrentModule->addLibrary(yyvsp[0].StrVal);
-          free(yyvsp[0].StrVal);
+        ;}
+    break;
+
+  case 209:
+#line 2110 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+          CurModule.CurrentModule->addLibrary((yyvsp[(1) - (1)].StrVal));
+          free((yyvsp[(1) - (1)].StrVal));
           CHECK_FOR_ERROR
-        ;
-    break;}
-case 203:
-#line 2077 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+        ;}
+    break;
+
+  case 210:
+#line 2115 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
           CHECK_FOR_ERROR
-        ;
-    break;}
-case 204:
-#line 2086 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+        ;}
+    break;
+
+  case 211:
+#line 2124 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    if (*yyvsp[-2].TypeVal == Type::VoidTy)
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (5)].TypeVal))->getDescription());
+    if (*(yyvsp[(3) - (5)].TypeVal) == Type::VoidTy)
       GEN_ERROR("void typed arguments are invalid");
-    ArgListEntry E; E.Attrs = yyvsp[-1].ParamAttrs; E.Ty = yyvsp[-2].TypeVal; E.Name = yyvsp[0].StrVal;
-    yyval.ArgList = yyvsp[-4].ArgList;
-    yyvsp[-4].ArgList->push_back(E);
+    ArgListEntry E; E.Attrs = (yyvsp[(4) - (5)].ParamAttrs); E.Ty = (yyvsp[(3) - (5)].TypeVal); E.Name = (yyvsp[(5) - (5)].StrVal);
+    (yyval.ArgList) = (yyvsp[(1) - (5)].ArgList);
+    (yyvsp[(1) - (5)].ArgList)->push_back(E);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 205:
-#line 2096 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 212:
+#line 2134 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    if (*yyvsp[-2].TypeVal == Type::VoidTy)
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription());
+    if (*(yyvsp[(1) - (3)].TypeVal) == Type::VoidTy)
       GEN_ERROR("void typed arguments are invalid");
-    ArgListEntry E; E.Attrs = yyvsp[-1].ParamAttrs; E.Ty = yyvsp[-2].TypeVal; E.Name = yyvsp[0].StrVal;
-    yyval.ArgList = new ArgListType;
-    yyval.ArgList->push_back(E);
+    ArgListEntry E; E.Attrs = (yyvsp[(2) - (3)].ParamAttrs); E.Ty = (yyvsp[(1) - (3)].TypeVal); E.Name = (yyvsp[(3) - (3)].StrVal);
+    (yyval.ArgList) = new ArgListType;
+    (yyval.ArgList)->push_back(E);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 206:
-#line 2107 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ArgList = yyvsp[0].ArgList;
+  ;}
+    break;
+
+  case 213:
+#line 2145 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ArgList) = (yyvsp[(1) - (1)].ArgList);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 207:
-#line 2111 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ArgList = yyvsp[-2].ArgList;
+  ;}
+    break;
+
+  case 214:
+#line 2149 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ArgList) = (yyvsp[(1) - (3)].ArgList);
     struct ArgListEntry E;
     E.Ty = new PATypeHolder(Type::VoidTy);
     E.Name = 0;
     E.Attrs = ParamAttr::None;
-    yyval.ArgList->push_back(E);
+    (yyval.ArgList)->push_back(E);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 208:
-#line 2120 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ArgList = new ArgListType;
+  ;}
+    break;
+
+  case 215:
+#line 2158 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ArgList) = new ArgListType;
     struct ArgListEntry E;
     E.Ty = new PATypeHolder(Type::VoidTy);
     E.Name = 0;
     E.Attrs = ParamAttr::None;
-    yyval.ArgList->push_back(E);
+    (yyval.ArgList)->push_back(E);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 209:
-#line 2129 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ArgList = 0;
+  ;}
+    break;
+
+  case 216:
+#line 2167 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ArgList) = 0;
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 210:
-#line 2135 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-  UnEscapeLexed(yyvsp[-6].StrVal);
-  std::string FunctionName(yyvsp[-6].StrVal);
-  free(yyvsp[-6].StrVal);  // Free strdup'd memory!
+  ;}
+    break;
+
+  case 217:
+#line 2173 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+  UnEscapeLexed((yyvsp[(3) - (9)].StrVal));
+  std::string FunctionName((yyvsp[(3) - (9)].StrVal));
+  free((yyvsp[(3) - (9)].StrVal));  // Free strdup'd memory!
   
   // Check the function result for abstractness if this is a define. We should
   // have no abstract types at this point
-  if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(yyvsp[-7].TypeVal))
-    GEN_ERROR("Reference to abstract result: "+ yyvsp[-7].TypeVal->get()->getDescription());
+  if (!CurFun.isDeclare && CurModule.TypeIsUnresolved((yyvsp[(2) - (9)].TypeVal)))
+    GEN_ERROR("Reference to abstract result: "+ (yyvsp[(2) - (9)].TypeVal)->get()->getDescription());
 
   std::vector<const Type*> ParamTypeList;
   ParamAttrsVector Attrs;
-  if (yyvsp[-2].ParamAttrs != ParamAttr::None) {
-    ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = yyvsp[-2].ParamAttrs;
+  if ((yyvsp[(7) - (9)].ParamAttrs) != ParamAttr::None) {
+    ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = (yyvsp[(7) - (9)].ParamAttrs);
     Attrs.push_back(PAWI);
   }
-  if (yyvsp[-4].ArgList) {   // If there are arguments...
+  if ((yyvsp[(5) - (9)].ArgList)) {   // If there are arguments...
     unsigned index = 1;
-    for (ArgListType::iterator I = yyvsp[-4].ArgList->begin(); I != yyvsp[-4].ArgList->end(); ++I, ++index) {
+    for (ArgListType::iterator I = (yyvsp[(5) - (9)].ArgList)->begin(); I != (yyvsp[(5) - (9)].ArgList)->end(); ++I, ++index) {
       const Type* Ty = I->Ty->get();
       if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty))
         GEN_ERROR("Reference to abstract argument: " + Ty->getDescription());
@@ -3886,9 +4960,9 @@
   if (!Attrs.empty())
     PAL = ParamAttrsList::get(Attrs);
 
-  FunctionType *FT = FunctionType::get(*yyvsp[-7].TypeVal, ParamTypeList, isVarArg, PAL);
+  FunctionType *FT = FunctionType::get(*(yyvsp[(2) - (9)].TypeVal), ParamTypeList, isVarArg, PAL);
   const PointerType *PFT = PointerType::get(FT);
-  delete yyvsp[-7].TypeVal;
+  delete (yyvsp[(2) - (9)].TypeVal);
 
   ValID ID;
   if (!FunctionName.empty()) {
@@ -3912,9 +4986,9 @@
       // error.
       GEN_ERROR("Overload of function '" + FunctionName + "' not permitted.");
     } else if (!CurFun.isDeclare && !Fn->isDeclaration()) {
-      // Neither the existing or the current function is a declaration and they
-      // have the same name and same type. Clearly this is a redefinition.
-      GEN_ERROR("Redefinition of function '" + FunctionName + "'");
+        // Neither the existing or the current function is a declaration and they
+        // have the same name and same type. Clearly this is a redefinition.
+        GEN_ERROR("Redefinition of function '" + FunctionName + "'");
     } if (Fn->isDeclaration()) {
       // Make sure to strip off any argument names so we can't get conflicts.
       for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
@@ -3937,26 +5011,26 @@
     Fn->setLinkage(CurFun.Linkage);
     Fn->setVisibility(CurFun.Visibility);
   }
-  Fn->setCallingConv(yyvsp[-8].UIntVal);
-  Fn->setAlignment(yyvsp[0].UIntVal);
-  if (yyvsp[-1].StrVal) {
-    Fn->setSection(yyvsp[-1].StrVal);
-    free(yyvsp[-1].StrVal);
+  Fn->setCallingConv((yyvsp[(1) - (9)].UIntVal));
+  Fn->setAlignment((yyvsp[(9) - (9)].UIntVal));
+  if ((yyvsp[(8) - (9)].StrVal)) {
+    Fn->setSection((yyvsp[(8) - (9)].StrVal));
+    free((yyvsp[(8) - (9)].StrVal));
   }
 
   // Add all of the arguments we parsed to the function...
-  if (yyvsp[-4].ArgList) {                     // Is null if empty...
+  if ((yyvsp[(5) - (9)].ArgList)) {                     // Is null if empty...
     if (isVarArg) {  // Nuke the last entry
-      assert(yyvsp[-4].ArgList->back().Ty->get() == Type::VoidTy && yyvsp[-4].ArgList->back().Name == 0 &&
+      assert((yyvsp[(5) - (9)].ArgList)->back().Ty->get() == Type::VoidTy && (yyvsp[(5) - (9)].ArgList)->back().Name == 0 &&
              "Not a varargs marker!");
-      delete yyvsp[-4].ArgList->back().Ty;
-      yyvsp[-4].ArgList->pop_back();  // Delete the last entry
+      delete (yyvsp[(5) - (9)].ArgList)->back().Ty;
+      (yyvsp[(5) - (9)].ArgList)->pop_back();  // Delete the last entry
     }
     Function::arg_iterator ArgIt = Fn->arg_begin();
     Function::arg_iterator ArgEnd = Fn->arg_end();
     unsigned Idx = 1;
-    for (ArgListType::iterator I = yyvsp[-4].ArgList->begin(); 
-         I != yyvsp[-4].ArgList->end() && ArgIt != ArgEnd; ++I, ++ArgIt) {
+    for (ArgListType::iterator I = (yyvsp[(5) - (9)].ArgList)->begin(); 
+         I != (yyvsp[(5) - (9)].ArgList)->end() && ArgIt != ArgEnd; ++I, ++ArgIt) {
       delete I->Ty;                          // Delete the typeholder...
       setValueName(ArgIt, I->Name);          // Insert arg into symtab...
       CHECK_FOR_ERROR
@@ -3964,114 +5038,128 @@
       Idx++;
     }
 
-    delete yyvsp[-4].ArgList;                     // We're now done with the argument list
+    delete (yyvsp[(5) - (9)].ArgList);                     // We're now done with the argument list
   }
   CHECK_FOR_ERROR
-;
-    break;}
-case 213:
-#line 2258 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-  yyval.FunctionVal = CurFun.CurrentFunction;
+;}
+    break;
+
+  case 220:
+#line 2296 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+  (yyval.FunctionVal) = CurFun.CurrentFunction;
 
   // Make sure that we keep track of the linkage type even if there was a
   // previous "declare".
-  yyval.FunctionVal->setLinkage(yyvsp[-3].Linkage);
-  yyval.FunctionVal->setVisibility(yyvsp[-2].Visibility);
-;
-    break;}
-case 216:
-#line 2269 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-  yyval.FunctionVal = yyvsp[-1].FunctionVal;
+  (yyval.FunctionVal)->setLinkage((yyvsp[(1) - (4)].Linkage));
+  (yyval.FunctionVal)->setVisibility((yyvsp[(2) - (4)].Visibility));
+;}
+    break;
+
+  case 223:
+#line 2307 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+  (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal);
   CHECK_FOR_ERROR
-;
-    break;}
-case 217:
-#line 2274 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    CurFun.CurrentFunction->setLinkage(yyvsp[-2].Linkage);
-    CurFun.CurrentFunction->setVisibility(yyvsp[-1].Visibility);
-    yyval.FunctionVal = CurFun.CurrentFunction;
+;}
+    break;
+
+  case 224:
+#line 2312 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    CurFun.CurrentFunction->setLinkage((yyvsp[(1) - (3)].Linkage));
+    CurFun.CurrentFunction->setVisibility((yyvsp[(2) - (3)].Visibility));
+    (yyval.FunctionVal) = CurFun.CurrentFunction;
     CurFun.FunctionDone();
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 218:
-#line 2286 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.BoolVal = false;
+  ;}
+    break;
+
+  case 225:
+#line 2324 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.BoolVal) = false;
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 219:
-#line 2290 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.BoolVal = true;
+  ;}
+    break;
+
+  case 226:
+#line 2328 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.BoolVal) = true;
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 220:
-#line 2295 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{    // A reference to a direct constant
-    yyval.ValIDVal = ValID::create(yyvsp[0].SInt64Val);
+  ;}
+    break;
+
+  case 227:
+#line 2333 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {    // A reference to a direct constant
+    (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].SInt64Val));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 221:
-#line 2299 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ValIDVal = ValID::create(yyvsp[0].UInt64Val);
+  ;}
+    break;
+
+  case 228:
+#line 2337 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].UInt64Val));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 222:
-#line 2303 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{                     // Perhaps it's an FP constant?
-    yyval.ValIDVal = ValID::create(yyvsp[0].FPVal);
+  ;}
+    break;
+
+  case 229:
+#line 2341 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {                     // Perhaps it's an FP constant?
+    (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].FPVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 223:
-#line 2307 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ValIDVal = ValID::create(ConstantInt::getTrue());
+  ;}
+    break;
+
+  case 230:
+#line 2345 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ValIDVal) = ValID::create(ConstantInt::getTrue());
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 224:
-#line 2311 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ValIDVal = ValID::create(ConstantInt::getFalse());
+  ;}
+    break;
+
+  case 231:
+#line 2349 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ValIDVal) = ValID::create(ConstantInt::getFalse());
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 225:
-#line 2315 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ValIDVal = ValID::createNull();
+  ;}
+    break;
+
+  case 232:
+#line 2353 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ValIDVal) = ValID::createNull();
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 226:
-#line 2319 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ValIDVal = ValID::createUndef();
+  ;}
+    break;
+
+  case 233:
+#line 2357 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ValIDVal) = ValID::createUndef();
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 227:
-#line 2323 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{     // A vector zero constant.
-    yyval.ValIDVal = ValID::createZeroInit();
+  ;}
+    break;
+
+  case 234:
+#line 2361 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {     // A vector zero constant.
+    (yyval.ValIDVal) = ValID::createZeroInit();
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 228:
-#line 2327 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ // Nonempty unsized packed vector
-    const Type *ETy = (*yyvsp[-1].ConstVector)[0]->getType();
-    int NumElements = yyvsp[-1].ConstVector->size(); 
+  ;}
+    break;
+
+  case 235:
+#line 2365 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { // Nonempty unsized packed vector
+    const Type *ETy = (*(yyvsp[(2) - (3)].ConstVector))[0]->getType();
+    int NumElements = (yyvsp[(2) - (3)].ConstVector)->size(); 
     
     VectorType* pt = VectorType::get(ETy, NumElements);
     PATypeHolder* PTy = new PATypeHolder(
@@ -4083,213 +5171,233 @@
                                          );
     
     // Verify all elements are correct type!
-    for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) {
-      if (ETy != (*yyvsp[-1].ConstVector)[i]->getType())
+    for (unsigned i = 0; i < (yyvsp[(2) - (3)].ConstVector)->size(); i++) {
+      if (ETy != (*(yyvsp[(2) - (3)].ConstVector))[i]->getType())
         GEN_ERROR("Element #" + utostr(i) + " is not of type '" + 
                      ETy->getDescription() +"' as required!\nIt is of type '" +
-                     (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'.");
+                     (*(yyvsp[(2) - (3)].ConstVector))[i]->getType()->getDescription() + "'.");
     }
 
-    yyval.ValIDVal = ValID::create(ConstantVector::get(pt, *yyvsp[-1].ConstVector));
-    delete PTy; delete yyvsp[-1].ConstVector;
+    (yyval.ValIDVal) = ValID::create(ConstantVector::get(pt, *(yyvsp[(2) - (3)].ConstVector)));
+    delete PTy; delete (yyvsp[(2) - (3)].ConstVector);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 229:
-#line 2352 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ValIDVal = ValID::create(yyvsp[0].ConstVal);
+  ;}
+    break;
+
+  case 236:
+#line 2390 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].ConstVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 230:
-#line 2356 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    char *End = UnEscapeLexed(yyvsp[-2].StrVal, true);
-    std::string AsmStr = std::string(yyvsp[-2].StrVal, End);
-    End = UnEscapeLexed(yyvsp[0].StrVal, true);
-    std::string Constraints = std::string(yyvsp[0].StrVal, End);
-    yyval.ValIDVal = ValID::createInlineAsm(AsmStr, Constraints, yyvsp[-3].BoolVal);
-    free(yyvsp[-2].StrVal);
-    free(yyvsp[0].StrVal);
+  ;}
+    break;
+
+  case 237:
+#line 2394 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    char *End = UnEscapeLexed((yyvsp[(3) - (5)].StrVal), true);
+    std::string AsmStr = std::string((yyvsp[(3) - (5)].StrVal), End);
+    End = UnEscapeLexed((yyvsp[(5) - (5)].StrVal), true);
+    std::string Constraints = std::string((yyvsp[(5) - (5)].StrVal), End);
+    (yyval.ValIDVal) = ValID::createInlineAsm(AsmStr, Constraints, (yyvsp[(2) - (5)].BoolVal));
+    free((yyvsp[(3) - (5)].StrVal));
+    free((yyvsp[(5) - (5)].StrVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 231:
-#line 2370 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{  // Is it an integer reference...?
-    yyval.ValIDVal = ValID::createLocalID(yyvsp[0].UIntVal);
+  ;}
+    break;
+
+  case 238:
+#line 2408 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {  // Is it an integer reference...?
+    (yyval.ValIDVal) = ValID::createLocalID((yyvsp[(1) - (1)].UIntVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 232:
-#line 2374 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ValIDVal = ValID::createGlobalID(yyvsp[0].UIntVal);
+  ;}
+    break;
+
+  case 239:
+#line 2412 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ValIDVal) = ValID::createGlobalID((yyvsp[(1) - (1)].UIntVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 233:
-#line 2378 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{                   // Is it a named reference...?
-    yyval.ValIDVal = ValID::createLocalName(yyvsp[0].StrVal);
+  ;}
+    break;
+
+  case 240:
+#line 2416 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {                   // Is it a named reference...?
+    (yyval.ValIDVal) = ValID::createLocalName((yyvsp[(1) - (1)].StrVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 234:
-#line 2382 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{                   // Is it a named reference...?
-    yyval.ValIDVal = ValID::createGlobalName(yyvsp[0].StrVal);
+  ;}
+    break;
+
+  case 241:
+#line 2420 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {                   // Is it a named reference...?
+    (yyval.ValIDVal) = ValID::createGlobalName((yyvsp[(1) - (1)].StrVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 237:
-#line 2394 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 244:
+#line 2432 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    yyval.ValueVal = getVal(*yyvsp[-1].TypeVal, yyvsp[0].ValIDVal); 
-    delete yyvsp[-1].TypeVal;
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
+    (yyval.ValueVal) = getVal(*(yyvsp[(1) - (2)].TypeVal), (yyvsp[(2) - (2)].ValIDVal)); 
+    delete (yyvsp[(1) - (2)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 238:
-#line 2403 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.FunctionVal = yyvsp[-1].FunctionVal;
+  ;}
+    break;
+
+  case 245:
+#line 2441 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 239:
-#line 2407 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ // Do not allow functions with 0 basic blocks   
-    yyval.FunctionVal = yyvsp[-1].FunctionVal;
+  ;}
+    break;
+
+  case 246:
+#line 2445 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { // Do not allow functions with 0 basic blocks   
+    (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 240:
-#line 2416 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    setValueName(yyvsp[0].TermInstVal, yyvsp[-1].StrVal);
+  ;}
+    break;
+
+  case 247:
+#line 2454 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    setValueName((yyvsp[(3) - (3)].TermInstVal), (yyvsp[(2) - (3)].StrVal));
     CHECK_FOR_ERROR
-    InsertValue(yyvsp[0].TermInstVal);
-    yyvsp[-2].BasicBlockVal->getInstList().push_back(yyvsp[0].TermInstVal);
-    yyval.BasicBlockVal = yyvsp[-2].BasicBlockVal;
+    InsertValue((yyvsp[(3) - (3)].TermInstVal));
+    (yyvsp[(1) - (3)].BasicBlockVal)->getInstList().push_back((yyvsp[(3) - (3)].TermInstVal));
+    (yyval.BasicBlockVal) = (yyvsp[(1) - (3)].BasicBlockVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 241:
-#line 2425 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (CastInst *CI1 = dyn_cast<CastInst>(yyvsp[0].InstVal))
+  ;}
+    break;
+
+  case 248:
+#line 2463 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if (CastInst *CI1 = dyn_cast<CastInst>((yyvsp[(2) - (2)].InstVal)))
       if (CastInst *CI2 = dyn_cast<CastInst>(CI1->getOperand(0)))
         if (CI2->getParent() == 0)
-          yyvsp[-1].BasicBlockVal->getInstList().push_back(CI2);
-    yyvsp[-1].BasicBlockVal->getInstList().push_back(yyvsp[0].InstVal);
-    yyval.BasicBlockVal = yyvsp[-1].BasicBlockVal;
+          (yyvsp[(1) - (2)].BasicBlockVal)->getInstList().push_back(CI2);
+    (yyvsp[(1) - (2)].BasicBlockVal)->getInstList().push_back((yyvsp[(2) - (2)].InstVal));
+    (yyval.BasicBlockVal) = (yyvsp[(1) - (2)].BasicBlockVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 242:
-#line 2434 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{          // Empty space between instruction lists
-    yyval.BasicBlockVal = defineBBVal(ValID::createLocalID(CurFun.NextValNum));
-    CHECK_FOR_ERROR
-  ;
-    break;}
-case 243:
-#line 2438 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{             // Labelled (named) basic block
-    yyval.BasicBlockVal = defineBBVal(ValID::createLocalName(yyvsp[0].StrVal));
-    CHECK_FOR_ERROR
-  ;
-    break;}
-case 244:
-#line 2443 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{              // Return with a result...
-    yyval.TermInstVal = new ReturnInst(yyvsp[0].ValueVal);
-    CHECK_FOR_ERROR
-  ;
-    break;}
-case 245:
-#line 2447 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{                                    // Return with no result...
-    yyval.TermInstVal = new ReturnInst();
-    CHECK_FOR_ERROR
-  ;
-    break;}
-case 246:
-#line 2451 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{                           // Unconditional Branch...
-    BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
-    CHECK_FOR_ERROR
-    yyval.TermInstVal = new BranchInst(tmpBB);
-  ;
-    break;}
-case 247:
-#line 2456 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{  
-    assert(cast<IntegerType>(yyvsp[-7].PrimType)->getBitWidth() == 1 && "Not Bool?");
-    BasicBlock* tmpBBA = getBBVal(yyvsp[-3].ValIDVal);
-    CHECK_FOR_ERROR
-    BasicBlock* tmpBBB = getBBVal(yyvsp[0].ValIDVal);
-    CHECK_FOR_ERROR
-    Value* tmpVal = getVal(Type::Int1Ty, yyvsp[-6].ValIDVal);
-    CHECK_FOR_ERROR
-    yyval.TermInstVal = new BranchInst(tmpBBA, tmpBBB, tmpVal);
-  ;
-    break;}
-case 248:
-#line 2466 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    Value* tmpVal = getVal(yyvsp[-7].PrimType, yyvsp[-6].ValIDVal);
-    CHECK_FOR_ERROR
-    BasicBlock* tmpBB = getBBVal(yyvsp[-3].ValIDVal);
-    CHECK_FOR_ERROR
-    SwitchInst *S = new SwitchInst(tmpVal, tmpBB, yyvsp[-1].JumpTable->size());
-    yyval.TermInstVal = S;
+  ;}
+    break;
 
-    std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = yyvsp[-1].JumpTable->begin(),
-      E = yyvsp[-1].JumpTable->end();
+  case 249:
+#line 2472 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {          // Empty space between instruction lists
+    (yyval.BasicBlockVal) = defineBBVal(ValID::createLocalID(CurFun.NextValNum));
+    CHECK_FOR_ERROR
+  ;}
+    break;
+
+  case 250:
+#line 2476 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {             // Labelled (named) basic block
+    (yyval.BasicBlockVal) = defineBBVal(ValID::createLocalName((yyvsp[(1) - (1)].StrVal)));
+    CHECK_FOR_ERROR
+  ;}
+    break;
+
+  case 251:
+#line 2481 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {              // Return with a result...
+    (yyval.TermInstVal) = new ReturnInst((yyvsp[(2) - (2)].ValueVal));
+    CHECK_FOR_ERROR
+  ;}
+    break;
+
+  case 252:
+#line 2485 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {                                    // Return with no result...
+    (yyval.TermInstVal) = new ReturnInst();
+    CHECK_FOR_ERROR
+  ;}
+    break;
+
+  case 253:
+#line 2489 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {                           // Unconditional Branch...
+    BasicBlock* tmpBB = getBBVal((yyvsp[(3) - (3)].ValIDVal));
+    CHECK_FOR_ERROR
+    (yyval.TermInstVal) = new BranchInst(tmpBB);
+  ;}
+    break;
+
+  case 254:
+#line 2494 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {  
+    assert(cast<IntegerType>((yyvsp[(2) - (9)].PrimType))->getBitWidth() == 1 && "Not Bool?");
+    BasicBlock* tmpBBA = getBBVal((yyvsp[(6) - (9)].ValIDVal));
+    CHECK_FOR_ERROR
+    BasicBlock* tmpBBB = getBBVal((yyvsp[(9) - (9)].ValIDVal));
+    CHECK_FOR_ERROR
+    Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[(3) - (9)].ValIDVal));
+    CHECK_FOR_ERROR
+    (yyval.TermInstVal) = new BranchInst(tmpBBA, tmpBBB, tmpVal);
+  ;}
+    break;
+
+  case 255:
+#line 2504 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    Value* tmpVal = getVal((yyvsp[(2) - (9)].PrimType), (yyvsp[(3) - (9)].ValIDVal));
+    CHECK_FOR_ERROR
+    BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (9)].ValIDVal));
+    CHECK_FOR_ERROR
+    SwitchInst *S = new SwitchInst(tmpVal, tmpBB, (yyvsp[(8) - (9)].JumpTable)->size());
+    (yyval.TermInstVal) = S;
+
+    std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = (yyvsp[(8) - (9)].JumpTable)->begin(),
+      E = (yyvsp[(8) - (9)].JumpTable)->end();
     for (; I != E; ++I) {
       if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
           S->addCase(CI, I->second);
       else
         GEN_ERROR("Switch case is constant, but not a simple integer");
     }
-    delete yyvsp[-1].JumpTable;
+    delete (yyvsp[(8) - (9)].JumpTable);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 249:
-#line 2485 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    Value* tmpVal = getVal(yyvsp[-6].PrimType, yyvsp[-5].ValIDVal);
+  ;}
+    break;
+
+  case 256:
+#line 2523 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    Value* tmpVal = getVal((yyvsp[(2) - (8)].PrimType), (yyvsp[(3) - (8)].ValIDVal));
     CHECK_FOR_ERROR
-    BasicBlock* tmpBB = getBBVal(yyvsp[-2].ValIDVal);
+    BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (8)].ValIDVal));
     CHECK_FOR_ERROR
     SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
-    yyval.TermInstVal = S;
+    (yyval.TermInstVal) = S;
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 250:
-#line 2495 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 257:
+#line 2533 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
 
     // Handle the short syntax
     const PointerType *PFTy = 0;
     const FunctionType *Ty = 0;
-    if (!(PFTy = dyn_cast<PointerType>(yyvsp[-11].TypeVal->get())) ||
+    if (!(PFTy = dyn_cast<PointerType>((yyvsp[(3) - (14)].TypeVal)->get())) ||
         !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
       // Pull out the types of all of the arguments...
       std::vector<const Type*> ParamTypes;
       ParamAttrsVector Attrs;
-      if (yyvsp[-6].ParamAttrs != ParamAttr::None) {
+      if ((yyvsp[(8) - (14)].ParamAttrs) != ParamAttr::None) {
         ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = 8;
         Attrs.push_back(PAWI);
       }
-      ValueRefList::iterator I = yyvsp[-8].ValueRefList->begin(), E = yyvsp[-8].ValueRefList->end();
+      ValueRefList::iterator I = (yyvsp[(6) - (14)].ValueRefList)->begin(), E = (yyvsp[(6) - (14)].ValueRefList)->end();
       unsigned index = 1;
       for (; I != E; ++I, ++index) {
         const Type *Ty = I->Val->getType();
@@ -4305,22 +5413,22 @@
       ParamAttrsList *PAL = 0;
       if (!Attrs.empty())
         PAL = ParamAttrsList::get(Attrs);
-      Ty = FunctionType::get(yyvsp[-11].TypeVal->get(), ParamTypes, false, PAL);
+      Ty = FunctionType::get((yyvsp[(3) - (14)].TypeVal)->get(), ParamTypes, false, PAL);
       PFTy = PointerType::get(Ty);
     }
 
-    delete yyvsp[-11].TypeVal;
+    delete (yyvsp[(3) - (14)].TypeVal);
 
-    Value *V = getVal(PFTy, yyvsp[-10].ValIDVal);   // Get the function we're calling...
+    Value *V = getVal(PFTy, (yyvsp[(4) - (14)].ValIDVal));   // Get the function we're calling...
     CHECK_FOR_ERROR
-    BasicBlock *Normal = getBBVal(yyvsp[-3].ValIDVal);
+    BasicBlock *Normal = getBBVal((yyvsp[(11) - (14)].ValIDVal));
     CHECK_FOR_ERROR
-    BasicBlock *Except = getBBVal(yyvsp[0].ValIDVal);
+    BasicBlock *Except = getBBVal((yyvsp[(14) - (14)].ValIDVal));
     CHECK_FOR_ERROR
 
     // Check the arguments
     ValueList Args;
-    if (yyvsp[-8].ValueRefList->empty()) {                                   // Has no arguments?
+    if ((yyvsp[(6) - (14)].ValueRefList)->empty()) {                                   // Has no arguments?
       // Make sure no arguments is a good thing!
       if (Ty->getNumParams() != 0)
         GEN_ERROR("No arguments passed to a function that "
@@ -4330,7 +5438,7 @@
       // correctly!
       FunctionType::param_iterator I = Ty->param_begin();
       FunctionType::param_iterator E = Ty->param_end();
-      ValueRefList::iterator ArgI = yyvsp[-8].ValueRefList->begin(), ArgE = yyvsp[-8].ValueRefList->end();
+      ValueRefList::iterator ArgI = (yyvsp[(6) - (14)].ValueRefList)->begin(), ArgE = (yyvsp[(6) - (14)].ValueRefList)->end();
 
       for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
         if (ArgI->Val->getType() != *I)
@@ -4349,322 +5457,348 @@
 
     // Create the InvokeInst
     InvokeInst *II = new InvokeInst(V, Normal, Except, &Args[0], Args.size());
-    II->setCallingConv(yyvsp[-12].UIntVal);
-    yyval.TermInstVal = II;
-    delete yyvsp[-8].ValueRefList;
+    II->setCallingConv((yyvsp[(2) - (14)].UIntVal));
+    (yyval.TermInstVal) = II;
+    delete (yyvsp[(6) - (14)].ValueRefList);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 251:
-#line 2574 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.TermInstVal = new UnwindInst();
+  ;}
+    break;
+
+  case 258:
+#line 2612 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.TermInstVal) = new UnwindInst();
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 252:
-#line 2578 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.TermInstVal = new UnreachableInst();
+  ;}
+    break;
+
+  case 259:
+#line 2616 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.TermInstVal) = new UnreachableInst();
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 253:
-#line 2585 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.JumpTable = yyvsp[-5].JumpTable;
-    Constant *V = cast<Constant>(getExistingVal(yyvsp[-4].PrimType, yyvsp[-3].ValIDVal));
+  ;}
+    break;
+
+  case 260:
+#line 2623 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.JumpTable) = (yyvsp[(1) - (6)].JumpTable);
+    Constant *V = cast<Constant>(getExistingVal((yyvsp[(2) - (6)].PrimType), (yyvsp[(3) - (6)].ValIDVal)));
     CHECK_FOR_ERROR
     if (V == 0)
       GEN_ERROR("May only switch on a constant pool value");
 
-    BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
+    BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (6)].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.JumpTable->push_back(std::make_pair(V, tmpBB));
-  ;
-    break;}
-case 254:
-#line 2596 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.JumpTable = new std::vector<std::pair<Constant*, BasicBlock*> >();
-    Constant *V = cast<Constant>(getExistingVal(yyvsp[-4].PrimType, yyvsp[-3].ValIDVal));
+    (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
+  ;}
+    break;
+
+  case 261:
+#line 2634 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.JumpTable) = new std::vector<std::pair<Constant*, BasicBlock*> >();
+    Constant *V = cast<Constant>(getExistingVal((yyvsp[(1) - (5)].PrimType), (yyvsp[(2) - (5)].ValIDVal)));
     CHECK_FOR_ERROR
 
     if (V == 0)
       GEN_ERROR("May only switch on a constant pool value");
 
-    BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
+    BasicBlock* tmpBB = getBBVal((yyvsp[(5) - (5)].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.JumpTable->push_back(std::make_pair(V, tmpBB)); 
-  ;
-    break;}
-case 255:
-#line 2609 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+    (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB)); 
+  ;}
+    break;
+
+  case 262:
+#line 2647 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     // Is this definition named?? if so, assign the name...
-    setValueName(yyvsp[0].InstVal, yyvsp[-1].StrVal);
+    setValueName((yyvsp[(2) - (2)].InstVal), (yyvsp[(1) - (2)].StrVal));
     CHECK_FOR_ERROR
-    InsertValue(yyvsp[0].InstVal);
-    yyval.InstVal = yyvsp[0].InstVal;
+    InsertValue((yyvsp[(2) - (2)].InstVal));
+    (yyval.InstVal) = (yyvsp[(2) - (2)].InstVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 256:
-#line 2619 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{    // Used for PHI nodes
+  ;}
+    break;
+
+  case 263:
+#line 2657 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {    // Used for PHI nodes
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-5].TypeVal)->getDescription());
-    yyval.PHIList = new std::list<std::pair<Value*, BasicBlock*> >();
-    Value* tmpVal = getVal(*yyvsp[-5].TypeVal, yyvsp[-3].ValIDVal);
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (6)].TypeVal))->getDescription());
+    (yyval.PHIList) = new std::list<std::pair<Value*, BasicBlock*> >();
+    Value* tmpVal = getVal(*(yyvsp[(1) - (6)].TypeVal), (yyvsp[(3) - (6)].ValIDVal));
     CHECK_FOR_ERROR
-    BasicBlock* tmpBB = getBBVal(yyvsp[-1].ValIDVal);
+    BasicBlock* tmpBB = getBBVal((yyvsp[(5) - (6)].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.PHIList->push_back(std::make_pair(tmpVal, tmpBB));
-    delete yyvsp[-5].TypeVal;
-  ;
-    break;}
-case 257:
-#line 2630 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.PHIList = yyvsp[-6].PHIList;
-    Value* tmpVal = getVal(yyvsp[-6].PHIList->front().first->getType(), yyvsp[-3].ValIDVal);
+    (yyval.PHIList)->push_back(std::make_pair(tmpVal, tmpBB));
+    delete (yyvsp[(1) - (6)].TypeVal);
+  ;}
+    break;
+
+  case 264:
+#line 2668 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.PHIList) = (yyvsp[(1) - (7)].PHIList);
+    Value* tmpVal = getVal((yyvsp[(1) - (7)].PHIList)->front().first->getType(), (yyvsp[(4) - (7)].ValIDVal));
     CHECK_FOR_ERROR
-    BasicBlock* tmpBB = getBBVal(yyvsp[-1].ValIDVal);
+    BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (7)].ValIDVal));
     CHECK_FOR_ERROR
-    yyvsp[-6].PHIList->push_back(std::make_pair(tmpVal, tmpBB));
-  ;
-    break;}
-case 258:
-#line 2640 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{    
+    (yyvsp[(1) - (7)].PHIList)->push_back(std::make_pair(tmpVal, tmpBB));
+  ;}
+    break;
+
+  case 265:
+#line 2678 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {    
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription());
     // Used for call and invoke instructions
-    yyval.ValueRefList = new ValueRefList();
-    ValueRefListEntry E; E.Attrs = yyvsp[0].ParamAttrs; E.Val = getVal(yyvsp[-2].TypeVal->get(), yyvsp[-1].ValIDVal);
-    yyval.ValueRefList->push_back(E);
-    delete yyvsp[-2].TypeVal;
-  ;
-    break;}
-case 259:
-#line 2649 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+    (yyval.ValueRefList) = new ValueRefList();
+    ValueRefListEntry E; E.Attrs = (yyvsp[(3) - (3)].ParamAttrs); E.Val = getVal((yyvsp[(1) - (3)].TypeVal)->get(), (yyvsp[(2) - (3)].ValIDVal));
+    (yyval.ValueRefList)->push_back(E);
+    delete (yyvsp[(1) - (3)].TypeVal);
+  ;}
+    break;
+
+  case 266:
+#line 2687 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    yyval.ValueRefList = yyvsp[-4].ValueRefList;
-    ValueRefListEntry E; E.Attrs = yyvsp[0].ParamAttrs; E.Val = getVal(yyvsp[-2].TypeVal->get(), yyvsp[-1].ValIDVal);
-    yyval.ValueRefList->push_back(E);
-    delete yyvsp[-2].TypeVal;
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (5)].TypeVal))->getDescription());
+    (yyval.ValueRefList) = (yyvsp[(1) - (5)].ValueRefList);
+    ValueRefListEntry E; E.Attrs = (yyvsp[(5) - (5)].ParamAttrs); E.Val = getVal((yyvsp[(3) - (5)].TypeVal)->get(), (yyvsp[(4) - (5)].ValIDVal));
+    (yyval.ValueRefList)->push_back(E);
+    delete (yyvsp[(3) - (5)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 260:
-#line 2658 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.ValueRefList = new ValueRefList(); ;
-    break;}
-case 261:
-#line 2661 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{ yyval.ValueList = new std::vector<Value*>(); ;
-    break;}
-case 262:
-#line 2662 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.ValueList = yyvsp[-2].ValueList;
-    yyval.ValueList->push_back(yyvsp[0].ValueVal);
+  ;}
+    break;
+
+  case 267:
+#line 2696 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ValueRefList) = new ValueRefList(); ;}
+    break;
+
+  case 268:
+#line 2699 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ValueList) = new std::vector<Value*>(); ;}
+    break;
+
+  case 269:
+#line 2700 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.ValueList) = (yyvsp[(1) - (3)].ValueList);
+    (yyval.ValueList)->push_back((yyvsp[(3) - (3)].ValueVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 263:
-#line 2669 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.BoolVal = true;
+  ;}
+    break;
+
+  case 270:
+#line 2707 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.BoolVal) = true;
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 264:
-#line 2673 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.BoolVal = false;
+  ;}
+    break;
+
+  case 271:
+#line 2711 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.BoolVal) = false;
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 265:
-#line 2678 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 272:
+#line 2716 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
-    if (!(*yyvsp[-3].TypeVal)->isInteger() && !(*yyvsp[-3].TypeVal)->isFloatingPoint() && 
-        !isa<VectorType>((*yyvsp[-3].TypeVal).get()))
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (5)].TypeVal))->getDescription());
+    if (!(*(yyvsp[(2) - (5)].TypeVal))->isInteger() && !(*(yyvsp[(2) - (5)].TypeVal))->isFloatingPoint() && 
+        !isa<VectorType>((*(yyvsp[(2) - (5)].TypeVal)).get()))
       GEN_ERROR(
         "Arithmetic operator requires integer, FP, or packed operands");
-    if (isa<VectorType>((*yyvsp[-3].TypeVal).get()) && 
-        (yyvsp[-4].BinaryOpVal == Instruction::URem || 
-         yyvsp[-4].BinaryOpVal == Instruction::SRem ||
-         yyvsp[-4].BinaryOpVal == Instruction::FRem))
+    if (isa<VectorType>((*(yyvsp[(2) - (5)].TypeVal)).get()) && 
+        ((yyvsp[(1) - (5)].BinaryOpVal) == Instruction::URem || 
+         (yyvsp[(1) - (5)].BinaryOpVal) == Instruction::SRem ||
+         (yyvsp[(1) - (5)].BinaryOpVal) == Instruction::FRem))
       GEN_ERROR("Remainder not supported on vector types");
-    Value* val1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal); 
+    Value* val1 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(3) - (5)].ValIDVal)); 
     CHECK_FOR_ERROR
-    Value* val2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
+    Value* val2 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(5) - (5)].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = BinaryOperator::create(yyvsp[-4].BinaryOpVal, val1, val2);
-    if (yyval.InstVal == 0)
+    (yyval.InstVal) = BinaryOperator::create((yyvsp[(1) - (5)].BinaryOpVal), val1, val2);
+    if ((yyval.InstVal) == 0)
       GEN_ERROR("binary operator returned null");
-    delete yyvsp[-3].TypeVal;
-  ;
-    break;}
-case 266:
-#line 2699 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+    delete (yyvsp[(2) - (5)].TypeVal);
+  ;}
+    break;
+
+  case 273:
+#line 2737 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
-    if (!(*yyvsp[-3].TypeVal)->isInteger()) {
-      if (Instruction::isShift(yyvsp[-4].BinaryOpVal) || !isa<VectorType>(yyvsp[-3].TypeVal->get()) ||
-          !cast<VectorType>(yyvsp[-3].TypeVal->get())->getElementType()->isInteger())
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (5)].TypeVal))->getDescription());
+    if (!(*(yyvsp[(2) - (5)].TypeVal))->isInteger()) {
+      if (Instruction::isShift((yyvsp[(1) - (5)].BinaryOpVal)) || !isa<VectorType>((yyvsp[(2) - (5)].TypeVal)->get()) ||
+          !cast<VectorType>((yyvsp[(2) - (5)].TypeVal)->get())->getElementType()->isInteger())
         GEN_ERROR("Logical operator requires integral operands");
     }
-    Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal);
+    Value* tmpVal1 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(3) - (5)].ValIDVal));
     CHECK_FOR_ERROR
-    Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
+    Value* tmpVal2 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(5) - (5)].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = BinaryOperator::create(yyvsp[-4].BinaryOpVal, tmpVal1, tmpVal2);
-    if (yyval.InstVal == 0)
+    (yyval.InstVal) = BinaryOperator::create((yyvsp[(1) - (5)].BinaryOpVal), tmpVal1, tmpVal2);
+    if ((yyval.InstVal) == 0)
       GEN_ERROR("binary operator returned null");
-    delete yyvsp[-3].TypeVal;
-  ;
-    break;}
-case 267:
-#line 2716 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+    delete (yyvsp[(2) - (5)].TypeVal);
+  ;}
+    break;
+
+  case 274:
+#line 2754 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
-    if (isa<VectorType>((*yyvsp[-3].TypeVal).get()))
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription());
+    if (isa<VectorType>((*(yyvsp[(3) - (6)].TypeVal)).get()))
       GEN_ERROR("Vector types not supported by icmp instruction");
-    Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal);
+    Value* tmpVal1 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(4) - (6)].ValIDVal));
     CHECK_FOR_ERROR
-    Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
+    Value* tmpVal2 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(6) - (6)].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = CmpInst::create(yyvsp[-5].OtherOpVal, yyvsp[-4].IPredicate, tmpVal1, tmpVal2);
-    if (yyval.InstVal == 0)
+    (yyval.InstVal) = CmpInst::create((yyvsp[(1) - (6)].OtherOpVal), (yyvsp[(2) - (6)].IPredicate), tmpVal1, tmpVal2);
+    if ((yyval.InstVal) == 0)
       GEN_ERROR("icmp operator returned null");
-    delete yyvsp[-3].TypeVal;
-  ;
-    break;}
-case 268:
-#line 2730 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+    delete (yyvsp[(3) - (6)].TypeVal);
+  ;}
+    break;
+
+  case 275:
+#line 2768 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
-    if (isa<VectorType>((*yyvsp[-3].TypeVal).get()))
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription());
+    if (isa<VectorType>((*(yyvsp[(3) - (6)].TypeVal)).get()))
       GEN_ERROR("Vector types not supported by fcmp instruction");
-    Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal);
+    Value* tmpVal1 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(4) - (6)].ValIDVal));
     CHECK_FOR_ERROR
-    Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
+    Value* tmpVal2 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(6) - (6)].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = CmpInst::create(yyvsp[-5].OtherOpVal, yyvsp[-4].FPredicate, tmpVal1, tmpVal2);
-    if (yyval.InstVal == 0)
+    (yyval.InstVal) = CmpInst::create((yyvsp[(1) - (6)].OtherOpVal), (yyvsp[(2) - (6)].FPredicate), tmpVal1, tmpVal2);
+    if ((yyval.InstVal) == 0)
       GEN_ERROR("fcmp operator returned null");
-    delete yyvsp[-3].TypeVal;
-  ;
-    break;}
-case 269:
-#line 2744 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+    delete (yyvsp[(3) - (6)].TypeVal);
+  ;}
+    break;
+
+  case 276:
+#line 2782 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
-    Value* Val = yyvsp[-2].ValueVal;
-    const Type* DestTy = yyvsp[0].TypeVal->get();
-    if (!CastInst::castIsValid(yyvsp[-3].CastOpVal, Val, DestTy))
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(4) - (4)].TypeVal))->getDescription());
+    Value* Val = (yyvsp[(2) - (4)].ValueVal);
+    const Type* DestTy = (yyvsp[(4) - (4)].TypeVal)->get();
+    if (!CastInst::castIsValid((yyvsp[(1) - (4)].CastOpVal), Val, DestTy))
       GEN_ERROR("invalid cast opcode for cast from '" +
                 Val->getType()->getDescription() + "' to '" +
                 DestTy->getDescription() + "'"); 
-    yyval.InstVal = CastInst::create(yyvsp[-3].CastOpVal, Val, DestTy);
-    delete yyvsp[0].TypeVal;
-  ;
-    break;}
-case 270:
-#line 2756 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (yyvsp[-4].ValueVal->getType() != Type::Int1Ty)
+    (yyval.InstVal) = CastInst::create((yyvsp[(1) - (4)].CastOpVal), Val, DestTy);
+    delete (yyvsp[(4) - (4)].TypeVal);
+  ;}
+    break;
+
+  case 277:
+#line 2794 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if ((yyvsp[(2) - (6)].ValueVal)->getType() != Type::Int1Ty)
       GEN_ERROR("select condition must be boolean");
-    if (yyvsp[-2].ValueVal->getType() != yyvsp[0].ValueVal->getType())
+    if ((yyvsp[(4) - (6)].ValueVal)->getType() != (yyvsp[(6) - (6)].ValueVal)->getType())
       GEN_ERROR("select value types should match");
-    yyval.InstVal = new SelectInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
+    (yyval.InstVal) = new SelectInst((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 271:
-#line 2764 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 278:
+#line 2802 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
-    yyval.InstVal = new VAArgInst(yyvsp[-2].ValueVal, *yyvsp[0].TypeVal);
-    delete yyvsp[0].TypeVal;
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(4) - (4)].TypeVal))->getDescription());
+    (yyval.InstVal) = new VAArgInst((yyvsp[(2) - (4)].ValueVal), *(yyvsp[(4) - (4)].TypeVal));
+    delete (yyvsp[(4) - (4)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 272:
-#line 2771 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (!ExtractElementInst::isValidOperands(yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
+  ;}
+    break;
+
+  case 279:
+#line 2809 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if (!ExtractElementInst::isValidOperands((yyvsp[(2) - (4)].ValueVal), (yyvsp[(4) - (4)].ValueVal)))
       GEN_ERROR("Invalid extractelement operands");
-    yyval.InstVal = new ExtractElementInst(yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
+    (yyval.InstVal) = new ExtractElementInst((yyvsp[(2) - (4)].ValueVal), (yyvsp[(4) - (4)].ValueVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 273:
-#line 2777 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (!InsertElementInst::isValidOperands(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
+  ;}
+    break;
+
+  case 280:
+#line 2815 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if (!InsertElementInst::isValidOperands((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal)))
       GEN_ERROR("Invalid insertelement operands");
-    yyval.InstVal = new InsertElementInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
+    (yyval.InstVal) = new InsertElementInst((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 274:
-#line 2783 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (!ShuffleVectorInst::isValidOperands(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
+  ;}
+    break;
+
+  case 281:
+#line 2821 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if (!ShuffleVectorInst::isValidOperands((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal)))
       GEN_ERROR("Invalid shufflevector operands");
-    yyval.InstVal = new ShuffleVectorInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
+    (yyval.InstVal) = new ShuffleVectorInst((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 275:
-#line 2789 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    const Type *Ty = yyvsp[0].PHIList->front().first->getType();
+  ;}
+    break;
+
+  case 282:
+#line 2827 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    const Type *Ty = (yyvsp[(2) - (2)].PHIList)->front().first->getType();
     if (!Ty->isFirstClassType())
       GEN_ERROR("PHI node operands must be of first class type");
-    yyval.InstVal = new PHINode(Ty);
-    ((PHINode*)yyval.InstVal)->reserveOperandSpace(yyvsp[0].PHIList->size());
-    while (yyvsp[0].PHIList->begin() != yyvsp[0].PHIList->end()) {
-      if (yyvsp[0].PHIList->front().first->getType() != Ty) 
+    (yyval.InstVal) = new PHINode(Ty);
+    ((PHINode*)(yyval.InstVal))->reserveOperandSpace((yyvsp[(2) - (2)].PHIList)->size());
+    while ((yyvsp[(2) - (2)].PHIList)->begin() != (yyvsp[(2) - (2)].PHIList)->end()) {
+      if ((yyvsp[(2) - (2)].PHIList)->front().first->getType() != Ty) 
         GEN_ERROR("All elements of a PHI node must be of the same type");
-      cast<PHINode>(yyval.InstVal)->addIncoming(yyvsp[0].PHIList->front().first, yyvsp[0].PHIList->front().second);
-      yyvsp[0].PHIList->pop_front();
+      cast<PHINode>((yyval.InstVal))->addIncoming((yyvsp[(2) - (2)].PHIList)->front().first, (yyvsp[(2) - (2)].PHIList)->front().second);
+      (yyvsp[(2) - (2)].PHIList)->pop_front();
     }
-    delete yyvsp[0].PHIList;  // Free the list...
+    delete (yyvsp[(2) - (2)].PHIList);  // Free the list...
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 276:
-#line 2805 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 283:
+#line 2843 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
 
     // Handle the short syntax
     const PointerType *PFTy = 0;
     const FunctionType *Ty = 0;
-    if (!(PFTy = dyn_cast<PointerType>(yyvsp[-5].TypeVal->get())) ||
+    if (!(PFTy = dyn_cast<PointerType>((yyvsp[(3) - (8)].TypeVal)->get())) ||
         !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
       // Pull out the types of all of the arguments...
       std::vector<const Type*> ParamTypes;
       ParamAttrsVector Attrs;
-      if (yyvsp[0].ParamAttrs != ParamAttr::None) {
-        ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = yyvsp[0].ParamAttrs;
+      if ((yyvsp[(8) - (8)].ParamAttrs) != ParamAttr::None) {
+        ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = (yyvsp[(8) - (8)].ParamAttrs);
         Attrs.push_back(PAWI);
       }
       unsigned index = 1;
-      ValueRefList::iterator I = yyvsp[-2].ValueRefList->begin(), E = yyvsp[-2].ValueRefList->end();
+      ValueRefList::iterator I = (yyvsp[(6) - (8)].ValueRefList)->begin(), E = (yyvsp[(6) - (8)].ValueRefList)->end();
       for (; I != E; ++I, ++index) {
         const Type *Ty = I->Val->getType();
         if (Ty == Type::VoidTy)
@@ -4680,13 +5814,13 @@
       if (!Attrs.empty())
         PAL = ParamAttrsList::get(Attrs);
 
-      Ty = FunctionType::get(yyvsp[-5].TypeVal->get(), ParamTypes, false, PAL);
+      Ty = FunctionType::get((yyvsp[(3) - (8)].TypeVal)->get(), ParamTypes, false, PAL);
       PFTy = PointerType::get(Ty);
     }
-
-    Value *V = getVal(PFTy, yyvsp[-4].ValIDVal);   // Get the function we're calling...
+    
+    Value *V = getVal(PFTy, (yyvsp[(4) - (8)].ValIDVal));   // Get the function we're calling...
     CHECK_FOR_ERROR
-
+          
     // Check for call to invalid intrinsic to avoid crashing later.
     if (Function *theF = dyn_cast<Function>(V)) {
       if (theF->hasName() && (theF->getValueName()->getKeyLength() >= 5) &&
@@ -4698,7 +5832,7 @@
 
     // Check the arguments 
     ValueList Args;
-    if (yyvsp[-2].ValueRefList->empty()) {                                   // Has no arguments?
+    if ((yyvsp[(6) - (8)].ValueRefList)->empty()) {                                   // Has no arguments?
       // Make sure no arguments is a good thing!
       if (Ty->getNumParams() != 0)
         GEN_ERROR("No arguments passed to a function that "
@@ -4709,7 +5843,7 @@
       //
       FunctionType::param_iterator I = Ty->param_begin();
       FunctionType::param_iterator E = Ty->param_end();
-      ValueRefList::iterator ArgI = yyvsp[-2].ValueRefList->begin(), ArgE = yyvsp[-2].ValueRefList->end();
+      ValueRefList::iterator ArgI = (yyvsp[(6) - (8)].ValueRefList)->begin(), ArgE = (yyvsp[(6) - (8)].ValueRefList)->end();
 
       for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
         if (ArgI->Val->getType() != *I)
@@ -4726,365 +5860,371 @@
     }
     // Create the call node
     CallInst *CI = new CallInst(V, &Args[0], Args.size());
-    CI->setTailCall(yyvsp[-7].BoolVal);
-    CI->setCallingConv(yyvsp[-6].UIntVal);
-    yyval.InstVal = CI;
-    delete yyvsp[-2].ValueRefList;
-    delete yyvsp[-5].TypeVal;
+    CI->setTailCall((yyvsp[(1) - (8)].BoolVal));
+    CI->setCallingConv((yyvsp[(2) - (8)].UIntVal));
+    (yyval.InstVal) = CI;
+    delete (yyvsp[(6) - (8)].ValueRefList);
+    delete (yyvsp[(3) - (8)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 277:
-#line 2889 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.InstVal = yyvsp[0].InstVal;
+  ;}
+    break;
+
+  case 284:
+#line 2927 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.InstVal) = (yyvsp[(1) - (1)].InstVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 278:
-#line 2894 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.BoolVal = true;
+  ;}
+    break;
+
+  case 285:
+#line 2932 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.BoolVal) = true;
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 279:
-#line 2898 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    yyval.BoolVal = false;
+  ;}
+    break;
+
+  case 286:
+#line 2936 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.BoolVal) = false;
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 280:
-#line 2905 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 287:
+#line 2943 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    yyval.InstVal = new MallocInst(*yyvsp[-1].TypeVal, 0, yyvsp[0].UIntVal);
-    delete yyvsp[-1].TypeVal;
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (3)].TypeVal))->getDescription());
+    (yyval.InstVal) = new MallocInst(*(yyvsp[(2) - (3)].TypeVal), 0, (yyvsp[(3) - (3)].UIntVal));
+    delete (yyvsp[(2) - (3)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 281:
-#line 2912 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 288:
+#line 2950 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
-    Value* tmpVal = getVal(yyvsp[-2].PrimType, yyvsp[-1].ValIDVal);
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (6)].TypeVal))->getDescription());
+    Value* tmpVal = getVal((yyvsp[(4) - (6)].PrimType), (yyvsp[(5) - (6)].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = new MallocInst(*yyvsp[-4].TypeVal, tmpVal, yyvsp[0].UIntVal);
-    delete yyvsp[-4].TypeVal;
-  ;
-    break;}
-case 282:
-#line 2920 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+    (yyval.InstVal) = new MallocInst(*(yyvsp[(2) - (6)].TypeVal), tmpVal, (yyvsp[(6) - (6)].UIntVal));
+    delete (yyvsp[(2) - (6)].TypeVal);
+  ;}
+    break;
+
+  case 289:
+#line 2958 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    yyval.InstVal = new AllocaInst(*yyvsp[-1].TypeVal, 0, yyvsp[0].UIntVal);
-    delete yyvsp[-1].TypeVal;
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (3)].TypeVal))->getDescription());
+    (yyval.InstVal) = new AllocaInst(*(yyvsp[(2) - (3)].TypeVal), 0, (yyvsp[(3) - (3)].UIntVal));
+    delete (yyvsp[(2) - (3)].TypeVal);
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 283:
-#line 2927 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 290:
+#line 2965 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
-    Value* tmpVal = getVal(yyvsp[-2].PrimType, yyvsp[-1].ValIDVal);
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (6)].TypeVal))->getDescription());
+    Value* tmpVal = getVal((yyvsp[(4) - (6)].PrimType), (yyvsp[(5) - (6)].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = new AllocaInst(*yyvsp[-4].TypeVal, tmpVal, yyvsp[0].UIntVal);
-    delete yyvsp[-4].TypeVal;
-  ;
-    break;}
-case 284:
-#line 2935 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
-    if (!isa<PointerType>(yyvsp[0].ValueVal->getType()))
+    (yyval.InstVal) = new AllocaInst(*(yyvsp[(2) - (6)].TypeVal), tmpVal, (yyvsp[(6) - (6)].UIntVal));
+    delete (yyvsp[(2) - (6)].TypeVal);
+  ;}
+    break;
+
+  case 291:
+#line 2973 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
+    if (!isa<PointerType>((yyvsp[(2) - (2)].ValueVal)->getType()))
       GEN_ERROR("Trying to free nonpointer type " + 
-                     yyvsp[0].ValueVal->getType()->getDescription() + "");
-    yyval.InstVal = new FreeInst(yyvsp[0].ValueVal);
+                     (yyvsp[(2) - (2)].ValueVal)->getType()->getDescription() + "");
+    (yyval.InstVal) = new FreeInst((yyvsp[(2) - (2)].ValueVal));
     CHECK_FOR_ERROR
-  ;
-    break;}
-case 285:
-#line 2943 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+  ;}
+    break;
+
+  case 292:
+#line 2981 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    if (!isa<PointerType>(yyvsp[-2].TypeVal->get()))
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (5)].TypeVal))->getDescription());
+    if (!isa<PointerType>((yyvsp[(3) - (5)].TypeVal)->get()))
       GEN_ERROR("Can't load from nonpointer type: " +
-                     (*yyvsp[-2].TypeVal)->getDescription());
-    if (!cast<PointerType>(yyvsp[-2].TypeVal->get())->getElementType()->isFirstClassType())
+                     (*(yyvsp[(3) - (5)].TypeVal))->getDescription());
+    if (!cast<PointerType>((yyvsp[(3) - (5)].TypeVal)->get())->getElementType()->isFirstClassType())
       GEN_ERROR("Can't load from pointer of non-first-class type: " +
-                     (*yyvsp[-2].TypeVal)->getDescription());
-    Value* tmpVal = getVal(*yyvsp[-2].TypeVal, yyvsp[-1].ValIDVal);
+                     (*(yyvsp[(3) - (5)].TypeVal))->getDescription());
+    Value* tmpVal = getVal(*(yyvsp[(3) - (5)].TypeVal), (yyvsp[(4) - (5)].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = new LoadInst(tmpVal, "", yyvsp[-4].BoolVal, yyvsp[0].UIntVal);
-    delete yyvsp[-2].TypeVal;
-  ;
-    break;}
-case 286:
-#line 2957 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+    (yyval.InstVal) = new LoadInst(tmpVal, "", (yyvsp[(1) - (5)].BoolVal), (yyvsp[(5) - (5)].UIntVal));
+    delete (yyvsp[(3) - (5)].TypeVal);
+  ;}
+    break;
+
+  case 293:
+#line 2995 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    const PointerType *PT = dyn_cast<PointerType>(yyvsp[-2].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(5) - (7)].TypeVal))->getDescription());
+    const PointerType *PT = dyn_cast<PointerType>((yyvsp[(5) - (7)].TypeVal)->get());
     if (!PT)
       GEN_ERROR("Can't store to a nonpointer type: " +
-                     (*yyvsp[-2].TypeVal)->getDescription());
+                     (*(yyvsp[(5) - (7)].TypeVal))->getDescription());
     const Type *ElTy = PT->getElementType();
-    if (ElTy != yyvsp[-4].ValueVal->getType())
-      GEN_ERROR("Can't store '" + yyvsp[-4].ValueVal->getType()->getDescription() +
+    if (ElTy != (yyvsp[(3) - (7)].ValueVal)->getType())
+      GEN_ERROR("Can't store '" + (yyvsp[(3) - (7)].ValueVal)->getType()->getDescription() +
                      "' into space of type '" + ElTy->getDescription() + "'");
 
-    Value* tmpVal = getVal(*yyvsp[-2].TypeVal, yyvsp[-1].ValIDVal);
+    Value* tmpVal = getVal(*(yyvsp[(5) - (7)].TypeVal), (yyvsp[(6) - (7)].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = new StoreInst(yyvsp[-4].ValueVal, tmpVal, yyvsp[-6].BoolVal, yyvsp[0].UIntVal);
-    delete yyvsp[-2].TypeVal;
-  ;
-    break;}
-case 287:
-#line 2974 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
-{
+    (yyval.InstVal) = new StoreInst((yyvsp[(3) - (7)].ValueVal), tmpVal, (yyvsp[(1) - (7)].BoolVal), (yyvsp[(7) - (7)].UIntVal));
+    delete (yyvsp[(5) - (7)].TypeVal);
+  ;}
+    break;
+
+  case 294:
+#line 3012 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+    {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    if (!isa<PointerType>(yyvsp[-2].TypeVal->get()))
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (4)].TypeVal))->getDescription());
+    if (!isa<PointerType>((yyvsp[(2) - (4)].TypeVal)->get()))
       GEN_ERROR("getelementptr insn requires pointer operand");
 
-    if (!GetElementPtrInst::getIndexedType(*yyvsp[-2].TypeVal, &(*yyvsp[0].ValueList)[0], yyvsp[0].ValueList->size(), true))
+    if (!GetElementPtrInst::getIndexedType(*(yyvsp[(2) - (4)].TypeVal), &(*(yyvsp[(4) - (4)].ValueList))[0], (yyvsp[(4) - (4)].ValueList)->size(), true))
       GEN_ERROR("Invalid getelementptr indices for type '" +
-                     (*yyvsp[-2].TypeVal)->getDescription()+ "'");
-    Value* tmpVal = getVal(*yyvsp[-2].TypeVal, yyvsp[-1].ValIDVal);
+                     (*(yyvsp[(2) - (4)].TypeVal))->getDescription()+ "'");
+    Value* tmpVal = getVal(*(yyvsp[(2) - (4)].TypeVal), (yyvsp[(3) - (4)].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = new GetElementPtrInst(tmpVal, &(*yyvsp[0].ValueList)[0], yyvsp[0].ValueList->size());
-    delete yyvsp[-2].TypeVal; 
-    delete yyvsp[0].ValueList;
-  ;
-    break;}
-}
-   /* the action file gets copied in in place of this dollarsign */
-#line 543 "/usr/share/bison.simple"
-
-  yyvsp -= yylen;
-  yyssp -= yylen;
-#ifdef YYLSP_NEEDED
-  yylsp -= yylen;
-#endif
+    (yyval.InstVal) = new GetElementPtrInst(tmpVal, &(*(yyvsp[(4) - (4)].ValueList))[0], (yyvsp[(4) - (4)].ValueList)->size());
+    delete (yyvsp[(2) - (4)].TypeVal); 
+    delete (yyvsp[(4) - (4)].ValueList);
+  ;}
+    break;
 
-#if YYDEBUG != 0
-  if (yydebug)
-    {
-      short *ssp1 = yyss - 1;
-      fprintf (stderr, "state stack now");
-      while (ssp1 != yyssp)
-	fprintf (stderr, " %d", *++ssp1);
-      fprintf (stderr, "\n");
+
+/* Line 1267 of yacc.c.  */
+#line 6014 "llvmAsmParser.tab.c"
+      default: break;
     }
-#endif
+  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
 
   *++yyvsp = yyval;
 
-#ifdef YYLSP_NEEDED
-  yylsp++;
-  if (yylen == 0)
-    {
-      yylsp->first_line = yylloc.first_line;
-      yylsp->first_column = yylloc.first_column;
-      yylsp->last_line = (yylsp-1)->last_line;
-      yylsp->last_column = (yylsp-1)->last_column;
-      yylsp->text = 0;
-    }
-  else
-    {
-      yylsp->last_line = (yylsp+yylen-1)->last_line;
-      yylsp->last_column = (yylsp+yylen-1)->last_column;
-    }
-#endif
 
-  /* Now "shift" the result of the reduction.
-     Determine what state that goes to,
-     based on the state we popped back to
-     and the rule number reduced by.  */
+  /* Now `shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
 
   yyn = yyr1[yyn];
 
-  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
-  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
     yystate = yytable[yystate];
   else
-    yystate = yydefgoto[yyn - YYNTBASE];
+    yystate = yydefgoto[yyn - YYNTOKENS];
 
   goto yynewstate;
 
-yyerrlab:   /* here on detecting error */
 
-  if (! yyerrstatus)
-    /* If not already recovering from an error, report this error.  */
+/*------------------------------------.
+| yyerrlab -- here on detecting error |
+`------------------------------------*/
+yyerrlab:
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
     {
       ++yynerrs;
+#if ! YYERROR_VERBOSE
+      yyerror (YY_("syntax error"));
+#else
+      {
+	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
+	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
+	  {
+	    YYSIZE_T yyalloc = 2 * yysize;
+	    if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
+	      yyalloc = YYSTACK_ALLOC_MAXIMUM;
+	    if (yymsg != yymsgbuf)
+	      YYSTACK_FREE (yymsg);
+	    yymsg = (char *) YYSTACK_ALLOC (yyalloc);
+	    if (yymsg)
+	      yymsg_alloc = yyalloc;
+	    else
+	      {
+		yymsg = yymsgbuf;
+		yymsg_alloc = sizeof yymsgbuf;
+	      }
+	  }
 
-#ifdef YYERROR_VERBOSE
-      yyn = yypact[yystate];
-
-      if (yyn > YYFLAG && yyn < YYLAST)
-	{
-	  int size = 0;
-	  char *msg;
-	  int x, count;
-
-	  count = 0;
-	  /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
-	  for (x = (yyn < 0 ? -yyn : 0);
-	       x < (sizeof(yytname) / sizeof(char *)); x++)
-	    if (yycheck[x + yyn] == x)
-	      size += strlen(yytname[x]) + 15, count++;
-	  msg = (char *) malloc(size + 15);
-	  if (msg != 0)
-	    {
-	      strcpy(msg, "parse error");
-
-	      if (count < 5)
-		{
-		  count = 0;
-		  for (x = (yyn < 0 ? -yyn : 0);
-		       x < (sizeof(yytname) / sizeof(char *)); x++)
-		    if (yycheck[x + yyn] == x)
-		      {
-			strcat(msg, count == 0 ? ", expecting `" : " or `");
-			strcat(msg, yytname[x]);
-			strcat(msg, "'");
-			count++;
-		      }
-		}
-	      yyerror(msg);
-	      free(msg);
-	    }
-	  else
-	    yyerror ("parse error; also virtual memory exceeded");
-	}
-      else
-#endif /* YYERROR_VERBOSE */
-	yyerror("parse error");
+	if (0 < yysize && yysize <= yymsg_alloc)
+	  {
+	    (void) yysyntax_error (yymsg, yystate, yychar);
+	    yyerror (yymsg);
+	  }
+	else
+	  {
+	    yyerror (YY_("syntax error"));
+	    if (yysize != 0)
+	      goto yyexhaustedlab;
+	  }
+      }
+#endif
     }
 
-  goto yyerrlab1;
-yyerrlab1:   /* here on error raised explicitly by an action */
+
 
   if (yyerrstatus == 3)
     {
-      /* if just tried and failed to reuse lookahead token after an error, discard it.  */
+      /* If just tried and failed to reuse look-ahead token after an
+	 error, discard it.  */
 
-      /* return failure if at end of input */
-      if (yychar == YYEOF)
+      if (yychar <= YYEOF)
+	{
+	  /* Return failure if at end of input.  */
+	  if (yychar == YYEOF)
+	    YYABORT;
+	}
+      else
+	{
+	  yydestruct ("Error: discarding",
+		      yytoken, &yylval);
+	  yychar = YYEMPTY;
+	}
+    }
+
+  /* Else will try to reuse look-ahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (/*CONSTCOND*/ 0)
+     goto yyerrorlab;
+
+  /* Do not reclaim the symbols of the rule which action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+  yyerrstatus = 3;	/* Each real token shifted decrements this.  */
+
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (yyn != YYPACT_NINF)
+	{
+	  yyn += YYTERROR;
+	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+	    {
+	      yyn = yytable[yyn];
+	      if (0 < yyn)
+		break;
+	    }
+	}
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
 	YYABORT;
 
-#if YYDEBUG != 0
-      if (yydebug)
-	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
-#endif
 
-      yychar = YYEMPTY;
+      yydestruct ("Error: popping",
+		  yystos[yystate], yyvsp);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
     }
 
-  /* Else will try to reuse lookahead token
-     after shifting the error token.  */
-
-  yyerrstatus = 3;		/* Each real token shifted decrements this */
-
-  goto yyerrhandle;
-
-yyerrdefault:  /* current state does not do anything special for the error token. */
-
-#if 0
-  /* This is wrong; only states that explicitly want error tokens
-     should shift them.  */
-  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
-  if (yyn) goto yydefault;
-#endif
-
-yyerrpop:   /* pop the current state because it cannot handle the error token */
-
-  if (yyssp == yyss) YYABORT;
-  yyvsp--;
-  yystate = *--yyssp;
-#ifdef YYLSP_NEEDED
-  yylsp--;
-#endif
-
-#if YYDEBUG != 0
-  if (yydebug)
-    {
-      short *ssp1 = yyss - 1;
-      fprintf (stderr, "Error: state stack now");
-      while (ssp1 != yyssp)
-	fprintf (stderr, " %d", *++ssp1);
-      fprintf (stderr, "\n");
-    }
-#endif
-
-yyerrhandle:
-
-  yyn = yypact[yystate];
-  if (yyn == YYFLAG)
-    goto yyerrdefault;
-
-  yyn += YYTERROR;
-  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
-    goto yyerrdefault;
-
-  yyn = yytable[yyn];
-  if (yyn < 0)
-    {
-      if (yyn == YYFLAG)
-	goto yyerrpop;
-      yyn = -yyn;
-      goto yyreduce;
-    }
-  else if (yyn == 0)
-    goto yyerrpop;
-
   if (yyn == YYFINAL)
     YYACCEPT;
 
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Shifting error token, ");
-#endif
-
   *++yyvsp = yylval;
-#ifdef YYLSP_NEEDED
-  *++yylsp = yylloc;
-#endif
+
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
 
   yystate = yyn;
   goto yynewstate;
 
- yyacceptlab:
-  /* YYACCEPT comes here.  */
-  if (yyfree_stacks)
-    {
-      free (yyss);
-      free (yyvs);
-#ifdef YYLSP_NEEDED
-      free (yyls);
-#endif
-    }
-  return 0;
 
- yyabortlab:
-  /* YYABORT comes here.  */
-  if (yyfree_stacks)
-    {
-      free (yyss);
-      free (yyvs);
-#ifdef YYLSP_NEEDED
-      free (yyls);
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturn;
+
+#ifndef yyoverflow
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (YY_("memory exhausted"));
+  yyresult = 2;
+  /* Fall through.  */
 #endif
+
+yyreturn:
+  if (yychar != YYEOF && yychar != YYEMPTY)
+     yydestruct ("Cleanup: discarding lookahead",
+		 yytoken, &yylval);
+  /* Do not reclaim the symbols of the rule which action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+		  yystos[*yyssp], yyvsp);
+      YYPOPSTACK (1);
     }
-  return 1;
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+  if (yymsg != yymsgbuf)
+    YYSTACK_FREE (yymsg);
+#endif
+  /* Make sure YYID is used.  */
+  return YYID (yyresult);
 }
-#line 2991 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
+
+
+#line 3029 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
 
 
 // common code from the two 'RunVMAsmParser' functions
@@ -5165,3 +6305,4 @@
   GenerateError(errMsg);
   return 0;
 }
+
diff --git a/lib/AsmParser/llvmAsmParser.h.cvs b/lib/AsmParser/llvmAsmParser.h.cvs
index a242ab1..cdc0e97 100644
--- a/lib/AsmParser/llvmAsmParser.h.cvs
+++ b/lib/AsmParser/llvmAsmParser.h.cvs
@@ -1,4 +1,321 @@
-typedef union {
+/* A Bison parser, made by GNU Bison 2.3.  */
+
+/* Skeleton interface for Bison's Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     ESINT64VAL = 258,
+     EUINT64VAL = 259,
+     ESAPINTVAL = 260,
+     EUAPINTVAL = 261,
+     LOCALVAL_ID = 262,
+     GLOBALVAL_ID = 263,
+     FPVAL = 264,
+     VOID = 265,
+     INTTYPE = 266,
+     FLOAT = 267,
+     DOUBLE = 268,
+     LABEL = 269,
+     TYPE = 270,
+     LOCALVAR = 271,
+     GLOBALVAR = 272,
+     LABELSTR = 273,
+     STRINGCONSTANT = 274,
+     ATSTRINGCONSTANT = 275,
+     ZEROINITIALIZER = 276,
+     TRUETOK = 277,
+     FALSETOK = 278,
+     BEGINTOK = 279,
+     ENDTOK = 280,
+     DECLARE = 281,
+     DEFINE = 282,
+     GLOBAL = 283,
+     CONSTANT = 284,
+     SECTION = 285,
+     ALIAS = 286,
+     VOLATILE = 287,
+     THREAD_LOCAL = 288,
+     TO = 289,
+     DOTDOTDOT = 290,
+     NULL_TOK = 291,
+     UNDEF = 292,
+     INTERNAL = 293,
+     LINKONCE = 294,
+     WEAK = 295,
+     APPENDING = 296,
+     DLLIMPORT = 297,
+     DLLEXPORT = 298,
+     EXTERN_WEAK = 299,
+     OPAQUE = 300,
+     EXTERNAL = 301,
+     TARGET = 302,
+     TRIPLE = 303,
+     ALIGN = 304,
+     DEPLIBS = 305,
+     CALL = 306,
+     TAIL = 307,
+     ASM_TOK = 308,
+     MODULE = 309,
+     SIDEEFFECT = 310,
+     CC_TOK = 311,
+     CCC_TOK = 312,
+     FASTCC_TOK = 313,
+     COLDCC_TOK = 314,
+     X86_STDCALLCC_TOK = 315,
+     X86_FASTCALLCC_TOK = 316,
+     DATALAYOUT = 317,
+     RET = 318,
+     BR = 319,
+     SWITCH = 320,
+     INVOKE = 321,
+     UNWIND = 322,
+     UNREACHABLE = 323,
+     ADD = 324,
+     SUB = 325,
+     MUL = 326,
+     UDIV = 327,
+     SDIV = 328,
+     FDIV = 329,
+     UREM = 330,
+     SREM = 331,
+     FREM = 332,
+     AND = 333,
+     OR = 334,
+     XOR = 335,
+     SHL = 336,
+     LSHR = 337,
+     ASHR = 338,
+     ICMP = 339,
+     FCMP = 340,
+     EQ = 341,
+     NE = 342,
+     SLT = 343,
+     SGT = 344,
+     SLE = 345,
+     SGE = 346,
+     ULT = 347,
+     UGT = 348,
+     ULE = 349,
+     UGE = 350,
+     OEQ = 351,
+     ONE = 352,
+     OLT = 353,
+     OGT = 354,
+     OLE = 355,
+     OGE = 356,
+     ORD = 357,
+     UNO = 358,
+     UEQ = 359,
+     UNE = 360,
+     MALLOC = 361,
+     ALLOCA = 362,
+     FREE = 363,
+     LOAD = 364,
+     STORE = 365,
+     GETELEMENTPTR = 366,
+     TRUNC = 367,
+     ZEXT = 368,
+     SEXT = 369,
+     FPTRUNC = 370,
+     FPEXT = 371,
+     BITCAST = 372,
+     UITOFP = 373,
+     SITOFP = 374,
+     FPTOUI = 375,
+     FPTOSI = 376,
+     INTTOPTR = 377,
+     PTRTOINT = 378,
+     PHI_TOK = 379,
+     SELECT = 380,
+     VAARG = 381,
+     EXTRACTELEMENT = 382,
+     INSERTELEMENT = 383,
+     SHUFFLEVECTOR = 384,
+     NORETURN = 385,
+     INREG = 386,
+     SRET = 387,
+     NOUNWIND = 388,
+     DEFAULT = 389,
+     HIDDEN = 390
+   };
+#endif
+/* Tokens.  */
+#define ESINT64VAL 258
+#define EUINT64VAL 259
+#define ESAPINTVAL 260
+#define EUAPINTVAL 261
+#define LOCALVAL_ID 262
+#define GLOBALVAL_ID 263
+#define FPVAL 264
+#define VOID 265
+#define INTTYPE 266
+#define FLOAT 267
+#define DOUBLE 268
+#define LABEL 269
+#define TYPE 270
+#define LOCALVAR 271
+#define GLOBALVAR 272
+#define LABELSTR 273
+#define STRINGCONSTANT 274
+#define ATSTRINGCONSTANT 275
+#define ZEROINITIALIZER 276
+#define TRUETOK 277
+#define FALSETOK 278
+#define BEGINTOK 279
+#define ENDTOK 280
+#define DECLARE 281
+#define DEFINE 282
+#define GLOBAL 283
+#define CONSTANT 284
+#define SECTION 285
+#define ALIAS 286
+#define VOLATILE 287
+#define THREAD_LOCAL 288
+#define TO 289
+#define DOTDOTDOT 290
+#define NULL_TOK 291
+#define UNDEF 292
+#define INTERNAL 293
+#define LINKONCE 294
+#define WEAK 295
+#define APPENDING 296
+#define DLLIMPORT 297
+#define DLLEXPORT 298
+#define EXTERN_WEAK 299
+#define OPAQUE 300
+#define EXTERNAL 301
+#define TARGET 302
+#define TRIPLE 303
+#define ALIGN 304
+#define DEPLIBS 305
+#define CALL 306
+#define TAIL 307
+#define ASM_TOK 308
+#define MODULE 309
+#define SIDEEFFECT 310
+#define CC_TOK 311
+#define CCC_TOK 312
+#define FASTCC_TOK 313
+#define COLDCC_TOK 314
+#define X86_STDCALLCC_TOK 315
+#define X86_FASTCALLCC_TOK 316
+#define DATALAYOUT 317
+#define RET 318
+#define BR 319
+#define SWITCH 320
+#define INVOKE 321
+#define UNWIND 322
+#define UNREACHABLE 323
+#define ADD 324
+#define SUB 325
+#define MUL 326
+#define UDIV 327
+#define SDIV 328
+#define FDIV 329
+#define UREM 330
+#define SREM 331
+#define FREM 332
+#define AND 333
+#define OR 334
+#define XOR 335
+#define SHL 336
+#define LSHR 337
+#define ASHR 338
+#define ICMP 339
+#define FCMP 340
+#define EQ 341
+#define NE 342
+#define SLT 343
+#define SGT 344
+#define SLE 345
+#define SGE 346
+#define ULT 347
+#define UGT 348
+#define ULE 349
+#define UGE 350
+#define OEQ 351
+#define ONE 352
+#define OLT 353
+#define OGT 354
+#define OLE 355
+#define OGE 356
+#define ORD 357
+#define UNO 358
+#define UEQ 359
+#define UNE 360
+#define MALLOC 361
+#define ALLOCA 362
+#define FREE 363
+#define LOAD 364
+#define STORE 365
+#define GETELEMENTPTR 366
+#define TRUNC 367
+#define ZEXT 368
+#define SEXT 369
+#define FPTRUNC 370
+#define FPEXT 371
+#define BITCAST 372
+#define UITOFP 373
+#define SITOFP 374
+#define FPTOUI 375
+#define FPTOSI 376
+#define INTTOPTR 377
+#define PTRTOINT 378
+#define PHI_TOK 379
+#define SELECT 380
+#define VAARG 381
+#define EXTRACTELEMENT 382
+#define INSERTELEMENT 383
+#define SHUFFLEVECTOR 384
+#define NORETURN 385
+#define INREG 386
+#define SRET 387
+#define NOUNWIND 388
+#define DEFAULT 389
+#define HIDDEN 390
+
+
+
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
+#line 938 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
+{
   llvm::Module                           *ModuleVal;
   llvm::Function                         *FunctionVal;
   llvm::BasicBlock                       *BasicBlockVal;
@@ -43,139 +360,14 @@
   llvm::Instruction::OtherOps       OtherOpVal;
   llvm::ICmpInst::Predicate         IPredicate;
   llvm::FCmpInst::Predicate         FPredicate;
-} YYSTYPE;
-#define	ESINT64VAL	257
-#define	EUINT64VAL	258
-#define	ESAPINTVAL	259
-#define	EUAPINTVAL	260
-#define	LOCALVAL_ID	261
-#define	GLOBALVAL_ID	262
-#define	FPVAL	263
-#define	VOID	264
-#define	INTTYPE	265
-#define	FLOAT	266
-#define	DOUBLE	267
-#define	LABEL	268
-#define	TYPE	269
-#define	LOCALVAR	270
-#define	GLOBALVAR	271
-#define	LABELSTR	272
-#define	STRINGCONSTANT	273
-#define	ATSTRINGCONSTANT	274
-#define	ZEROINITIALIZER	275
-#define	TRUETOK	276
-#define	FALSETOK	277
-#define	BEGINTOK	278
-#define	ENDTOK	279
-#define	DECLARE	280
-#define	DEFINE	281
-#define	GLOBAL	282
-#define	CONSTANT	283
-#define	SECTION	284
-#define	VOLATILE	285
-#define	THREAD_LOCAL	286
-#define	TO	287
-#define	DOTDOTDOT	288
-#define	NULL_TOK	289
-#define	UNDEF	290
-#define	INTERNAL	291
-#define	LINKONCE	292
-#define	WEAK	293
-#define	APPENDING	294
-#define	DLLIMPORT	295
-#define	DLLEXPORT	296
-#define	EXTERN_WEAK	297
-#define	OPAQUE	298
-#define	EXTERNAL	299
-#define	TARGET	300
-#define	TRIPLE	301
-#define	ALIGN	302
-#define	DEPLIBS	303
-#define	CALL	304
-#define	TAIL	305
-#define	ASM_TOK	306
-#define	MODULE	307
-#define	SIDEEFFECT	308
-#define	CC_TOK	309
-#define	CCC_TOK	310
-#define	FASTCC_TOK	311
-#define	COLDCC_TOK	312
-#define	X86_STDCALLCC_TOK	313
-#define	X86_FASTCALLCC_TOK	314
-#define	DATALAYOUT	315
-#define	RET	316
-#define	BR	317
-#define	SWITCH	318
-#define	INVOKE	319
-#define	UNWIND	320
-#define	UNREACHABLE	321
-#define	ADD	322
-#define	SUB	323
-#define	MUL	324
-#define	UDIV	325
-#define	SDIV	326
-#define	FDIV	327
-#define	UREM	328
-#define	SREM	329
-#define	FREM	330
-#define	AND	331
-#define	OR	332
-#define	XOR	333
-#define	SHL	334
-#define	LSHR	335
-#define	ASHR	336
-#define	ICMP	337
-#define	FCMP	338
-#define	EQ	339
-#define	NE	340
-#define	SLT	341
-#define	SGT	342
-#define	SLE	343
-#define	SGE	344
-#define	ULT	345
-#define	UGT	346
-#define	ULE	347
-#define	UGE	348
-#define	OEQ	349
-#define	ONE	350
-#define	OLT	351
-#define	OGT	352
-#define	OLE	353
-#define	OGE	354
-#define	ORD	355
-#define	UNO	356
-#define	UEQ	357
-#define	UNE	358
-#define	MALLOC	359
-#define	ALLOCA	360
-#define	FREE	361
-#define	LOAD	362
-#define	STORE	363
-#define	GETELEMENTPTR	364
-#define	TRUNC	365
-#define	ZEXT	366
-#define	SEXT	367
-#define	FPTRUNC	368
-#define	FPEXT	369
-#define	BITCAST	370
-#define	UITOFP	371
-#define	SITOFP	372
-#define	FPTOUI	373
-#define	FPTOSI	374
-#define	INTTOPTR	375
-#define	PTRTOINT	376
-#define	PHI_TOK	377
-#define	SELECT	378
-#define	VAARG	379
-#define	EXTRACTELEMENT	380
-#define	INSERTELEMENT	381
-#define	SHUFFLEVECTOR	382
-#define	NORETURN	383
-#define	INREG	384
-#define	SRET	385
-#define	NOUNWIND	386
-#define	DEFAULT	387
-#define	HIDDEN	388
-
+}
+/* Line 1489 of yacc.c.  */
+#line 366 "llvmAsmParser.tab.h"
+	YYSTYPE;
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
 
 extern YYSTYPE llvmAsmlval;
+
diff --git a/lib/AsmParser/llvmAsmParser.y.cvs b/lib/AsmParser/llvmAsmParser.y.cvs
index 2b08d3a..21aa30b 100644
--- a/lib/AsmParser/llvmAsmParser.y.cvs
+++ b/lib/AsmParser/llvmAsmParser.y.cvs
@@ -1004,6 +1004,7 @@
 %type <BoolVal>       OptSideEffect               // 'sideeffect' or not.
 %type <Linkage>       GVInternalLinkage GVExternalLinkage
 %type <Linkage>       FunctionDefineLinkage FunctionDeclareLinkage
+%type <Linkage>       AliasLinkage
 %type <Visibility>    GVVisibilityStyle
 
 // ValueRef - Unresolved reference to a definition or BB
@@ -1035,12 +1036,12 @@
 
 %token<StrVal> LOCALVAR GLOBALVAR LABELSTR STRINGCONSTANT ATSTRINGCONSTANT
 %type <StrVal> LocalName OptLocalName OptLocalAssign
-%type <StrVal> GlobalName OptGlobalAssign
+%type <StrVal> GlobalName OptGlobalAssign GlobalAssign
 %type <UIntVal> OptAlign OptCAlign
 %type <StrVal> OptSection SectionString
 
 %token ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK
-%token DECLARE DEFINE GLOBAL CONSTANT SECTION VOLATILE THREAD_LOCAL
+%token DECLARE DEFINE GLOBAL CONSTANT SECTION ALIAS VOLATILE THREAD_LOCAL
 %token TO DOTDOTDOT NULL_TOK UNDEF INTERNAL LINKONCE WEAK APPENDING
 %token DLLIMPORT DLLEXPORT EXTERN_WEAK
 %token OPAQUE EXTERNAL TARGET TRIPLE ALIGN
@@ -1136,15 +1137,17 @@
 
 GlobalName : GLOBALVAR | ATSTRINGCONSTANT;
 
-OptGlobalAssign : GlobalName '=' {
-    $$ = $1;
-    CHECK_FOR_ERROR
-  }
+OptGlobalAssign : GlobalAssign
   | /*empty*/ {
     $$ = 0;
     CHECK_FOR_ERROR
   };
 
+GlobalAssign : GlobalName '=' {
+    $$ = $1;
+    CHECK_FOR_ERROR
+  }
+
 GVInternalLinkage 
   : INTERNAL    { $$ = GlobalValue::InternalLinkage; } 
   | WEAK        { $$ = GlobalValue::WeakLinkage; } 
@@ -1161,6 +1164,7 @@
 
 GVVisibilityStyle
   : /*empty*/ { $$ = GlobalValue::DefaultVisibility; }
+  | DEFAULT   { $$ = GlobalValue::DefaultVisibility; }
   | HIDDEN    { $$ = GlobalValue::HiddenVisibility;  }
   ;
 
@@ -1170,7 +1174,7 @@
   | EXTERN_WEAK { $$ = GlobalValue::ExternalWeakLinkage; }
   ;
   
-FunctionDefineLinkage 
+FunctionDefineLinkage
   : /*empty*/   { $$ = GlobalValue::ExternalLinkage; }
   | INTERNAL    { $$ = GlobalValue::InternalLinkage; }
   | LINKONCE    { $$ = GlobalValue::LinkOnceLinkage; }
@@ -1178,6 +1182,12 @@
   | DLLEXPORT   { $$ = GlobalValue::DLLExportLinkage; } 
   ; 
 
+AliasLinkage
+  : /*empty*/   { $$ = GlobalValue::ExternalLinkage; }
+  | WEAK        { $$ = GlobalValue::WeakLinkage; }
+  | INTERNAL    { $$ = GlobalValue::InternalLinkage; }
+  ;
+
 OptCallingConv : /*empty*/          { $$ = CallingConv::C; } |
                  CCC_TOK            { $$ = CallingConv::C; } |
                  FASTCC_TOK         { $$ = CallingConv::Fast; } |
@@ -2031,6 +2041,34 @@
     CurGV = 0;
     CHECK_FOR_ERROR
   }
+  | OptGlobalAssign GVVisibilityStyle ALIAS AliasLinkage ResultTypes SymbolicValueRef {
+    std::string Name($1);
+    if (Name.empty())
+      GEN_ERROR("Alias name cannot be empty")
+    const PointerType *PFTy = 0;
+    const FunctionType *Ty = 0;
+    Value* V = 0;
+    const Type* VTy = 0;
+    if (!(PFTy = dyn_cast<PointerType>($5->get())) ||
+        !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
+      VTy = $5->get();
+      V = getExistingVal(VTy, $6);
+    } else {
+      VTy = PFTy;
+      V = getExistingVal(PFTy, $6);
+    }
+    if (V == 0)
+      GEN_ERROR(std::string("Invalid aliasee for alias: ") + $1);
+    GlobalValue* Aliasee;
+    if (Aliasee = dyn_cast<GlobalValue>(V)) {
+      GlobalAlias* GA = new GlobalAlias(VTy, $4, Name, Aliasee, CurModule.CurrentModule);
+      GA->setVisibility($2);
+      InsertValue(GA, CurModule.Values);
+    } else
+      GEN_ERROR("Aliases can be created only to global values");
+    CHECK_FOR_ERROR
+    delete $5;
+  }
   | TARGET TargetDefinition { 
     CHECK_FOR_ERROR
   }
@@ -2196,9 +2234,9 @@
       // error.
       GEN_ERROR("Overload of function '" + FunctionName + "' not permitted.");
     } else if (!CurFun.isDeclare && !Fn->isDeclaration()) {
-      // Neither the existing or the current function is a declaration and they
-      // have the same name and same type. Clearly this is a redefinition.
-      GEN_ERROR("Redefinition of function '" + FunctionName + "'");
+        // Neither the existing or the current function is a declaration and they
+        // have the same name and same type. Clearly this is a redefinition.
+        GEN_ERROR("Redefinition of function '" + FunctionName + "'");
     } if (Fn->isDeclaration()) {
       // Make sure to strip off any argument names so we can't get conflicts.
       for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
@@ -2836,10 +2874,10 @@
       Ty = FunctionType::get($3->get(), ParamTypes, false, PAL);
       PFTy = PointerType::get(Ty);
     }
-
+    
     Value *V = getVal(PFTy, $4);   // Get the function we're calling...
     CHECK_FOR_ERROR
-
+          
     // Check for call to invalid intrinsic to avoid crashing later.
     if (Function *theF = dyn_cast<Function>(V)) {
       if (theF->hasName() && (theF->getValueName()->getKeyLength() >= 5) &&