Context Navigation

source: src/Tests/Expect-r/ShortCircuit.txt@ f6d7e0f

Visit:

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors ctor deferred_resn demangler enum forall-pointer-decay gc_noraii jacob/cs343-translation jenkins-sandbox memory new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new string with_gc

Last change on this file since f6d7e0f was b1d6dd5, checked in by Peter A. Buhr <pabuhr@…>, 10 years ago
fix parsing error for EOF message, change cfa-ccp -x flag to -v, regression testing third attempt: consolidate example programs
Property mode set to `100644`
File size: 60.5 KB

Rev	Line
[b1d6dd5]	1	nameExpr is g
	2	decl is g: function
	3	with parameters
	4	float
	5	returning
	6	nothing
	7
	8	newExpr is Variable Expression: g: function
	9	with parameters
	10	float
	11	returning
	12	nothing
	13
	14
	15	decl is g: function
	16	with parameters
	17	signed int
	18	returning
	19	nothing
	20
	21	newExpr is Variable Expression: g: function
	22	with parameters
	23	signed int
	24	returning
	25	nothing
	26
	27
	28	alternatives before prune:
	29	Cost ( 0, 0, 0 ): Variable Expression: g: function
	30	with parameters
	31	float
	32	returning
	33	nothing
	34
	35	(types:
	36	pointer to function
	37	with parameters
	38	float
	39	returning
	40	nothing
	41
	42	)
	43	Environment:
	44
	45	Cost ( 0, 0, 0 ): Variable Expression: g: function
	46	with parameters
	47	signed int
	48	returning
	49	nothing
	50
	51	(types:
	52	pointer to function
	53	with parameters
	54	signed int
	55	returning
	56	nothing
	57
	58	)
	59	Environment:
	60
	61	there are 2 alternatives before elimination
	62	there are 2 alternatives after elimination
	63	nameExpr is ?!=?
	64	decl is ?!=?: function
	65	with parameters
	66	float
	67	float
	68	returning
	69	signed int
	70
	71	newExpr is Variable Expression: ?!=?: function
	72	with parameters
	73	float
	74	float
	75	returning
	76	signed int
	77
	78
	79	decl is ?!=?: function
	80	with parameters
	81	signed int
	82	signed int
	83	returning
	84	signed int
	85
	86	newExpr is Variable Expression: ?!=?: function
	87	with parameters
	88	signed int
	89	signed int
	90	returning
	91	signed int
	92
	93
	94	alternatives before prune:
	95	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	96	with parameters
	97	float
	98	float
	99	returning
	100	signed int
	101
	102	(types:
	103	pointer to function
	104	with parameters
	105	float
	106	float
	107	returning
	108	signed int
	109
	110	)
	111	Environment:
	112
	113	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	114	with parameters
	115	signed int
	116	signed int
	117	returning
	118	signed int
	119
	120	(types:
	121	pointer to function
	122	with parameters
	123	signed int
	124	signed int
	125	returning
	126	signed int
	127
	128	)
	129	Environment:
	130
	131	there are 2 alternatives before elimination
	132	there are 2 alternatives after elimination
	133	nameExpr is a
	134	decl is a: signed int
	135	newExpr is Variable Expression: a: signed int
	136
	137	alternatives before prune:
	138	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
	139	(types:
	140	lvalue signed int
	141	)
	142	Environment:
	143
	144	there are 1 alternatives before elimination
	145	there are 1 alternatives after elimination
	146	findSubExprs
	147	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
	148	(types:
	149	lvalue signed int
	150	)
	151	Environment:
	152
	153	nameExpr is 0
	154	decl is 0: signed int
	155	newExpr is Variable Expression: 0: signed int
	156
	157	alternatives before prune:
	158	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
	159	(types:
	160	lvalue signed int
	161	)
	162	Environment:
	163
	164	there are 1 alternatives before elimination
	165	there are 1 alternatives after elimination
	166	findSubExprs
	167	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
	168	(types:
	169	lvalue signed int
	170	)
	171	Environment:
	172
	173	working on alternative:
	174	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	175	with parameters
	176	signed int
	177	signed int
	178	returning
	179	signed int
	180
	181	(types:
	182	pointer to function
	183	with parameters
	184	signed int
	185	signed int
	186	returning
	187	signed int
	188
	189	)
	190	Environment:
	191	formal type is signed int
	192	actual type is lvalue signed int
	193	formal type is signed int
	194	actual type is lvalue signed int
	195	need assertions:
	196	============= original indexer
	197	===idTable===
	198	===typeTable===
	199	===structTable===
	200	===enumTable===
	201	===unionTable===
	202	===contextTable===
	203	============= new indexer
	204	===idTable===
	205	===typeTable===
	206	===structTable===
	207	===enumTable===
	208	===unionTable===
	209	===contextTable===
	210	working on alternative:
	211	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	212	with parameters
	213	float
	214	float
	215	returning
	216	signed int
	217
	218	(types:
	219	pointer to function
	220	with parameters
	221	float
	222	float
	223	returning
	224	signed int
	225
	226	)
	227	Environment:
	228	formal type is float
	229	actual type is lvalue signed int
	230	formal type is float
	231	actual type is lvalue signed int
	232	need assertions:
	233	============= original indexer
	234	===idTable===
	235	===typeTable===
	236	===structTable===
	237	===enumTable===
	238	===unionTable===
	239	===contextTable===
	240	============= new indexer
	241	===idTable===
	242	===typeTable===
	243	===structTable===
	244	===enumTable===
	245	===unionTable===
	246	===contextTable===
	247	actual expression:
	248	Variable Expression: a: signed int
	249	--- results are
	250	lvalue signed int
	251
	252	converting lvalue signed int
	253	to signed int
	254	cost is( 0, 0, 0 )
	255	actual expression:
	256	Variable Expression: 0: signed int
	257	--- results are
	258	lvalue signed int
	259
	260	converting lvalue signed int
	261	to signed int
	262	cost is( 0, 0, 0 )
	263	Case +++++++++++++
	264	formals are:
	265	signed int
	266	signed int
	267	actuals are:
	268	Variable Expression: a: signed int
	269
	270	Variable Expression: 0: signed int
	271
	272	bindings are:
	273	cost of conversion is:( 0, 0, 0 )
	274	actual expression:
	275	Variable Expression: a: signed int
	276	--- results are
	277	lvalue signed int
	278
	279	converting lvalue signed int
	280	to float
	281	cost is( 0, 0, 5 )
	282	actual expression:
	283	Variable Expression: 0: signed int
	284	--- results are
	285	lvalue signed int
	286
	287	converting lvalue signed int
	288	to float
	289	cost is( 0, 0, 5 )
	290	Case +++++++++++++
	291	formals are:
	292	float
	293	float
	294	actuals are:
	295	Cast of:
	296	Variable Expression: a: signed int
	297
	298	to:
	299	float
	300
	301	Cast of:
	302	Variable Expression: 0: signed int
	303
	304	to:
	305	float
	306
	307	bindings are:
	308	cost of conversion is:( 0, 0, 10 )
	309	alternatives before prune:
	310	Cost ( 0, 0, 0 ): Application of
	311	Variable Expression: ?!=?: function
	312	with parameters
	313	signed int
	314	signed int
	315	returning
	316	signed int
	317
	318	to arguments
	319	Variable Expression: a: signed int
	320
	321	Variable Expression: 0: signed int
	322
	323	(types:
	324	signed int
	325	)
	326	Environment:
	327
	328	Cost ( 0, 0, 10 ): Application of
	329	Variable Expression: ?!=?: function
	330	with parameters
	331	float
	332	float
	333	returning
	334	signed int
	335
	336	to arguments
	337	Cast of:
	338	Variable Expression: a: signed int
	339
	340	to:
	341	float
	342
	343	Cast of:
	344	Variable Expression: 0: signed int
	345
	346	to:
	347	float
	348
	349	(types:
	350	signed int
	351	)
	352	Environment:
	353
	354	there are 1 alternatives before elimination
	355	there are 1 alternatives after elimination
	356	alternatives before prune:
	357	Cost ( 0, 0, 0 ): Cast of:
	358	Application of
	359	Variable Expression: ?!=?: function
	360	with parameters
	361	signed int
	362	signed int
	363	returning
	364	signed int
	365
	366	to arguments
	367	Variable Expression: a: signed int
	368
	369	Variable Expression: 0: signed int
	370
	371
	372	to:
	373	signed int
	374	(types:
	375	signed int
	376	)
	377	Environment:
	378
	379	there are 1 alternatives before elimination
	380	there are 1 alternatives after elimination
	381	nameExpr is b
	382	decl is b: signed int
	383	newExpr is Variable Expression: b: signed int
	384
	385	alternatives before prune:
	386	Cost ( 0, 0, 0 ): Variable Expression: b: signed int
	387	(types:
	388	lvalue signed int
	389	)
	390	Environment:
	391
	392	there are 1 alternatives before elimination
	393	there are 1 alternatives after elimination
	394	nameExpr is c
	395	decl is c: float
	396	newExpr is Variable Expression: c: float
	397
	398	alternatives before prune:
	399	Cost ( 0, 0, 0 ): Variable Expression: c: float
	400	(types:
	401	lvalue float
	402	)
	403	Environment:
	404
	405	there are 1 alternatives before elimination
	406	there are 1 alternatives after elimination
	407	============= original indexer
	408	===idTable===
	409	===typeTable===
	410	===structTable===
	411	===enumTable===
	412	===unionTable===
	413	===contextTable===
	414	============= new indexer
	415	===idTable===
	416	===typeTable===
	417	===structTable===
	418	===enumTable===
	419	===unionTable===
	420	===contextTable===
	421	alternatives before prune:
	422	Cost ( 0, 0, 0 ): Conditional expression on:
	423	Cast of:
	424	Application of
	425	Variable Expression: ?!=?: function
	426	with parameters
	427	signed int
	428	signed int
	429	returning
	430	signed int
	431
	432	to arguments
	433	Variable Expression: a: signed int
	434
	435	Variable Expression: 0: signed int
	436
	437
	438	to:
	439	signed int
	440	First alternative:
	441	Variable Expression: b: signed int
	442	Second alternative:
	443	Variable Expression: c: float
	444
	445	(types:
	446	lvalue float
	447	)
	448	Environment:
	449
	450	there are 1 alternatives before elimination
	451	there are 1 alternatives after elimination
	452	findSubExprs
	453	Cost ( 0, 0, 0 ): Conditional expression on:
	454	Cast of:
	455	Application of
	456	Variable Expression: ?!=?: function
	457	with parameters
	458	signed int
	459	signed int
	460	returning
	461	signed int
	462
	463	to arguments
	464	Variable Expression: a: signed int
	465
	466	Variable Expression: 0: signed int
	467
	468
	469	to:
	470	signed int
	471	First alternative:
	472	Variable Expression: b: signed int
	473	Second alternative:
	474	Variable Expression: c: float
	475
	476	(types:
	477	lvalue float
	478	)
	479	Environment:
	480
	481	working on alternative:
	482	Cost ( 0, 0, 0 ): Variable Expression: g: function
	483	with parameters
	484	signed int
	485	returning
	486	nothing
	487
	488	(types:
	489	pointer to function
	490	with parameters
	491	signed int
	492	returning
	493	nothing
	494
	495	)
	496	Environment:
	497	formal type is signed int
	498	actual type is lvalue float
	499	need assertions:
	500	============= original indexer
	501	===idTable===
	502	===typeTable===
	503	===structTable===
	504	===enumTable===
	505	===unionTable===
	506	===contextTable===
	507	============= new indexer
	508	===idTable===
	509	===typeTable===
	510	===structTable===
	511	===enumTable===
	512	===unionTable===
	513	===contextTable===
	514	working on alternative:
	515	Cost ( 0, 0, 0 ): Variable Expression: g: function
	516	with parameters
	517	float
	518	returning
	519	nothing
	520
	521	(types:
	522	pointer to function
	523	with parameters
	524	float
	525	returning
	526	nothing
	527
	528	)
	529	Environment:
	530	formal type is float
	531	actual type is lvalue float
	532	need assertions:
	533	============= original indexer
	534	===idTable===
	535	===typeTable===
	536	===structTable===
	537	===enumTable===
	538	===unionTable===
	539	===contextTable===
	540	============= new indexer
	541	===idTable===
	542	===typeTable===
	543	===structTable===
	544	===enumTable===
	545	===unionTable===
	546	===contextTable===
	547	actual expression:
	548	Conditional expression on:
	549	Cast of:
	550	Application of
	551	Variable Expression: ?!=?: function
	552	with parameters
	553	signed int
	554	signed int
	555	returning
	556	signed int
	557
	558	to arguments
	559	Variable Expression: a: signed int
	560
	561	Variable Expression: 0: signed int
	562
	563
	564	to:
	565	signed int
	566	First alternative:
	567	Variable Expression: b: signed int
	568	Second alternative:
	569	Variable Expression: c: float
	570
	571	--- results are
	572	lvalue float
	573
	574	converting lvalue float
	575	to signed int
	576	cost is( 1, 0, 0 )
	577	Case +++++++++++++
	578	formals are:
	579	signed int
	580	actuals are:
	581	Cast of:
	582	Conditional expression on:
	583	Cast of:
	584	Application of
	585	Variable Expression: ?!=?: function
	586	with parameters
	587	signed int
	588	signed int
	589	returning
	590	signed int
	591
	592	to arguments
	593	Variable Expression: a: signed int
	594
	595	Variable Expression: 0: signed int
	596
	597
	598	to:
	599	signed int
	600	First alternative:
	601	Variable Expression: b: signed int
	602	Second alternative:
	603	Variable Expression: c: float
	604
	605
	606	to:
	607	signed int
	608
	609	bindings are:
	610	cost of conversion is:( 1, 0, 0 )
	611	actual expression:
	612	Conditional expression on:
	613	Cast of:
	614	Application of
	615	Variable Expression: ?!=?: function
	616	with parameters
	617	signed int
	618	signed int
	619	returning
	620	signed int
	621
	622	to arguments
	623	Variable Expression: a: signed int
	624
	625	Variable Expression: 0: signed int
	626
	627
	628	to:
	629	signed int
	630	First alternative:
	631	Variable Expression: b: signed int
	632	Second alternative:
	633	Variable Expression: c: float
	634
	635	--- results are
	636	lvalue float
	637
	638	converting lvalue float
	639	to float
	640	cost is( 0, 0, 0 )
	641	Case +++++++++++++
	642	formals are:
	643	float
	644	actuals are:
	645	Conditional expression on:
	646	Cast of:
	647	Application of
	648	Variable Expression: ?!=?: function
	649	with parameters
	650	signed int
	651	signed int
	652	returning
	653	signed int
	654
	655	to arguments
	656	Variable Expression: a: signed int
	657
	658	Variable Expression: 0: signed int
	659
	660
	661	to:
	662	signed int
	663	First alternative:
	664	Variable Expression: b: signed int
	665	Second alternative:
	666	Variable Expression: c: float
	667
	668
	669	bindings are:
	670	cost of conversion is:( 0, 0, 0 )
	671	alternatives before prune:
	672	Cost ( 1, 0, 0 ): Application of
	673	Variable Expression: g: function
	674	with parameters
	675	signed int
	676	returning
	677	nothing
	678
	679	to arguments
	680	Cast of:
	681	Conditional expression on:
	682	Cast of:
	683	Application of
	684	Variable Expression: ?!=?: function
	685	with parameters
	686	signed int
	687	signed int
	688	returning
	689	signed int
	690
	691	to arguments
	692	Variable Expression: a: signed int
	693
	694	Variable Expression: 0: signed int
	695
	696
	697	to:
	698	signed int
	699	First alternative:
	700	Variable Expression: b: signed int
	701	Second alternative:
	702	Variable Expression: c: float
	703
	704
	705	to:
	706	signed int
	707
	708	(types:
	709	)
	710	Environment:
	711
	712	Cost ( 0, 0, 0 ): Application of
	713	Variable Expression: g: function
	714	with parameters
	715	float
	716	returning
	717	nothing
	718
	719	to arguments
	720	Conditional expression on:
	721	Cast of:
	722	Application of
	723	Variable Expression: ?!=?: function
	724	with parameters
	725	signed int
	726	signed int
	727	returning
	728	signed int
	729
	730	to arguments
	731	Variable Expression: a: signed int
	732
	733	Variable Expression: 0: signed int
	734
	735
	736	to:
	737	signed int
	738	First alternative:
	739	Variable Expression: b: signed int
	740	Second alternative:
	741	Variable Expression: c: float
	742
	743
	744	(types:
	745	)
	746	Environment:
	747
	748	cost ( 0, 0, 0 ) beats ( 1, 0, 0 )
	749	there are 1 alternatives before elimination
	750	there are 1 alternatives after elimination
	751	alternatives before prune:
	752	Cost ( 0, 0, 0 ): Cast of:
	753	Application of
	754	Variable Expression: g: function
	755	with parameters
	756	float
	757	returning
	758	nothing
	759
	760	to arguments
	761	Conditional expression on:
	762	Cast of:
	763	Application of
	764	Variable Expression: ?!=?: function
	765	with parameters
	766	signed int
	767	signed int
	768	returning
	769	signed int
	770
	771	to arguments
	772	Variable Expression: a: signed int
	773
	774	Variable Expression: 0: signed int
	775
	776
	777	to:
	778	signed int
	779	First alternative:
	780	Variable Expression: b: signed int
	781	Second alternative:
	782	Variable Expression: c: float
	783
	784
	785
	786	to:
	787	nothing
	788	(types:
	789	)
	790	Environment:
	791
	792	there are 1 alternatives before elimination
	793	there are 1 alternatives after elimination
	794	nameExpr is g
	795	decl is g: function
	796	with parameters
	797	float
	798	returning
	799	nothing
	800
	801	newExpr is Variable Expression: g: function
	802	with parameters
	803	float
	804	returning
	805	nothing
	806
	807
	808	decl is g: function
	809	with parameters
	810	signed int
	811	returning
	812	nothing
	813
	814	newExpr is Variable Expression: g: function
	815	with parameters
	816	signed int
	817	returning
	818	nothing
	819
	820
	821	alternatives before prune:
	822	Cost ( 0, 0, 0 ): Variable Expression: g: function
	823	with parameters
	824	float
	825	returning
	826	nothing
	827
	828	(types:
	829	pointer to function
	830	with parameters
	831	float
	832	returning
	833	nothing
	834
	835	)
	836	Environment:
	837
	838	Cost ( 0, 0, 0 ): Variable Expression: g: function
	839	with parameters
	840	signed int
	841	returning
	842	nothing
	843
	844	(types:
	845	pointer to function
	846	with parameters
	847	signed int
	848	returning
	849	nothing
	850
	851	)
	852	Environment:
	853
	854	there are 2 alternatives before elimination
	855	there are 2 alternatives after elimination
	856	nameExpr is ?!=?
	857	decl is ?!=?: function
	858	with parameters
	859	float
	860	float
	861	returning
	862	signed int
	863
	864	newExpr is Variable Expression: ?!=?: function
	865	with parameters
	866	float
	867	float
	868	returning
	869	signed int
	870
	871
	872	decl is ?!=?: function
	873	with parameters
	874	signed int
	875	signed int
	876	returning
	877	signed int
	878
	879	newExpr is Variable Expression: ?!=?: function
	880	with parameters
	881	signed int
	882	signed int
	883	returning
	884	signed int
	885
	886
	887	alternatives before prune:
	888	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	889	with parameters
	890	float
	891	float
	892	returning
	893	signed int
	894
	895	(types:
	896	pointer to function
	897	with parameters
	898	float
	899	float
	900	returning
	901	signed int
	902
	903	)
	904	Environment:
	905
	906	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	907	with parameters
	908	signed int
	909	signed int
	910	returning
	911	signed int
	912
	913	(types:
	914	pointer to function
	915	with parameters
	916	signed int
	917	signed int
	918	returning
	919	signed int
	920
	921	)
	922	Environment:
	923
	924	there are 2 alternatives before elimination
	925	there are 2 alternatives after elimination
	926	nameExpr is a
	927	decl is a: signed int
	928	newExpr is Variable Expression: a: signed int
	929
	930	alternatives before prune:
	931	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
	932	(types:
	933	lvalue signed int
	934	)
	935	Environment:
	936
	937	there are 1 alternatives before elimination
	938	there are 1 alternatives after elimination
	939	findSubExprs
	940	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
	941	(types:
	942	lvalue signed int
	943	)
	944	Environment:
	945
	946	nameExpr is 0
	947	decl is 0: signed int
	948	newExpr is Variable Expression: 0: signed int
	949
	950	alternatives before prune:
	951	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
	952	(types:
	953	lvalue signed int
	954	)
	955	Environment:
	956
	957	there are 1 alternatives before elimination
	958	there are 1 alternatives after elimination
	959	findSubExprs
	960	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
	961	(types:
	962	lvalue signed int
	963	)
	964	Environment:
	965
	966	working on alternative:
	967	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	968	with parameters
	969	signed int
	970	signed int
	971	returning
	972	signed int
	973
	974	(types:
	975	pointer to function
	976	with parameters
	977	signed int
	978	signed int
	979	returning
	980	signed int
	981
	982	)
	983	Environment:
	984	formal type is signed int
	985	actual type is lvalue signed int
	986	formal type is signed int
	987	actual type is lvalue signed int
	988	need assertions:
	989	============= original indexer
	990	===idTable===
	991	===typeTable===
	992	===structTable===
	993	===enumTable===
	994	===unionTable===
	995	===contextTable===
	996	============= new indexer
	997	===idTable===
	998	===typeTable===
	999	===structTable===
	1000	===enumTable===
	1001	===unionTable===
	1002	===contextTable===
	1003	working on alternative:
	1004	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	1005	with parameters
	1006	float
	1007	float
	1008	returning
	1009	signed int
	1010
	1011	(types:
	1012	pointer to function
	1013	with parameters
	1014	float
	1015	float
	1016	returning
	1017	signed int
	1018
	1019	)
	1020	Environment:
	1021	formal type is float
	1022	actual type is lvalue signed int
	1023	formal type is float
	1024	actual type is lvalue signed int
	1025	need assertions:
	1026	============= original indexer
	1027	===idTable===
	1028	===typeTable===
	1029	===structTable===
	1030	===enumTable===
	1031	===unionTable===
	1032	===contextTable===
	1033	============= new indexer
	1034	===idTable===
	1035	===typeTable===
	1036	===structTable===
	1037	===enumTable===
	1038	===unionTable===
	1039	===contextTable===
	1040	actual expression:
	1041	Variable Expression: a: signed int
	1042	--- results are
	1043	lvalue signed int
	1044
	1045	converting lvalue signed int
	1046	to signed int
	1047	cost is( 0, 0, 0 )
	1048	actual expression:
	1049	Variable Expression: 0: signed int
	1050	--- results are
	1051	lvalue signed int
	1052
	1053	converting lvalue signed int
	1054	to signed int
	1055	cost is( 0, 0, 0 )
	1056	Case +++++++++++++
	1057	formals are:
	1058	signed int
	1059	signed int
	1060	actuals are:
	1061	Variable Expression: a: signed int
	1062
	1063	Variable Expression: 0: signed int
	1064
	1065	bindings are:
	1066	cost of conversion is:( 0, 0, 0 )
	1067	actual expression:
	1068	Variable Expression: a: signed int
	1069	--- results are
	1070	lvalue signed int
	1071
	1072	converting lvalue signed int
	1073	to float
	1074	cost is( 0, 0, 5 )
	1075	actual expression:
	1076	Variable Expression: 0: signed int
	1077	--- results are
	1078	lvalue signed int
	1079
	1080	converting lvalue signed int
	1081	to float
	1082	cost is( 0, 0, 5 )
	1083	Case +++++++++++++
	1084	formals are:
	1085	float
	1086	float
	1087	actuals are:
	1088	Cast of:
	1089	Variable Expression: a: signed int
	1090
	1091	to:
	1092	float
	1093
	1094	Cast of:
	1095	Variable Expression: 0: signed int
	1096
	1097	to:
	1098	float
	1099
	1100	bindings are:
	1101	cost of conversion is:( 0, 0, 10 )
	1102	alternatives before prune:
	1103	Cost ( 0, 0, 0 ): Application of
	1104	Variable Expression: ?!=?: function
	1105	with parameters
	1106	signed int
	1107	signed int
	1108	returning
	1109	signed int
	1110
	1111	to arguments
	1112	Variable Expression: a: signed int
	1113
	1114	Variable Expression: 0: signed int
	1115
	1116	(types:
	1117	signed int
	1118	)
	1119	Environment:
	1120
	1121	Cost ( 0, 0, 10 ): Application of
	1122	Variable Expression: ?!=?: function
	1123	with parameters
	1124	float
	1125	float
	1126	returning
	1127	signed int
	1128
	1129	to arguments
	1130	Cast of:
	1131	Variable Expression: a: signed int
	1132
	1133	to:
	1134	float
	1135
	1136	Cast of:
	1137	Variable Expression: 0: signed int
	1138
	1139	to:
	1140	float
	1141
	1142	(types:
	1143	signed int
	1144	)
	1145	Environment:
	1146
	1147	there are 1 alternatives before elimination
	1148	there are 1 alternatives after elimination
	1149	alternatives before prune:
	1150	Cost ( 0, 0, 0 ): Cast of:
	1151	Application of
	1152	Variable Expression: ?!=?: function
	1153	with parameters
	1154	signed int
	1155	signed int
	1156	returning
	1157	signed int
	1158
	1159	to arguments
	1160	Variable Expression: a: signed int
	1161
	1162	Variable Expression: 0: signed int
	1163
	1164
	1165	to:
	1166	signed int
	1167	(types:
	1168	signed int
	1169	)
	1170	Environment:
	1171
	1172	there are 1 alternatives before elimination
	1173	there are 1 alternatives after elimination
	1174	nameExpr is ?!=?
	1175	decl is ?!=?: function
	1176	with parameters
	1177	float
	1178	float
	1179	returning
	1180	signed int
	1181
	1182	newExpr is Variable Expression: ?!=?: function
	1183	with parameters
	1184	float
	1185	float
	1186	returning
	1187	signed int
	1188
	1189
	1190	decl is ?!=?: function
	1191	with parameters
	1192	signed int
	1193	signed int
	1194	returning
	1195	signed int
	1196
	1197	newExpr is Variable Expression: ?!=?: function
	1198	with parameters
	1199	signed int
	1200	signed int
	1201	returning
	1202	signed int
	1203
	1204
	1205	alternatives before prune:
	1206	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	1207	with parameters
	1208	float
	1209	float
	1210	returning
	1211	signed int
	1212
	1213	(types:
	1214	pointer to function
	1215	with parameters
	1216	float
	1217	float
	1218	returning
	1219	signed int
	1220
	1221	)
	1222	Environment:
	1223
	1224	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	1225	with parameters
	1226	signed int
	1227	signed int
	1228	returning
	1229	signed int
	1230
	1231	(types:
	1232	pointer to function
	1233	with parameters
	1234	signed int
	1235	signed int
	1236	returning
	1237	signed int
	1238
	1239	)
	1240	Environment:
	1241
	1242	there are 2 alternatives before elimination
	1243	there are 2 alternatives after elimination
	1244	nameExpr is c
	1245	decl is c: float
	1246	newExpr is Variable Expression: c: float
	1247
	1248	alternatives before prune:
	1249	Cost ( 0, 0, 0 ): Variable Expression: c: float
	1250	(types:
	1251	lvalue float
	1252	)
	1253	Environment:
	1254
	1255	there are 1 alternatives before elimination
	1256	there are 1 alternatives after elimination
	1257	findSubExprs
	1258	Cost ( 0, 0, 0 ): Variable Expression: c: float
	1259	(types:
	1260	lvalue float
	1261	)
	1262	Environment:
	1263
	1264	nameExpr is 0
	1265	decl is 0: signed int
	1266	newExpr is Variable Expression: 0: signed int
	1267
	1268	alternatives before prune:
	1269	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
	1270	(types:
	1271	lvalue signed int
	1272	)
	1273	Environment:
	1274
	1275	there are 1 alternatives before elimination
	1276	there are 1 alternatives after elimination
	1277	findSubExprs
	1278	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
	1279	(types:
	1280	lvalue signed int
	1281	)
	1282	Environment:
	1283
	1284	working on alternative:
	1285	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	1286	with parameters
	1287	signed int
	1288	signed int
	1289	returning
	1290	signed int
	1291
	1292	(types:
	1293	pointer to function
	1294	with parameters
	1295	signed int
	1296	signed int
	1297	returning
	1298	signed int
	1299
	1300	)
	1301	Environment:
	1302	formal type is signed int
	1303	actual type is lvalue float
	1304	formal type is signed int
	1305	actual type is lvalue signed int
	1306	need assertions:
	1307	============= original indexer
	1308	===idTable===
	1309	===typeTable===
	1310	===structTable===
	1311	===enumTable===
	1312	===unionTable===
	1313	===contextTable===
	1314	============= new indexer
	1315	===idTable===
	1316	===typeTable===
	1317	===structTable===
	1318	===enumTable===
	1319	===unionTable===
	1320	===contextTable===
	1321	working on alternative:
	1322	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	1323	with parameters
	1324	float
	1325	float
	1326	returning
	1327	signed int
	1328
	1329	(types:
	1330	pointer to function
	1331	with parameters
	1332	float
	1333	float
	1334	returning
	1335	signed int
	1336
	1337	)
	1338	Environment:
	1339	formal type is float
	1340	actual type is lvalue float
	1341	formal type is float
	1342	actual type is lvalue signed int
	1343	need assertions:
	1344	============= original indexer
	1345	===idTable===
	1346	===typeTable===
	1347	===structTable===
	1348	===enumTable===
	1349	===unionTable===
	1350	===contextTable===
	1351	============= new indexer
	1352	===idTable===
	1353	===typeTable===
	1354	===structTable===
	1355	===enumTable===
	1356	===unionTable===
	1357	===contextTable===
	1358	actual expression:
	1359	Variable Expression: c: float
	1360	--- results are
	1361	lvalue float
	1362
	1363	converting lvalue float
	1364	to signed int
	1365	cost is( 1, 0, 0 )
	1366	actual expression:
	1367	Variable Expression: 0: signed int
	1368	--- results are
	1369	lvalue signed int
	1370
	1371	converting lvalue signed int
	1372	to signed int
	1373	cost is( 0, 0, 0 )
	1374	Case +++++++++++++
	1375	formals are:
	1376	signed int
	1377	signed int
	1378	actuals are:
	1379	Cast of:
	1380	Variable Expression: c: float
	1381
	1382	to:
	1383	signed int
	1384
	1385	Variable Expression: 0: signed int
	1386
	1387	bindings are:
	1388	cost of conversion is:( 1, 0, 0 )
	1389	actual expression:
	1390	Variable Expression: c: float
	1391	--- results are
	1392	lvalue float
	1393
	1394	converting lvalue float
	1395	to float
	1396	cost is( 0, 0, 0 )
	1397	actual expression:
	1398	Variable Expression: 0: signed int
	1399	--- results are
	1400	lvalue signed int
	1401
	1402	converting lvalue signed int
	1403	to float
	1404	cost is( 0, 0, 5 )
	1405	Case +++++++++++++
	1406	formals are:
	1407	float
	1408	float
	1409	actuals are:
	1410	Variable Expression: c: float
	1411
	1412	Cast of:
	1413	Variable Expression: 0: signed int
	1414
	1415	to:
	1416	float
	1417
	1418	bindings are:
	1419	cost of conversion is:( 0, 0, 5 )
	1420	alternatives before prune:
	1421	Cost ( 1, 0, 0 ): Application of
	1422	Variable Expression: ?!=?: function
	1423	with parameters
	1424	signed int
	1425	signed int
	1426	returning
	1427	signed int
	1428
	1429	to arguments
	1430	Cast of:
	1431	Variable Expression: c: float
	1432
	1433	to:
	1434	signed int
	1435
	1436	Variable Expression: 0: signed int
	1437
	1438	(types:
	1439	signed int
	1440	)
	1441	Environment:
	1442
	1443	Cost ( 0, 0, 5 ): Application of
	1444	Variable Expression: ?!=?: function
	1445	with parameters
	1446	float
	1447	float
	1448	returning
	1449	signed int
	1450
	1451	to arguments
	1452	Variable Expression: c: float
	1453
	1454	Cast of:
	1455	Variable Expression: 0: signed int
	1456
	1457	to:
	1458	float
	1459
	1460	(types:
	1461	signed int
	1462	)
	1463	Environment:
	1464
	1465	cost ( 0, 0, 5 ) beats ( 1, 0, 0 )
	1466	there are 1 alternatives before elimination
	1467	there are 1 alternatives after elimination
	1468	alternatives before prune:
	1469	Cost ( 0, 0, 0 ): Cast of:
	1470	Application of
	1471	Variable Expression: ?!=?: function
	1472	with parameters
	1473	float
	1474	float
	1475	returning
	1476	signed int
	1477
	1478	to arguments
	1479	Variable Expression: c: float
	1480
	1481	Cast of:
	1482	Variable Expression: 0: signed int
	1483
	1484	to:
	1485	float
	1486
	1487
	1488	to:
	1489	signed int
	1490	(types:
	1491	signed int
	1492	)
	1493	Environment:
	1494
	1495	there are 1 alternatives before elimination
	1496	there are 1 alternatives after elimination
	1497	alternatives before prune:
	1498	Cost ( 0, 0, 0 ): Short-circuited operation (and) on: Cast of:
	1499	Application of
	1500	Variable Expression: ?!=?: function
	1501	with parameters
	1502	signed int
	1503	signed int
	1504	returning
	1505	signed int
	1506
	1507	to arguments
	1508	Variable Expression: a: signed int
	1509
	1510	Variable Expression: 0: signed int
	1511
	1512
	1513	to:
	1514	signed int
	1515	and Cast of:
	1516	Application of
	1517	Variable Expression: ?!=?: function
	1518	with parameters
	1519	float
	1520	float
	1521	returning
	1522	signed int
	1523
	1524	to arguments
	1525	Variable Expression: c: float
	1526
	1527	Cast of:
	1528	Variable Expression: 0: signed int
	1529
	1530	to:
	1531	float
	1532
	1533
	1534	to:
	1535	signed int
	1536
	1537	(types:
	1538	signed int
	1539	)
	1540	Environment:
	1541
	1542	there are 1 alternatives before elimination
	1543	there are 1 alternatives after elimination
	1544	findSubExprs
	1545	Cost ( 0, 0, 0 ): Short-circuited operation (and) on: Cast of:
	1546	Application of
	1547	Variable Expression: ?!=?: function
	1548	with parameters
	1549	signed int
	1550	signed int
	1551	returning
	1552	signed int
	1553
	1554	to arguments
	1555	Variable Expression: a: signed int
	1556
	1557	Variable Expression: 0: signed int
	1558
	1559
	1560	to:
	1561	signed int
	1562	and Cast of:
	1563	Application of
	1564	Variable Expression: ?!=?: function
	1565	with parameters
	1566	float
	1567	float
	1568	returning
	1569	signed int
	1570
	1571	to arguments
	1572	Variable Expression: c: float
	1573
	1574	Cast of:
	1575	Variable Expression: 0: signed int
	1576
	1577	to:
	1578	float
	1579
	1580
	1581	to:
	1582	signed int
	1583
	1584	(types:
	1585	signed int
	1586	)
	1587	Environment:
	1588
	1589	working on alternative:
	1590	Cost ( 0, 0, 0 ): Variable Expression: g: function
	1591	with parameters
	1592	signed int
	1593	returning
	1594	nothing
	1595
	1596	(types:
	1597	pointer to function
	1598	with parameters
	1599	signed int
	1600	returning
	1601	nothing
	1602
	1603	)
	1604	Environment:
	1605	formal type is signed int
	1606	actual type is signed int
	1607	need assertions:
	1608	============= original indexer
	1609	===idTable===
	1610	===typeTable===
	1611	===structTable===
	1612	===enumTable===
	1613	===unionTable===
	1614	===contextTable===
	1615	============= new indexer
	1616	===idTable===
	1617	===typeTable===
	1618	===structTable===
	1619	===enumTable===
	1620	===unionTable===
	1621	===contextTable===
	1622	working on alternative:
	1623	Cost ( 0, 0, 0 ): Variable Expression: g: function
	1624	with parameters
	1625	float
	1626	returning
	1627	nothing
	1628
	1629	(types:
	1630	pointer to function
	1631	with parameters
	1632	float
	1633	returning
	1634	nothing
	1635
	1636	)
	1637	Environment:
	1638	formal type is float
	1639	actual type is signed int
	1640	need assertions:
	1641	============= original indexer
	1642	===idTable===
	1643	===typeTable===
	1644	===structTable===
	1645	===enumTable===
	1646	===unionTable===
	1647	===contextTable===
	1648	============= new indexer
	1649	===idTable===
	1650	===typeTable===
	1651	===structTable===
	1652	===enumTable===
	1653	===unionTable===
	1654	===contextTable===
	1655	actual expression:
	1656	Short-circuited operation (and) on: Cast of:
	1657	Application of
	1658	Variable Expression: ?!=?: function
	1659	with parameters
	1660	signed int
	1661	signed int
	1662	returning
	1663	signed int
	1664
	1665	to arguments
	1666	Variable Expression: a: signed int
	1667
	1668	Variable Expression: 0: signed int
	1669
	1670
	1671	to:
	1672	signed int
	1673	and Cast of:
	1674	Application of
	1675	Variable Expression: ?!=?: function
	1676	with parameters
	1677	float
	1678	float
	1679	returning
	1680	signed int
	1681
	1682	to arguments
	1683	Variable Expression: c: float
	1684
	1685	Cast of:
	1686	Variable Expression: 0: signed int
	1687
	1688	to:
	1689	float
	1690
	1691
	1692	to:
	1693	signed int
	1694
	1695	--- results are
	1696	signed int
	1697
	1698	converting signed int
	1699	to signed int
	1700	cost is( 0, 0, 0 )
	1701	Case +++++++++++++
	1702	formals are:
	1703	signed int
	1704	actuals are:
	1705	Short-circuited operation (and) on: Cast of:
	1706	Application of
	1707	Variable Expression: ?!=?: function
	1708	with parameters
	1709	signed int
	1710	signed int
	1711	returning
	1712	signed int
	1713
	1714	to arguments
	1715	Variable Expression: a: signed int
	1716
	1717	Variable Expression: 0: signed int
	1718
	1719
	1720	to:
	1721	signed int
	1722	and Cast of:
	1723	Application of
	1724	Variable Expression: ?!=?: function
	1725	with parameters
	1726	float
	1727	float
	1728	returning
	1729	signed int
	1730
	1731	to arguments
	1732	Variable Expression: c: float
	1733
	1734	Cast of:
	1735	Variable Expression: 0: signed int
	1736
	1737	to:
	1738	float
	1739
	1740
	1741	to:
	1742	signed int
	1743
	1744
	1745	bindings are:
	1746	cost of conversion is:( 0, 0, 0 )
	1747	actual expression:
	1748	Short-circuited operation (and) on: Cast of:
	1749	Application of
	1750	Variable Expression: ?!=?: function
	1751	with parameters
	1752	signed int
	1753	signed int
	1754	returning
	1755	signed int
	1756
	1757	to arguments
	1758	Variable Expression: a: signed int
	1759
	1760	Variable Expression: 0: signed int
	1761
	1762
	1763	to:
	1764	signed int
	1765	and Cast of:
	1766	Application of
	1767	Variable Expression: ?!=?: function
	1768	with parameters
	1769	float
	1770	float
	1771	returning
	1772	signed int
	1773
	1774	to arguments
	1775	Variable Expression: c: float
	1776
	1777	Cast of:
	1778	Variable Expression: 0: signed int
	1779
	1780	to:
	1781	float
	1782
	1783
	1784	to:
	1785	signed int
	1786
	1787	--- results are
	1788	signed int
	1789
	1790	converting signed int
	1791	to float
	1792	cost is( 0, 0, 5 )
	1793	Case +++++++++++++
	1794	formals are:
	1795	float
	1796	actuals are:
	1797	Cast of:
	1798	Short-circuited operation (and) on: Cast of:
	1799	Application of
	1800	Variable Expression: ?!=?: function
	1801	with parameters
	1802	signed int
	1803	signed int
	1804	returning
	1805	signed int
	1806
	1807	to arguments
	1808	Variable Expression: a: signed int
	1809
	1810	Variable Expression: 0: signed int
	1811
	1812
	1813	to:
	1814	signed int
	1815	and Cast of:
	1816	Application of
	1817	Variable Expression: ?!=?: function
	1818	with parameters
	1819	float
	1820	float
	1821	returning
	1822	signed int
	1823
	1824	to arguments
	1825	Variable Expression: c: float
	1826
	1827	Cast of:
	1828	Variable Expression: 0: signed int
	1829
	1830	to:
	1831	float
	1832
	1833
	1834	to:
	1835	signed int
	1836
	1837
	1838	to:
	1839	float
	1840
	1841	bindings are:
	1842	cost of conversion is:( 0, 0, 5 )
	1843	alternatives before prune:
	1844	Cost ( 0, 0, 0 ): Application of
	1845	Variable Expression: g: function
	1846	with parameters
	1847	signed int
	1848	returning
	1849	nothing
	1850
	1851	to arguments
	1852	Short-circuited operation (and) on: Cast of:
	1853	Application of
	1854	Variable Expression: ?!=?: function
	1855	with parameters
	1856	signed int
	1857	signed int
	1858	returning
	1859	signed int
	1860
	1861	to arguments
	1862	Variable Expression: a: signed int
	1863
	1864	Variable Expression: 0: signed int
	1865
	1866
	1867	to:
	1868	signed int
	1869	and Cast of:
	1870	Application of
	1871	Variable Expression: ?!=?: function
	1872	with parameters
	1873	float
	1874	float
	1875	returning
	1876	signed int
	1877
	1878	to arguments
	1879	Variable Expression: c: float
	1880
	1881	Cast of:
	1882	Variable Expression: 0: signed int
	1883
	1884	to:
	1885	float
	1886
	1887
	1888	to:
	1889	signed int
	1890
	1891
	1892	(types:
	1893	)
	1894	Environment:
	1895
	1896	Cost ( 0, 0, 5 ): Application of
	1897	Variable Expression: g: function
	1898	with parameters
	1899	float
	1900	returning
	1901	nothing
	1902
	1903	to arguments
	1904	Cast of:
	1905	Short-circuited operation (and) on: Cast of:
	1906	Application of
	1907	Variable Expression: ?!=?: function
	1908	with parameters
	1909	signed int
	1910	signed int
	1911	returning
	1912	signed int
	1913
	1914	to arguments
	1915	Variable Expression: a: signed int
	1916
	1917	Variable Expression: 0: signed int
	1918
	1919
	1920	to:
	1921	signed int
	1922	and Cast of:
	1923	Application of
	1924	Variable Expression: ?!=?: function
	1925	with parameters
	1926	float
	1927	float
	1928	returning
	1929	signed int
	1930
	1931	to arguments
	1932	Variable Expression: c: float
	1933
	1934	Cast of:
	1935	Variable Expression: 0: signed int
	1936
	1937	to:
	1938	float
	1939
	1940
	1941	to:
	1942	signed int
	1943
	1944
	1945	to:
	1946	float
	1947
	1948	(types:
	1949	)
	1950	Environment:
	1951
	1952	there are 1 alternatives before elimination
	1953	there are 1 alternatives after elimination
	1954	alternatives before prune:
	1955	Cost ( 0, 0, 0 ): Cast of:
	1956	Application of
	1957	Variable Expression: g: function
	1958	with parameters
	1959	signed int
	1960	returning
	1961	nothing
	1962
	1963	to arguments
	1964	Short-circuited operation (and) on: Cast of:
	1965	Application of
	1966	Variable Expression: ?!=?: function
	1967	with parameters
	1968	signed int
	1969	signed int
	1970	returning
	1971	signed int
	1972
	1973	to arguments
	1974	Variable Expression: a: signed int
	1975
	1976	Variable Expression: 0: signed int
	1977
	1978
	1979	to:
	1980	signed int
	1981	and Cast of:
	1982	Application of
	1983	Variable Expression: ?!=?: function
	1984	with parameters
	1985	float
	1986	float
	1987	returning
	1988	signed int
	1989
	1990	to arguments
	1991	Variable Expression: c: float
	1992
	1993	Cast of:
	1994	Variable Expression: 0: signed int
	1995
	1996	to:
	1997	float
	1998
	1999
	2000	to:
	2001	signed int
	2002
	2003
	2004
	2005	to:
	2006	nothing
	2007	(types:
	2008	)
	2009	Environment:
	2010
	2011	there are 1 alternatives before elimination
	2012	there are 1 alternatives after elimination
	2013	nameExpr is g
	2014	decl is g: function
	2015	with parameters
	2016	float
	2017	returning
	2018	nothing
	2019
	2020	newExpr is Variable Expression: g: function
	2021	with parameters
	2022	float
	2023	returning
	2024	nothing
	2025
	2026
	2027	decl is g: function
	2028	with parameters
	2029	signed int
	2030	returning
	2031	nothing
	2032
	2033	newExpr is Variable Expression: g: function
	2034	with parameters
	2035	signed int
	2036	returning
	2037	nothing
	2038
	2039
	2040	alternatives before prune:
	2041	Cost ( 0, 0, 0 ): Variable Expression: g: function
	2042	with parameters
	2043	float
	2044	returning
	2045	nothing
	2046
	2047	(types:
	2048	pointer to function
	2049	with parameters
	2050	float
	2051	returning
	2052	nothing
	2053
	2054	)
	2055	Environment:
	2056
	2057	Cost ( 0, 0, 0 ): Variable Expression: g: function
	2058	with parameters
	2059	signed int
	2060	returning
	2061	nothing
	2062
	2063	(types:
	2064	pointer to function
	2065	with parameters
	2066	signed int
	2067	returning
	2068	nothing
	2069
	2070	)
	2071	Environment:
	2072
	2073	there are 2 alternatives before elimination
	2074	there are 2 alternatives after elimination
	2075	nameExpr is ?!=?
	2076	decl is ?!=?: function
	2077	with parameters
	2078	float
	2079	float
	2080	returning
	2081	signed int
	2082
	2083	newExpr is Variable Expression: ?!=?: function
	2084	with parameters
	2085	float
	2086	float
	2087	returning
	2088	signed int
	2089
	2090
	2091	decl is ?!=?: function
	2092	with parameters
	2093	signed int
	2094	signed int
	2095	returning
	2096	signed int
	2097
	2098	newExpr is Variable Expression: ?!=?: function
	2099	with parameters
	2100	signed int
	2101	signed int
	2102	returning
	2103	signed int
	2104
	2105
	2106	alternatives before prune:
	2107	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	2108	with parameters
	2109	float
	2110	float
	2111	returning
	2112	signed int
	2113
	2114	(types:
	2115	pointer to function
	2116	with parameters
	2117	float
	2118	float
	2119	returning
	2120	signed int
	2121
	2122	)
	2123	Environment:
	2124
	2125	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	2126	with parameters
	2127	signed int
	2128	signed int
	2129	returning
	2130	signed int
	2131
	2132	(types:
	2133	pointer to function
	2134	with parameters
	2135	signed int
	2136	signed int
	2137	returning
	2138	signed int
	2139
	2140	)
	2141	Environment:
	2142
	2143	there are 2 alternatives before elimination
	2144	there are 2 alternatives after elimination
	2145	nameExpr is a
	2146	decl is a: signed int
	2147	newExpr is Variable Expression: a: signed int
	2148
	2149	alternatives before prune:
	2150	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
	2151	(types:
	2152	lvalue signed int
	2153	)
	2154	Environment:
	2155
	2156	there are 1 alternatives before elimination
	2157	there are 1 alternatives after elimination
	2158	findSubExprs
	2159	Cost ( 0, 0, 0 ): Variable Expression: a: signed int
	2160	(types:
	2161	lvalue signed int
	2162	)
	2163	Environment:
	2164
	2165	nameExpr is 0
	2166	decl is 0: signed int
	2167	newExpr is Variable Expression: 0: signed int
	2168
	2169	alternatives before prune:
	2170	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
	2171	(types:
	2172	lvalue signed int
	2173	)
	2174	Environment:
	2175
	2176	there are 1 alternatives before elimination
	2177	there are 1 alternatives after elimination
	2178	findSubExprs
	2179	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
	2180	(types:
	2181	lvalue signed int
	2182	)
	2183	Environment:
	2184
	2185	working on alternative:
	2186	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	2187	with parameters
	2188	signed int
	2189	signed int
	2190	returning
	2191	signed int
	2192
	2193	(types:
	2194	pointer to function
	2195	with parameters
	2196	signed int
	2197	signed int
	2198	returning
	2199	signed int
	2200
	2201	)
	2202	Environment:
	2203	formal type is signed int
	2204	actual type is lvalue signed int
	2205	formal type is signed int
	2206	actual type is lvalue signed int
	2207	need assertions:
	2208	============= original indexer
	2209	===idTable===
	2210	===typeTable===
	2211	===structTable===
	2212	===enumTable===
	2213	===unionTable===
	2214	===contextTable===
	2215	============= new indexer
	2216	===idTable===
	2217	===typeTable===
	2218	===structTable===
	2219	===enumTable===
	2220	===unionTable===
	2221	===contextTable===
	2222	working on alternative:
	2223	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	2224	with parameters
	2225	float
	2226	float
	2227	returning
	2228	signed int
	2229
	2230	(types:
	2231	pointer to function
	2232	with parameters
	2233	float
	2234	float
	2235	returning
	2236	signed int
	2237
	2238	)
	2239	Environment:
	2240	formal type is float
	2241	actual type is lvalue signed int
	2242	formal type is float
	2243	actual type is lvalue signed int
	2244	need assertions:
	2245	============= original indexer
	2246	===idTable===
	2247	===typeTable===
	2248	===structTable===
	2249	===enumTable===
	2250	===unionTable===
	2251	===contextTable===
	2252	============= new indexer
	2253	===idTable===
	2254	===typeTable===
	2255	===structTable===
	2256	===enumTable===
	2257	===unionTable===
	2258	===contextTable===
	2259	actual expression:
	2260	Variable Expression: a: signed int
	2261	--- results are
	2262	lvalue signed int
	2263
	2264	converting lvalue signed int
	2265	to signed int
	2266	cost is( 0, 0, 0 )
	2267	actual expression:
	2268	Variable Expression: 0: signed int
	2269	--- results are
	2270	lvalue signed int
	2271
	2272	converting lvalue signed int
	2273	to signed int
	2274	cost is( 0, 0, 0 )
	2275	Case +++++++++++++
	2276	formals are:
	2277	signed int
	2278	signed int
	2279	actuals are:
	2280	Variable Expression: a: signed int
	2281
	2282	Variable Expression: 0: signed int
	2283
	2284	bindings are:
	2285	cost of conversion is:( 0, 0, 0 )
	2286	actual expression:
	2287	Variable Expression: a: signed int
	2288	--- results are
	2289	lvalue signed int
	2290
	2291	converting lvalue signed int
	2292	to float
	2293	cost is( 0, 0, 5 )
	2294	actual expression:
	2295	Variable Expression: 0: signed int
	2296	--- results are
	2297	lvalue signed int
	2298
	2299	converting lvalue signed int
	2300	to float
	2301	cost is( 0, 0, 5 )
	2302	Case +++++++++++++
	2303	formals are:
	2304	float
	2305	float
	2306	actuals are:
	2307	Cast of:
	2308	Variable Expression: a: signed int
	2309
	2310	to:
	2311	float
	2312
	2313	Cast of:
	2314	Variable Expression: 0: signed int
	2315
	2316	to:
	2317	float
	2318
	2319	bindings are:
	2320	cost of conversion is:( 0, 0, 10 )
	2321	alternatives before prune:
	2322	Cost ( 0, 0, 0 ): Application of
	2323	Variable Expression: ?!=?: function
	2324	with parameters
	2325	signed int
	2326	signed int
	2327	returning
	2328	signed int
	2329
	2330	to arguments
	2331	Variable Expression: a: signed int
	2332
	2333	Variable Expression: 0: signed int
	2334
	2335	(types:
	2336	signed int
	2337	)
	2338	Environment:
	2339
	2340	Cost ( 0, 0, 10 ): Application of
	2341	Variable Expression: ?!=?: function
	2342	with parameters
	2343	float
	2344	float
	2345	returning
	2346	signed int
	2347
	2348	to arguments
	2349	Cast of:
	2350	Variable Expression: a: signed int
	2351
	2352	to:
	2353	float
	2354
	2355	Cast of:
	2356	Variable Expression: 0: signed int
	2357
	2358	to:
	2359	float
	2360
	2361	(types:
	2362	signed int
	2363	)
	2364	Environment:
	2365
	2366	there are 1 alternatives before elimination
	2367	there are 1 alternatives after elimination
	2368	alternatives before prune:
	2369	Cost ( 0, 0, 0 ): Cast of:
	2370	Application of
	2371	Variable Expression: ?!=?: function
	2372	with parameters
	2373	signed int
	2374	signed int
	2375	returning
	2376	signed int
	2377
	2378	to arguments
	2379	Variable Expression: a: signed int
	2380
	2381	Variable Expression: 0: signed int
	2382
	2383
	2384	to:
	2385	signed int
	2386	(types:
	2387	signed int
	2388	)
	2389	Environment:
	2390
	2391	there are 1 alternatives before elimination
	2392	there are 1 alternatives after elimination
	2393	nameExpr is ?!=?
	2394	decl is ?!=?: function
	2395	with parameters
	2396	float
	2397	float
	2398	returning
	2399	signed int
	2400
	2401	newExpr is Variable Expression: ?!=?: function
	2402	with parameters
	2403	float
	2404	float
	2405	returning
	2406	signed int
	2407
	2408
	2409	decl is ?!=?: function
	2410	with parameters
	2411	signed int
	2412	signed int
	2413	returning
	2414	signed int
	2415
	2416	newExpr is Variable Expression: ?!=?: function
	2417	with parameters
	2418	signed int
	2419	signed int
	2420	returning
	2421	signed int
	2422
	2423
	2424	alternatives before prune:
	2425	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	2426	with parameters
	2427	float
	2428	float
	2429	returning
	2430	signed int
	2431
	2432	(types:
	2433	pointer to function
	2434	with parameters
	2435	float
	2436	float
	2437	returning
	2438	signed int
	2439
	2440	)
	2441	Environment:
	2442
	2443	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	2444	with parameters
	2445	signed int
	2446	signed int
	2447	returning
	2448	signed int
	2449
	2450	(types:
	2451	pointer to function
	2452	with parameters
	2453	signed int
	2454	signed int
	2455	returning
	2456	signed int
	2457
	2458	)
	2459	Environment:
	2460
	2461	there are 2 alternatives before elimination
	2462	there are 2 alternatives after elimination
	2463	nameExpr is b
	2464	decl is b: signed int
	2465	newExpr is Variable Expression: b: signed int
	2466
	2467	alternatives before prune:
	2468	Cost ( 0, 0, 0 ): Variable Expression: b: signed int
	2469	(types:
	2470	lvalue signed int
	2471	)
	2472	Environment:
	2473
	2474	there are 1 alternatives before elimination
	2475	there are 1 alternatives after elimination
	2476	findSubExprs
	2477	Cost ( 0, 0, 0 ): Variable Expression: b: signed int
	2478	(types:
	2479	lvalue signed int
	2480	)
	2481	Environment:
	2482
	2483	nameExpr is 0
	2484	decl is 0: signed int
	2485	newExpr is Variable Expression: 0: signed int
	2486
	2487	alternatives before prune:
	2488	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
	2489	(types:
	2490	lvalue signed int
	2491	)
	2492	Environment:
	2493
	2494	there are 1 alternatives before elimination
	2495	there are 1 alternatives after elimination
	2496	findSubExprs
	2497	Cost ( 0, 0, 0 ): Variable Expression: 0: signed int
	2498	(types:
	2499	lvalue signed int
	2500	)
	2501	Environment:
	2502
	2503	working on alternative:
	2504	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	2505	with parameters
	2506	signed int
	2507	signed int
	2508	returning
	2509	signed int
	2510
	2511	(types:
	2512	pointer to function
	2513	with parameters
	2514	signed int
	2515	signed int
	2516	returning
	2517	signed int
	2518
	2519	)
	2520	Environment:
	2521	formal type is signed int
	2522	actual type is lvalue signed int
	2523	formal type is signed int
	2524	actual type is lvalue signed int
	2525	need assertions:
	2526	============= original indexer
	2527	===idTable===
	2528	===typeTable===
	2529	===structTable===
	2530	===enumTable===
	2531	===unionTable===
	2532	===contextTable===
	2533	============= new indexer
	2534	===idTable===
	2535	===typeTable===
	2536	===structTable===
	2537	===enumTable===
	2538	===unionTable===
	2539	===contextTable===
	2540	working on alternative:
	2541	Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
	2542	with parameters
	2543	float
	2544	float
	2545	returning
	2546	signed int
	2547
	2548	(types:
	2549	pointer to function
	2550	with parameters
	2551	float
	2552	float
	2553	returning
	2554	signed int
	2555
	2556	)
	2557	Environment:
	2558	formal type is float
	2559	actual type is lvalue signed int
	2560	formal type is float
	2561	actual type is lvalue signed int
	2562	need assertions:
	2563	============= original indexer
	2564	===idTable===
	2565	===typeTable===
	2566	===structTable===
	2567	===enumTable===
	2568	===unionTable===
	2569	===contextTable===
	2570	============= new indexer
	2571	===idTable===
	2572	===typeTable===
	2573	===structTable===
	2574	===enumTable===
	2575	===unionTable===
	2576	===contextTable===
	2577	actual expression:
	2578	Variable Expression: b: signed int
	2579	--- results are
	2580	lvalue signed int
	2581
	2582	converting lvalue signed int
	2583	to signed int
	2584	cost is( 0, 0, 0 )
	2585	actual expression:
	2586	Variable Expression: 0: signed int
	2587	--- results are
	2588	lvalue signed int
	2589
	2590	converting lvalue signed int
	2591	to signed int
	2592	cost is( 0, 0, 0 )
	2593	Case +++++++++++++
	2594	formals are:
	2595	signed int
	2596	signed int
	2597	actuals are:
	2598	Variable Expression: b: signed int
	2599
	2600	Variable Expression: 0: signed int
	2601
	2602	bindings are:
	2603	cost of conversion is:( 0, 0, 0 )
	2604	actual expression:
	2605	Variable Expression: b: signed int
	2606	--- results are
	2607	lvalue signed int
	2608
	2609	converting lvalue signed int
	2610	to float
	2611	cost is( 0, 0, 5 )
	2612	actual expression:
	2613	Variable Expression: 0: signed int
	2614	--- results are
	2615	lvalue signed int
	2616
	2617	converting lvalue signed int
	2618	to float
	2619	cost is( 0, 0, 5 )
	2620	Case +++++++++++++
	2621	formals are:
	2622	float
	2623	float
	2624	actuals are:
	2625	Cast of:
	2626	Variable Expression: b: signed int
	2627
	2628	to:
	2629	float
	2630
	2631	Cast of:
	2632	Variable Expression: 0: signed int
	2633
	2634	to:
	2635	float
	2636
	2637	bindings are:
	2638	cost of conversion is:( 0, 0, 10 )
	2639	alternatives before prune:
	2640	Cost ( 0, 0, 0 ): Application of
	2641	Variable Expression: ?!=?: function
	2642	with parameters
	2643	signed int
	2644	signed int
	2645	returning
	2646	signed int
	2647
	2648	to arguments
	2649	Variable Expression: b: signed int
	2650
	2651	Variable Expression: 0: signed int
	2652
	2653	(types:
	2654	signed int
	2655	)
	2656	Environment:
	2657
	2658	Cost ( 0, 0, 10 ): Application of
	2659	Variable Expression: ?!=?: function
	2660	with parameters
	2661	float
	2662	float
	2663	returning
	2664	signed int
	2665
	2666	to arguments
	2667	Cast of:
	2668	Variable Expression: b: signed int
	2669
	2670	to:
	2671	float
	2672
	2673	Cast of:
	2674	Variable Expression: 0: signed int
	2675
	2676	to:
	2677	float
	2678
	2679	(types:
	2680	signed int
	2681	)
	2682	Environment:
	2683
	2684	there are 1 alternatives before elimination
	2685	there are 1 alternatives after elimination
	2686	alternatives before prune:
	2687	Cost ( 0, 0, 0 ): Cast of:
	2688	Application of
	2689	Variable Expression: ?!=?: function
	2690	with parameters
	2691	signed int
	2692	signed int
	2693	returning
	2694	signed int
	2695
	2696	to arguments
	2697	Variable Expression: b: signed int
	2698
	2699	Variable Expression: 0: signed int
	2700
	2701
	2702	to:
	2703	signed int
	2704	(types:
	2705	signed int
	2706	)
	2707	Environment:
	2708
	2709	there are 1 alternatives before elimination
	2710	there are 1 alternatives after elimination
	2711	alternatives before prune:
	2712	Cost ( 0, 0, 0 ): Short-circuited operation (or) on: Cast of:
	2713	Application of
	2714	Variable Expression: ?!=?: function
	2715	with parameters
	2716	signed int
	2717	signed int
	2718	returning
	2719	signed int
	2720
	2721	to arguments
	2722	Variable Expression: a: signed int
	2723
	2724	Variable Expression: 0: signed int
	2725
	2726
	2727	to:
	2728	signed int
	2729	and Cast of:
	2730	Application of
	2731	Variable Expression: ?!=?: function
	2732	with parameters
	2733	signed int
	2734	signed int
	2735	returning
	2736	signed int
	2737
	2738	to arguments
	2739	Variable Expression: b: signed int
	2740
	2741	Variable Expression: 0: signed int
	2742
	2743
	2744	to:
	2745	signed int
	2746
	2747	(types:
	2748	signed int
	2749	)
	2750	Environment:
	2751
	2752	there are 1 alternatives before elimination
	2753	there are 1 alternatives after elimination
	2754	findSubExprs
	2755	Cost ( 0, 0, 0 ): Short-circuited operation (or) on: Cast of:
	2756	Application of
	2757	Variable Expression: ?!=?: function
	2758	with parameters
	2759	signed int
	2760	signed int
	2761	returning
	2762	signed int
	2763
	2764	to arguments
	2765	Variable Expression: a: signed int
	2766
	2767	Variable Expression: 0: signed int
	2768
	2769
	2770	to:
	2771	signed int
	2772	and Cast of:
	2773	Application of
	2774	Variable Expression: ?!=?: function
	2775	with parameters
	2776	signed int
	2777	signed int
	2778	returning
	2779	signed int
	2780
	2781	to arguments
	2782	Variable Expression: b: signed int
	2783
	2784	Variable Expression: 0: signed int
	2785
	2786
	2787	to:
	2788	signed int
	2789
	2790	(types:
	2791	signed int
	2792	)
	2793	Environment:
	2794
	2795	working on alternative:
	2796	Cost ( 0, 0, 0 ): Variable Expression: g: function
	2797	with parameters
	2798	signed int
	2799	returning
	2800	nothing
	2801
	2802	(types:
	2803	pointer to function
	2804	with parameters
	2805	signed int
	2806	returning
	2807	nothing
	2808
	2809	)
	2810	Environment:
	2811	formal type is signed int
	2812	actual type is signed int
	2813	need assertions:
	2814	============= original indexer
	2815	===idTable===
	2816	===typeTable===
	2817	===structTable===
	2818	===enumTable===
	2819	===unionTable===
	2820	===contextTable===
	2821	============= new indexer
	2822	===idTable===
	2823	===typeTable===
	2824	===structTable===
	2825	===enumTable===
	2826	===unionTable===
	2827	===contextTable===
	2828	working on alternative:
	2829	Cost ( 0, 0, 0 ): Variable Expression: g: function
	2830	with parameters
	2831	float
	2832	returning
	2833	nothing
	2834
	2835	(types:
	2836	pointer to function
	2837	with parameters
	2838	float
	2839	returning
	2840	nothing
	2841
	2842	)
	2843	Environment:
	2844	formal type is float
	2845	actual type is signed int
	2846	need assertions:
	2847	============= original indexer
	2848	===idTable===
	2849	===typeTable===
	2850	===structTable===
	2851	===enumTable===
	2852	===unionTable===
	2853	===contextTable===
	2854	============= new indexer
	2855	===idTable===
	2856	===typeTable===
	2857	===structTable===
	2858	===enumTable===
	2859	===unionTable===
	2860	===contextTable===
	2861	actual expression:
	2862	Short-circuited operation (or) on: Cast of:
	2863	Application of
	2864	Variable Expression: ?!=?: function
	2865	with parameters
	2866	signed int
	2867	signed int
	2868	returning
	2869	signed int
	2870
	2871	to arguments
	2872	Variable Expression: a: signed int
	2873
	2874	Variable Expression: 0: signed int
	2875
	2876
	2877	to:
	2878	signed int
	2879	and Cast of:
	2880	Application of
	2881	Variable Expression: ?!=?: function
	2882	with parameters
	2883	signed int
	2884	signed int
	2885	returning
	2886	signed int
	2887
	2888	to arguments
	2889	Variable Expression: b: signed int
	2890
	2891	Variable Expression: 0: signed int
	2892
	2893
	2894	to:
	2895	signed int
	2896
	2897	--- results are
	2898	signed int
	2899
	2900	converting signed int
	2901	to signed int
	2902	cost is( 0, 0, 0 )
	2903	Case +++++++++++++
	2904	formals are:
	2905	signed int
	2906	actuals are:
	2907	Short-circuited operation (or) on: Cast of:
	2908	Application of
	2909	Variable Expression: ?!=?: function
	2910	with parameters
	2911	signed int
	2912	signed int
	2913	returning
	2914	signed int
	2915
	2916	to arguments
	2917	Variable Expression: a: signed int
	2918
	2919	Variable Expression: 0: signed int
	2920
	2921
	2922	to:
	2923	signed int
	2924	and Cast of:
	2925	Application of
	2926	Variable Expression: ?!=?: function
	2927	with parameters
	2928	signed int
	2929	signed int
	2930	returning
	2931	signed int
	2932
	2933	to arguments
	2934	Variable Expression: b: signed int
	2935
	2936	Variable Expression: 0: signed int
	2937
	2938
	2939	to:
	2940	signed int
	2941
	2942
	2943	bindings are:
	2944	cost of conversion is:( 0, 0, 0 )
	2945	actual expression:
	2946	Short-circuited operation (or) on: Cast of:
	2947	Application of
	2948	Variable Expression: ?!=?: function
	2949	with parameters
	2950	signed int
	2951	signed int
	2952	returning
	2953	signed int
	2954
	2955	to arguments
	2956	Variable Expression: a: signed int
	2957
	2958	Variable Expression: 0: signed int
	2959
	2960
	2961	to:
	2962	signed int
	2963	and Cast of:
	2964	Application of
	2965	Variable Expression: ?!=?: function
	2966	with parameters
	2967	signed int
	2968	signed int
	2969	returning
	2970	signed int
	2971
	2972	to arguments
	2973	Variable Expression: b: signed int
	2974
	2975	Variable Expression: 0: signed int
	2976
	2977
	2978	to:
	2979	signed int
	2980
	2981	--- results are
	2982	signed int
	2983
	2984	converting signed int
	2985	to float
	2986	cost is( 0, 0, 5 )
	2987	Case +++++++++++++
	2988	formals are:
	2989	float
	2990	actuals are:
	2991	Cast of:
	2992	Short-circuited operation (or) on: Cast of:
	2993	Application of
	2994	Variable Expression: ?!=?: function
	2995	with parameters
	2996	signed int
	2997	signed int
	2998	returning
	2999	signed int
	3000
	3001	to arguments
	3002	Variable Expression: a: signed int
	3003
	3004	Variable Expression: 0: signed int
	3005
	3006
	3007	to:
	3008	signed int
	3009	and Cast of:
	3010	Application of
	3011	Variable Expression: ?!=?: function
	3012	with parameters
	3013	signed int
	3014	signed int
	3015	returning
	3016	signed int
	3017
	3018	to arguments
	3019	Variable Expression: b: signed int
	3020
	3021	Variable Expression: 0: signed int
	3022
	3023
	3024	to:
	3025	signed int
	3026
	3027
	3028	to:
	3029	float
	3030
	3031	bindings are:
	3032	cost of conversion is:( 0, 0, 5 )
	3033	alternatives before prune:
	3034	Cost ( 0, 0, 0 ): Application of
	3035	Variable Expression: g: function
	3036	with parameters
	3037	signed int
	3038	returning
	3039	nothing
	3040
	3041	to arguments
	3042	Short-circuited operation (or) on: Cast of:
	3043	Application of
	3044	Variable Expression: ?!=?: function
	3045	with parameters
	3046	signed int
	3047	signed int
	3048	returning
	3049	signed int
	3050
	3051	to arguments
	3052	Variable Expression: a: signed int
	3053
	3054	Variable Expression: 0: signed int
	3055
	3056
	3057	to:
	3058	signed int
	3059	and Cast of:
	3060	Application of
	3061	Variable Expression: ?!=?: function
	3062	with parameters
	3063	signed int
	3064	signed int
	3065	returning
	3066	signed int
	3067
	3068	to arguments
	3069	Variable Expression: b: signed int
	3070
	3071	Variable Expression: 0: signed int
	3072
	3073
	3074	to:
	3075	signed int
	3076
	3077
	3078	(types:
	3079	)
	3080	Environment:
	3081
	3082	Cost ( 0, 0, 5 ): Application of
	3083	Variable Expression: g: function
	3084	with parameters
	3085	float
	3086	returning
	3087	nothing
	3088
	3089	to arguments
	3090	Cast of:
	3091	Short-circuited operation (or) on: Cast of:
	3092	Application of
	3093	Variable Expression: ?!=?: function
	3094	with parameters
	3095	signed int
	3096	signed int
	3097	returning
	3098	signed int
	3099
	3100	to arguments
	3101	Variable Expression: a: signed int
	3102
	3103	Variable Expression: 0: signed int
	3104
	3105
	3106	to:
	3107	signed int
	3108	and Cast of:
	3109	Application of
	3110	Variable Expression: ?!=?: function
	3111	with parameters
	3112	signed int
	3113	signed int
	3114	returning
	3115	signed int
	3116
	3117	to arguments
	3118	Variable Expression: b: signed int
	3119
	3120	Variable Expression: 0: signed int
	3121
	3122
	3123	to:
	3124	signed int
	3125
	3126
	3127	to:
	3128	float
	3129
	3130	(types:
	3131	)
	3132	Environment:
	3133
	3134	there are 1 alternatives before elimination
	3135	there are 1 alternatives after elimination
	3136	alternatives before prune:
	3137	Cost ( 0, 0, 0 ): Cast of:
	3138	Application of
	3139	Variable Expression: g: function
	3140	with parameters
	3141	signed int
	3142	returning
	3143	nothing
	3144
	3145	to arguments
	3146	Short-circuited operation (or) on: Cast of:
	3147	Application of
	3148	Variable Expression: ?!=?: function
	3149	with parameters
	3150	signed int
	3151	signed int
	3152	returning
	3153	signed int
	3154
	3155	to arguments
	3156	Variable Expression: a: signed int
	3157
	3158	Variable Expression: 0: signed int
	3159
	3160
	3161	to:
	3162	signed int
	3163	and Cast of:
	3164	Application of
	3165	Variable Expression: ?!=?: function
	3166	with parameters
	3167	signed int
	3168	signed int
	3169	returning
	3170	signed int
	3171
	3172	to arguments
	3173	Variable Expression: b: signed int
	3174
	3175	Variable Expression: 0: signed int
	3176
	3177
	3178	to:
	3179	signed int
	3180
	3181
	3182
	3183	to:
	3184	nothing
	3185	(types:
	3186	)
	3187	Environment:
	3188
	3189	there are 1 alternatives before elimination
	3190	there are 1 alternatives after elimination
	3191	int ___operator_notequal__Fi_ii_(int , int );
	3192	int ___operator_notequal__Fi_ff_(float , float );
	3193	int ___constant_zero__i;
	3194	void __g__F_f_(float );
	3195	void __g__F_i_(int );
	3196	void __f__F_i_(int __a__i){
	3197	int __b__i;
	3198	float __c__f;
	3199	__g__F_f_((((int )___operator_notequal__Fi_ii_(__a__i, ___constant_zero__i)) ? __b__i : __c__f));
	3200	__g__F_i_((((int )___operator_notequal__Fi_ii_(__a__i, ___constant_zero__i)) && ((int )___operator_notequal__Fi_ff_(__c__f, ((float )___constant_zero__i)))));
	3201	__g__F_i_((((int )___operator_notequal__Fi_ii_(__a__i, ___constant_zero__i)) \|\| ((int )___operator_notequal__Fi_ii_(__b__i, ___constant_zero__i))));
	3202	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: