var   d  =  window["Spif"] = {
    e:"undefined",
    f:"*",
    g:" ",
    
    h:"none",

    j:"threadStart",
    k:"threadEnd",
    l:"beforeChangeClassName",
    m:"afterChangeClassName",
    n:"beforeHtmlChanged",
    o:"afterHtmlChanged",
    r:"beforeAction",
    t:"afterElementActivation",
    v:"linkExecuteRequest",
    w:  400,
    z:  "loaded",
    B:  "unloaded\\b|\\bloading\\b|\\bloaded",

    C:"load",
    D:"click",
    F:"keydown",
    G:"keypress",
    H:"mousedown",
    I:"mousemove",
    J:"mouseup",

    K:"DXImageTransform.Microsoft.Alpha",

    L:  true,
    M:  false,

    N:"onBefore",
    O:"onFinish",

    P:"-delay",


    Q:(typeof(window.opera) !=  "undefined"),
    R:(navigator.userAgent.indexOf("MSIE") != -1) && !window.opera,
    
    
    S:(navigator.userAgent.indexOf("MSIE") != -1) && !window.opera  && (typeof(XMLHttpRequest) !=  "undefined"),
    T:((navigator.userAgent.indexOf("Gecko") != -1) && (navigator.appVersion.indexOf("AppleWebKit") == -1)),
    U:(navigator.appVersion.indexOf("AppleWebKit") != -1),
    
    V:  document.documentElement,

    W:  function(X)
   {
      if  (d.Y)
        for  (var   Z   in   d)
          if  (d[Z] ==  X)
 
 
            d.Y.aa(X,  "Spif."  +  Z);
 
      if  (X.ba)
        X.ba();
   }
};

 d["isIE"] =  d.R;
 d["isIE7"] =  d.S;
 d["isOpera"] =  d.Q;
 d["isGecko"] =  d.T;
 d["isSafari"] =  d.U;
 d["DEFAULTMORPHDURATION"] =  d.w;
 d["SUPPRESSEVENTS"] =  d.L;
 d["FIREEVENTS"] =  d.M;
 d.ca  = {
    da:"Q42",
    get:  function(name,  defaultValue)
   {
      var   ea  =  this.fa();

      return   ea[name] ||  null;
   },
    ga:  function(name,  value)
   {
      var   ea  =  this.fa();

      delete   ea[name];

      if  (value  !=  null)
        ea[name] =  value;

      this.ha(ea);
   },
    remove:  function(name)
   {
      var   ea  =  this.fa();

      delete   ea[name];

      this.ha(ea);
   },
    fa:  function()
   {
      var   c  =  document.cookie  +  "|;";
      var   ia  =  c.indexOf(this.da  +  "=");

      if  (ia  == -1)
        return  {};

      var   ja  =  c.indexOf("|;",  ia);

      var   ka  =  c.substring(ia  +  this.da.length  +  1,  ja).split("|");

      var   ea  = {};
      for  (var   i=0;  i<ka.length;  i++)
     {
        var   la  =  ka[i].split(":");
        ea[la[0]] =  unescape(la[1]);
     }
      
      return   ea;
   },
    ha:  function(ea)
   {
      var   s  =  "";
      for  (var   ma   in   ea)
        if  (ma)
          s  +=  ma  +  ":"  +  escape(ea[ma]) +  "|";

      var   na  =  new   Date();
      na.setFullYear(na.getFullYear()+1);

      var   c  =  this.da  +  "="  +  s  +  "; expires="  +  na.toGMTString() +  "; path=/;";

 
      document.cookie  =  c;
   }
};

 d["Cookies"] =  d.ca;
 d.ca["get"] =  d.ca.get;
 d.ca["set"] =  d.ca.ga;
 d.ca["remove"] =  d.ca.remove;
 
 
 
 
 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

 d.oa  = {
    pa:  function(qa,  delay,  X,  ra)
   {
      if  (delay  >=  0)
        return   setTimeout(this.sa(qa,  X,  ra),  delay);
      else 
     {
        qa.apply(X  ||  window,  ra  || []);
        return   null;
     }
   },
    ta:  function(qa,  ua,  X,  ra)
   {
      var   va  =  this.sa(qa,  X,  ra);
      va();
      return   setInterval(va,  ua);
   },

    sa:  function(qa,  X,  ra)
   {
      return   function()
     {
        d.wa.xa(d.j,  null,  null);
        qa.apply(X  ||  window,  ra  || []);
        d.wa.xa(d.k,  null,  null);
     };
   },

    ya:  function(za,  Aa,  Ba,  Ca,  Da)
   {
      var   Ea  = {};
      Ea.Fa  =  d.Ga.Ha(za,  Aa);
      if  (Ea.Fa)
     {
        Ea.Ia  =  d.Ja.Ka(Ea.Fa,  Aa,  Ca);
        Ea.object  =  d.Ga.Ha(Ea.Fa,  Ba);
        if  (Ea.object)
          Ea.La  =  d.Ja.Ka(Ea.object,  Ba,  Da);
     }
      return   Ea;
   },
    Ma:  function(s,  Na)
   {
      return   s?Function("a",  "b",  "c",  "d",  "e",  "return "  +  s  +  "(a, b, c, d, e);"):Na;
   },
    Oa:  function(za,  Pa,  Qa,  Ra,  Sa)
   {
      return   this.Ta(za,  Pa,  Qa,  Ra,  Sa).Ua[0];
   },
    Va:  function(za,  Pa,  Qa,  Ra,  Sa)
   {
      return   this.Ta(za,  Pa,  Qa,  Ra,  Sa).Ua;
   },
    Ta:  function(za,  Pa,  Qa,  Ra,  Sa)
   {
      var   Wa  = {
        Ua:[],
        za:null 
     };
      var   Xa;
      do 
     {
        if  (!(Xa  =  d.Ja.match(za,  Pa  +  "-[\\w-]+")))
          za  =  za.parentNode;
     }
      while  (!Xa  && !Ra  &&  za  &&  za.nodeType  ==  1);

      if  (Xa)
        for  (var   i=0;  i<Xa.length;  i++)
       {
          var   s  =  Xa[i].substring(Pa.length+1);
          if  (!Sa  || !Sa[s])
         {
            Wa.Ua.push(s);
            Wa.za  =  za;
         }
       }

      if  ((Qa  !=  null) && (Wa.Ua.length  ==  0))
        Wa.Ua[0] =  Qa;
      return   Wa;
   },
    Ya:  function(za,  Za,  _b,  Ra)
   {
      var   Xa;
      do 
     {
        Xa  =  d.Ja.match(za,  Za  +  "-?\\d+");
        za  =  za.parentNode;
     }
      while  (!Ra  &&  za  &&  za.nodeType  ==  1  && !Xa);
      return  (Xa?parseInt(Xa[0].substring(Za.length)):_b);
   },
    ab:  function(a)
   {
      var   bb  = {};
      for  (var   i=0;  i<a.length;  i++)
        bb[a[i]] =  i;
      return   bb;
   },
    cb:  function(za,  Z,  db)
   {
      var   eb  =  za.fb;
      if  (!eb)
        eb  =  za.fb  = {};

      eb[Z] =  db;
   },
    gb:  function(za,  Z)
   {
      var   eb  =  za.fb;
      if  (!eb)
        return   null;
      else 
        return   eb[Z];
   }
};

 d.oa.platform  = (d.S?"ie7":(d.R?"ie":(d.T?"gecko":(d.Q?"opera":(d.U?"safari":"unknown")))));



 if  (!Array.prototype.push)
{
    Array.prototype.push  =  function()
   {
      for  (var   i=0;  i<arguments.length;  i++)
        this[this.length] =  arguments[i];
   };
}

 if  (!Function.prototype.apply)
{
    Function.prototype.apply  =  function(X,  ra)
   {
      X.hb  =  this;
      var   ib  =  X.hb(ra[0],  ra[1],  ra[2],  ra[3],  ra[4]);
      X.hb  =  null;
      return   ib;
   }
}

 d.W(d.oa);

 d["Utils"] =  d.oa;
 d.oa["setTimeoutHandler"] =  d.oa.pa;
 d.oa["setIntervalHandler"] =  d.oa.ta;
 d.Ga  = {
    jb:  1,
    kb:{},

    lb:  function(za)
   {
      if  (!za.id)
     {
        var   id  =  "qid_"  +  this.jb++;
        za.id  =  id;
        this.kb[id] =  true;
     }

      return   za.id;
   },

    mb:  function(za)
   {
      var   nb  = [];

      if  (za.id  && !this.kb[za.id])
        nb[0] =  za;

      var   ob  =  za.getElementsByTagName(d.f);
      var   pb  =  ob.length;
      for  (var   i=0;  i<pb;  i++)
     {
        var   za  =  ob[i];
        if  (za.id  && !this.kb[za.id])
          nb[nb.length] =  za;
     }

      return   nb;
   },
    Ha:  function(za,  qb,  rb)
   {
      while  (za  &&  za.nodeType  ==  1)
     {
        if  (d.Ja.contains(za,  qb))
          return   za;

        za  =  za.parentNode;
        if  (rb  &&  za  &&  d.Ja.contains(za,  rb))
          return   null;
     }
   },
    sb:  function(za,  qb)
   {
      var   tb  =  za.getElementsByTagName("*");
      var   ub  =  tb.length;
      for  (var   i=0;  i<ub;  i++)
        if  (d.Ja.contains(tb[i],  qb))
          return   tb[i];
   },
    getElementsByTagName:  function(za,  tagName)
   {
      var   vb  = [];
      var   wb  =  za.getElementsByTagName(tagName);
      var   xb  =  wb.length;
      for  (var   i=0;  i<xb;  i++)
        vb.push(wb[i]);

      return   vb;
   },
    getBoxObjectFor:  function(za)
   {
      if  (d.R)
     {
        var   yb  =  za.getBoundingClientRect();
        return  {
          x:  yb.left,
          y:  yb.top,
          width:  yb.right  -  yb.left,
          height:  yb.bottom  -  yb.top 
       };
     }
      else   if  (d.T)
        return   za.ownerDocument.getBoxObjectFor(za);
      else   if  (d.Q)
     {
 zb("TO DO!!!");
        Ab  = {
          y:za.offsetTop,
          height:Bb.offsetHeight 
       };
     }
   },
    Cb:  function(Db,  Eb)
   {
      if  (d.R)
        return   Db.contains(Eb);

      while  (Eb)
     {
        if  (Db  ==  Eb)
          return   true;
        else 
          Eb  =  Eb.parentNode;
     }

      return   false;
   },
    Fb:  function(Gb,  Hb)
   {
      if  (!Gb  || !Hb  ||  Gb  ==  Hb)
        return   Gb  ||  Hb;

      while  (Gb)
     {
        if  (this.Cb(Gb,  Hb))
          return   Gb;
        Gb  =  Gb.parentNode;
     }
   },
    Ib:  function(za)
   {
      if  (d.R)
        return   za.style.cssText;
      else 
        return   za.getAttribute("style");
   },
    Jb:  function(za,  s)
   {
      if  (d.R)
        za.style.cssText  =  s;
      else 
        za.setAttribute("style",  s);
   }
};

 d.W(d.Ga);

 d["HtmlDomUtils"] =  d.Ga;
 d.Ga["acquireIdForHtmlElement"] =  d.Ga.lb;
 
 d.Ga["getAncestorWithClassName"] =  d.Ga.Ha;
    
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


 d.Ja  = {
    Kb:/\s+/,

    Lb:{},
    Mb:{},
    Nb:  function(qb,  Ob,  ua)
   {
      this.Mb[qb] = {
        Ob:Ob,
        Pb:  "(\\b"  +  Ob.join("-"  +  qb) +  "-"  +  qb  +  "\\b|\\b"  +  qb  +  "\\b)",
        ua:ua  ||  1.1*d.w 
     };
   },
   
    contains:  function(za,  qb)
   {
      return   this.Qb(za.className,  qb);
   },
    Qb:  function(s,  qb)
   {
      
      return  !!(s  &&  s.match(this.Rb(qb)));
   },
    match:  function(za,  qb)
   {
      return   za.className.match(this.Rb(qb));
   },
    add:  function(za,  Sb,  Tb)
   {
      if  (!this.contains(za,  Sb))
        if  (this.Mb[Sb])
          this.Ub(za,  null,  Sb,  0,  Tb);
        else 
       {
          var   Vb  =  za.className;
          var   Wb  =  Vb  +  d.g  +  Sb;
          this.Xb(za,  Vb,  Wb,  Tb);
       }
   },
    replace:  function(za,  Yb,  Sb,  Tb,  Zb)
   {
      if  (this.contains(za,  Yb))
     {
        if  (this.Mb[Yb])
          Yb  =  this.Mb[Yb].Pb;

        if  (!Zb  &&  this.Mb[Sb])
          this.Ub(za,  Yb,  Sb,  0,  Tb);
        else 
          this.Xb(za,  za.className,  this._c(za.className,  Yb,  Sb),  Tb);
     }
   },
    _c:  function(s,  ac,  bc)
   {
      var   cc  =  s.replace(this.Rb(ac),  bc);
      if  (!cc.match(this.Rb(bc)))
        cc  +=  d.g  +  bc;

      return   cc;
   },
    dc:  function(za,  qb,  ec,  Tb)
   {
      if  (ec)
        this.add(za,  qb,  Tb);
      else 
        this.remove(za,  qb,  Tb);
   },
 
 
 
 
 
 
 
 
 
 
    remove:  function(za,  Yb,  Tb)
   {
      if  (this.Mb[Yb])
        Yb  =  this.Mb[Yb].Pb;

      this.Xb(za,  za.className,  za.className.replace(this.Rb(Yb),  ""),  Tb);
   },
    ga:  function(za,  Wb,  Tb)
   {
      this.Xb(za,  za.className,  Wb,  Tb);

      var   qb;
      var   fc  =  Wb.split(this.Kb);
      for  (var   i=0;  i<fc.length;  i++,  qb=fc[i])
        if  (this.Mb[qb])
       {
          this.Ub(za,  qb,  qb,  0,  Tb);
          return;
       }
   },

    gc:  new   RegExp("(-[^_-]+)|(_-\\d+)|(_\\w+)",  "g"),
    hc:{
      "delay":"int",
      "delayOn":"int",
      "delayOff":"int",
      "delaySwap":"int",
      "duration":"int",
      "delta":"int",
      "max":"int",
      "interval":"int",
      "step":"int",
      "onBefore":"function",
      "onFinish":"function",
      "props":"array",
      "classes":"array",
      "limitmorphto":"array",
      "replace":"array",
      "target":"array" 
   },
    Ka:  function(za,  ic,  jc)
   {
      var   kc  =  null;
      var   lc  =  this.Rb(ic  +  "\\b-?([\\w\\-\\_]*)\\b");

      var   matches  =  za.className.match(lc);
      if  (matches)
     {
        kc  = {};
        if  (jc)
          for  (var   ma   in   jc)
            kc[ma] =  jc[ma];

        kc.mc  =  matches[0].split("-")[0];

        for  (var   nc=0;  nc<matches.length;  nc++)
       {
          var   ea  =  matches[nc].match(this.gc);
          if  (ea)
            for  (var   i=0;  i<ea.length;  i++)
           {
              var   Z  =  ea[i].substring(1);
              if  (i<ea.length-1  &&  ea[i+1].charAt(0) ==  "_")
             {
                var   db  =  ea[i++ +  1].substring(1);
                switch  (this.hc[Z])
               {
                  case   "function":
                    db  =  d.oa.Ma(db);
                    break;
                  case   "int":
                    db  =  parseInt(db);
                    break;
                  case   "array":
                    db  =  db.split("_");
                    break;
               }
                kc[Z] =  db;
                if  (!kc.action)
                  kc.action  =  Z;
             }
              else 
             {
                kc[Z] =  true;
                kc.action  =  Z;
             }
           }
       }
     }

      return   kc;
   },



    oc:  null,
    pc:  function()
   {
      this.oc  = {
        qc:null,
        setData:[]
     };
   },
    
    rc:  function()
   {
      var   sc  =  this.oc;

      this.oc  =  null;

      if  (sc.setData.length  >  0)
     {
        var   tc  =  this.uc(sc.vc,  sc.qc.className,  false);

        d.wa.xa(d.l,  sc.qc,  tc);

        for  (var   i=0;  i<sc.setData.length;  i++)
       {
          var   wc  =  sc.setData[i];
          this.Xb(wc.za,  wc.Vb,  wc.Wb,  d.M,  true);
       }

        d.wa.xa(d.m,  sc.qc,  tc);
     }
   },

    xc:  function(za,  kc)
   {
      for  (var   name   in   kc)
        switch  (name)
       {
          case   "add":
            this.add(za,  kc[name]);
            break;
          case   "remove":
            this.remove(za,  kc[name]);
            break;
          case   "replace":
            this.replace(za,  kc[name][0],  kc[name][1]);
            break;
          case   "set":
            this.ga(za,  kc[name]);
            break;
          case   "empty":
            this.ga(za,  "");
            break;
       }
   },
    Rb:  function(qb)
   {
      return   this.Lb[qb] || (this.Lb[qb] =  new   RegExp("\\b"  +  qb  +  "\\b",  "g"));
   },
    Xb:  function(za,  Vb,  Wb,  Tb,  yc)
   {
      Wb  =  Wb.replace(/^\s+|\s+$/g,  "");
      if  (Wb  !=  Vb)
     {
        if  (this.oc)
       {
          var   zc  =  d.Ga.Fb(this.oc.qc,  za);
          if  (zc  !=  this.oc.qc)
         {
            this.oc.qc  =  zc;
            this.oc.vc  =  zc.className;
         }

          this.oc.setData.push(
           {
              za:za,
              Vb:Vb,
              Wb:Wb 
           }
         );
       }
        else 
       {
          if  (!Tb)
         {
            var   Ac  =  this.uc(Vb,  Wb,  yc);
            d.wa.xa(d.l,  za,  Ac);
         }
          za.className  =  Wb;
          if  (!Tb)
            d.wa.xa(d.m,  za,  Ac);

          if  (d.R)
         {
            
            
            
            
            if  (za.getAttribute("tabIndex",  2) ==  0)
           {
              za.tabIndex  = -1;
              setTimeout(function(){  za.tabIndex  =  0; },  0);
           }
         }
       }
     }
   },
    Ub:  function(za,  Yb,  qb,  Bc,  Tb)
   {
      var   data  =  this.Mb[qb];
      var   Ob  =  data.Ob;

      var   Sb  =  Ob[Bc] +  "-"  +  qb;

      d.oa.cb(za,  d.w,  data.ua);

      if  (Yb  &&  this.contains(za,  Yb))
        this.replace(za,  Yb,  Sb,  Tb,  true);
      else 
        this.add(za,  Sb,  Tb,  true);

      var   Cc  =  this;
      if  (Bc  <  Ob.length-1)
        d.oa.pa(function(){  Cc.Ub(za,  Sb,  qb,  Bc+1,  Tb); },  data.ua);
      else 
        d.oa.pa(function(){  if  (Cc.contains(za,  Sb))  Cc.replace(za,  Sb,  qb,  Tb,  true); },  data.ua);
   },
    
    uc:  function(Vb,  Wb,  yc)
   {
      var   Dc  =  Vb.split(this.Kb);
      var   Ec    =  Wb.split(this.Kb);

      var   Fc  = {};
      for  (var   i=0;  i<Dc.length;  i++)
     {
        Fc[Dc[i]] =  1;

        var   Gc  =  Dc[i].split(/[-_]/);
        for  (var   Hc=0;  Hc<Gc.length;  Hc++)
          Fc[Gc[Hc]]=  1;
     }

      var   addCNs  = [];
      for  (var   i=0;  i<Ec.length;  i++)
     {
        if  (!Fc[Ec[i]])
          addCNs.push(Ec[i]);
        var   Ic  =  Ec[i].split(/[-_]/);
        for  (var   Hc=0;  Hc<Ic.length;  Hc++)
          if  (!Fc[Ic[Hc]])
            addCNs.push(Ic[Hc]);
     }

 
      var   delCNs  = [];
      for  (var   i=0;  i<Dc.length;  i++)
        if  (!addCNs[Dc[i]])
          delCNs.push(Dc[i]);

      return  {  fromValue:  Vb,  toValue:Wb,  delCNs:delCNs,  addCNs:addCNs,  yc:yc  };
   }
};

 d.W(d.Ja);

 d["ClassNameAbstraction"] =  d.Ja;
 d.Ja["addClassNameSequence"] =  d.Ja.Nb;
 d.Ja["contains"] =  d.Ja.contains;
 d.Ja["add"] =  d.Ja.add;
 d.Ja["replace"] =  d.Ja.replace;
 d.Ja["toggle"] =  d.Ja.dc;
 d.Ja["remove"] =  d.Ja.remove;
 d.Ja["set"] =  d.Ja.ga;
 
 
 

 
 
 
 
 
 
 
 
 

 
 
 

 
 
 
 
 
 
 

 d.Jc  = {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

    Kc:  false,
    Lc: {},
    Mc:{},
    
    Nc:  function(Oc,  Pc,  qa,  X)
   {
      var   Qc  = {qa:qa,  X:X};
      var   Rc  =  d.Ga.lb(Oc) +  "-"  +  Pc;

      var   Sc  =  this.Lc[Rc];
      if  (this.Mc[Rc] ==  Oc  &&  Sc)
        Sc.push(Qc);
      else 
     {
        this.Mc[Rc] =  Oc;
        Sc  =  this.Lc[Rc] = [Qc];

        var   va  =  function(Tc)
       {
          
          
          if  (typeof(d) !=  "undefined")
         {
 

            
            d.wa.xa(d.j,  Tc);

            Tc  =  d.Jc.Uc(Tc);

            
            
            if  (Tc.type  ==  d.D  &&  d.T  &&  Tc.Vc)
              return   false;

            var   ib  =  false;

            var   ra  = [Tc,  Oc];
            for  (var   i=0;  i<Sc.length;  i++)
              ib  =  Sc[i].qa.apply(Sc[i].X  ||  Oc,  ra) &&  ib;

            if  (Tc.Wc  ==  true)
              d.Jc.Xc(Tc);

            
            d.wa.xa(d.k,  Tc);

            return   ib;
         }
       };
        if  (d.Y)
       {
          var   X  = {  Yc:va  };
          d.Y.Zc(X,  "eventHandler",  "Spif.DOMEvents."  +  Pc);
          va  =  X.Yc;
       }

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

        if  (Oc.addEventListener)
          Oc.addEventListener(Pc,  va,  false);
        else 
       {
          if  (Pc  ==  "DOMMouseScroll")
            Pc  =  "mousewheel";
          Oc.attachEvent("on"  +  Pc,  va);
       }
     }
   },

    _d:  function()
   {
      this.Wc  =  true;
   },
    Xc:  function(Tc)
   {
      Tc.preventDefault();
      Tc.stopPropagation();

      if  (d.U  &&  this.type  ==  d.D)
     {
        var   za  =  Tc.subject;
        while  (za  &&  za.nodeName  !=  "A")
          za  =  za.parentNode;

        if  (za)
       {
          za.ad  =  za.href;
          za.href  =  "javascript://";
          setTimeout(function(){  za.href  =  za.ad; },  10);
       }
     }
   },
    bd:  function()
   {
      this.returnValue  =  false;
   },
    cd:  function()
   {
      this.cancelBubble  =  true;
   },

    Uc:  function(Tc)
   {
 
      if  (d.R)
     {
        Tc.subject  =  Tc.srcElement;
        Tc.preventDefault   =  this.bd;
        Tc.stopPropagation  =  this.cd;
     }
      else 
     {
        Tc.subject  =  Tc.target  ||  Tc.currentTarget;
        if  (Tc.subject  &&  Tc.subject.nodeType  ==  3)
          Tc.subject  =  Tc.subject.parentNode;
     }

      Tc.cancel  =  this._d;

      switch  (Tc.type)
     {
        case   d.D:
        case   "mousedown":
        case   "mouseup":
        case   "mousemove":
          Tc.ed   = (d.R||d.U?Tc.button  ==  1:Tc.button  ==  0);
          Tc.Vc  =  Tc.button  ==  2;
          break;
        case   d.F:
        case   "keyup":
        case   d.G:
          if  (d.R  &&  Tc.subject.isContentEditable)
         {
            var   fd  =  document.selection.createRange();
            if  (fd.length)
              Tc.subject  =  fd.item(0);
            else 
              Tc.subject  =  fd.parentElement();
         }

          if  (d.T  &&  Tc.subject  ==  document.documentElement)
            
            
            Tc.subject  =  document.body;
          break;
        case   "mousewheel":
          if  (d.R)
            Tc.detail  = -Tc.wheelDelta/20;
          break;
     }

      return   Tc;
   }
};

 d["DOMEvents"] =  d.Jc;
 d.Jc["attach"] =  d.Jc.Nc;
 d.wa  = {
    gd: {},
    hd:  function(Pc,  qa,  X)
   {
      var   jd  =  this.gd[Pc] =  this.gd[Pc] || [];

      jd[jd.length] = {qa:qa,  X:X};
   },
    xa:  function(Pc,  subject,  ea)
   {
      var   ib  =  true;

      var   jd  =  this.gd[Pc];
      if  (jd)
     {
        var   Tc  =  ea  || {};
        Tc.type  =  Pc;
        Tc.subject  =  subject;

        for  (var   i=jd.length-1;  i>=0;  i--)
          ib  = (jd[i].qa.apply(jd[i].X  ||  subject, [Tc]) !=  false) &&  ib;
     }
    
      return   ib;
   }
};

 d["CustomEvents"] =  d.wa;
 d.wa["listen"] =  d.wa.hd;
 d.wa["fire"] =  d.wa.xa;
 
 
 
 
 
 
 
 
 


 d.kd  = {
    ba:  function()
   {
      d.wa.hd(d.m,  this.ld,  this);
      d.wa.hd(d.o,  this.md,  this);
      d.Jc.Nc(document.documentElement,  "DOMMouseScroll",    this.nd,  this);
   },
    ld:  function(Tc)
   {
      if  (Tc.addCNs.length  >  0  &&  d.wa.xa(d.r,  Tc.subject))
        this.od(Tc.subject,  Tc.addCNs);
   },
    md:  function(Tc)
   {
      if  (d.wa.xa(d.r,  Tc.subject))
        this.od(Tc.subject, [d.C]);
   },
    od:  function(pd,  qd,  context)
   {
      var   rd  =  false;

      
      for  (var   i=0;  i<qd.length;  i++)
        d.wa.xa("on"  +  qd[i],  pd);

      var   sd  =  "\\bon"  +  qd.join("\\b|\\bon") +  "\\b";
      for  (var   ud  =  pd.firstChild;  ud;  ud  =  ud.nextSibling)
        if  (ud.nodeName  ==  "A"  &&  d.Ja.contains(ud,  sd))
       {
          d.wa.xa(d.v,  ud, {  context:context  });
          rd  =  true;
       }

      return   rd;
   },
    nd:  function(Tc)
   {
      var   vd  =  false;
      var   Pc  = ["mousescroll"  + (Tc.detail>0?"down":"up")];
      for  (var   za  =  Tc.subject;  za;  za  =  za.parentNode)
        vd  =  vd  ||  this.od(za,  Pc,  null);

      if  (vd)
        Tc.cancel();
   }
};

 d.W(d.kd);
 
 
 
 
 
 
 
 
 
 
 
 
 

 d.wd  = {
    xd:[],
    yd:  null,
    zd:{},
    Ad:{},
    Bd:  null,
    Cd:  null,
    Dd:  false,
    ba:  function()
   {
      d.Jc.Nc(document.documentElement,  d.D,    this.Ed,  this);

      
      
      
      d.Jc.Nc(document.documentElement, (d.R?d.F:d.G),  this.Ed,  this);
   },
    Fd:  function(qb,  qa,  X)
   {
      this.Gd(qb,  qa,  X,  true);
   },
    Hd:  function(qb,  qa,  X)
   {
      this.Gd(qb,  qa,  X,  false);
      this.Dd  =  true;
   },
    Gd:  function(qb,  qa,  X,  Id)
   {
      this.xd[this.xd.length] =  qb;
      this.zd[qb] = {  qa:qa,  X:X  };
      this.Ad[qb] =  Id;

      this.xd  =  this.xd.sort().reverse();

      this.yd  =  new   RegExp("(\\b"  +  this.xd.join("\\b)|(\\b") +  "\\b)|(\\b[\\w\\-]+\\b|\\s+)",  "g");
   },
    Ed:  function(Tc)
   {
      this.Cd  = (Tc.type  ==  d.D  ||  Tc.keyCode  ==  13  ||  Tc.keyCode  ==  32);

      if  (!this.Dd  && !this.Cd)
        return;

      this.Bd  =  Tc;
      var   ob  = [];

      for  (var   za  =  Tc.subject;  za  &&  za.nodeType  ==  1;  za  =  za.parentNode)
        ob[ob.length] =  za;

      for  (var   i=0;  i<ob.length;  i++)
     {
        this.Jd  =  ob[i];
        if  (this.Jd.className)
          this.Jd.className.replace(this.yd,  this.Kd);
     }
   },
    Kd:  function()
   {
      if  (!arguments[arguments.length-3])
     {
        var   Cc  =  d.wd;
        for  (var   i=1;  i<arguments.length-3;  i++)
          if  (arguments[i])
         {
            var   qb  =  Cc.xd[i-1];
            if  (Cc.Cd  || !Cc.Ad[qb])
           {
              if  (d.wa.xa(d.r,  Cc.Jd))
             {
                var   qa  =  Cc.zd[qb];
                qa.qa.apply(qa.X  ||  Cc.Jd, [Cc.Jd,  arguments[i],  Cc.Bd]);
             }
              return;
           }
         }
     }
   }
};

 d.W(d.wd);
 
 
 


 d.Ld  = {
    Md:[],
    Nd:"",
    Od:{},
    Pd:{},
    Qd:[],

    ba:  function()
   {
      d.Jc.Nc(document.documentElement,  d.D,      this.Rd,  this);
      d.Jc.Nc(document.documentElement,  "dblclick",      this.Rd,  this);
      d.Jc.Nc(document.documentElement,  "keyup",   this.Sd,  this);
      d.wa.hd(d.v,  this.Td,  this);
   },
    Ud:  function(Vd,  X)
   {
      this.Qd.push({qa:Vd,  X:X});
   },
    Wd:  function(Xd,  Yd,  Vd,  X)
   {
      var   Zd  =  "("  +  Yd.join("|") +  ")";
      for  (var   i=0;  i<Xd.length;  i++)
     {
        var   ic  =  Xd[i];
        this.Md[this.Md.length] =  ic;
        this.Od[ic] =  Zd;
        this.Pd[ic] = {  qa:Vd,  X:X};
     }

      this.Nd  =  "(\\b"  +  this.Md.join("\\b|\\b") +  "\\b)";
   },
    Rd:  function(Tc)
   {
      this.Td(Tc);
   },
    Sd:  function(Tc)
   {
      if  (Tc.keyCode  ==  32  ||  Tc.keyCode  ==  13)
        this.Td(Tc);
   },
    Td:  function(Tc)
   {
 
      var   Xd;
      var   za  =  Tc.subject;

      
      while  (za  &&  za.nodeType  ==  1)
     {
        
        
        if  (Tc.type  ==  d.G  &&  za.nodeName  ==  "A")
          return;

        if  ((Xd  =  d.Ja.match(za,  this.Nd)) &&  d.wa.xa(d.r,  za))
       {
          var   _e  = {};

          for  (var   i=0;  i<Xd.length;  i++)
         {
            var   ic  =  Xd[i];
            if  (ic  && !_e[ic])
           {
              var   ae  =  d.Ja.Ka(za,  ic);
              if  (
               (!ae["require"] ||  d.Ga.Ha(za,  ae["require"]))
               &&
               (!ae["disallow"] || !d.Ga.Ha(za,  ae["disallow"]))
             )
             {
                var   be  =  this.ce(za,  ic,  Tc.context);
                if  (!be  || !be.za  || !d.wa.xa(d.r,  be.za))
                  continue;

                var   de  =  d.Ja.Ka(be.za,  be.ee);
                if  (
                  de 
                 &&
                 (!de["require"] ||  d.Ga.Ha(za,  de["require"]))
                 &&
                 (!de["disallow"] || !d.Ga.Ha(za,  de["disallow"]))
               )
                  _e[ic] = {
                    fe:  this.Pd[ic],
                    be:  be,
                    ae:  ae,
                    de:  de 
                 };
           }
           }
         }

          for  (ic   in   _e)
         {
            var   ge  =  _e[ic];
            d.oa.pa(this.he(Tc,  za,  ic,  ge),  1*ge.ae.delay||-1);
         }
       }

        if  (za.nodeName  ==  "A")
       {
          for  (var   i=0;  i<this.Qd.length;  i++)
         {
            var   qa  =  this.Qd[i];
            qa.qa.apply(qa.X  ||  za, [za,  Tc]);
         }
          
          
          if  (Tc.cancel  &&  Xd  &&  Xd.length  >  0  &&  za.getAttribute("href",  2).charAt(0) ==  "#")
            Tc.cancel();
       }

        za  =  za.parentNode;
     }
   },

    he:  function(Tc,  za,  ic,  ge)
   {
      return   function()
     {
        ge.fe.qa.apply(ge.fe.X  ||  za, [za,  ic,  ge.be.za,  ge.be.ee,  Tc,  ge.ae,  ge.de]);
     };
   },

    ce:  function(ie,  ic,  context)
   {
      var   je  =  this.ke(ie,  ic,  context);

      if  (je)
     {
        var   le  =  d.Ja.match(je,  this.Od[ic]);
        return  {  za:je,  ee:(le?le[0]:null) };
     }
   },
    ke:  function(ie,  ic,  context)
   {
      var   me  =  ie.href;
      if  (me)
        var   ne  =  me.split("#")[1];
      
      if  (ne)
        return   document.getElementById(ne);

      
      for  (var   za  =  context  ||  ie;  za  !=  document.documentElement;  za  =  za.parentNode)
        if  (d.Ja.match(za,  this.Od[ic]))
          return   za;
   }
};

 d.W(d.Ld);
 
 
 
 
 
 
 
 
 
 
 

 d.wa.hd(
    d.r,
    function(Tc)
   {
      return  !d.Ga.Ha(Tc.subject,  "(^|\\s)disabled(\\s|$)");
   }
);
(function(){
 d.oe  = {
    pe:"exclusive-",
    qe:"(allexclusive-|exclusive-)",
    re:"delayexclusive",
    se:"exclusive-reset",

    te:1,
    ue:{},
    ve:{},
    we:{},
    xe:{},
    ye:{},
    ze:{},
    Ae:{},
    Be: {},

    ba:  function()
   {
      d.wa.hd(d.j,  this.Ce,  this);
      d.wa.hd(d.m,  this.ld,  this);
   },

    De:  function(Xd,  Ee,  Fe,  Ge)
   {
      var   id  =  this.te++;
      var   He  =  Ee[Ee.length  -  1];
      for  (var   i=0;  i<Xd.length;  i++)
     {
        var   ic  =  Xd[i];
        var   Ie  =  Ee[i];

        this.we[He] =  Ie;
        this.xe[Ie] =  He;

        He  =  Ie;

        this.ue[ic] =  Ie;
        this.ve[Ie] =  ic;
        this.ye[ic] =  id;
     }

      if  (Fe)
     {
        for  (var   i=0;  i<Fe.length;  i++)
       {
          Xd[Xd.length] =  Fe[i];
          this.ze[Fe[i]] =  true;
          this.ue[Fe[i]] =  Ee[0];
       }
     }
      if  (Ge)
     {
        for  (var   i=0;  i<Ge.length;  i++)
       {
          Xd[Xd.length] =  Ge[i];
          this.Ae[Ge[i]] =  true;
          this.ue[Ge[i]] =  Ee[0];
       }
     }

      d.Ld.Wd(Xd,  Ee,  this.Je,  this);
   },

    Ce:  function()
   {
      this.Be  = {};
   },
    ld:  function(Tc)
   {
      var   Ke  = [];

      for  (var   i=0;  i<Tc.addCNs.length;  i++)
        this.Le(Tc.subject,  Tc.addCNs[i],  Ke);

      for  (var   i=Ke.length-1;  i>=0;  i--)
        this.Me(Ke[i]);
   },
    Je:  function(ie,  ic,  je,  Ne)
   {
      var   Ke  = [];
      this.Oe(Ke,  ic,  je,  Ne);

      d.Ja.pc();
      for  (var   i=Ke.length-1;  i>=0;  i--)
        this.Me(Ke[i]);
      d.Ja.rc();
   },     
    Oe:  function(Ke,  ic,  je,  Ne)
   {
      var   Pe  =  this.ue[ic];

      if  (this.ze[ic])
     {
        Pe  =  this.we[Ne];
        ic  =  this.ve[Pe];
     }
      else   if  (this.Ae[ic])
     {
        Pe  =  this.xe[Ne];
        ic  =  this.ve[Pe];
     }

      if  (!d.Ja.contains(je,  Pe))
     {
        Ke[Ke.length] = {
          ic:ic,
          je:je,
          Qe:Ne,
          Pe:Pe,
          delay:-1 
       };

        this.Le(je,  Pe,  Ke);
     }
   },

    Le:  function(je,  Pe,  Ke)
   {
      var   Re,  Se;
      
      if  (Re  =  d.Ga.Ha(je,  this.qe  +  Pe,  this.se))
        if  (d.Ja.contains(Re,  this.pe  +  Pe))
          Se  =  je.parentNode.childNodes;
        else 
          Se  =  d.Ga.getElementsByTagName(Re,  d.f);
      
      if  (Se)
     {
        var   Te  =  this.we[Pe];
        var   Ue  =  this.ve[Te];

        var   Ve  =  Se.length;
        for  (var   i=0;  i<Ve;  i++)
       {
          var   We  =  Se[i];

          if  (We.nodeType  ==  1  &&  We  !=  je  &&  d.Ja.contains(We,  Pe))
            if  (d.wa.xa(d.r,  We))
           {
              if  (Ke.length  >  0  &&  Ke[Ke.length-1].delay  == -1)
                Ke[Ke.length-1].delay  =  d.oa.Ya(je.parentNode,  this.re, -1);

              this.Oe(Ke,  Ue,  We,  Pe);
           }
       }
     }
   },
    
    Me:  function(Xe)
   {
      var   Ye  =  d.Ga.lb(Xe.je) +  "-"  +  this.ye[Xe.ic];
      if  (!this.Be[Ye])
     {
        this.Be[Ye] =  true;
        
        d.oa.pa(
          function()
         {
            
            d.Ja.replace(Xe.je,  Xe.Qe,  Xe.Pe,  d.M);
         },
          Xe.delay 
       );
   }
   }
};

 d.W(d.oe);

 d["Behaviors"] =  d.oe;
 d.oe["addStateSequence"] =  d.oe.De;

 
 d.oe.De(["collapser",  "expander"],    ["collapsed",  "expanded"],   ["expandedToggle",  "expandcollapser"]);
 d.oe.De(["opener",     "closer"],      ["open",       "close"],      ["openToggle"]);
 d.oe.De(["selector",   "unselector"],  ["selected",   "unselected"], ["selectedToggle"]);
 d.oe.De(["shower",     "hider"],       ["shown",      "hidden"],     ["shownToggle",  "showswitch"]);
 d.oe.De(["focuser",    "blurrer"],     ["focus",      "blur"],       ["focusToggle"]);
 d.oe.De(["onswitch",   "offswitch"],   ["on",         "off"],        ["onToggle"]);
 d.oe.De(["enabler",    "disabler"],    ["enabled",    "disabled"],   ["enabledToggle"]);
})();d.Ld.Wd(
   ["classchanger"],
   [],
    function(ie,  x,  je,  Ne,  Tc,  ae,  de)
   {
      d.oa.pa(
        function()
       {
          d.Ja.xc(je,  ae);
       },
        ae["delay"]
     );
   }
);
 d.Ld.Wd(
   ["execute"],
   [],
    function(ie,  ic,  je,  Ne,  Tc,  ae,  de)
   {
      var   ra  =  ae[ae.action];
      ra  = (ra!=true?ra.split("_"):null);
      d.oa.Ma(ae.action)(ie,  je,  ra);
   }
);
 d.Ze  =
{
    _f:  "activation-inert",
    af:  "delayOn",
    bf:  "delayOff",
    cf:  "delaySwitch",
    df: [],
    ef: [],
    ff:{},
    gf: [],
    hf: {},
    jf: {},
    kf:  null,

    lf: {},
    mf: {},
    nf: {},
    of: {},
    pf: {},
    qf: {},

    ba:  function()
   {
      
      this.rf("unhover",  "hover");
      this.rf("mouseout",  "mouseover");
      this.rf("neverhovered",  "");

      
      this.sf("inactive",  "active",  "activator",  "inactivator");
      this.sf("blurred",  "focused",  "focuser",  "blurrer");

      d.Jc.Nc(document.documentElement,  "mouseover",  this.tf,  this);

      d.Jc.Nc(document.documentElement,  d.D,  this.Td,  this);
      d.Jc.Nc(document.documentElement,  "contextmenu",  this.Td,  this);
      d.Jc.Nc(document.documentElement,  "keyup",  this.Td,  this);

      d.wa.hd(d.m,  this.ld,  this);
   },
    rf:  function(uf,  vf)
   {
      if  (uf)
        this.df.push(uf);
      if  (vf)
     {
        this.df.push(vf);
        this.ff[vf] =  vf;
        if  (uf)
          this.ff[uf] =  vf;
     }
      this.wf  =  "("  +  this.df.join("\\b|\\b") +  ")";
      this.jf[uf] =  vf;
      this.jf[vf] =  uf;
   },
    sf:  function(xf,  yf,  zf,  Af)
   {
      if  (xf)
        this.gf.push(xf);
      if  (yf)
     {
        this.ff[yf] =  yf;
        if  (xf)
          this.ff[xf] =  yf;
        this.ef.push(yf);
     }
      this.Bf  =  "("  +  this.ef.join("\\b|\\b") +  ")";
      this.Cf  =  "("  +  this.gf.join("\\b|\\b") +  ")";
      this.Df  =  "("  +  this.ef.join("\\b|\\b") +  "\\b|\\b"  +  this.gf.join("\\b|\\b") +  ")";
      this.jf[xf] =  yf;
      this.jf[yf] =  xf;

      if  (zf  &&  Af)
     {
        this.hf[zf] =  zf;
        d.Ld.Wd([zf,  Af], [yf,  xf],  this.Ef,  this);
     }
   },

    Ef:  function(ie,  ic,  je,  Ne)
   {
      var   Ff  =  d.Ga.lb(je);
      var   kc  =  d.Ja.Ka(je,  this.Df);
      var   data  = {  za:je,  kc:kc  };
      if  (this.hf[ic])
        this.Gf(Ff,  data,  this.pf,  this.of,  this.qf);
      else 
     {
        kc.mc  =  this.jf[kc.mc];
        this.Hf(Ff,  data,  this.pf,  this.of,  this.qf);
     }
   },

    tf:  function(Tc)
   {
      this.If(Tc,  this.wf,  this.mf,  this.lf,  this.nf);
   },

    Td:  function(Tc)
   {
      var   za  =  Tc.subject;
      
      if  (za  !=  this.kf)
     {
        this.kf  =  za;

        if  (!d.Ga.Ha(za,  this._f))
       {
          this.If(
            Tc,
            this.Df,
            this.pf,
            this.of,
            this.qf,
            d.Ga.Ha(za,  this._f) !=  null,
            Tc.ctrlKey  ||  d.Ga.Ha(za,  this._f) !=  null,
            d.Ga.Ha(za,  "activation-box")
         );

          d.wa.xa("afterActivationChange",  Tc.subject);
       }
     }
   },

    ld:  function(Tc)
   {
      if  (!d.Ja.Qb(Tc.fromValue,  this.Bf) &&  d.Ja.Qb(Tc.toValue,  this.Bf))
        
        this.Td(Tc);
      else   if  (d.Ja.Qb(Tc.fromValue,  this.Bf) && !d.Ja.Qb(Tc.toValue,  this.Bf))
     {
        var   Ff  =  d.Ga.lb(Tc.subject);
        delete   this.lf[Ff];
     }
   },

    If:  function(Tc,  Jf,  Kf,  Lf,  Mf,  Nf,  Of,  Pf)
   {
      var   Qf  = {};

 
 
      var   za  =  Tc.subject;
      while  (za  &&  za.nodeType  ==  1)
     {
        var   kc  =  d.Ja.Ka(za,  Jf);
        if  (
          kc 
         && (!kc["require"]  ||   d.Ga.Ha(za,  kc["require"]))
         && (!kc["disallow"] || !d.Ga.Ha(za,  kc["disallow"]))
       )
          Qf[d.Ga.lb(za)] = {  za:za,  kc:kc  };

        za  =  za.parentNode;
     }   

      this.Rf  =  false;

 
 
      if  (!Of)
        for  (var   Ff   in   Lf)
          if  (!Qf[Ff] && (!Pf  ||  d.Ga.Cb(Pf,  Lf[Ff].za)))
            this.Hf(Ff,  Lf[Ff],  Kf,  Lf,  Mf);

      if  (!Nf)
        for  (var   Ff   in   Qf)
          if  (!Lf[Ff] && (!Pf  ||  d.Ga.Cb(Pf,  Qf[Ff].za)))
            this.Gf(Ff,  Qf[Ff],  Kf,  Lf,  Mf);
   },
    
    Gf:  function(Ff,  data,  Kf,  Lf,  Mf)
   {
 
      if  (!Lf[Ff] &&  d.wa.xa(d.r,  data.za))
     {
        if  (Mf[Ff])
          this.Sf(Ff,  Mf);
        else 
       {
          var   delay  = (this.Rf?data.kc[this.cf]:0) ||  data.kc[this.af];
          if  (delay)
         {
            Kf[Ff] =  data;
            data.Tf  =  d.oa.pa(this.Uf,  delay,  this, [Ff,  data,  Kf,  Mf]);
         }
          else 
            this.Vf(Ff,  data,  Mf);
       }
        Lf[Ff] =  data;
     }
   },
    Hf:  function(Ff,  data,  Kf,  Lf,  Mf)
   {
 
      if  (Lf[Ff] &&  d.wa.xa(d.r,  data.za))
     {
        if  (Kf[Ff])
          this.Wf(Ff,  Kf[Ff],  Kf,  Lf);
        else 
       {
          this.Rf  =  true  &&  data.kc[this.cf];
          if  (data.kc[this.bf])
         {
            Mf[Ff] =  data;
            data.Tf  =  d.oa.pa(this.Xf,  data.kc[this.bf],  this, [Ff,  Mf]);
         }
          else 
            this.Yf(Ff,  data);

          delete   Lf[Ff];
       }
     }
   },
    Wf:  function(Ff,  data,  Kf,  Lf)
   {
      clearTimeout(data.Tf);
      delete   Kf[Ff];
      delete   Lf[Ff];
   },
    Uf:  function(Ff,  data,  Kf,  Mf)
   {
      delete   Kf[Ff];
      this.Vf(Ff,  data,  Mf);
   },
    Vf:  function(Ff,  data,  Mf)
   {
      d.Ja.replace(data.za,  this.jf[this.ff[data.kc.mc]],  this.ff[data.kc.mc]);

      var   Re  =  d.Ga.Ha(data.za,  "exclusive"  +  this.jf[data.kc.mc]);
      for  (var   Ff   in   Mf)
        if  (Re  &&  d.Ga.Ha(Mf[Ff].za,  "exclusive"  +  this.jf[data.kc.mc]) ==  Re)
       {
          this.Yf(Ff,  Mf[Ff]);
          this.Sf(Ff,  Mf);
       }
   },
    Xf:  function(Ff,  Mf)
   {
      this.Yf(Ff,  Mf[Ff]);
      delete   Mf[Ff];
   },
    Sf:  function(Ff,  Mf)
   {
      clearTimeout(Mf[Ff].Tf);
      delete   Mf[Ff];
   },
    Yf:  function(Ff,  data)
   {
      d.Ja.replace(data.za,  this.ff[data.kc.mc],  this.jf[this.ff[data.kc.mc]]);
   }
};

 d.W(d.Ze);

 
 
 
 

 

 d.Zf  = {
    _g:1,
    ag:2,
    bg:3,
    cg:4,
    dg:5,
    eg:6,
    fg:7,
    gg:8,
    hg:9,
    ig:null,
    ba:  function()
   {
      if  (d.R)
     {
        this.jg  =  this.kg;
        this.lg  =  this.mg;
     }
      d.Zf["getRawComputedStyleProperty"] =  d.Zf.jg;

      this.ig  = {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        "borderWidth":this.ag,
        "borderTopWidth":this.ag,
        "borderRightWidth":this.ag,
        "borderBottomWidth":this.ag,
        "borderLeftWidth":this.ag,
        "width":this.bg,
        "height":this.bg,
        "scrollTop":this.cg,
        "scrollLeft":this.cg,
        "color":this.dg,
        "backgroundColor":this.dg,
        "borderColor":this.dg,
        "borderTopColor":this.dg,
        "borderRightColor":this.dg,
        "borderBottomColor":this.dg,
        "borderLeftColor":this.dg,
        "opacity":this.eg,
        "zoom":this.fg,
        "display":this.gg,
        "overflow":this.gg,
        "position":this.gg,
        "visibility":this.gg,
        "zIndex":this.hg 
     };

      this.ng  = {};
      this.ng[this._g] =  "px";
      this.ng[this.ag] =  "px";
      this.ng[this.bg] =  "px";
      this.ng[this.cg] =  "px";
      this.ng[this.dg] =  "";
      this.ng[this.eg] =  "%";
      this.ng[this.fg] =  "%";
      this.ng[this.gg] =  "";
      this.ng[this.hg] =  "";
   },
    og:{
      "width":["offsetWidth"],
      "height":["offsetHeight"]
   },
    pg:{
      "width":["height",  "offsetHeight"],
      "height":["width",  "offsetWidth"]
   },

    qg:  function(za,  Z)
   {
      var   rg  =  this.jg(za,  Z);
      return   this.lg(za,  Z,  rg).value;
   },

    jg:  function(za,  Z,  sg)
   {
      var   tg  =  this.ug(Z);
      var   vg  =  document.defaultView.getComputedStyle(za,  "");

      if  (vg)
        switch  (this.wg(Z))
       {
          case   this.bg:
            if  (d.Q)
           {
              var   xg  =  this.og[Z];
              var   db  =  za[xg[0]];
              for  (var   i=1;  i<xg.length;  i++)
                db  -=  parseInt(za.currentStyle[xg[i]]);
              return   Math.max(0,  db);
           }
          case   this.ag:
            if  (vg.getPropertyValue(tg.replace(/width/,  "style")) ==  d.h)
              return   0;
          case   this.hg:
          case   this._g:
          case   this.fg:
          case   this.eg:
            return   vg.getPropertyValue(tg);
          case   this.cg:
            return   za[Z];
            break;
          case   this.dg:
            if  (
              tg.indexOf("border") != -1 
             &&  vg.getPropertyValue(tg.replace(/color/,  "style")) ==  d.h 
           )
              return   null;
            
          case   this.gg:
            return   vg.getPropertyValue(tg);
       }

      return   null;
   },
    lg:  function(za,  Z,  rg)
   {
      var   yg  =  this.wg(Z);

      var   X  = {  value:  rg  };

      switch  (yg)
     {
        case   this.hg:
        case   this._g:
        case   this.fg:
          var   zg  =  parseInt(rg);
          if  (isNaN(zg))
            switch  (rg)
           {
              case   "auto":  X.value  =  0;  break;
              default:  X.value  =  null;
           }
          else 
            X.Ag  = (""  +  rg).replace(/^[-\d]+/,  "") ||  null;
          X.value  =  zg;
          break;
        case   this.eg:
          X.value  =  Math.round(100*rg);
          break;
        case   this.dg:
          X.value  =  this.Bg(rg);
          break;
        case   this.bg:
        case   this.cg:
          X.value  =  parseInt(rg);
     }

      return   X;
   },


    kg:  function(za,  Z)
   {
      
      if  (!za.currentStyle)
        return   null;

      switch  (this.wg(Z))
     {
        case   this.bg:
 
 
 
            
            
            var   Cg  =  za[this.pg[Z][1]] ==  0;
            if  (Cg)
              za.runtimeStyle[this.pg[Z][0]] =  "1px";

            var   db  =  za[this.og[Z]];

 za.runtimeStyle[Z] =  db;
 db  +=  db  -  za[this.og[Z]];
 za.runtimeStyle[Z] =  "";

            if  (Cg)
              za.runtimeStyle[this.pg[Z][0]] =  "";
 

          return   db;
        case   this.cg:
          return   za[Z];
          break;
        case   this.eg:
          try 
         {
            return   za.filters.item(d.K).opacity;
         }
          catch(Dg)
         {
            return   100;
         }
          break;
        case   this._g:
        case   this.fg:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        default:
          return   za.currentStyle[Z];
     }
   },

    mg:  function(za,  Z,  rg)
   {
      var   yg  =  this.wg(Z);

      var   X  = {  value:  rg  };
      var   zg  =  null;

      if  (rg  ==  "0px")
        rg  =  "0";

      switch  (yg)
     {
        case   this.bg:

 zg  =  parseInt(rg);

          X.Ag  = (""  +  rg).replace(/^[-\d\.]+/,  "") ||  null;
          X.value  =  Math.max(0,  zg);
          break;
        case   this.dg:
          X.value  =  this.Bg(rg);
          break;
        case   this.ag:
        case   this.hg:
        case   this._g:
        case   this.fg:
          zg  =  parseInt(rg);
          if  (isNaN(zg))
            switch  (rg)
           {
              case   "auto":  zg  =  0;  break;
              case   "thin":  zg  =  2;  break;
              case   "medium":  zg  =  4;  break;
              case   "thick":zg  =  6;  break;
              default:  zg  =  parseInt(rg);
           }
          else 
            X.Ag  = (""  +  rg).replace(/^[-\d\.]+/,  "") ||  null;

          X.value  =  zg;
          break;
     }

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

      return   X;
   },

    Eg:  function(za,  Z,  db)
   {
      switch  (this.wg(Z))
     {
        case   this.dg:
          za.style[Z] =  "rgb("  +  db.join(",") +  ")";
          break;
        case   this.gg:
        case   this.hg:
          za.style[Z] =  db;
          break;
        case   this.bg:
        case   this.fg:
        case   this.ag:
        case   this._g:
          za.style[Z] =  db  +  "px";
          break;
        case   this.cg:
          za[Z] =  db  +  "px";
          break;
     }
   },

    Fg:  function(za,  Z)
   {
      za.style[Z] =  "";
   },

    wg:  function(Z)
   {
      return   this.ig[Z] ||  this._g;
   },

    ug:  function(Z)
   {
      return   Z.replace(/([A-Z])/g,  function(Gg){  return   "-"  +  Gg.toLowerCase(); });
   },
    Hg: {
      "white":"#FFFFFF",  "black":"#000000","blue":"#0000FF",
      "green":"#008000",  "red":"#FF0000",  "yellow":"#FFFF00",
      "aqua":"#00FFFF","azure":"#F0FFFF","beige":"#F5F5DC",
      "black":"#000000","blue":"#0000FF","brown":"#A52A2A",
      "cyan":"#00FFFF","darkblue":"#00008B","darkcyan":"#008B8B",
      "darkgray":"#A9A9A9","darkgreen":"#006400","darkred":"#8B0000",
      "fuchsia":"#FF00FF","gold":"#FFD700","gray":"#808080",
      "green":"#008000","indigo":"#4B0082","lightblue":"#ADD8E6",
      "lightcyan":"#E0FFFF","lightgreen":"#90EE90","lightgrey":"#D3D3D3",
      "lightyellow":"#FFFFE0","lime":"#00FF00","magenta":"#FF00FF",
      "maroon":"#800000","navy":"#000080","orange":"#FFA500",
      "pink":"#FFC0CB","purple":"#800080","red":"#FF0000",
      "silver":"#C0C0C0","steelblue":"#4682B4","turquoise":"#40E0D0",
      "violet":"#EE82EE","white":"#FFFFFF","yellow":"#FFFF00" 
    },

    Bg:  function(c)
   {
      c  =  this.Hg[c] ||  c;

      if  (typeof(c) ==  "object")
        return   c;
      if  (c.indexOf("#") ==  0)
     {
        if  (c.length  ==  7)
          return  [
            parseInt(c.substring(1,  3),  16),
            parseInt(c.substring(3,  5),  16),
            parseInt(c.substring(5,  7),  16)
         ];
        else 
          return  [
            17*parseInt(c.substring(1,  2),  16),
            17*parseInt(c.substring(2,  3),  16),
            17*parseInt(c.substring(3,  4),  16)
         ];
     }
      if  (c.indexOf("rgb(") ==  0)
     {
        var   Ig  =  c.substring(4,  c.length  -  1).split(",");
        return  [
          parseInt(Ig[0]),
          parseInt(Ig[1]),
          parseInt(Ig[2])
       ];
     }

      return  [255,  255,  255];
   }
};

 d.W(d.Zf);

 d["StyleUtils"] =  d.Zf;
 d.Zf["getComputedStyleProperty"] =  d.Zf.qg;
 
 
 d.Animator  =  _a  = {
    Jg:{},
    animate:  function(Kg,  Lg)
   {
      var   Mg  =  Kg.length;

 
 
 
 
 
 
 
 
 
 
 
      var   Ng  =  10;
      var   Og  =  1  <<  Ng;

      var   Pg  =  7;
      var   Qg  =  1  <<  Pg;

      var   code  = [
        "  var tPhase = Math.min(1, (t - TSTART)/DURATION);\n",
        "if (tPhase>=0){\n",
        "  var f = ",  _a.Rg[Lg.profile],  ";\n",
        "\n" 
     ];

      var   Sg  = [];
      var   Tg  = [];
      var   Ug  = [];


      for  (var   i=0;  i<Mg;  i++)
     {
        var   Vg  =  Kg[i];
        var   za  =  Vg.element;
        var   id  =  d.Ga.lb(za);
        var   Wg  =  Vg.targetState;

        for  (var   Xg   in   Wg)
       {
          var   Yg  =  Xg;
          if  (!d.R)
            Yg  =  Xg.replace(/([A-Z])/g,  function(Gg){  return   "-"  +  Gg.toLowerCase(); });

          var   Zg  =  Wg[Xg];

          
          var   _h  = (Vg.currentState&&typeof(Vg.currentState[Xg])!=d.e)?Vg.currentState[Xg]:d.Zf.qg(za,  Xg);

          if  (Xg  ==  "zoom")
         {
            
            _h  *=  100;
            Zg  *=  10000;
         }

          
          _a[id  +  "el"] =  za;
          switch  (d.Zf.wg(Xg))
         {
            case   d.Zf.cg:
                _a[id  +  "elscroll"] = (za  !=  document.body  ||  document.compatMode  ==  "BackCompat")?za:document.documentElement;
              break;
            case   d.Zf.eg:
              if  (d.R)
             {
                _a[id  +  "opacity"] =  za.filters.item(d.K);
                break;
             }
              
            default:
              _a[id  +  "elStyle"] =  za.style;

              if  (Lg.removeAfterwards)
 
                Ug.push("_a[\"",  id,  "elStyle\"]."  +  Xg  +  "='';\n");
         }

          
          if  (d.Zf.wg(Xg) ==  "rgb")
            Zg  =  d.Zf.Bg(Zg);

          if  (Zg.constructor  ==  Array)
         {
            var   ah  = [];
            for  (var   Hc=0;  Hc<Zg.length;  Hc++)
              ah[Hc] =  Math.floor(Zg[Hc] -  _h[Hc]);
         }
          else   if  (!isNaN(Zg))
         {
            var   ah  =  Math.floor(Zg-_h);
         }

          var   bh  = (Vg.units  &&  Vg.units[Xg])?" + '"  +  Vg.units[Xg] +  "';\n":_a.ch;

          
          switch  (d.Zf.wg(Xg))
         {
            case   d.Zf.dg:
              if  (d.R)
             {
                if  (Xg  ==  "borderColor")
                  Tg.push(
                    '_a["',  id,  'elStyle"].',  Xg,  '=["rgb(",',
                    '(',  Math.floor(Qg*(_h[0]+0.5)),  '+colorPhase*',  ah[0],  ')>>',  Pg,  ',",", ',
                    '(',  Math.floor(Qg*(_h[1]+0.5)),  '+colorPhase*',  ah[1],  ')>>',  Pg,  ',",", ',
                    '(',  Math.floor(Qg*(_h[2]+0.5)),  '+colorPhase*',  ah[2],  ')>>',  Pg,  ', ")"].join("");\n' 
                 );
                else 
                  Tg.push(
                    '_a["',  id,  'elStyle"].',  Xg,  '=',
                    '((',  Math.floor(Qg*(_h[0]+0.5)),  '+colorPhase*',  ah[0],  ')>>',  Pg,  '<<16) | ',
                    '((',  Math.floor(Qg*(_h[1]+0.5)),  '+colorPhase*',  ah[1],  ')>>',  Pg,  '<<8) | ',
                    '((',  Math.floor(Qg*(_h[2]+0.5)),  '+colorPhase*',  ah[2],  ')>>',  Pg,  ');\n' 
                 );
             }
              else 
                Tg.push(
                  '_a["',  id,  'elStyle"].',  Xg,  '=["rgb(",',
                  '(',  Math.floor(Qg*(_h[0]+0.5)),  '+colorPhase*',  ah[0],  ')>>',  Pg,  ',",", ',
                  '(',  Math.floor(Qg*(_h[1]+0.5)),  '+colorPhase*',  ah[1],  ')>>',  Pg,  ',",", ',
                  '(',  Math.floor(Qg*(_h[2]+0.5)),  '+colorPhase*',  ah[2],  ')>>',  Pg,  ', ")"].join("");\n' 
               );
              break;
            case   d.Zf.eg:
              Tg.push('try{_a["',  id, (d.R?'opacity"].opacity=(':'elStyle"].opacity=(('),  Qg*(_h+0.5),  '+colorPhase*',  ah,  ')>>',  Pg, (d.R?';':')/100;'),  "}catch(e){};\n");
              break;
            case   d.Zf.cg:
              Sg.push('_a["',  id,  'elscroll"].',  Xg,  '=(',  Og*(_h+0.5),  '+normalPhase*',  ah,  ')>>',  Ng,  ';\n');
              break;
            case   d.Zf.fg:
              Sg.push('_a["',  id,  'elStyle"].',  Xg,  '=((',  Math.floor(Og*(_h+0.5)),  '+normalPhase*',  ah,  ')>>',  Ng,  ')/10000;\n');
            case   d.Zf.gg:
              switch  (Xg)
             {
                case   "visibility":
                  za.style.visibility  =  "visible";
                  break;
                case   "display":
                  za.style.display  = (Zg=='none'?_h:Zg);
                  break;
                case   "overflow":
                  za.style.overflow  =  "hidden";
                  break;
 
 
 
 
 
 
             }
              break;
            case   d.Zf.hg:
              Sg.push('_a["',  id,  'elStyle"].',  Xg,  '=((',  Math.floor(Og*(_h+0.5)),  '+normalPhase*',  ah,  ')>>',  Ng,  ');\n');
              break;
            default:
              Sg.push('_a["',  id,  'elStyle"].',  Xg,  '=((',  Math.floor(Og*(_h+0.5)),  '+normalPhase*',  ah,  ')>>',  Ng,  ')', (Xg=='zoom'?'/10000':''),  bh,  ";\n");
         }

       }
     }

 

      if  (Sg.length  >  0)
     {
        code.push(
          "var normalPhase=Math.round(",  Og,  "*f);\n",
          Sg.join("")
       );
     }
      if  (Tg.length  >  0)
     {
        code.push(
          'var colorPhase=Math.round(',  Qg,  '*f);\n',
         Tg.join("")
       );
     }

 

      if  (Lg.removeAfterwards)
        code.push(
          "",
          "if(t==TSTOP)",
          "{",
          Ug.join(""),
          "}\n");

      code.push("}\n\n");

      _a.dh(code,  Lg.delay,  Lg.duration,  Kg,  Lg.onFinish);
   },

    Rg: [
      'tPhase',
      'tPhase*tPhase',
      '(1-Math.pow(1-tPhase, 4))',
      '(1-Math.cos('  +  Math.PI  +  '*tPhase)/2.0)',
      '(tPhase<0.5?Math.exp(3*Math.log(tPhase*2))/2:1-Math.exp(3*Math.log((1-tPhase)*2))/2)',
      '(-Math.cos('  +  4*Math.PI  +  '*tPhase) + 1)/2',
      'tPhase + (1-tPhase)*Math.sin('   +   3*Math.PI   +   '*tPhase)',
      '(1-Math.exp(4*Math.log(1-tPhase)))' 
   ],

    ch: (document.defaultView?" + 'px';\n":";\n"),
    eh:  0,
    fh:  null,
    gh:  1,
    hh:  0,
    ih:  Infinity,
    jh:  500,
    kh:  "",
    dh:  function(lh,  delay,  duration,  Kg,  onFinish)
   {
      _a.eh++;
      _a.gh++;

      for  (var   i=0;  i<Kg.length;  i++)
        _a.Jg[Kg[i].element.id] =  _a.gh++;

      if  (onFinish)
     {
        _a["__onFinish"  +  _a.gh] =  onFinish;
        _a["__anims"  +  _a.gh] =  Kg;
     }

      mh  = [
        "/*** ",  _a.gh,  " ***/\n",
        "var t=Math.min(tNow, TSTOP);\n",
        lh.join(""),
        "if(t==TSTOP)\n",
        "{\n",
        "_a.__rC(",  _a.gh,  ");\n",
       (onFinish?("_a.__onFinish"  +  _a.gh  +  "(_a.__anims"  +  _a.gh  +  ");"):""),
        "\n}\n",
        "/*** /",  _a.gh,  " ***/\n"].join("");

      var   nh  = +new   Date() +  delay  -  _a.hh;
      var   oh  =  nh  +  duration;
      mh  =  mh.replace(/TSTART/g,  nh);
      mh  =  mh.replace(/DURATION/g,  duration);
      mh  =  mh.replace(/TSTOP/g,  oh);
      mh  =  mh.replace(/RUNINDEX/g,  _a.gh);

      if  (_a.fh)
        _a.ph(Kg);

      _a.kh  =  _a.kh  +  mh;

 

      _a.qh  =  Function("tNow",  _a.kh);

 

      if  (!_a.fh)
     {
        _a.hh  =  0;
        _a.ih  =  Infinity;

 
 

        _a.fh  =  setInterval(_a.rh,  1);
 _a.sh  =  true;
        _a.rh();
 _a.sh  =  false;
     }
   },
    rh:  function()
   {
      var   uh  = +new   Date() -  _a.hh;

      var   vh  =  uh  -  _a.ih;
      if  (vh  >  _a.jh)
     {
        _a.hh  +=  vh;
        uh  -=  vh;
     }

      _a.ih  =  uh;

 
 

      _a.qh(uh);
   },
    "__rC":  function(wh)
   {
      var   xh  =  "/*** "  +  wh  +  " ***/";
      var   yh    =  "/*** /"  +  wh  +  " ***/";
      _a.kh  =  _a.kh.substring(0,  _a.kh.indexOf(xh)) +  _a.kh.substring(_a.kh.indexOf(yh) +  yh.length);

      _a.qh  =  Function("tNow",  _a.kh);

      _a.zh(wh);

      _a.eh--;
      if  (_a.eh  ==  0)
     {
        clearInterval(_a.fh);
        _a.Jg  = {};
        _a.fh  =  null;
     }
   },
    zh:  function(wh)
   {
      for  (var   id   in   _a.Jg)
        if  (_a.Jg[id] ==  wh)
          delete   _a.Jg[id];
   },
   ph:  function(Kg)
   {
      var   Ah  = [];
      var   Mg  =  Kg.length;
      for  (var   i=0;  i<Mg;  i++)
     {
        var   Vg  =  Kg[i];
        var   id  =  Vg.element.id.replace(/(\W)/g,  "\\$1");
        var   Wg  =  Vg.targetState;

        for  (var   Xg   in   Wg)
       {
          
          switch  (Xg)
         {
            case   'scrollTop':
            case   'scrollLeft':
              Ah.push("|_a\\[\"",  id,  "el\"\\]\\.",  Xg,  "[^;]+;");
              break;
            case   "opacity":
              Ah.push("|try{_a\\[\"",  id,  "opacity\"\\][^;]+}catch(e){};");
              break;
            default:
              Ah.push("|_a\\[\"",  id,  "elStyle\"\\]\\.",  Xg,  "[^;]+;");
              Ah.push("|_a\\[\"",  id,  "elStyle\"\\]\\.",  Xg,  "='';");
         }
       }
     }

      if  (Ah.length  >  0)
     {
 
        _a.kh  =  _a.kh.replace(new   RegExp(Ah.join("").substr(1),  "g"),  "");
 
     }
   },
    Bh:  function(Ch)
   {
 
 
 
 
 
 
 
 
 
 
 
 
   }
};


 d.Modifiers  =  function  ()
{
    this.delay  =  0;
    this.duration  =  300;
    this.profile  =  7;
    this.removeAfterwards  =  false;
    this.onFinish  =  null;
};

 d.Modifiers.prototype  = {
    "LINEAR":0,
    "ACCELERATING":1,
    "DECELERATING":2,
    "NORMAL":3,
    "SLOWFASTSLOW":4,
    "BLINK":5,
    "HEARTBEAT":6 
};

 d["Animator"] =  d.Animator;
 d.Animator["disabled"] =  d.Animator.disabled;
 d.Animator["animate"] =  d.Animator.animate;
 
 
 
 
 
 
 
 
 


 
 
 
 
 
 
 
 
 
 
 
 

 
 
 


 



 d.Dh  = {
    Eh:"display",
    Fh:"block",
    Gh:"morph",
    Hh:"shallow",


    Ih:  true,
    Jh:[
      "display",
      "overflow",
      "backgroundColor",
 
 
 
 
 
      "color",
      "fontSize",
      "height",
      "left",
      "marginTop",
 
 
      "marginLeft",
      "opacity",
 
 
 
 
 
      "top",
 
      "width",
      "zIndex" 
   ],
    Kh:{},
    Lh:  false,
    Mh:  true,
    Nh:  {  BODY:1,  DIV:1,  A:1,  IMG:1,  LI:1,  OL:1,  UL:1,  SPAN:1,  TD:1,  TH:1,  TR:1,  TABLE:1,  H1:1,  H2:1,  H3:1  },
    ba:  function()
   {
      d.wa.hd(d.k,  this.Oh,  this);
      d.wa.hd(d.l,  this.Ph,  this);
      d.wa.hd(d.n,  this.Ph,  this);
   },

    Qh:  function()
   {
      this.Ih  =  true;
   },
    Rh:  function()
   {
      this.Ih  =  false;
   },
    Sh:  function()
   {
      this.Mh  =  false;
   },
    Th:  function(Uh)
   {
      d.w  =  Uh;
   },
    Vh:  function(Wh)
   {
      var   Xh  = {};
      for  (var   i=0;  i<Wh.length;  i++)
        Xh[Wh[i].toUpperCase()] =  1;
      this.Nh  =  Xh;
   },
    Yh:  function(Zh)
   {
      this.Jh  =  Zh;
   },
    Ph:  function(Tc)
   {
      if  (d.Dh.Ih  && !Tc.yc)
        this._i(Tc.subject);
   },
    _i:function(pd)
   {
 
      var   ai  = {};

      var   kc  =  d.Ja.Ka(pd,  this.Gh, {"delay":0,  "duration":d.w});
      if  (!kc  || (!kc["not"] && (!kc["require"] ||  d.Ja.contains(pd,  kc["require"]))))
     {
        if  (kc)
          this.bi(ai,  pd,  kc);
        else   if  (!this.Mh)
          this.ci(pd,  ai);

        if  (this.Lh)
       {
          this.di(ai,  true);

          for  (var   Ff   in   ai)
            this.Kh[Ff] =  ai[Ff];
       }
     }
 
   },

    bi:  function(Ch,  za,  kc)
   {
      var   Ff  =  d.Ga.lb(za);
      if  (!this.Kh[Ff])
     {
        Ch[Ff] = {
          element:za,
          kc:kc,
          eb:kc[this.ei]||this.Jh 
       };

        this.Lh  =  true;
     }

      if  (!this.Mh  ||  kc["deep"])
        this.ci(za,  Ch);
   },

    ci:  function(za,  ai)
   {
      for  (var   ud  =  za.firstChild;  ud;  ud  =  ud.nextSibling)
        if  (ud.nodeType  ==  1)
       {
          var   kc  =  null;
          var   fi  =  false;
          if  (this.Nh[ud.nodeName])
         {
            kc  =  d.Ja.Ka(ud,  this.Gh, {"delay":0,  "duration":d.w});
            if  (kc  && !kc["not"])
           {
              this.bi(ai,  ud,  kc);
              fi  =  true;
           }
         }

          if  (!fi)
         {
            var   gi  =  d.Zf.jg(ud,  "display");
            if  (gi  !=  d.h  && (!kc  || !kc[this.Hh]))
              this.ci(ud,  ai);
         }
       }
   },

    Oh:function()
   {
      
      
      
      if  (d.Q)
        document.body.scrollLeft  +=  0;

      if  (this.Lh)
     {
        
        
        for  (var   Ff   in   this.Kh)
          if  (!this.hi(this.Kh[Ff].element))
         {
            var   za  =  document.getElementById(Ff);
            if  (za)
              this.Kh[Ff].element  =  document.getElementById(Ff);
            else 
              delete   this.Kh[Ff];
         }

 
        this.ii(this.Kh);
 
        this.di(this.Kh,  false);
 
        this.ji(this.Kh);
 

        var   ki  =  this.mi();
 

        this.Lh  =  false;
        this.Kh  = {};
 

        this.ni(ki);
 

        
        
        
        
        
        
        
        if  (d.T)
          document.body.offsetWidth;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
     }
   },
    ii:  function(Ch)
   {
 
 
 
 
 

      for  (var   Ff   in   Ch)
        if  (d.Animator.Jg[Ff])
       {
          var   oi  =  Ch[Ff];
          var   za  =  oi.element;

          if  (d.R)
         {
            oi.pi  =  za.style.cssText;
            za.style.cssText  =  "";
         }
          else 
            for  (var   Z   in   oi.qi)
           {
              var   db  =  za.style[Z];
              if  (db)
             {
                oi.ri[Z] =  db;
                za.style[Z] =  "";
             }
           }
       }
   },
    ji:  function(Ch)
   {
      for  (var   Ff   in   Ch)
     {
        if  (d.Animator.Jg[Ff])
       {
          var   oi  =  Ch[Ff];
          var   za  =  oi.element;
          if  (d.R)
            za.style.cssText  =  oi.pi;
          else 
            for  (var   Z   in   oi.ri)
              za.style[Z] =  oi.ri[Z];
       }
     }
   },
    di:  function(Ch,  si)
   {
      var   ti  = [];
      var   ui  = [];
      var   vi  =  null;

      for  (var   Ff   in   Ch)
     {
        var   oi  =  Ch[Ff];
        var   za  =  oi.element;

 
 
 
 if  (za.offsetWidth  ==  0  && (!za.parentNode  ||  za.parentNode.offsetWidth  ==  0))
{
    delete   Ch[Ff];
    continue;
}
        if  (si)
       {
          oi.ri  = {};
          oi.qi  = {};
          oi.wi  = {};
       }

        
        if  (!si  &&  vi  &&  d.Ga.Cb(vi,  za) && (vi.style.display  ==  d.h))
       {
          delete   Ch[Ff];
          continue;
       }

        var   xi  = (si?oi.qi:oi.wi);

        for  (var   i=0;  i<oi.eb.length;  i++)
       {
          var   Z  =  oi.eb[i];
 

          xi[Z] =  d.Zf.jg(za,  Z);

          if  (Z  ==  this.Eh  &&  xi[Z] ==  d.h)
         {
 
 
 
 
 
            
            if  (!si  &&  oi.qi.display  ==  d.h)
           {
              delete   Ch[Ff];
              break;
           }

            vi  =  za;
            ti.push(vi);
            ui.push(vi.style.display);
            vi.style.display  =  this.Fh;
         }
       }
     }

      for  (var   i=0;  i<ti.length;  i++)
        ti[i].style.display  =  ui[i];
   },
    mi:  function()
   {
      var   ki  = {};
      var   yi  = {};
      for  (var   Ff   in   this.Kh)
     {
        var   oi  =  this.Kh[Ff];
        var   za  =  oi.element;
        var   currentState  = {};
        var   units  = {};
        var   targetState  = {};
        var   zi  =  false;
        for  (var   Z   in   oi.wi)
       {
          var   Ai  =  oi.qi[Z];
          var   Bi  =  oi.wi[Z];

          if  (Bi  !=  null)
         {
            
 
 
 
 
            if  (Ai  !=  Bi)
           {
              zi  =  true;
              var   Ci  =  d.Zf.lg(za,  Z,  Ai);
              var   Di    =  d.Zf.lg(za,  Z,  Bi);
              currentState[Z] =  Ci.value;
              targetState[Z] =  Di.value;
              units[Z] =  Ci.Ag  ||  Di.Ag;
           }
         }
       }

        if  (zi)
       {
          if  (d.Q)
         {
            
            
            
            if  (targetState.top  &&  targetState.marginTop  &&  targetState.top  ==  targetState.marginTop)
              delete   targetState.top;
            if  (targetState.left  &&  targetState.marginLeft  &&  targetState.left  ==  targetState.marginLeft)
              delete   targetState.left;
         }

          var   Ei  =  ki[oi.kc["delay"]] =  ki[oi.kc["delay"]] || {};
          var   Kg  =  Ei[oi.kc["duration"]] =  Ei[oi.kc["duration"]] || [];

          Kg[Kg.length] = {
            element:za,
            currentState:currentState,
            targetState:targetState,
            units:units 
         };
       }
     }
      return   ki;
   },
    ni:  function(ki)
   {
      for  (var   delay   in   ki)
     {
        delay  *=  1;
        for  (var   duration   in   ki[delay])
       {
          duration  *=  1;
          var   Kg  =  ki[delay][duration];
          for  (var   i=0;  i<Kg.length;  i++)
         {
            var   Vg  =  Kg[i];
            var   za  =  Vg.element;
            
 
 
            
            for  (var   Z   in   Vg.currentState)
           {
 
 
              d.Zf.Eg(za,  Z,  Vg.currentState[Z]);
           }
         }

 
 
 
 
 
 
 
 
 

          var   Lg  =  new   d.Modifiers();
          Lg.delay  =  delay;
          Lg.duration  =  duration;
 
 
          Lg.removeAfterwards  =  true;

 
 
          d.Animator.animate(Kg,  Lg);
 
       }
     }
   },
    hi:  function(za)
   {
      if  (d.R)
        return   za.parentTextEdit  !=  null;
      else   if  (d.Q)
        return   za.sourceIndex  != -1;
      else 
        return   za.offsetParent  !=  null;
   },
    Fi:  function(Gi,  Hi)
   {
      for  (var   i=0;  i<Gi.length;  i++)
        if  (Gi[i] !=  Hi[i])
          return   false;

      return   true;
   }
};
 d.W(d.Dh);

 d["StyleMorpher"] =  d.Dh;
 d.Dh["enableDeepMorphing"] =  d.Dh.Sh;
 d.Dh["setMorphDuration"] =  d.Dh.Th;
 d.Dh["setMorphableNodeNames"] =  d.Dh.Vh;
 d.Dh["setMorphableProperties"] =  d.Dh.Yh;
 d.Dh["enable"] =  d.Dh.Qh;
 d.Dh["disable"] =  d.Dh.Rh;

 d.Dh["morph"] =  d.Dh.Oh;
 d.Dh["beforeClassNameChange"] =  d.Dh.Ph;
 
 
 
 
 


 d.Ii  = {
    Ji:  null,
    Ki:  null,
    ba:  function()
   {
      d.Jc.Nc(document.documentElement,  d.H,  this.Li,  this);
      d.Jc.Nc(document.documentElement,  d.I,  this.Mi,  this);
      d.Jc.Nc(document.documentElement,  d.J,    this.Ni,  this);
      d.Jc.Nc(document.documentElement,  "DOMMouseScroll",    this.nd,  this);

      d.wa.hd("persist-pos",  this.Oi,  this);
   },
    
    Oi:  function(Tc)
   {
      var   za  =  Tc.subject;
      if  (d.Ja.contains(za,  "movable"))
     {
        var   Pi  = {  x:  parseInt(za.style.left),  y:  parseInt(za.style.top) };
        if  (!isNaN(Pi.x) || !isNaN(Pi.y))
       {
          var   La  =  d.Ja.Ka(za,  "movable");
          if  (La[d.N])
            La[d.N](za,  Pi);
       }
     }
   },

    Li:  function(Tc)
   {
      this.Ni();

      this.Qi  =  d.oa.ya(Tc.subject,  "mover",  "movable");
      if  (this.Qi.object)
     {
       this.Qi.box  =  this.Qi.object.offsetParent  ||  d.V;

        this.Ri  =  d.V.scrollTop;
        this.Si  =  this.Qi.object.offsetLeft  -  Tc.clientX  -  d.Zf.qg(this.Qi.object,  "marginLeft");
        this.Ti  =  this.Qi.object.offsetTop  -  Tc.clientY  -  d.Zf.qg(this.Qi.object,  "marginTop");

        this.Ui();

        this.Vi  =  false;
     }
      else 
        this.Qi  =  null;
   },
    Mi:  function(Tc)
   {
      this.Ki  =  Tc.clientY;

      if  (this.Qi)
        if  (Tc.ed)
       {
          if  (!this.Vi)
         {
            d.Jc.Kc  =  true;

            if  (d.R)
              this.Qi.Fa.setCapture();

            d.Ja.replace(this.Qi.box,  "notMoving",  "moving");
            d.Ja.replace(this.Qi.object,  "notMoving",  "moving");
            d.Ja.replace(this.Qi.Fa,  "notMoving",  "moving");

            this.Ji  =  d.oa.ta(this.Wi,  15,  this);

            this.Vi  =  true;
         }

          this.Xi  = {  x:  this.Si  +  Tc.clientX,  y:  this.Ti  +  Tc.clientY  +  d.V.scrollTop  -  this.Ri  };
          this.Yi();

          if  (this.Qi.La[d.N])
         {
            this.Qi.La[d.N](this.Qi.object,  this.Xi);
            this.Yi();
         }

          if  (this.Qi.Ia.dir  !=  "vertical")
            d.Zf.Eg(this.Qi.object,  "left",  this.Xi.x);
          if  (this.Qi.Ia.dir  !=  "horizontal")
            d.Zf.Eg(this.Qi.object,  "top",   this.Xi.y);
       }
        else 
          this.Ni();
   },
    nd:  function(Tc)
   {
      this.Ni();

      var   Zi  =  d.Ga.Ha(Tc.subject,  "move");
      if  (Zi)
     {
        var   kc  =  d.Ja.Ka(Zi,  "move");

        if  (kc["onMouseScroll"])
       {
          if  (this._j)
            clearTimeout(this._j);

          var   aj  =  document.getElementById(kc["onMouseScroll"]);
          this.Qi  = {
            box:  aj.offsetParent  ||  d.V,
            object:  aj,
            La:  d.Ja.Ka(aj,  "movable")
         };
          
          this.Ui();

          var   bj  =  this.Qi.object.offsetTop;

          var   cj  =  kc["delta"] ||  Math.abs(Tc.detail);

          this.Xi  = {  x:0,  y:bj  +  cj  *  Tc.detail  /  Math.abs(Tc.detail) };
          this.Yi();

          if  (this.Qi.La[d.N])
         {
            this.Qi.La[d.N](this.Qi.object,  this.Xi);
            this.Yi();
         }

          d.Zf.Eg(this.Qi.object,  "top",   this.Xi.y);

          var   dj  =  d.Ii.Qi.La[d.O];
          if  (this.Qi.La[d.O])
         {
            var   X  =  d.Ii.Qi.object;
            var   Pi  =  d.Ii.Xi;
            this._j  =  d.oa.pa(function() {  dj(X,  Pi); },  500);
         }

          this.Ni();
          
          Tc.cancel();
       }
     }
   },

    Ui:  function()
   {
      
      
      
      var   ej   = -1;
      var   fj  = -1;
      var   gj  =  this.Qi.box;
      while  (ej  <=  1  ||  fj  <=  1)
     {
        ej  = (document.compatMode  !=  "BackCompat"  ||  gj  !=  d.V)?gj.offsetWidth:gj.clientWidth;
        fj  =  gj.offsetHeight;
        gj  =  gj.offsetParent  ||  d.V;
     }
      

      if  (this.Qi.La["restricted"])
     {
        this.hj  =  ej   -  d.Zf.qg(this.Qi.object,  "width") -  d.Zf.qg(this.Qi.object,  "marginRight") - (gj  ==  d.V?2:0);
        this.ij  =  fj  -  d.Zf.qg(this.Qi.object,  "height") -  d.Zf.qg(this.Qi.object,  "marginBottom");
     }
   },

    Yi:  function()
   {
      if  (this.Qi.La["restricted"])
     {
        this.Xi.x  =  Math.max(0,  Math.min(this.Xi.x,  this.hj)),
        this.Xi.y  =  Math.max(0,  Math.min(this.Xi.y,  this.ij))
     }
   },
    Ni:  function()
   {
      if  (this.Qi)
     {
        if  (this.Vi)
       {
          if  (this.Qi.box)
            d.Ja.replace(this.Qi.box,  "moving",  "notMoving");
          if  (this.Qi.object)
            d.Ja.replace(this.Qi.object,  "moving",  "notMoving");
          if  (this.Qi.Fa)
            d.Ja.replace(this.Qi.Fa,  "moving",  "notMoving");

          if  (this.Qi.La[d.O])
            this.Qi.La[d.O](this.Qi.object,  this.Xi);

          d.Jc.Kc  =  false;

          if  (d.R)
            this.Qi.Fa.releaseCapture();

          this.Ki  =  null;
          clearTimeout(this.Ji);
          this.Ji  =  null;
       }

        this.Qi  =  null;
     }

      this.jj  =  d.V.scrollHeight  -  d.V.offsetHeight;
   },
    Wi:  function()
   {
      if  (this.Qi.Ia.dir  !=  "horizontal")
     {
        var   kj  =  d.V.scrollTop;
      
        if  (this.Ki  <  50)
          d.V.scrollTop  -=  Math.round(10  -  this.Ki/5);

        if  (this.Ki  >  d.V.offsetHeight  -  50)
          d.V.scrollTop  =  Math.min(d.V.scrollTop  +  Math.round(10  - (d.V.offsetHeight  -  this.Ki)/5),  this.jj);

        if  (d.V.scrollTop  !=  kj)
       {
          this.Xi.y  +=  d.V.scrollTop  -  kj;
          this.Yi();

          if  (this.Qi.La[d.N])
         {
            this.Qi.La[d.N](this.Qi.object,  this.Xi);
            this.Yi();
         }
          d.Zf.Eg(this.Qi.object,  "top",   this.Xi.y);
       }
     }
   }
};

 d.W(d.Ii);
 d.lj  = {
    ba:  function()
   {
      d.Jc.Nc(document.documentElement,  d.H,  this.Li,  this);
      d.Jc.Nc(document.documentElement,  d.I,  this.Mi,  this);
      d.Jc.Nc(document.documentElement,  d.J,    this.Ni,  this);

      d.wa.hd("persist-dim",  this.Oi,  this);
   },

    Oi:  function(Tc)
   {
      var   za  =  Tc.subject;
      if  (d.Ja.contains(za,  "resizable"))
     {
        var   mj  = {  width:  parseInt(za.style.width),  height:  parseInt(za.style.height) };
        if  (!isNaN(mj.width) || !isNaN(mj.height))
       {
          var   La  =  d.Ja.Ka(za,  "resizable");
          if  (La[d.N])
            La[d.N](za,  mj);
       }
     }
   },
    
    Li:  function(Tc)
   {
      
      this.Ni();

      this.nj  =  d.oa.ya(Tc.subject,  "resizer",  "resizable");
      if  (this.nj.object)
     {
        
        this.oj  =  d.Zf.qg(this.nj.object,  "width");
        this.pj  =  d.Zf.qg(this.nj.object,  "minWidth") ||  0;
        this.qj  =  d.Zf.qg(this.nj.object,  "maxWidth") ||  Infinity;

        this.rj  =  d.Zf.qg(this.nj.object,  "height");
        this.sj  =  d.Zf.qg(this.nj.object,  "minHeight") ||  0;
        this.tj  =  d.Zf.qg(this.nj.object,  "maxHeight") ||  Infinity;

        this.Si  =  Tc.clientX;
        this.Ti  =  Tc.clientY;

        this.uj  =  false;
     }
      else 
        this.nj  =  null;
   },
    
    Mi:  function(Tc)
   {
      if  (this.nj)
        if  (Tc.ed)
       {
          if  (!this.uj)
         {
            d.Jc.Kc  =  true;

            if  (d.R)
              this.nj.Fa.setCapture();

            d.Ja.replace(this.nj.object,  "notResizing",  "resizing");
            d.Ja.replace(this.nj.Fa,  "notResizing",  "resizing");
            this.uj  =  true;
         }

          this.vj  = {
            width:this.oj  +  Tc.clientX  -  this.Si,
            height:this.rj  +  Tc.clientY  -  this.Ti 
         };
          this.Yi();

          if  (this.nj.La[d.N])
         {
            this.nj.La[d.N](this.nj.object,  this.vj);
            this.Yi();
         }

          if  (this.nj.Ia.wj  !=  "height")
            this.nj.object.style.width   =  this.vj.width   +  "px";
          if  (this.nj.Ia.wj  !=  "width")
            this.nj.object.style.height  =  this.vj.height  +  "px";
       }
        else 
          this.Ni();
   },
    Yi:  function()
   {
      this.vj.width   =  Math.max(this.pj,  Math.min(this.qj,  this.vj.width));
      this.vj.height  =  Math.max(this.sj,  Math.min(this.tj,  this.vj.height));
   },

    Ni:  function()
   {
      if  (this.nj)
     {
        if  (this.uj)
       {
          d.Ja.replace(this.nj.object,  "resizing",  "notResizing");
          d.Ja.replace(this.nj.Fa,  "resizing",  "notResizing");

          if  (this.nj.La[d.O])
            this.nj.La[d.O](this.nj.object,  this.vj);

          d.Jc.Kc  =  false;

          if  (d.R)
            this.nj.Fa.releaseCapture();
       }

        this.nj  =  null;
     }
   }
};

 d.lj.ba();
 d.xj  = {
    kf:  null,
    yj:  Math.pow(2,  15),
    ba:  function()
   {
      d.Jc.Nc(document.documentElement,  "mousedown",  this.zj,  this);
      d.Jc.Nc(document.documentElement,  "keyup",  this.zj,  this);
      d.wa.hd(d.m,  this.zj,  this);
   },
    
    zj:  function(Tc)
   {
      var   za  =  Tc.subject;

      if  (za  !=  this.kf)
     {
        this.kf  =  za;

        for  (;za  &&   za.nodeType  ==  1;  za  =  za.parentNode)
          if  (d.Ja.contains(za,  "stackable"))
            za.style.zIndex  =  this.yj++;
     }
   }
};


 d.xj.ba();
 d.Aj  = {
    Bj:"dragging",
    Cj:"notDragging",
    Dj:"dropping",
    Ej:"notDropping",
    ba:  function()
   {
      d.Jc.Nc(document.documentElement,  d.H,  this.Li,  this);
      d.Jc.Nc(document.documentElement,  d.I,  this.Mi,  this);
      d.Jc.Nc(document.documentElement,  d.J,    this.Fj,  this);
   },
    
    Li:  function(Tc)
   {
      
      this.Ni();

      
      var   Gj  =  d.Ga.Ha(Tc.subject,  "dragger");
      if  (Gj)
     {
        
        var   Hj  =  d.Ga.Ha(Tc.subject,  "draggable");

        
        if  (Hj)
       {
          
          if  (!d.Ga.Ha(Tc.subject,  "dragging-disabled"))
            
            this.Ij(Hj,  Gj);

          
          
          Tc.cancel();
       }
     }
   },
    
    Mi:  function(Tc)
   {
      this.Ki  =  Tc.clientY;

      if  (this.Jj)
        if  (Tc.ed)
       {
          this.Kj();

          
          this.Lj.style.left  = (d.V.scrollLeft  +  Tc.clientX) +  "px";
          this.Lj.style.top  = (d.V.scrollTop  +  5  +  this.Ki) +  "px";

          
          
          
          var   Hj  =  d.Ga.Ha(Tc.subject,  "draggable");
          if  (Hj  !=  this.Lj)
         {
            
            var   Mj  =  d.Ga.Ha(Tc.subject,  "dropBox");
            if  (Mj  &&  Mj  !=  this.Nj)
           {
              
              var   Oj  =  d.oa.Va(Mj,  "dropType",  "",  true);
              for  (var   i=0;  i<Oj.length;  i++)
                if  (!isNaN(this.Pj[Oj[i]]))
                  break;
              
              if  (i  >=  Oj.length)
                Mj  =  null;
           }

            var   Qj  =  null;

            if  (d.Ga.Ha(Tc.subject,  "noDrop",  "dropBox"))
              Mj  =  null;

            if  (Mj)
           {
              var   Rj  =  d.R?Tc.clientY:(Tc.clientY  +  d.V.scrollTop);
              if  (d.Q)
             {
                Rj  =  Tc.offsetY;
                var   za  =  Tc.subject;
                while  (za  !=  Mj)
               {
                  Rj  +=  za.offsetTop;
                  za  =  za.offsetParent  ||  d.V;
               }
             }

              for  (var   i=0; !Qj  &&  i<Mj.childNodes.length;  i++)
             {
                var   Bb  =  Mj.childNodes[i];
                if  (Bb  !=  this.Sj  &&  Bb  !=  this.Lj  &&  Bb.nodeType  ==  1)
               {
                  var   Ab  =  d.Ga.getBoxObjectFor(Bb);
                  if  (Rj  < (Ab.y  +  Ab.height/2))
                    Qj  =  Bb;
               }
             }
           }
            this.Tj(Mj,  Qj);
         }

          
          Tc.cancel();
       }
        else 
          this.Fj();
   },

 Ki:  null,
 Uj:  null,
 Vj:  null,
        
    Ij:  function(Hj,  Gj)
   {
      this.Wj  =  Gj;
      this.Jj  =  Hj;
      this.Xj  =  Hj.parentNode;
      this.Yj  =  Hj.nextSibling;

      
      this.Zj  =  d.oa.Va(this.Jj,  "dragType",  "",  true);
      this.Pj  =  d.oa.ab(this.Zj);

      this._k  =  false;

      
      d.Ja.add(document.body,  "dragging-"  +  this.Zj.join(" dragging-"));
   },


    Kj:  function()
   {
      if  (this._k)
        return;

      this._k  =  true;

      d.Jc.Kc  =  true;

      if  (d.R)
        this.Wj.setCapture();

      
      var   ak  =  d.Ga.sb(this.Jj,  "dragPlaceholder");
      if  (ak)
        this.Lj  =  ak.cloneNode(true);
      else 
     {
        this.Lj  =  this.Jj.cloneNode(true);
        this.Lj.style.width  =  this.Jj.offsetWidth  +  "px";
     }

      d.Ja.add(this.Lj,  "dragPlaceholder");
      d.Ja.replace(this.Lj,  this.Cj,  this.Bj);
      this.Jj.parentNode.insertBefore(this.Lj,  this.Jj);

      this.Lj.style.position  =  "absolute";
      this.Lj.style.zIndex  =  Math.pow(2,  15);
      document.body.appendChild(this.Lj);

      
      var   bk  =  d.Ga.sb(this.Jj,  "dropPlaceholder");
      if  (bk)
        this.Sj  =  bk.cloneNode(true);
      else 
     {
        this.Sj  =  this.Jj.cloneNode(true);
 
     }
      d.Ja.add(this.Sj,  "dropPlaceholder");
      d.Ja.remove(this.Sj,  this.Cj);

      
      d.Ja.replace(this.Jj,  this.Cj,  this.Bj);
      d.Ja.replace(this.Jj.parentNode,  this.Cj,  this.Bj);

      this.Ji  =  d.oa.ta(this.Wi,  15,  this);
   },
    Tj:  function(Mj,  Qj)
   {
      if  (Mj  !=  this.Nj  ||  Qj  !=  this.ck)
     {
        
        if  (this.Nj  &&  Mj  !=  this.Nj)
          d.Ja.replace(this.Nj,  this.Dj,  this.Ej);

        
        this.Nj  =  Mj;
        this.ck  =  Qj;

        if  (!Mj)
          this.Sj.parentNode.removeChild(this.Sj);
        else 
       {
          d.Ja.replace(Mj,  this.Ej,  this.Dj);
          Mj.insertBefore(this.Sj,  Qj  ||  null);
       }
     }
   },

    Fj:  function()
   {
      if  (this.Jj  &&  this.Nj)
     {
        var   Hj  =  this.Jj;
        var   dk  =  this.Sj.parentNode;
        var   ek  =  this.Sj.nextSibling;

        this.Ni();

        var   fk  =  d.Ja.contains(this.Xj,  "clone-box") &&  dk  !=  this.Xj;
        if  (dk  !=  this.Xj  ||  ek  !=  this.Yj)
       {
          var   Qj  =  fk?Hj.cloneNode(true):Hj;

          dk.insertBefore(Qj,  ek);

          var   gk  =  d.Ja.Ka(dk,  "dropBox");
          if  (gk[d.O])
            if  (gk[d.O](Qj,  this.Xj,  this.Yj,  dk,  ek) ==  false)
              this.Xj.insertBefore(Qj,  this.Yj);
       }
     }

      this.Ni();
   },

    Ni:  function()
   {
      if  (this.Jj)
     {
        d.Ja.remove(document.body,  "dragging-"  +  this.Zj.join(" dragging-"));

        if  (this._k)
       {
          d.Ja.replace(this.Jj.parentNode,  this.Bj,  this.Cj);
          d.Ja.replace(this.Jj,  this.Bj,  this.Cj);
          if  (this.Nj)
            d.Ja.replace(this.Nj,  this.Dj,  this.Ej);

          
          this.Lj.parentNode.removeChild(this.Lj);
          if  (this.Sj.parentNode)
            this.Sj.parentNode.removeChild(this.Sj);
       }

        d.Jc.Kc  =  false;

        if  (d.R)
          this.Wj.releaseCapture();

        this.Wj  =  null;
        this.Jj  =  null;
        this.Nj  =  null;
        this.Ki  =  null;
        clearTimeout(this.Ji);
        this.Ji  =  null;
     }
      this.jj  =  d.V.scrollHeight  -  d.V.offsetHeight;
   },
    
    Wi:  function()
   {
      var   kj  =  d.V.scrollTop;
      
      if  (this.Ki  <  50)
        d.V.scrollTop  -=  Math.round(10  -  this.Ki/5);

      if  (this.Ki  >  d.V.offsetHeight  -  50)
        d.V.scrollTop  =  Math.min(d.V.scrollTop  +  Math.round(10  - (d.V.offsetHeight  -  this.Ki)/5),  this.jj);

      if  (d.V.scrollTop  !=  kj)
        this.Lj.style.top  = (d.V.scrollTop  +  5  +  this.Ki) +  "px";
   }
};

 d.W(d.Aj);


 
 
 
 
 
 
 
 
 d.hk  =
{
    ik:0,
    jk:1,
    kk:2,
    lk:-1,
    mk:-2,
    nk: {},
    ba:  function()
   {
      d.Ld.Wd(["classShifter"], ["classShiftee",  "classChain"],  this.Je,  this);
      d.wd.Fd("classChain",  this.ok,  this);
   },
    ok:  function(je,  pk,  Tc)
   {
      var   za  =  Tc.subject;
      while  (za  &&  za.parentNode  !=  je)
        za  =  za.parentNode;

      var   Ff  =  d.Ga.lb(je);
      var   de  =  d.Ja.Ka(je,  "classChain");
      var   data  =  this.qk(Ff,  je,  je,  "classChain", {},  de);

      for  (var   c=0;  c<data.children.length;  c++)
        if  (data.children[c] ==  za)
       {
          data.rk  =  c;

          if  (data.rk  ==  data.sk)
            break;

          if  (data.Tf)
         {
            clearTimeout(data.Tf);
            data.Tf  =  null;
         }

          this.tk(data);
        
          d.kd.od(data.je, ["jump"],  data.je);

          data.Tf  =  d.oa.pa(this.uk,  data.ua,  this, [data]);
    
          break;
       }
   },
    Je:  function(ie,  ic,  je,  Ne,  Tc,  ae,  de)
   {
      var   Ff  =  d.Ga.lb(je);
      var   data  =  this.qk(Ff,  ie,  je,  Ne,  ae,  de);

      var   vk  =  false;
      var   wk  =  false;
      var   xk  =  false;

      var   yk  =  data.zk;

      if  (ae["pause"] &&  data.zk  !=  null)
     {
        data.Ak  =  true;
        wk  =  true;
        d.Ja.dc(data.je,  "pausing",  true);
     }

      if  (ae["resume"])
        vk  =  true;

      if  (ae["stop"])
     {
        wk  =  true;
        data.zk  =  null;
        d.Ja.remove(data.je,  "sliding");
        if  (data.Ak)
          d.Ja.remove(data.je,  "pausing");
     }

      if  (ae["slideToStart"])
     {
        data.zk  =  0;
        vk  =  true;
     }
      if  (ae["slideToEnd"])
     {
        data.zk  =  data.Bk;
 
        vk  =  true;
     }
      if  (ae["slideToNext"] ||  ae["jumpToNext"])
     {
        this.Ck(data,  1);
        xk  =  true;
     }
      if  (ae["slideToPrevious"] ||  ae["jumpToPrevious"])
     {
        this.Ck(data, -1);
        xk  =  true;
     }
      if  (ae["slideForward"])
     {
        data.zk  =  this.lk;
        vk  =  true;
     }
      if  (ae["slideBackward"])
     {
        data.zk  =  this.mk;
        vk  =  true;
     }
      if  (ae["slideTo"])
     {
        if  (data.Dk)
          data.zk  =  this.Ek(data,  ae["slideTo"]);
        else 
          data.zk  =  data.Fk[ae["slideTo"]];
        vk  =  true;
     }

      if  (ae["jumpToStart"])
     {
        data.rk  =  0;
        xk  =  true;
     }
      if  (ae["jumpToEnd"])
     {
        data.rk  =  data.Bk;
        xk  =  true;
     }
      if  (ae["jumpTo"])
     {
        if  (data.Dk)
          data.rk  =  this.Ek(data,  ae["jumpTo"]);
        else 
          data.rk  =  data.Fk[ae["jumpTo"]];
        xk  =  true;
     }

      if  (xk  &&  data.rk  ==  data.sk)
        xk  =  false;

      if  (!data.Ak  &&  vk  &&  data.zk  ==  yk)
        vk  =  false;

      if  (data.Tf  && (wk  ||  vk  ||  xk))
     {
        clearTimeout(data.Tf);
        data.Tf  =  null;
     }

      if  (vk  &&  data.sk  ==  data.zk)
        vk  =  false;

      if  (vk)
     {
        data.Ak  =  false;
        data.dir  =  1;
        d.Ja.dc(data.je,  "pausing",  false);
     }

      if  (xk)
     {
        this.tk(data);
        
        d.kd.od(data.je, ["jump"],  data.je);
     }

      if  (xk)
        data.Tf  =  d.oa.pa(this.uk,  data.ua,  this, [data]);
      else   if  (vk)
     {
        d.Ja.add(data.je,  "sliding");
        this.uk(data);
     }
   },
    qk:  function(Ff,  ie,  je,  Ne,  ae,  de)
   {
      var   data  =  this.nk[Ff];

      if  (!data)
     {
        data  =  this.nk[Ff] = {
          Ff:Ff,
          ie:ie,
          je:je,
          Ne:Ne,
          Dk:(Ne  ==  "classChain"),
          Gk:(de["wrap"]?this.jk:(de["bounce"]?this.kk:this.ik)),
          dir:1,
          Hk:de["classes"],
          Fk:d.oa.ab(de["classes"]),
          Ik:de["classes"].join("\\b|\\b"),
          zk:null,
          ua:(ae["interval"] ||  de["interval"] ||  d.w),
          Jk:d.oa.Ma(de["onbeforechange"],  null)
       };
        if  (data.Dk)
       {
          data.Kk  =  de["mainClass"];
          data.children  =  this.Lk(data.je,  data.Ik);
          data.Mk  =  data.Fk[data.Kk];
       }
        data.Bk  = (data.Dk?data.children.length-1:data.Hk.length-1),
        data.sk  =  this.Nk(data);
     }

      return   data;
   },
    Nk:  function(data)
   {
      for  (var   i=0;  i<=data.Bk;  i++)
        if  (
         (data.Dk  &&  d.Ja.contains(data.children[i],  data.Kk))
         ||
         (!data.Dk  &&  d.Ja.contains(data.je,  data.Hk[i]))
       )
          return   i;
   },
    Ek:  function(data,  qb)
   {
      for  (var   i=0;  i<data.children.length;  i++)
        if  (d.Ja.contains(data.children[i],  qb))
          return   i;
   },
    Lk:  function(za,  Ik)
   {
      var   Ig  = [];
      for  (var   Ok  =  za.firstChild;  Ok;  Ok  =  Ok.nextSibling)
        if  (d.Ja.contains(Ok,  Ik))
          Ig.push(Ok);
      return   Ig;
   },
    Ck:  function(data,  cj)
   {
      data.rk  =  data.sk  +  data.dir*cj;
      if  (data.rk  <  0)
     {
        if  (data.Gk  ==  this.jk)
          data.rk  =  data.Bk;
        else   if  (data.Gk  ==  this.kk)
       {
          data.rk  =  1;
          data.dir  *= -1;
       }
        else 
          data.rk  =  0;
     }
      else   if  (data.rk  >  data.Bk)
     {
        if  (data.Gk  ==  this.jk)
          data.rk  =  0;
        else   if  (data.Gk  ==  this.kk)
       {
          data.rk  =  data.Bk  -  1;
          data.dir  *= -1;
       }
        else 
          data.rk  =  data.Bk;
     }
   },
    uk:  function(data)
   {
      if  (!data.Ak  &&  data.zk  !=  null)
     {
        if  (data.zk  ==  this.lk)
          this.Ck(data,  1);
        else   if  (data.zk  ==  this.mk)
          this.Ck(data, -1);
        else   if  (data.sk  !=  data.zk)
       {
          var   Pk  =  data.zk  -  data.sk;
          this.Ck(data,  Pk  /  Math.abs(Pk));
       }

        this.tk(data);

        d.kd.od(data.je, ["slide"],  data.je);

        if  (data.sk  !=  data.zk)
       {
          var   ae  =  d.Ja.Ka(data.ie,  "classShifter");
          var   de  =  d.Ja.Ka(data.je,  data.Ne);
          var   ua  = (ae?ae["interval"]:null) ||  de["interval"] ||  data.ua  ||  d.w;

          data.Tf  =  d.oa.pa(this.uk,  ua,  this, [data]);
       }
        else 
       {
          data.zk  =  null;
          d.Ja.remove(data.je,  "sliding");
       }
     }
   },
    tk:  function(data)
   {
      if  (data.rk  !=  data.sk)
     {
        if  (!data.Jk  || (data.Jk(data.je) !=  false))
       {
          if  (data.Dk)
         {
 

            if  (data.Bk  >=  data.Hk.length)
           {
              var   Qk  =  0;
              var   Rk  =  data.Hk.length  -  1;
           }
            else 
           {
              var   Qk  =  data.Mk  -  Math.floor(data.Bk/2);
              var   Rk  =  Qk  +  data.Bk;
           }

            var   Hk  = [];
            for  (var   i=0;  i<data.Hk.length;  i++)
              Hk[i] =  i;
            var   Sk  = (data.Gk  ==  this.jk?Rk:Qk);
            for  (var   i=-1;  i<Qk;  i++)
              Hk[i] =  Sk;
            Sk  = (data.Gk  ==  this.jk?Qk:Rk);
            for  (var   i=Rk  +  1;  i<=  data.Hk.length;  i++)
              Hk[i] =  Sk;

 

            var   Tk  = [];
            for  (var   i=0;  i<=data.Bk;  i++)
              Tk[i] =  data.Fk[d.Ja.match(data.children[i],  data.Ik)];

            var   Uk  =  data.rk  -  data.sk;
            var   Vk  =  Uk/Math.abs(Uk);
            for  (var   Wk  =  1;  Wk  <=  Math.abs(Uk);  Wk++)
           {
              Tk[-1] =  Tk[data.Bk];
              Tk[data.Bk+1] =  Tk[0];

              var   Xk  = [];

              if  (Vk  ==  1)
                for  (var   i  =  0;  i  <=  data.Bk;  i++)
                  Xk[i] =  Hk[Tk[i] - (Tk[i] !=  Tk[i-data.dir]?Vk:0)];
              else 
                for  (var   i  =  data.Bk;  i>=0;  i--)
                  Xk[i] =  Hk[Tk[i] - (Tk[i] !=  Tk[i+data.dir]?Vk:0)];

              Tk  =  Xk;
 
           }

            for  (var   i=0;  i<=data.Bk;  i++)
              d.Ja.replace(data.children[i],  data.Ik,  data.Hk[Tk[i]]);
         }
          else 
            d.Ja.replace(data.je,  data.Ik,  data.Hk[data.rk]);

          data.sk  =  data.rk;
       }
     }
   }
};

 d.W(d.hk);
 
 
 d.Ja.add(document.documentElement,  "spiffy "  +  d.oa.platform,  d.L);

 d.Jc.Nc(
    window,
    d.C,
    function()
   {
      if  (document.compatMode  ==  "BackCompat")
        d.V  =  document.body;

      
      if  (d.R)
     {
        var   Yk  =  document.getElementsByTagName("object");
        for  (var   i=Yk.length-1;  i>=0;  i--)
          Yk[i].outerHTML  =  Yk[i].outerHTML;
     }

      d.Ja.replace(document.body,  d.B,  d.z);

      d.wa.xa(d.o,  document.body);
   }
);

 if  (d.R)
{
    
    
    
 

 
 

    
    
    
    

    
    if  (!d.S)
   {
      try 
     {
        document.execCommand("BackgroundImageCache",  false,  true);
     }
      catch(Dg){}
   }
}

 d.wa.xa("spifLoaded");

 d["documentScrollElement"] =  d.V;