OpenShadingLanguage 1.01
# Compiled by oslc 1.6.2
light uberlight	%meta{string,help,"Mother of all lights"} %emit{1}
param	string	lighttype	"spot"		%meta{string,help,"Light type"}  %read{5,86} %write{2147483647,-1}
param	float	intensity	1		%meta{string,help,"Overall light intensity"} %meta{float,min,0}  %read{39,301} %write{2147483647,-1}
param	color	lightcolor	1 1 1		%meta{string,help,"Overall light color"}  %read{38,38} %write{2147483647,-1}
param	float	falloff	0		%meta{string,help,"Distance falloff exponent"} %meta{float,min,0} %meta{float,max,3}  %read{58,67} %write{2147483647,-1}
param	float	falloffdist	1		%meta{string,help,"Scale for distance falloff"} %meta{float,min,0}  %read{60,69} %write{2147483647,-1}
param	float	maxintensity	2		%meta{string,help,"Maximum intensity clamp"} %meta{float,min,0}  %read{42,42} %write{2147483647,-1}
param	float	cuton	0.0099999998		%meta{string,help,"Depth at which light is fully on"} %meta{float,min,0}  %read{51,206} %write{2147483647,-1}
param	float	cutoff	1000000		%meta{string,help,"Depth at which light starts turning off"} %meta{float,min,0}  %read{54,55} %write{2147483647,-1}
param	float	nearedge	0		%meta{string,help,"Depth at which light starts turning on"} %meta{float,min,0}  %read{51,51} %write{2147483647,-1}
param	float	faredge	0		%meta{string,help,"Depth at which light is fully off"} %meta{float,min,0}  %read{54,54} %write{2147483647,-1}
param	float	parallelrays	0		%meta{string,help,"Are rays parallel?"}  %read{198,303} %write{2147483647,-1}
param	float	zreverse	0		%meta{string,help,"Send light to -z instead of +z?"}  %read{2,203} %write{2147483647,-1}
param	float	shearx	0		%meta{string,help,"x shear of light frustum"} %meta{float,min,-1} %meta{float,max,1}  %read{18,89} %write{2147483647,-1}
param	float	sheary	0		%meta{string,help,"y shear of light frustum"} %meta{float,min,-1} %meta{float,max,1}  %read{15,89} %write{2147483647,-1}
param	float	width	1		%meta{string,help,"x dimension of barn door"} %meta{float,min,0}  %read{17,163} %write{2147483647,-1} %derivs
param	float	height	1		%meta{string,help,"y dimension of barn door"} %meta{float,min,0}  %read{14,164} %write{2147483647,-1} %derivs
param	float	wedge	0.1		%meta{string,help,"width of barn door edge fuzz"} %meta{float,min,0} %meta{float,max,1}  %read{17,163} %write{2147483647,-1} %derivs
param	float	hedge	0.1		%meta{string,help,"height of barn door edge fuzz"} %meta{float,min,0} %meta{float,max,1}  %read{14,164} %write{2147483647,-1} %derivs
param	float	roundness	1		%meta{string,help,"Roundness of light cone shape"} %meta{float,min,0} %meta{float,max,1}  %read{106,137} %write{2147483647,-1}
param	float	beamdistribution	0		%meta{string,help,"Angular falloff exponent"} %meta{float,min,0}  %read{78,84} %write{2147483647,-1}
param	string	slidename	""		%meta{string,help,"Name of texture for slide projector"}  %read{161,176} %write{2147483647,-1}
param	float	noiseamp	0		%meta{string,help,"Noise amplitude"} %meta{float,min,0}  %read{180,187} %write{2147483647,-1}
param	float	noisefreq	4		%meta{string,help,"Noise frequency"} %meta{float,min,0}  %read{183,183} %write{2147483647,-1}
param	vector	noiseoffset	0 0 0		%meta{string,help,"Noise spatial offset"}  %read{182,182} %write{2147483647,-1}
param	string	shadowname	""		%meta{string,help,"Shadow name (map or geomset)"}  %read{192,196} %write{2147483647,-1}
param	float	shadowblur	0		%meta{string,help,"Shadow blur"} %meta{float,min,0} %meta{float,max,1}  %read{196,196} %write{2147483647,-1}
param	float	shadowsamples	1		%meta{string,help,"Shadow samples"} %meta{int,min,1} %meta{int,max,256}  %read{195,195} %write{2147483647,-1}
param	float	shadowbias	-1		%meta{string,help,"Shadow bias (-1 means default)"} %meta{float,min,-1} %meta{float,max,1}  %read{196,196} %write{2147483647,-1}
param	color	shadowcolor	0 0 0		%meta{string,help,"Shadow tint"}  %read{297,297} %write{2147483647,-1}
param	string	blockercoords	""		%meta{string,help,"Blocker coordinate system"}  %read{208,215} %write{2147483647,-1}
param	float	blockerwidth	1		%meta{string,help,"Blocker width"}  %read{227,277} %write{2147483647,-1}
param	float	blockerheight	1		%meta{string,help,"Blocker height"} %meta{float,min,0}  %read{228,275} %write{2147483647,-1}
param	float	blockerwedge	0.1		%meta{string,help,"Blocker width fuzz"} %meta{float,min,0}  %read{227,227} %write{2147483647,-1}
param	float	blockerhedge	0.1		%meta{string,help,"Blocker height fuzz"} %meta{float,min,0} %meta{float,max,1}  %read{228,228} %write{2147483647,-1}
param	float	blockerround	1		%meta{string,help,"Blocker roundness"} %meta{float,min,0} %meta{float,max,1}  %read{242,273} %write{2147483647,-1}
oparam	float	__nonspecular	0		%read{298,310} %write{300,300}
oparam	float	__nondiffuse	0		%read{311,311} %write{2147483647,-1}
oparam	float	__foglight	1		%read{309,309} %write{2147483647,-1}
global	point	P	%read{25,25} %write{2147483647,-1} %derivs
global	normal	N	%read{26,26} %write{2147483647,-1} %derivs
global	point	Ps	%read{1,306} %write{2147483647,-1} %derivs
global	vector	L	%read{194,194} %write{308,308} %derivs
global	color	Cl	%read{2147483647,-1} %write{302,302}
local	float	___291_result	%read{157,293} %write{94,292}
local	float	___291_x	%read{99,284} %write{96,232}
local	float	___291_y	%read{102,286} %write{98,234}
local	float	___294_q	%read{136,272} %write{125,261}
local	float	___294_r	%read{136,272} %write{135,271}
local	float	___296_re	%read{140,289} %write{137,273}
local	float	___296_q	%read{156,292} %write{146,282}
local	float	___296_r	%read{156,292} %write{155,291}
local	float	___297_atten	%read{53,160} %write{45,159}
local	float	___297_PLlen	%read{50,69} %write{46,46}
local	float	___297_Pz	%read{52,88} %write{49,50}
local	float	___302_s	%read{68,71} %write{66,66}
local	float	___302_beta	%read{70,70} %write{68,68}
local	vector	___303_PLN	%read{83,83} %write{82,82}
local	float	___305_unoccluded	%read{294,295} %write{211,294}
local	point	___305_Pb1	%read{217,226} %write{213,213}
local	point	___305_Pb2	%read{216,221} %write{215,215}
local	vector	___306_Vlight	%read{223,225} %write{221,221}
local	point	___306_Pplane	%read{231,233} %write{226,226}
local	point	PL	%read{4,202} %write{1,4} %derivs
local	point	from	%read{36,306} %write{7,28} %derivs
local	vector	axis	%read{36,305} %write{13,34} %derivs
local	float	angle	%read{36,36} %write{22,35}
local	float	___307_maxradius	%read{22,22} %write{21,21}
local	float	___310_atten	%read{178,301} %write{41,190}
local	color	___310_lcol	%read{177,302} %write{38,297}
local	point	___311_Pslide	%read{167,172} %write{166,166} %derivs
local	float	___311_zslide	%read{170,174} %write{167,167} %derivs
local	float	___311_xslide	%read{176,176} %write{171,171} %derivs
local	float	___311_yslide	%read{176,176} %write{175,175} %derivs
local	float	___313_n	%read{186,190} %write{185,189}
local	float	___312_unoccluded	%read{197,299} %write{191,296}
local	point	___312_shadoworigin	%read{215,215} %write{200,207}
const	string	$const1	"shader"		%read{1,207} %write{2147483647,-1}
const	string	$const2	"transform"		%read{0,214} %write{2147483647,-1}
const	string	$const3	"common"		%read{1,215} %write{2147483647,-1}
temp	int	$tmp1	%read{3,3} %write{2,2}
const	float	$const4	0		%read{2,303} %write{2147483647,-1}
const	vector	$const5	1 1 -1		%read{4,4} %write{2147483647,-1}
const	string	$const6	"spot"		%read{5,86} %write{2147483647,-1}
temp	int	$tmp3	%read{6,6} %write{5,5}
const	int	$const7	0		%read{39,239} %write{2147483647,-1}
temp	int	$tmp4	%read{12,12} %write{10,11} %derivs
temp	int	$tmp5	%read{9,9} %write{8,8}
const	int	$const8	-1		%read{10,31} %write{2147483647,-1}
const	int	$const9	1		%read{11,233} %write{2147483647,-1}
temp	float	$tmp6	%read{13,13} %write{12,12} %derivs
const	float	$const10	1.4142135		%read{21,21} %write{2147483647,-1}
temp	float	$tmp7	%read{21,21} %write{20,20}
temp	float	$tmp8	%read{16,16} %write{14,14}
temp	float	$tmp9	%read{16,16} %write{15,15}
temp	float	$tmp10	%read{20,20} %write{16,16}
temp	float	$tmp11	%read{19,19} %write{17,17}
temp	float	$tmp12	%read{19,19} %write{18,18}
temp	float	$tmp13	%read{20,20} %write{19,19}
const	string	$const11	"arealight"		%read{23,23} %write{2147483647,-1}
temp	int	$tmp14	%read{24,24} %write{23,23}
const	float	$const12	1.5707964		%read{27,27} %write{2147483647,-1}
temp	int	$tmp15	%read{33,33} %write{31,32} %derivs
temp	int	$tmp16	%read{30,30} %write{29,29}
temp	float	$tmp17	%read{34,34} %write{33,33} %derivs
const	float	$const13	3.1415927		%read{35,35} %write{2147483647,-1}
temp	int	$tmp18	%read{37,37} %write{36,36}
temp	int	$tmp19	%read{40,40} %write{39,39}
temp	float	$tmp20	%read{65,73} %write{43,43}
const	float	$const14	1.01		%read{43,43} %write{2147483647,-1}
temp	float	$tmp21	%read{43,43} %write{42,42}
const	string	$const15	"ShapeLightVolume"		%read{44,44} %write{2147483647,-1}
temp	int	$tmp22	%read{48,48} %write{47,47}
const	int	$const16	2		%read{49,223} %write{2147483647,-1}
temp	float	$tmp23	%read{53,53} %write{52,52}
temp	float	$tmp24	%read{52,52} %write{51,51}
temp	float	$tmp25	%read{56,56} %write{55,55}
temp	float	$tmp26	%read{55,55} %write{54,54}
temp	float	$tmp27	%read{57,57} %write{56,56}
const	float	$const17	1		%read{56,300} %write{2147483647,-1}
temp	int	$tmp28	%read{59,59} %write{58,58}
temp	int	$tmp29	%read{61,61} %write{60,60}
temp	float	$tmp30	%read{64,64} %write{63,63}
temp	float	$tmp31	%read{63,63} %write{62,62}
temp	float	$tmp32	%read{66,66} %write{65,65}
temp	float	$tmp33	%read{68,68} %write{67,67}
temp	float	$tmp34	%read{73,73} %write{72,72}
temp	float	$tmp35	%read{71,71} %write{70,70}
temp	float	$tmp36	%read{70,70} %write{69,69}
temp	float	$tmp37	%read{72,72} %write{71,71}
temp	float	$tmp38	%read{74,74} %write{73,73}
const	string	$const18	"omni"		%read{75,75} %write{2147483647,-1}
temp	int	$tmp39	%read{76,76} %write{75,75}
temp	int	$tmp40	%read{77,81} %write{76,80}
temp	int	$tmp41	%read{79,79} %write{78,78}
temp	int	$tmp42	%read{80,80} %write{79,79}
temp	float	$tmp43	%read{85,85} %write{84,84}
temp	float	$tmp44	%read{84,84} %write{83,83}
temp	int	$tmp45	%read{87,87} %write{86,86}
temp	float	$tmp46	%read{158,158} %write{157,157}
temp	point	$tmp47	%read{90,90} %write{88,88}
temp	point	$tmp48	%read{90,90} %write{89,89}
temp	vector	$tmp49	%read{95,97} %write{90,90}
temp	float	$tmp50	%read{108,150} %write{91,91}
temp	float	$tmp51	%read{110,148} %write{92,92}
const	string	$const19	"clipSuperellipse"		%read{93,229} %write{2147483647,-1}
temp	float	$tmp52	%read{96,96} %write{95,95}
temp	float	$tmp53	%read{98,98} %write{97,97}
temp	int	$tmp54	%read{100,100} %write{99,99}
temp	int	$tmp55	%read{101,105} %write{100,104}
temp	int	$tmp56	%read{103,103} %write{102,102}
temp	int	$tmp57	%read{104,104} %write{103,103}
const	float	$const20	1e-006		%read{106,242} %write{2147483647,-1}
temp	int	$tmp58	%read{107,107} %write{106,106}
temp	float	$tmp59	%read{109,109} %write{108,108}
temp	float	$tmp60	%read{112,112} %write{109,109}
temp	float	$tmp61	%read{111,111} %write{110,110}
temp	float	$tmp62	%read{112,112} %write{111,111}
temp	float	$tmp63	%read{113,113} %write{112,112}
const	float	$const21	0.99989998		%read{114,250} %write{2147483647,-1}
temp	int	$tmp64	%read{115,115} %write{114,114}
temp	float	$tmp65	%read{125,125} %write{116,116}
temp	float	$tmp66	%read{125,125} %write{124,124}
temp	float	$tmp67	%read{123,123} %write{119,119}
temp	float	$tmp68	%read{119,119} %write{117,117}
const	string	$const22	"sqr"		%read{118,267} %write{2147483647,-1}
temp	float	$tmp69	%read{123,123} %write{122,122}
temp	float	$tmp70	%read{122,122} %write{120,120}
temp	float	$tmp71	%read{124,124} %write{123,123}
temp	float	$tmp72	%read{135,135} %write{126,126}
temp	float	$tmp73	%read{135,135} %write{134,134}
temp	float	$tmp74	%read{133,133} %write{129,129}
temp	float	$tmp75	%read{129,129} %write{127,127}
temp	float	$tmp76	%read{133,133} %write{132,132}
temp	float	$tmp77	%read{132,132} %write{130,130}
temp	float	$tmp78	%read{134,134} %write{133,133}
const	float	$const23	2		%read{137,273} %write{2147483647,-1}
temp	float	$tmp79	%read{146,146} %write{138,138}
temp	float	$tmp80	%read{146,146} %write{145,145}
temp	float	$tmp81	%read{143,143} %write{140,140}
temp	float	$tmp82	%read{140,140} %write{139,139}
temp	float	$tmp83	%read{143,143} %write{142,142}
temp	float	$tmp84	%read{142,142} %write{141,141}
temp	float	$tmp85	%read{145,145} %write{143,143}
temp	float	$tmp86	%read{145,145} %write{144,144}
const	float	$const24	-1		%read{144,289} %write{2147483647,-1}
temp	float	$tmp87	%read{155,155} %write{147,147}
temp	float	$tmp88	%read{155,155} %write{154,154}
temp	float	$tmp89	%read{152,152} %write{149,149}
temp	float	$tmp90	%read{149,149} %write{148,148}
temp	float	$tmp91	%read{152,152} %write{151,151}
temp	float	$tmp92	%read{151,151} %write{150,150}
temp	float	$tmp93	%read{154,154} %write{152,152}
temp	float	$tmp94	%read{154,154} %write{153,153}
temp	float	$tmp95	%read{159,159} %write{158,158}
temp	int	$tmp96	%read{162,162} %write{161,161}
const	string	$const25	""		%read{161,208} %write{2147483647,-1}
temp	point	$tmp97	%read{166,166} %write{165,165} %derivs
temp	float	$tmp98	%read{165,165} %write{163,163} %derivs
temp	float	$tmp99	%read{165,165} %write{164,164} %derivs
const	float	$const26	0.5		%read{169,188} %write{2147483647,-1}
temp	float	$tmp100	%read{169,169} %write{168,168} %derivs
temp	float	$tmp101	%read{170,170} %write{169,169} %derivs
temp	float	$tmp102	%read{171,171} %write{170,170} %derivs
temp	float	$tmp103	%read{173,173} %write{172,172} %derivs
temp	float	$tmp104	%read{174,174} %write{173,173} %derivs
temp	float	$tmp105	%read{175,175} %write{174,174} %derivs
temp	color	$tmp106	%read{177,177} %write{176,176}
temp	int	$tmp107	%read{179,179} %write{178,178}
temp	int	$tmp108	%read{181,181} %write{180,180}
temp	point	$tmp109	%read{183,183} %write{182,182}
temp	point	$tmp110	%read{184,184} %write{183,183}
const	point	$const27	1 1 0		%read{184,184} %write{2147483647,-1}
temp	point	$tmp112	%read{185,185} %write{184,184}
temp	float	$tmp113	%read{187,187} %write{186,186}
temp	float	$tmp114	%read{188,188} %write{187,187}
temp	float	$tmp115	%read{189,189} %write{188,188}
temp	int	$tmp116	%read{193,193} %write{192,192}
temp	float	$tmp117	%read{197,197} %write{196,196}
temp	point	$tmp118	%read{196,196} %write{194,194} %derivs
const	string	$const28	"traceset"		%read{196,196} %write{2147483647,-1}
const	string	$const29	"blur"		%read{196,196} %write{2147483647,-1}
const	string	$const30	"samples"		%read{196,196} %write{2147483647,-1}
temp	int	$tmp119	%read{196,196} %write{195,195}
const	string	$const31	"bias"		%read{196,196} %write{2147483647,-1}
temp	int	$tmp120	%read{199,199} %write{198,198}
temp	float	$tmp121	%read{207,207} %write{201,201}
temp	float	$tmp122	%read{207,207} %write{202,202}
temp	float	$tmp123	%read{207,207} %write{205,206}
temp	int	$tmp124	%read{204,204} %write{203,203}
temp	int	$tmp125	%read{209,209} %write{208,208}
temp	float	$tmp126	%read{296,296} %write{295,295}
const	string	$const32	"BlockerContribution"		%read{210,210} %write{2147483647,-1}
temp	float	$tmp127	%read{218,218} %write{216,216}
temp	float	$tmp128	%read{218,218} %write{217,217}
temp	float	$tmp129	%read{219,219} %write{218,218}
temp	int	$tmp130	%read{220,220} %write{219,219}
temp	float	$tmp131	%read{224,224} %write{222,222}
temp	float	$tmp132	%read{224,224} %write{223,223}
temp	float	$tmp133	%read{225,225} %write{224,224}
temp	vector	$tmp134	%read{226,226} %write{225,225}
temp	float	$tmp135	%read{294,294} %write{293,293}
temp	float	$tmp136	%read{244,286} %write{227,227}
temp	float	$tmp137	%read{246,284} %write{228,228}
temp	float	$tmp138	%read{232,232} %write{231,231}
temp	float	$tmp139	%read{234,234} %write{233,233}
temp	int	$tmp140	%read{236,236} %write{235,235}
temp	int	$tmp141	%read{237,241} %write{236,240}
temp	int	$tmp142	%read{239,239} %write{238,238}
temp	int	$tmp143	%read{240,240} %write{239,239}
temp	int	$tmp144	%read{243,243} %write{242,242}
temp	float	$tmp145	%read{245,245} %write{244,244}
temp	float	$tmp146	%read{248,248} %write{245,245}
temp	float	$tmp147	%read{247,247} %write{246,246}
temp	float	$tmp148	%read{248,248} %write{247,247}
temp	float	$tmp149	%read{249,249} %write{248,248}
temp	int	$tmp150	%read{251,251} %write{250,250}
temp	float	$tmp151	%read{261,261} %write{252,252}
temp	float	$tmp152	%read{261,261} %write{260,260}
temp	float	$tmp153	%read{259,259} %write{255,255}
temp	float	$tmp154	%read{255,255} %write{253,253}
temp	float	$tmp155	%read{259,259} %write{258,258}
temp	float	$tmp156	%read{258,258} %write{256,256}
temp	float	$tmp157	%read{260,260} %write{259,259}
temp	float	$tmp158	%read{271,271} %write{262,262}
temp	float	$tmp159	%read{271,271} %write{270,270}
temp	float	$tmp160	%read{269,269} %write{265,265}
temp	float	$tmp161	%read{265,265} %write{263,263}
temp	float	$tmp162	%read{269,269} %write{268,268}
temp	float	$tmp163	%read{268,268} %write{266,266}
temp	float	$tmp164	%read{270,270} %write{269,269}
temp	float	$tmp165	%read{282,282} %write{274,274}
temp	float	$tmp166	%read{282,282} %write{281,281}
temp	float	$tmp167	%read{279,279} %write{276,276}
temp	float	$tmp168	%read{276,276} %write{275,275}
temp	float	$tmp169	%read{279,279} %write{278,278}
temp	float	$tmp170	%read{278,278} %write{277,277}
temp	float	$tmp171	%read{281,281} %write{279,279}
temp	float	$tmp172	%read{281,281} %write{280,280}
temp	float	$tmp173	%read{291,291} %write{283,283}
temp	float	$tmp174	%read{291,291} %write{290,290}
temp	float	$tmp175	%read{288,288} %write{285,285}
temp	float	$tmp176	%read{285,285} %write{284,284}
temp	float	$tmp177	%read{288,288} %write{287,287}
temp	float	$tmp178	%read{287,287} %write{286,286}
temp	float	$tmp179	%read{290,290} %write{288,288}
temp	float	$tmp180	%read{290,290} %write{289,289}
temp	float	$tmp181	%read{299,299} %write{298,298}
temp	float	$tmp182	%read{300,300} %write{299,299}
temp	float	$tmp183	%read{302,302} %write{301,301}
temp	int	$tmp184	%read{304,304} %write{303,303}
temp	vector	$tmp185	%read{308,308} %write{305,305} %derivs
temp	float	$tmp186	%read{308,308} %write{307,307} %derivs
temp	vector	$tmp187	%read{307,307} %write{306,306} %derivs
const	string	$const33	"__foglight"		%read{309,309} %write{2147483647,-1}
const	string	$const34	"__nonspecular"		%read{310,310} %write{2147483647,-1}
const	string	$const35	"__nondiffuse"		%read{311,311} %write{2147483647,-1}
code ___main___
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:544
#     if (zreverse)
	functioncall	$const2 2 	%filename{"D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl"} %line{544} %argrw{"r"}
