var fxNow, timerId, rfxtypes = /^(?:toggle|show|hide)$/, rfxnum = new RegExp("^(?:([+-])=|)(" + core_pnum + ")([a-z%]*)$", "i"), rrun = /queueHooks$/, animationPrefilters = [defaultPrefilter] , tweeners = { 
"*": [function (prop, value){ 
var tween = this.createTween(prop, value), target = tween.cur(), parts = rfxnum.exec(value), unit = parts && parts[3] || (jQuery.cssNumber[prop]? "": "px"), start = (jQuery.cssNumber[prop] || unit !== "px" && + target) && rfxnum.exec(jQuery.css(tween.elem, prop)), scale = 1, maxIterations = 20; 
if (start && start[3] !== unit) { 
unit = unit || start[3]; 
parts = parts || [] ; 
start = + target || 1; 
do { 
scale = scale || ".5"; 
start = start / scale; 
jQuery.style(tween.elem, prop, start + unit); 
} 
while(scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations)} 
if (parts) { 
start = tween.start = + start || + target || 0; 
tween.unit = unit; 
tween.end = parts[1]? start + (parts[1] + 1) * parts[2]: + parts[2]; 
} 
return tween; 
} 
] }
; 
function createFxNow(){ 
_AN_Call_settimeout("setTimeout", window, function (){ 
fxNow = undefined; 
} 
); 
return (fxNow = jQuery.now()); 
} 
function createTween(value, prop, animation){ 
var tween, collection = (tweeners[prop] || [] ).concat(tweeners["*"] ), index = 0, length = _AN_Read_length("length", collection); 
for (; index < length; index++ ){ 
if ((tween = collection[index].call(animation, prop, value))) { 
return tween; 
} 
} 
} 
function Animation(elem, properties, options){ 
var result, stopped, index = 0, length = _AN_Read_length("length", animationPrefilters), deferred = jQuery.Deferred().always(function (){ 
delete tick.elem; 
} 
), tick = function (){ 
if (stopped) { 
return false ; 
} 
var currentTime = fxNow || createFxNow(), remaining = Math.max(0, animation.startTime + animation.duration - currentTime), temp = remaining / animation.duration || 0, percent = 1 - temp, index = 0, length = _AN_Read_length("length", animation.tweens); 
for (; index < length; index++ ){ 
animation.tweens[index].run(percent); 
} 
deferred.notifyWith(elem, [animation, percent, remaining] ); 
if (percent < 1 && length) { 
return remaining; 
} 
 else { 
deferred.resolveWith(elem, [animation] ); 
return false ; 
} 
} 
, animation = deferred.promise({ 
elem: elem,
props: jQuery.extend({ 
}
, properties),
opts: jQuery.extend(true , { 
specialEasing: { 
}
}
, options),
originalProperties: properties,
originalOptions: options,
startTime: fxNow || createFxNow(),
duration: options.duration,
tweens: [] ,
createTween: function (prop, end){ 
var tween = jQuery.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing); 
animation.tweens.push(tween); 
return tween; 
} 
,
stop: function (gotoEnd){ 
var index = 0, length = gotoEnd? _AN_Read_length("length", animation.tweens): 0; 
if (stopped) { 
return this; 
} 
stopped = true ; 
for (; index < length; index++ ){ 
animation.tweens[index].run(1); 
} 
if (gotoEnd) { 
deferred.resolveWith(elem, [animation, gotoEnd] ); 
} 
 else { 
deferred.rejectWith(elem, [animation, gotoEnd] ); 
} 
return this; 
} 
}
), props = animation.props; 
propFilter(props, animation.opts.specialEasing); 
for (; index < length; index++ ){ 
result = animationPrefilters[index].call(animation, elem, props, animation.opts); 
if (result) { 
return result; 
} 
} 
jQuery.map(props, createTween, animation); 
if (jQuery.isFunction(animation.opts.start)) { 
animation.opts.start.call(elem, animation); 
} 
jQuery.fx.timer(jQuery.extend(tick, { 
elem: elem,
anim: animation,
queue: animation.opts.queue}
)); 
return animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always); 
} 
function propFilter(props, specialEasing){ 
var index, name, easing, value, hooks; 
for (index in props){ 
name = jQuery.camelCase(index); 
easing = specialEasing[name]; 
value = props[index]; 
if (jQuery.isArray(value)) { 
easing = value[1]; 
value = props[index] = value[0]; 
} 
if (index !== name) { 
props[name] = value; 
delete props[index]; 
} 
hooks = jQuery.cssHooks[name]; 
if (hooks && "expand" in hooks) { 
value = hooks.expand(value); 
delete props[name]; 
for (index in value){ 
if (!(index in props)) { 
props[index] = value[index]; 
specialEasing[index] = easing; 
} 
} 
} 
 else { 
specialEasing[name] = easing; 
} 
} 
} 
jQuery.Animation = jQuery.extend(Animation, { 
tweener: function (props, callback){ 
if (jQuery.isFunction(props)) { 
callback = props; 
props = ["*"] ; 
} 
 else { 
props = props.split(" "); 
} 
var prop, index = 0, length = _AN_Read_length("length", props); 
for (; index < length; index++ ){ 
prop = props[index]; 
tweeners[prop] = tweeners[prop] || [] ; 
tweeners[prop].unshift(callback); 
} 
} 
,
prefilter: function (callback, prepend){ 
if (prepend) { 
animationPrefilters.unshift(callback); 
} 
 else { 
animationPrefilters.push(callback); 
} 
} 
}
); 
function defaultPrefilter(elem, props, opts){ 
var prop, value, toggle, tween, hooks, oldfire, anim = this, orig = { 
}
, style = elem.style, hidden = elem.nodeType && isHidden(elem), dataShow = data_priv.get(elem, "fxshow"); 
if (!opts.queue) { 
hooks = jQuery._queueHooks(elem, "fx"); 
if (hooks.unqueued == null ) { 
hooks.unqueued = 0; 
oldfire = hooks.empty.fire; 
hooks.empty.fire = function (){ 
if (!hooks.unqueued) { 
oldfire(); 
} 
} 
; 
} 
hooks.unqueued++ ; 
anim.always(function (){ 
anim.always(function (){ 
hooks.unqueued-- ; 
if (!_AN_Read_length("length", jQuery.queue(elem, "fx"))) { 
hooks.empty.fire(); 
} 
} 
); 
} 
); 
} 
if (elem.nodeType === 1 && ("height" in props || "width" in props)) { 
opts.overflow = [style.overflow, style.overflowX, style.overflowY] ; 
if (jQuery.css(elem, "display") === "inline" && jQuery.css(elem, "float") === "none") { 
style.display = "inline-block"; 
} 
} 
if (opts.overflow) { 
style.overflow = "hidden"; 
anim.always(function (){ 
style.overflow = opts.overflow[0]; 
style.overflowX = opts.overflow[1]; 
style.overflowY = opts.overflow[2]; 
} 
); 
} 
for (prop in props){ 
value = props[prop]; 
if (rfxtypes.exec(value)) { 
delete props[prop]; 
toggle = toggle || value === "toggle"; 
if (value === (hidden? "hide": "show")) { 
if (value === "show" && dataShow && dataShow[prop] !== undefined) { 
hidden = true ; 
} 
 else { 
continue ; 
} 
} 
orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop); 
} 
} 
if (!jQuery.isEmptyObject(orig)) { 
if (dataShow) { 
if ("hidden" in dataShow) { 
hidden = dataShow.hidden; 
} 
} 
 else { 
dataShow = data_priv.access(elem, "fxshow", { 
}
); 
} 
if (toggle) { 
dataShow.hidden = !hidden; 
} 
if (hidden) { 
_AN_Call_show("show", jQuery(elem)); 
} 
 else { 
anim.done(function (){ 
jQuery(elem).hide(); 
} 
); 
} 
anim.done(function (){ 
var prop; 
data_priv.remove(elem, "fxshow"); 
for (prop in orig){ 
jQuery.style(elem, prop, orig[prop]); 
} 
} 
); 
for (prop in orig){ 
tween = createTween(hidden? dataShow[prop]: 0, prop, anim); 
if (!(prop in dataShow)) { 
dataShow[prop] = tween.start; 
if (hidden) { 
tween.end = tween.start; 
tween.start = prop === "width" || prop === "height"? 1: 0; 
} 
} 
} 
} 
} 
function Tween(elem, options, prop, end, easing){ 
return new Tween.prototype.init(elem, options, prop, end, easing); 
} 
jQuery.Tween = Tween; 
Tween.prototype = { 
constructor: Tween,
init: function (elem, options, prop, end, easing, unit){ 
this.elem = elem; 
this.prop = prop; 
this.easing = easing || "swing"; 
this.options = options; 
this.start = this.now = this.cur(); 
this.end = end; 
this.unit = unit || (jQuery.cssNumber[prop]? "": "px"); 
} 
,
cur: function (){ 
var hooks = Tween.propHooks[this.prop]; 
return hooks && hooks.get? hooks.get(this): Tween.propHooks._default.get(this); 
} 
,
run: function (percent){ 
var eased, hooks = Tween.propHooks[this.prop]; 
if (this.options.duration) { 
this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration); 
} 
 else { 
this.pos = eased = percent; 
} 
this.now = (this.end - this.start) * eased + this.start; 
if (this.options.step) { 
this.options.step.call(this.elem, this.now, this); 
} 
if (hooks && hooks.set) { 
hooks.set(this); 
} 
 else { 
Tween.propHooks._default.set(this); 
} 
return this; 
} 
}
; 
Tween.prototype.init.prototype = Tween.prototype; 
Tween.propHooks = { 
_default: { 
get: function (tween){ 
var result; 
if (tween.elem[tween.prop] != null  && (!tween.elem.style || tween.elem.style[tween.prop] == null )) { 
return tween.elem[tween.prop]; 
} 
result = jQuery.css(tween.elem, tween.prop, ""); 
return !result || result === "auto"? 0: result; 
} 
,
set: function (tween){ 
if (jQuery.fx.step[tween.prop]) { 
jQuery.fx.step[tween.prop](tween); 
} 
 else if (tween.elem.style && (tween.elem.style[jQuery.cssProps[tween.prop]] != null  || jQuery.cssHooks[tween.prop])) { 
jQuery.style(tween.elem, tween.prop, tween.now + tween.unit); 
} 
 else { 
tween.elem[tween.prop] = tween.now; 
} 
} 
}
}
; 
Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { 
set: function (tween){ 
if (tween.elem.nodeType && tween.elem.parentNode) { 
tween.elem[tween.prop] = tween.now; 
} 
} 
}
; 
jQuery.each(["toggle", "show", "hide"] , function (i, name){ 
var cssFn = jQuery.fn[name]; 
jQuery.fn[name] = function (speed, easing, callback){ 
return speed == null  || typeof speed === "boolean"? cssFn.apply(this, arguments): this.animate(genFx(name, true ), speed, easing, callback); 
} 
; 
} 
); 
jQuery.fn.extend({ 
fadeTo: function (speed, to, easing, callback){ 
return _AN_Call_show("show", this.filter(isHidden).css("opacity", 0)).end().animate({ 
opacity: to}
, speed, easing, callback); 
} 
,
animate: function (prop, speed, easing, callback){ 
var empty = jQuery.isEmptyObject(prop), optall = jQuery.speed(speed, easing, callback), doAnimation = function (){ 
var anim = Animation(this, jQuery.extend({ 
}
, prop), optall); 
if (empty || data_priv.get(this, "finish")) { 
anim.stop(true ); 
} 
} 
; 
doAnimation.finish = doAnimation; 
return empty || optall.queue === false ? this.each(doAnimation): this.queue(optall.queue, doAnimation); 
} 
,
stop: function (type, clearQueue, gotoEnd){ 
var stopQueue = function (hooks){ 
var stop = hooks.stop; 
delete hooks.stop; 
stop(gotoEnd); 
} 
; 
if (typeof type !== "string") { 
gotoEnd = clearQueue; 
clearQueue = type; 
type = undefined; 
} 
if (clearQueue && type !== false ) { 
this.queue(type || "fx", [] ); 
} 
return this.each(function (){ 
var dequeue = true , index = type != null  && type + "queueHooks", timers = jQuery.timers, data = data_priv.get(this); 
if (index) { 
if (data[index] && data[index].stop) { 
stopQueue(data[index]); 
} 
} 
 else { 
for (index in data){ 
if (data[index] && data[index].stop && rrun.test(index)) { 
stopQueue(data[index]); 
} 
} 
} 
for (index = _AN_Read_length("length", timers); index-- ; ){ 
if (timers[index].elem === this && (type == null  || timers[index].queue === type)) { 
timers[index].anim.stop(gotoEnd); 
dequeue = false ; 
timers.splice(index, 1); 
} 
} 
if (dequeue || !gotoEnd) { 
jQuery.dequeue(this, type); 
} 
} 
); 
} 
,
finish: function (type){ 
if (type !== false ) { 
type = type || "fx"; 
} 
return this.each(function (){ 
var index, data = data_priv.get(this), queue = data[type + "queue"], hooks = data[type + "queueHooks"], timers = jQuery.timers, length = queue? _AN_Read_length("length", queue): 0; 
data.finish = true ; 
jQuery.queue(this, type, [] ); 
if (hooks && hooks.stop) { 
hooks.stop.call(this, true ); 
} 
for (index = _AN_Read_length("length", timers); index-- ; ){ 
if (timers[index].elem === this && timers[index].queue === type) { 
timers[index].anim.stop(true ); 
timers.splice(index, 1); 
} 
} 
for (index = 0; index < length; index++ ){ 
if (queue[index] && queue[index].finish) { 
queue[index].finish.call(this); 
} 
} 
delete data.finish; 
} 
); 
} 
}
); 
function genFx(type, includeWidth){ 
var which, attrs = { 
height: type}
, i = 0; 
includeWidth = includeWidth? 1: 0; 
for (; i < 4; i += 2 - includeWidth){ 
which = cssExpand[i]; 
attrs["margin" + which] = attrs["padding" + which] = type; 
} 
if (includeWidth) { 
attrs.opacity = attrs.width = type; 
} 
return attrs; 
} 
jQuery.each({ 
slideDown: genFx("show"),
slideUp: genFx("hide"),
slideToggle: genFx("toggle"),
fadeIn: { 
opacity: "show"}
,
fadeOut: { 
opacity: "hide"}
,
fadeToggle: { 
opacity: "toggle"}
}
, function (name, props){ 
jQuery.fn[name] = function (speed, easing, callback){ 
return this.animate(props, speed, easing, callback); 
} 
; 
} 
); 
jQuery.speed = function (speed, easing, fn){ 
var opt = speed && typeof speed === "object"? jQuery.extend({ 
}
, speed): { 
complete: fn || !fn && easing || jQuery.isFunction(speed) && speed,
duration: speed,
easing: fn && easing || easing && !jQuery.isFunction(easing) && easing}
; 
opt.duration = jQuery.fx.off? 0: typeof opt.duration === "number"? opt.duration: opt.duration in jQuery.fx.speeds? jQuery.fx.speeds[opt.duration]: jQuery.fx.speeds._default; 
if (opt.queue == null  || opt.queue === true ) { 
opt.queue = "fx"; 
} 
opt.old = opt.complete; 
opt.complete = function (){ 
if (jQuery.isFunction(opt.old)) { 
opt.old.call(this); 
} 
if (opt.queue) { 
jQuery.dequeue(this, opt.queue); 
} 
} 
; 
return opt; 
} 
; 
jQuery.easing = { 
linear: function (p){ 
return p; 
} 
,
swing: function (p){ 
return 0.5 - Math.cos(p * Math.PI) / 2; 
} 
}
; 
jQuery.timers = [] ; 
jQuery.fx = Tween.prototype.init; 
jQuery.fx.tick = function (){ 
var timer, timers = jQuery.timers, i = 0; 
fxNow = jQuery.now(); 
for (; i < _AN_Read_length("length", timers); i++ ){ 
timer = timers[i]; 
if (!timer() && timers[i] === timer) { 
timers.splice(i-- , 1); 
} 
} 
if (!_AN_Read_length("length", timers)) { 
jQuery.fx.stop(); 
} 
fxNow = undefined; 
} 
; 
jQuery.fx.timer = function (timer){ 
if (timer() && jQuery.timers.push(timer)) { 
jQuery.fx.start(); 
} 
} 
; 
jQuery.fx.interval = 13; 
jQuery.fx.start = function (){ 
if (!timerId) { 
timerId = _AN_Call_setinterval("setInterval", window, jQuery.fx.tick, jQuery.fx.interval); 
} 
} 
; 
jQuery.fx.stop = function (){ 
clearInterval(timerId); 
timerId = null ; 
} 
; 
jQuery.fx.speeds = { 
slow: 600,
fast: 200,
_default: 400}
; 
jQuery.fx.step = { 
}
; 
if (jQuery.expr && jQuery.expr.filters) { 
jQuery.expr.filters.animated = function (elem){ 
return _AN_Read_length("length", jQuery.grep(jQuery.timers, function (fn){ 
return elem === fn.elem; 
} 
)); 
} 
; 
}