# D:/xrt.git\\build\\vc10\\Win32\\Release\\shaders\\stdosl.h:249
# point  transform (string to, point p)  { return transform("common",to,p); }
	transform	PL $const3 $const1 Ps 	%filename{"D:/xrt.git\\build\\vc10\\Win32\\Release\\shaders\\stdosl.h"} %line{249} %argrw{"wrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:545
#     if (falloff != 0) {
	neq		$tmp1 zreverse $const4 	%filename{"D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl"} %line{545} %argrw{"wrr"}
	if		$tmp1 5 5 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:546
# 	if (PLlen > falloffdist) {
	mul		PL PL $const5 	%line{546} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:555
#     // Clip to superellipse
	eq		$tmp3 lighttype $const6 	%line{555} %argrw{"wrr"}
	if		$tmp3 23 36 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:556
#     if (lighttype != "omni" && beamdistribution > 0) {
	point		from $const1 $const4 $const4 $const4 	%line{556} %argrw{"wrrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:557
# 	vector PLN = normalize((vector)PL);
	neq		$tmp5 zreverse $const4 	%line{557} %argrw{"wrr"}
	if		$tmp5 11 12 	%argrw{"r"}
	assign		$tmp4 $const8 	%argrw{"wr"}
	assign		$tmp4 $const9 	%argrw{"wr"}
	assign		$tmp6 $tmp4 	%argrw{"wr"}
	vector		axis $const1 $const4 $const4 $tmp6 	%argrw{"wrrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:558
# 	atten *= pow (PLN[2], beamdistribution);
	add		$tmp8 height hedge 	%line{558} %argrw{"wrr"}
	abs		$tmp9 sheary 	%argrw{"wr"}
	add		$tmp10 $tmp8 $tmp9 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:559
#     }
	add		$tmp11 width wedge 	%line{559} %argrw{"wrr"}
	abs		$tmp12 shearx 	%argrw{"wr"}
	add		$tmp13 $tmp11 $tmp12 	%argrw{"wrr"}
	max		$tmp7 $tmp10 $tmp13 	%argrw{"wrr"}
	mul		___307_maxradius $const10 $tmp7 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:560
#     if (lighttype == "spot") {
	atan		angle ___307_maxradius 	%line{560} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:561
# 	atten *= 1 - clipSuperellipse (PL/Pz-point(shearx,sheary,0),
	eq		$tmp14 lighttype $const11 	%line{561} %argrw{"wrr"}
	if		$tmp14 28 36 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:562
# 				       width, height,
	assign		from P 	%line{562} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:563
# 				       width+wedge, height+hedge, roundness);
	assign		axis N 	%line{563} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:564
#     }
	assign		angle $const12 	%line{564} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:566
# }
	point		from $const1 $const4 $const4 $const4 	%line{566} %argrw{"wrrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:567
# 
	neq		$tmp16 zreverse $const4 	%line{567} %argrw{"wrr"}
	if		$tmp16 32 33 	%argrw{"r"}
	assign		$tmp15 $const8 	%argrw{"wr"}
	assign		$tmp15 $const9 	%argrw{"wr"}
	assign		$tmp17 $tmp15 	%argrw{"wr"}
	vector		axis $const1 $const4 $const4 $tmp17 	%argrw{"wrrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:568
# 
	assign		angle $const13 	%line{568} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:633
#                    [[
	emit		$tmp18 from axis angle 	%line{633} %argrw{"wrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:570
# 	// Accumulate attenuation of the light as it is affected by various
	if		$tmp18 309 309 	%line{570} %argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:575
# 
	assign		___310_lcol lightcolor 	%line{575} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:579
# 	    atten = 0;
	eq		$tmp19 intensity $const7 	%line{579} %argrw{"wrr"}
	if		$tmp19 42 161 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:580
# 	else
	assign		___310_atten $const7 	%line{580} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:584
#                                       shearx, sheary,
	div		$tmp21 maxintensity intensity 	%line{584} %argrw{"wrr"}
	max		$tmp20 $const14 $tmp21 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:587
# 
	functioncall	$const15 161 	%line{587} %argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:284
#     float PLlen = length(PL);
	assign		___297_atten $const9 	%line{284} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:285
#     float Pz;
	length		___297_PLlen PL 	%line{285} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:287
# 	Pz = PL[2];
	eq		$tmp22 lighttype $const6 	%line{287} %argrw{"wrr"}
	if		$tmp22 50 51 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:288
#     } else {
	compref		___297_Pz PL $const16 	%line{288} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:291
#     }
	assign		___297_Pz ___297_PLlen 	%line{291} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:293
#     atten *= 1 - smoothstep (zfar, zfar+faredge, Pz);
	sub		$tmp24 cuton nearedge 	%line{293} %argrw{"wrr"}
	smoothstep	$tmp23 $tmp24 cuton ___297_Pz 	%argrw{"wrrr"}
	mul		___297_atten ___297_atten $tmp23 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:294
#     
	add		$tmp26 cutoff faredge 	%line{294} %argrw{"wrr"}
	smoothstep	$tmp25 cutoff $tmp26 ___297_Pz 	%argrw{"wrrr"}
	sub		$tmp27 $const17 $tmp25 	%argrw{"wrr"}
	mul		___297_atten ___297_atten $tmp27 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:297
# 	if (PLlen > falloffdist) {
	neq		$tmp28 falloff $const7 	%line{297} %argrw{"wrr"}
	if		$tmp28 75 75 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:298
# 	    atten *= pow (falloffdist/PLlen, falloff);
	gt		$tmp29 ___297_PLlen falloffdist 	%line{298} %argrw{"wrr"}
	if		$tmp29 65 75 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:299
# 	} else {
	div		$tmp31 falloffdist ___297_PLlen 	%line{299} %argrw{"wrr"}
	pow		$tmp30 $tmp31 falloff 	%argrw{"wrr"}
	mul		___297_atten ___297_atten $tmp30 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:301
# 	    float beta = -falloff/s;
	div		$tmp32 $const17 $tmp20 	%line{301} %argrw{"wrr"}
	log		___302_s $tmp32 	%argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:302
# 	    atten *= (maxintensity * exp (s * pow(PLlen/falloffdist, beta)));
	neg		$tmp33 falloff 	%line{302} %argrw{"wr"}
	div		___302_beta $tmp33 ___302_s 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:303
# 	}
	div		$tmp36 ___297_PLlen falloffdist 	%line{303} %argrw{"wrr"}
	pow		$tmp35 $tmp36 ___302_beta 	%argrw{"wrr"}
	mul		$tmp37 ___302_s $tmp35 	%argrw{"wrr"}
	exp		$tmp34 $tmp37 	%argrw{"wr"}
	mul		$tmp38 $tmp20 $tmp34 	%argrw{"wrr"}
	mul		___297_atten ___297_atten $tmp38 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:308
# 	vector PLN = normalize((vector)PL);
	neq		$tmp39 lighttype $const18 	%line{308} %argrw{"wrr"}
	neq		$tmp40 $tmp39 $const7 	%argrw{"wrr"}
	if		$tmp40 81 81 	%argrw{"r"}
	gt		$tmp41 beamdistribution $const7 	%argrw{"wrr"}
	neq		$tmp42 $tmp41 $const7 	%argrw{"wrr"}
	assign		$tmp40 $tmp42 	%argrw{"wr"}
	if		$tmp40 86 86 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:309
# 	atten *= pow (PLN[2], beamdistribution);
	normalize	___303_PLN PL 	%line{309} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:310
#     }
	compref		$tmp44 ___303_PLN $const16 	%line{310} %argrw{"wrr"}
	pow		$tmp43 $tmp44 beamdistribution 	%argrw{"wrr"}
	mul		___297_atten ___297_atten $tmp43 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:312
# 	atten *= 1 - clipSuperellipse (PL/Pz-point(shearx,sheary,0),
	eq		$tmp45 lighttype $const6 	%line{312} %argrw{"wrr"}
	if		$tmp45 160 160 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:313
# 				       width, height,
	div		$tmp47 PL ___297_Pz 	%line{313} %argrw{"wrr"}
	point		$tmp48 shearx sheary $const4 	%argrw{"wrrr"}
	sub		$tmp49 $tmp47 $tmp48 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:315
#     }
	add		$tmp50 width wedge 	%line{315} %argrw{"wrr"}
	add		$tmp51 height hedge 	%argrw{"wrr"}
	functioncall	$const19 158 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:232
#     float x = abs(Q[0]), y = abs(Q[1]);
	assign		___291_result $const7 	%line{232} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:233
#     if (x != 0 || y != 0) {  // avoid degenerate case
	compref		$tmp52 $tmp49 $const7 	%line{233} %argrw{"wrr"}
	abs		___291_x $tmp52 	%argrw{"wr"}
	compref		$tmp53 $tmp49 $const9 	%argrw{"wrr"}
	abs		___291_y $tmp53 	%argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:234
# 	if (roundness < 1.0e-6) {
	neq		$tmp54 ___291_x $const7 	%line{234} %argrw{"wrr"}
	neq		$tmp55 $tmp54 $const7 	%argrw{"wrr"}
	if		$tmp55 102 105 	%argrw{"r"}
	neq		$tmp56 ___291_y $const7 	%argrw{"wrr"}
	neq		$tmp57 $tmp56 $const7 	%argrw{"wrr"}
	assign		$tmp55 $tmp57 	%argrw{"wr"}
	if		$tmp55 157 157 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:235
# 	    // Simpler case of a square
	lt		$tmp58 roundness $const20 	%line{235} %argrw{"wrr"}
	if		$tmp58 114 157 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:237
# 	} else if (roundness > 0.9999) {
	smoothstep	$tmp59 width $tmp50 ___291_x 	%line{237} %argrw{"wrrr"}
	sub		$tmp60 $const17 $tmp59 	%argrw{"wrr"}
	smoothstep	$tmp61 height $tmp51 ___291_y 	%argrw{"wrrr"}
	sub		$tmp62 $const17 $tmp61 	%argrw{"wrr"}
	mul		$tmp63 $tmp60 $tmp62 	%argrw{"wrr"}
	sub		___291_result $const17 $tmp63 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:238
# 	    // Simple case of a circle
	gt		$tmp64 roundness $const21 	%line{238} %argrw{"wrr"}
	if		$tmp64 137 157 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:241
# 	    float r = A * B / sqrt (sqr(B*x) + sqr(A*y));
	mul		$tmp65 width height 	%line{241} %argrw{"wrr"}
	mul		$tmp68 height ___291_x 	%argrw{"wrr"}
	functioncall	$const22 120 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:240
# 	    float q = a * b / sqrt (sqr(b*x) + sqr(a*y));
	mul		$tmp67 $tmp68 $tmp68 	%line{240} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:241
# 	    float r = A * B / sqrt (sqr(B*x) + sqr(A*y));
	mul		$tmp70 width ___291_y 	%line{241} %argrw{"wrr"}
	functioncall	$const22 123 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:240
# 	    float q = a * b / sqrt (sqr(b*x) + sqr(a*y));
	mul		$tmp69 $tmp70 $tmp70 	%line{240} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:241
# 	    float r = A * B / sqrt (sqr(B*x) + sqr(A*y));
	add		$tmp71 $tmp67 $tmp69 	%line{241} %argrw{"wrr"}
	sqrt		$tmp66 $tmp71 	%argrw{"wr"}
	div		___294_q $tmp65 $tmp66 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:242
# 	    result = smoothstep (q, r, 1);
	mul		$tmp72 $tmp50 $tmp51 	%line{242} %argrw{"wrr"}
	mul		$tmp75 $tmp51 ___291_x 	%argrw{"wrr"}
	functioncall	$const22 130 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:240
# 	    float q = a * b / sqrt (sqr(b*x) + sqr(a*y));
	mul		$tmp74 $tmp75 $tmp75 	%line{240} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:242
# 	    result = smoothstep (q, r, 1);
	mul		$tmp77 $tmp50 ___291_y 	%line{242} %argrw{"wrr"}
	functioncall	$const22 133 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:240
# 	    float q = a * b / sqrt (sqr(b*x) + sqr(a*y));
	mul		$tmp76 $tmp77 $tmp77 	%line{240} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:242
# 	    result = smoothstep (q, r, 1);
	add		$tmp78 $tmp74 $tmp76 	%line{242} %argrw{"wrr"}
	sqrt		$tmp73 $tmp78 	%argrw{"wr"}
	div		___294_r $tmp72 $tmp73 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:243
# 	} else {
	smoothstep	___291_result ___294_q ___294_r $const17 	%line{243} %argrw{"wrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:246
# 	    float q = a * b * pow (pow(b*x, re) + pow(a*y, re), -1/re);
	div		___296_re $const23 roundness 	%line{246} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:247
# 	    float r = A * B * pow (pow(B*x, re) + pow(A*y, re), -1/re);
	mul		$tmp79 width height 	%line{247} %argrw{"wrr"}
	mul		$tmp82 height ___291_x 	%argrw{"wrr"}
	pow		$tmp81 $tmp82 ___296_re 	%argrw{"wrr"}
	mul		$tmp84 width ___291_y 	%argrw{"wrr"}
	pow		$tmp83 $tmp84 ___296_re 	%argrw{"wrr"}
	add		$tmp85 $tmp81 $tmp83 	%argrw{"wrr"}
	div		$tmp86 $const24 ___296_re 	%argrw{"wrr"}
	pow		$tmp80 $tmp85 $tmp86 	%argrw{"wrr"}
	mul		___296_q $tmp79 $tmp80 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:248
# 	    result = smoothstep (q, r, 1);
	mul		$tmp87 $tmp50 $tmp51 	%line{248} %argrw{"wrr"}
	mul		$tmp90 $tmp51 ___291_x 	%argrw{"wrr"}
	pow		$tmp89 $tmp90 ___296_re 	%argrw{"wrr"}
	mul		$tmp92 $tmp50 ___291_y 	%argrw{"wrr"}
	pow		$tmp91 $tmp92 ___296_re 	%argrw{"wrr"}
	add		$tmp93 $tmp89 $tmp91 	%argrw{"wrr"}
	div		$tmp94 $const24 ___296_re 	%argrw{"wrr"}
	pow		$tmp88 $tmp93 $tmp94 	%argrw{"wrr"}
	mul		___296_r $tmp87 $tmp88 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:249
# 	}
	smoothstep	___291_result ___296_q ___296_r $const17 	%line{249} %argrw{"wrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:252
# }
	assign		$tmp46 ___291_result 	%line{252} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:315
#     }
	sub		$tmp95 $const17 $tmp46 	%line{315} %argrw{"wrr"}
	mul		___297_atten ___297_atten $tmp95 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:317
# }
	assign		___310_atten ___297_atten 	%line{317} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:590
# 	    point Pslide = PL / point (width+wedge, height+hedge, 1);
	neq		$tmp96 slidename $const25 	%line{590} %argrw{"wrr"}
	if		$tmp96 178 178 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:591
# 	    float zslide = Pslide[2];
	add		$tmp98 width wedge 	%line{591} %argrw{"wrr"}
	add		$tmp99 height hedge 	%argrw{"wrr"}
	point		$tmp97 $tmp98 $tmp99 $const17 	%argrw{"wrrr"}
	div		___311_Pslide PL $tmp97 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:592
# 	    float xslide = 0.5+0.5*Pslide[0]/zslide;
	compref		___311_zslide ___311_Pslide $const16 	%line{592} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:593
# 	    float yslide = 0.5-0.5*Pslide[1]/zslide;
	compref		$tmp100 ___311_Pslide $const7 	%line{593} %argrw{"wrr"}
	mul		$tmp101 $const26 $tmp100 	%argrw{"wrr"}
	div		$tmp102 $tmp101 ___311_zslide 	%argrw{"wrr"}
	add		___311_xslide $const26 $tmp102 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:594
# 	    lcol *= (color) texture (slidename, xslide, yslide);
	compref		$tmp103 ___311_Pslide $const9 	%line{594} %argrw{"wrr"}
	mul		$tmp104 $const26 $tmp103 	%argrw{"wrr"}
	div		$tmp105 $tmp104 ___311_zslide 	%argrw{"wrr"}
	sub		___311_yslide $const26 $tmp105 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:595
# 	}
	texture		$tmp106 slidename ___311_xslide ___311_yslide 	%line{595} %argrw{"wrrr"} %argderivs{2,3}
	mul		___310_lcol ___310_lcol $tmp106 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:599
# 	    // Apply noise
	gt		$tmp107 ___310_atten $const7 	%line{599} %argrw{"wrr"}
	if		$tmp107 301 301 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:601
# 		float n = noise (noisefreq * (PL+noiseoffset) * point(1,1,0));
	gt		$tmp108 noiseamp $const7 	%line{601} %argrw{"wrr"}
	if		$tmp108 191 191 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:602
# 		n = smoothstep (0, 1, 0.5 + noiseamp * (n-0.5));
	add		$tmp109 PL noiseoffset 	%line{602} %argrw{"wrr"}
	mul		$tmp110 noisefreq $tmp109 	%argrw{"wrr"}
	mul		$tmp112 $tmp110 $const27 	%argrw{"wrr"}
	noise		___313_n $tmp112 	%argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:603
# 		atten *= n;
	sub		$tmp113 ___313_n $const26 	%line{603} %argrw{"wrr"}
	mul		$tmp114 noiseamp $tmp113 	%argrw{"wrr"}
	add		$tmp115 $const26 $tmp114 	%argrw{"wrr"}
	smoothstep	___313_n $const4 $const17 $tmp115 	%argrw{"wrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:604
# 	    }
	mul		___310_atten ___310_atten ___313_n 	%line{604} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:608
# 	    if (shadowname)
	assign		___312_unoccluded $const9 	%line{608} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:609
# 		unoccluded *= transmission (Ps, Ps + L, "traceset", shadowname, "blur", shadowblur,
	neq		$tmp116 shadowname $const25 	%line{609} %argrw{"wrr"}
	if		$tmp116 198 198 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:610
# 					  "samples", (int)shadowsamples,
	add		$tmp118 Ps L 	%line{610} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:611
# 					  "bias", shadowbias);
	assign		$tmp119 shadowsamples 	%line{611} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:612
# 	    point shadoworigin;
	transmission	$tmp117 Ps $tmp118 $const28 shadowname $const29 shadowblur $const30 $tmp119 $const31 shadowbias 	%line{612} %argrw{"wrrrrrrrrrr"} %argderivs{1,2}
	mul		___312_unoccluded ___312_unoccluded $tmp117 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:614
# 		 shadoworigin = from;
	eq		$tmp120 parallelrays $const7 	%line{614} %argrw{"wrr"}
	if		$tmp120 201 208 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:615
# 	    else shadoworigin = point ("shader", PL[0], PL[1],
	assign		___312_shadoworigin from 	%line{615} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:616
#                                        zreverse ? -cuton : cuton);
	compref		$tmp121 PL $const7 	%line{616} %argrw{"wrr"}
	compref		$tmp122 PL $const9 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:617
# 
	neq		$tmp124 zreverse $const4 	%line{617} %argrw{"wrr"}
	if		$tmp124 206 207 	%argrw{"r"}
	neg		$tmp123 cuton 	%argrw{"wr"}
	assign		$tmp123 cuton 	%argrw{"wr"}
	point		___312_shadoworigin $const1 $tmp121 $tmp122 $tmp123 	%argrw{"wrrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:620
# 		unoccluded *= 
	neq		$tmp125 blockercoords $const25 	%line{620} %argrw{"wrr"}
	if		$tmp125 297 297 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:625
# 	    }
	functioncall	$const32 296 	%line{625} %argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:335
#     // Get the surface and light positions in blocker coords
	assign		___305_unoccluded $const9 	%line{335} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:337
#     point Pb2 = transform (blockercoords, P2);
	functioncall	$const2 214 	%line{337} %argrw{"r"}
# D:/xrt.git\\build\\vc10\\Win32\\Release\\shaders\\stdosl.h:249
# point  transform (string to, point p)  { return transform("common",to,p); }
	transform	___305_Pb1 $const3 blockercoords Ps 	%filename{"D:/xrt.git\\build\\vc10\\Win32\\Release\\shaders\\stdosl.h"} %line{249} %argrw{"wrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:338
# //   noiseamp - amplitude of the noise.  A value of 0 (the default) 
	functioncall	$const2 216 	%filename{"D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl"} %line{338} %argrw{"r"}
# D:/xrt.git\\build\\vc10\\Win32\\Release\\shaders\\stdosl.h:249
# point  transform (string to, point p)  { return transform("common",to,p); }
	transform	___305_Pb2 $const3 blockercoords ___312_shadoworigin 	%filename{"D:/xrt.git\\build\\vc10\\Win32\\Release\\shaders\\stdosl.h"} %line{249} %argrw{"wrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:340
# //       of the projected noise.
	compref		$tmp127 ___305_Pb2 $const16 	%filename{"D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl"} %line{340} %argrw{"wrr"}
	compref		$tmp128 ___305_Pb1 $const16 	%argrw{"wrr"}
	mul		$tmp129 $tmp127 $tmp128 	%argrw{"wrr"}
	lt		$tmp130 $tmp129 $const7 	%argrw{"wrr"}
	if		$tmp130 295 295 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:341
# //   noisefreq - frequency of the noise.
	sub		___306_Vlight ___305_Pb1 ___305_Pb2 	%line{341} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:342
# //   noiseoffset - spatial offset of the noise.  This can be animated,
	compref		$tmp131 ___305_Pb1 $const16 	%line{342} %argrw{"wrr"}
	compref		$tmp132 ___306_Vlight $const16 	%argrw{"wrr"}
	div		$tmp133 $tmp131 $tmp132 	%argrw{"wrr"}
	mul		$tmp134 ___306_Vlight $tmp133 	%argrw{"wrr"}
	sub		___306_Pplane ___305_Pb1 $tmp134 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:344
# //       attenuation of light as it passes through a window with 
	add		$tmp136 blockerwidth blockerwedge 	%line{344} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:345
# //       water drops dripping down it.
	add		$tmp137 blockerheight blockerhedge 	%line{345} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:346
# // 
	functioncall	$const19 294 	%line{346} %argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:232
#     float x = abs(Q[0]), y = abs(Q[1]);
	assign		___291_result $const7 	%line{232} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:233
#     if (x != 0 || y != 0) {  // avoid degenerate case
	compref		$tmp138 ___306_Pplane $const7 	%line{233} %argrw{"wrr"}
	abs		___291_x $tmp138 	%argrw{"wr"}
	compref		$tmp139 ___306_Pplane $const9 	%argrw{"wrr"}
	abs		___291_y $tmp139 	%argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:234
# 	if (roundness < 1.0e-6) {
	neq		$tmp140 ___291_x $const7 	%line{234} %argrw{"wrr"}
	neq		$tmp141 $tmp140 $const7 	%argrw{"wrr"}
	if		$tmp141 238 241 	%argrw{"r"}
	neq		$tmp142 ___291_y $const7 	%argrw{"wrr"}
	neq		$tmp143 $tmp142 $const7 	%argrw{"wrr"}
	assign		$tmp141 $tmp143 	%argrw{"wr"}
	if		$tmp141 293 293 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:235
# 	    // Simpler case of a square
	lt		$tmp144 blockerround $const20 	%line{235} %argrw{"wrr"}
	if		$tmp144 250 293 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:237
# 	} else if (roundness > 0.9999) {
	smoothstep	$tmp145 blockerwidth $tmp136 ___291_x 	%line{237} %argrw{"wrrr"}
	sub		$tmp146 $const17 $tmp145 	%argrw{"wrr"}
	smoothstep	$tmp147 blockerheight $tmp137 ___291_y 	%argrw{"wrrr"}
	sub		$tmp148 $const17 $tmp147 	%argrw{"wrr"}
	mul		$tmp149 $tmp146 $tmp148 	%argrw{"wrr"}
	sub		___291_result $const17 $tmp149 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:238
# 	    // Simple case of a circle
	gt		$tmp150 blockerround $const21 	%line{238} %argrw{"wrr"}
	if		$tmp150 273 293 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:241
# 	    float r = A * B / sqrt (sqr(B*x) + sqr(A*y));
	mul		$tmp151 blockerwidth blockerheight 	%line{241} %argrw{"wrr"}
	mul		$tmp154 blockerheight ___291_x 	%argrw{"wrr"}
	functioncall	$const22 256 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:240
# 	    float q = a * b / sqrt (sqr(b*x) + sqr(a*y));
	mul		$tmp153 $tmp154 $tmp154 	%line{240} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:241
# 	    float r = A * B / sqrt (sqr(B*x) + sqr(A*y));
	mul		$tmp156 blockerwidth ___291_y 	%line{241} %argrw{"wrr"}
	functioncall	$const22 259 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:240
# 	    float q = a * b / sqrt (sqr(b*x) + sqr(a*y));
	mul		$tmp155 $tmp156 $tmp156 	%line{240} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:241
# 	    float r = A * B / sqrt (sqr(B*x) + sqr(A*y));
	add		$tmp157 $tmp153 $tmp155 	%line{241} %argrw{"wrr"}
	sqrt		$tmp152 $tmp157 	%argrw{"wr"}
	div		___294_q $tmp151 $tmp152 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:242
# 	    result = smoothstep (q, r, 1);
	mul		$tmp158 $tmp136 $tmp137 	%line{242} %argrw{"wrr"}
	mul		$tmp161 $tmp137 ___291_x 	%argrw{"wrr"}
	functioncall	$const22 266 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:240
# 	    float q = a * b / sqrt (sqr(b*x) + sqr(a*y));
	mul		$tmp160 $tmp161 $tmp161 	%line{240} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:242
# 	    result = smoothstep (q, r, 1);
	mul		$tmp163 $tmp136 ___291_y 	%line{242} %argrw{"wrr"}
	functioncall	$const22 269 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:240
# 	    float q = a * b / sqrt (sqr(b*x) + sqr(a*y));
	mul		$tmp162 $tmp163 $tmp163 	%line{240} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:242
# 	    result = smoothstep (q, r, 1);
	add		$tmp164 $tmp160 $tmp162 	%line{242} %argrw{"wrr"}
	sqrt		$tmp159 $tmp164 	%argrw{"wr"}
	div		___294_r $tmp158 $tmp159 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:243
# 	} else {
	smoothstep	___291_result ___294_q ___294_r $const17 	%line{243} %argrw{"wrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:246
# 	    float q = a * b * pow (pow(b*x, re) + pow(a*y, re), -1/re);
	div		___296_re $const23 blockerround 	%line{246} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:247
# 	    float r = A * B * pow (pow(B*x, re) + pow(A*y, re), -1/re);
	mul		$tmp165 blockerwidth blockerheight 	%line{247} %argrw{"wrr"}
	mul		$tmp168 blockerheight ___291_x 	%argrw{"wrr"}
	pow		$tmp167 $tmp168 ___296_re 	%argrw{"wrr"}
	mul		$tmp170 blockerwidth ___291_y 	%argrw{"wrr"}
	pow		$tmp169 $tmp170 ___296_re 	%argrw{"wrr"}
	add		$tmp171 $tmp167 $tmp169 	%argrw{"wrr"}
	div		$tmp172 $const24 ___296_re 	%argrw{"wrr"}
	pow		$tmp166 $tmp171 $tmp172 	%argrw{"wrr"}
	mul		___296_q $tmp165 $tmp166 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:248
# 	    result = smoothstep (q, r, 1);
	mul		$tmp173 $tmp136 $tmp137 	%line{248} %argrw{"wrr"}
	mul		$tmp176 $tmp137 ___291_x 	%argrw{"wrr"}
	pow		$tmp175 $tmp176 ___296_re 	%argrw{"wrr"}
	mul		$tmp178 $tmp136 ___291_y 	%argrw{"wrr"}
	pow		$tmp177 $tmp178 ___296_re 	%argrw{"wrr"}
	add		$tmp179 $tmp175 $tmp177 	%argrw{"wrr"}
	div		$tmp180 $const24 ___296_re 	%argrw{"wrr"}
	pow		$tmp174 $tmp179 $tmp180 	%argrw{"wrr"}
	mul		___296_r $tmp173 $tmp174 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:249
# 	}
	smoothstep	___291_result ___296_q ___296_r $const17 	%line{249} %argrw{"wrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:252
# }
	assign		$tmp135 ___291_result 	%line{252} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:346
#     }
	mul		___305_unoccluded ___305_unoccluded $tmp135 	%line{346} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:348
# }
	assign		$tmp126 ___305_unoccluded 	%line{348} %argrw{"wr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:625
# 	    }
	mul		___312_unoccluded ___312_unoccluded $tmp126 	%line{625} %argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:627
# 	    __nonspecular = 1 - unoccluded * (1 - __nonspecular);
	mix		___310_lcol shadowcolor ___310_lcol ___312_unoccluded 	%line{627} %argrw{"wrrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:628
# 	}
	sub		$tmp181 $const17 __nonspecular 	%line{628} %argrw{"wrr"}
	mul		$tmp182 ___312_unoccluded $tmp181 	%argrw{"wrr"}
	sub		__nonspecular $const17 $tmp182 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:630
# 	if (parallelrays)
	mul		$tmp183 ___310_atten intensity 	%line{630} %argrw{"wrr"}
	mul		Cl $tmp183 ___310_lcol 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:631
# 	    L = -axis * length(Ps-from);
	neq		$tmp184 parallelrays $const4 	%line{631} %argrw{"wrr"}
	if		$tmp184 309 309 	%argrw{"r"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:632
#     }
	neg		$tmp185 axis 	%line{632} %argrw{"wr"}
	sub		$tmp187 Ps from 	%argrw{"wrr"}
	length		$tmp186 $tmp187 	%argrw{"wr"}
	mul		L $tmp185 $tmp186 	%argrw{"wrr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:634
# 	setmessage ("__nonspecular", __nonspecular);
	setmessage	$const33 __foglight 	%line{634} %argrw{"rr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:635
# 	setmessage ("__nondiffuse", __nondiffuse);
	setmessage	$const34 __nonspecular 	%line{635} %argrw{"rr"}
# D:\\xrt.git\\src\\osl\\shaders\\uberlight.osl:636
# }
	setmessage	$const35 __nondiffuse 	%line{636} %argrw{"rr"}
	end
