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) && (typeof(XMLHttpRequest) ==  "undefined"),
    V:(navigator.appVersion.indexOf("AppleWebKit") != -1) && (typeof(XMLHttpRequest) !=  "undefined"),
    
    W:  document.documentElement,

    X:  function(Y)
   {
      if  (Y.Z)
        Y.Z();
   }
};

 d["isIE"] =  d.R;
 d["isIE7"] =  d.S;
 d["isOpera"] =  d.Q;
 d["isGecko"] =  d.T;
 d["isSafari"] =  d.V;
 d["DEFAULTMORPHDURATION"] =  d.w;
 d["SUPPRESSEVENTS"] =  d.L;
 d["FIREEVENTS"] =  d.M;
 d["THREADSTART"] =  d.j;
 d["THREADEND"] =  d.k;
 d.aa  = {
    ba:365,

    get:  function(name,  defaultValue)
   {
      var   ca=defaultValue;
      if  (document.cookie.length>0)
     {
        da=document.cookie.indexOf(name  +  "=");
        if  (da!=-1)
       {  
          da=da  +  name.length+1;  
          ea=document.cookie.indexOf(";",da);
          if  (ea==-1)  ea=document.cookie.length;
          ca  =  unescape(document.cookie.substring(da,ea));
       }  
     }
      return   ca;
   },

    fa:  function(name,value)
   {
      var   ga=new   Date();
      ga.setDate(ga.getDate()+this.ba);
      document.cookie=name+  "="  +escape(value)+";expires="+ga.toGMTString();
   },

    remove:  function(name)
   {
      var   ga=new   Date();
      ga.setDate(ga.getDate()-365);
      document.cookie=name+  "=;expires="+ga.toGMTString();
   }
};

 d["Cookies"] =  d.aa;
 d.aa["get"] =  d.aa.get;
 d.aa["set"] =  d.aa.fa;
 d.aa["remove"] =  d.aa.remove;
 
 
 
 
 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

 d.ha  = {
    ia:  function(ja,  delay,  Y,  ka)
   {
      if  (delay  >=  0)
        return   setTimeout(this.la(ja,  Y,  ka),  delay);
      else 
     {
        ja.apply(Y  ||  window,  ka  || []);
        return   null;
     }
   },
    ma:  function(ja,  na,  Y,  ka)
   {
      var   oa  =  this.la(ja,  Y,  ka);
      oa();
      return   setInterval(oa,  na);
   },

    la:  function(ja,  Y,  ka)
   {
      return   function()
     {
        d.pa.qa(d.j,  null,  null);
        ja.apply(Y  ||  window,  ka  || []);
        d.pa.qa(d.k,  null,  null);
     };
   },

    ra:  function(sa,  ta,  context)
   {
      var   ua  =  sa.href;
      if  (ua)
        var   va  =  ua.split("#")[1];
      
      if  (va)
        return   document.getElementById(va);

      
      return   d.wa.xa(context  ||  sa,  ta);
   },

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

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

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

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

 d.ha.platform  = (d.S?"ie ie7":(d.R?"ie ie6":(d.T?"gecko":(d.Q?"opera":(d.U?"safari2":(d.V?"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(Y,  ka)
   {
      Y.gb  =  this;
      var   hb  =  Y.gb(ka[0],  ka[1],  ka[2],  ka[3],  ka[4]);
      Y.gb  =  null;
      return   hb;
   }
}

 d.X(d.ha);

 d["Utils"] =  d.ha;
 d.ha["setTimeoutHandler"] =  d.ha.ia;
 d.ha["setIntervalHandler"] =  d.ha.ma;
 d.wa  = {
    ib:  1,
    jb:{},

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

      return   za.id;
   },

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

      if  (za.id  && !this.jb[za.id])
        mb[0] =  za;

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

      return   mb;
   },
    xa:  function(za,  pb,  qb)
   {
      while  (za  &&  za.nodeType  ==  1)
     {
        if  (d.Ha.contains(za,  pb))
          return   za;

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

      return   ub;
   },
    getBoxObjectFor:  function(za)
   {
      if  (d.R)
     {
        var   xb  =  za.getBoundingClientRect();
        return  {
          x:  xb.left,
          y:  xb.top,
          width:  xb.right  -  xb.left,
          height:  xb.bottom  -  xb.top 
       };
     }
      else   if  (d.T)
        return   za.ownerDocument.getBoxObjectFor(za);
      else   if  (d.Q)
     {
 yb("TO DO!!!");
        zb  = {
          y:za.offsetTop,
          height:Ab.offsetHeight 
       };
     }
      else   if  (d.V  ||  d.U)
     {
        var   zb  = {  x:  0,  y:  0,  width:  za.offsetWidth,  height:za.offsetHeight  };
        while  (za)
       {
          zb.x  +=  za.offsetLeft;
          zb.y  +=  za.offsetTop;
          za  =  za.offsetParent;
       }
        return   zb;
     }
   },

    Bb:  function(za)
   {
      var   value  =  za.value;
      switch  (za.nodeName)
     {
        case   "SELECT":
          value  =  za.options[za.selectedIndex].value;
          break;
        case   "INPUT":
          switch  (za.type)
         {
            case   "checkbox":
              value  =  za.checked;
              break;
         }
          break;
     }
      
      return   value;
   },

    Cb:  function(za)
   {
      if  (d.R)
        return   za.parentTextEdit  !=  null;
      else   if  (d.Q)
        return   za.sourceIndex  != -1;
      else 
        return   za.offsetParent  !=  null;
   },

    Db:  function(Eb,  Fb)
   {
      if  (d.R)
        return   Eb.contains(Fb);

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

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

      while  (Hb)
     {
        if  (this.Db(Hb,  Ib))
          return   Hb;
        Hb  =  Hb.parentNode;
     }
   },
    Jb:  function(za)
   {
      return   d.R  ?  za.style.cssText  :  za.getAttribute("style");
   },
    Kb:  function(za,  s)
   {
      if  (d.R)
        za.style.cssText  =  s;
      else 
        za.setAttribute("style",  s);
   },
    
    Lb:  function()
   {
      this.Mb  =  d.W.scrollTop;
      this.Nb  =  d.W.scrollHeight  -  d.W.clientHeight;
   },
    Ob:  function()
   {
      var   Pb  =  this.Nb  -  this.Mb;
      d.W.scrollTop  = (Pb  <  50  &&  this.Mb  >  100)?d.W.scrollHeight  -  d.W.clientHeight  -  Pb:this.Mb;
   }
};

 d.X(d.wa);

 d["HtmlDomUtils"] =  d.wa;
 d.wa["acquireIdForHtmlElement"] =  d.wa.kb;
 
 d.wa["getAncestorWithClassName"] =  d.wa.xa;

 
 d.wa["_storeScrollState"]   =  d.wa.Lb;
 d.wa["_restoreScrollState"] =  d.wa.Ob;
    
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


 d.Ha  = {
    Qb:/\s+/,

    Rb:{},
    Sb:{},
    Tb:[],
    Ub: {},
    Vb:  null,

    Wb:  function(pb,  ja,  Y)
   {
      this.Tb.push({  pb:pb,  ja:ja,  Y:Y});
   },

    Xb:  function(pb,  Yb,  na)
   {
      this.Sb[pb] = {
        Yb:Yb,
        Zb:  "(\\b"  +  Yb.join("-"  +  pb) +  "-"  +  pb  +  "\\b|\\b"  +  pb  +  "\\b)",
        na:na  ||  1.1*d.w 
     };
   },

    _c:  function(pb,  ac)
   {
      this.Ub[pb] =  " "  +  ac  +  " ";

      var   as  = [];
      for  (var   pb   in   this.Ub)
        as.push(pb);
      if  (as.length)
     {
        var   s  =  "(\\s)("  +  as.join("|") +  ")(\\s)";
        this.Vb  =  new   RegExp(s,  "g");
     }
      else 
        this.Vb  =  null;
   },
    bc: {},
    cc:  function(za)
   {
      if  (this.Vb)
     {
        var   dc  =  d.wa.kb(za);
        if  (!this.bc[dc])
       {
          za.className  = (" "  +  za.className  +  " ").replace(this.Vb,  this.ec);
          this.bc[dc] =  1;
       }
     }
      return   za.className;
   },
    ec:  function(a,  b,  pb)
   {
      return   d.Ha.Ub[pb];
   },
   
    contains:  function(za,  pb)
   {
      return   this.fc(this.cc(za),  pb);
   },
    fc:  function(s,  pb)
   {
      
      return  !!(s  &&  s.match(this.gc(pb)));
   },
    match:  function(za,  pb)
   {
      return   this.cc(za).match(this.gc(pb));
   },
    add:  function(za,  hc,  ic)
   {
      if  (!this.contains(za,  hc))
        if  (this.Sb[hc])
          this.jc(za,  null,  hc,  0,  ic);
        else 
       {
          var   kc  =  this.cc(za);
          var   lc  =  kc  +  d.g  +  hc;
          this.mc(za,  kc,  lc,  ic);
       }
   },
    replace:  function(za,  nc,  hc,  ic,  oc)
   {
      if  (this.contains(za,  nc))
     {
        if  (this.Sb[nc])
          nc  =  this.Sb[nc].Zb;

        if  (!oc  &&  this.Sb[hc])
          this.jc(za,  nc,  hc,  0,  ic);
        else 
       {
          var   pb  =  this.cc(za);
          this.mc(za,  pb,  this.pc(pb,  nc,  hc),  ic);
       }
     }
      else 
        this.add(za,  hc,  ic);
   },
    pc:  function(s,  qc,  rc)
   {
      var   sc  =  s.replace(this.gc(qc),  rc);
      if  (!sc.match(this.gc(rc)))
        sc  +=  d.g  +  rc;

      return   sc;
   },
    tc:  function(za,  pb,  uc,  ic)
   {
      if  (uc)
        this.add(za,  pb,  ic);
      else 
        this.remove(za,  pb,  ic);
   },
    vc:  function(za,  wc,  xc,  ic,  oc)
   {
      var   yc  =  this.contains(za,  wc);
      this.replace(za, (yc?wc:xc), (yc?xc:wc),  ic,  oc);
   },
    remove:  function(za,  nc,  ic)
   {
      if  (this.Sb[nc])
        nc  =  this.Sb[nc].Zb;

      var   pb  =  this.cc(za);
      this.mc(za,  pb,  pb.replace(this.gc(nc),  ""),  ic);
   },
    fa:  function(za,  lc,  ic)
   {
      this.mc(za,  this.cc(za),  lc,  ic);

      var   pb;
      var   zc  =  lc.split(this.Qb);
      for  (var   i=0;  i<zc.length;  i++,  pb=zc[i])
        if  (this.Sb[pb])
       {
          this.jc(za,  pb,  pb,  0,  ic);
          return;
       }
   },

    Ac:  new   RegExp("(-[^_-]+)|(_-\\d+)|(_\\w+)",  "g"),
    Bc:{
      "delay":"int",
      "delayOn":"int",
      "delayOff":"int",
      "duration":"int",
      "delta":"int",
      "max":"int",
      "interval":"int",
      "step":"int",
      "onBefore":"function",
      "onFinish":"function",
      "props":"array",
      "classes":"array",
      "limitmorphto":"array",
      "add":"array",
      "replace":"array",
      "target":"array" 
   },
    Ia:  function(za,  Cc,  Dc)
   {
      var   Ec  =  null;
      var   Fc  =  this.gc(Cc  +  "\\b-?([\\w\\-\\_]*)\\b");

      var   matches  =  this.cc(za).match(Fc);
      if  (matches)
     {
        Ec  = {};
        if  (Dc)
          for  (var   Gc   in   Dc)
            Ec[Gc] =  Dc[Gc];

        Ec.Hc  =  matches[0].split("-")[0];

        for  (var   Ic=0;  Ic<matches.length;  Ic++)
       {
          var   Jc  =  matches[Ic].match(this.Ac);
          if  (Jc)
            for  (var   i=0;  i<Jc.length;  i++)
           {
              var   bb  =  Jc[i].substring(1);
              if  (i<Jc.length-1  &&  Jc[i+1].charAt(0) ==  "_")
             {
                var   cb  =  Jc[i++ +  1].substring(1);
                switch  (this.Bc[bb])
               {
                  case   "function":
                    cb  =  d.ha.Ka(cb);
                    break;
                  case   "int":
                    cb  =  parseInt(cb);
                    break;
                  case   "array":
                    cb  =  cb.split("_");
                    break;
               }
                Ec[bb] =  cb;
                if  (!Ec.action)
                  Ec.action  =  bb;
             }
              else 
             {
                Ec[bb] =  true;
                Ec.action  =  bb;
             }
           }
       }
     }

      return   Ec;
   },



    Kc:  null,
    Lc:  function()
   {
      this.Kc  = {
        Mc:null,
        setData:[]
     };
   },
    
    Nc:  function()
   {
      var   Oc  =  this.Kc;

      this.Kc  =  null;

      if  (Oc.setData.length  >  0)
     {
        var   Pc  =  this.Qc(Oc.Rc,  this.cc(Oc.Mc),  false);

        d.pa.qa(d.l,  Oc.Mc,  Pc);

        for  (var   i=0;  i<Oc.setData.length;  i++)
       {
          var   Sc  =  Oc.setData[i];
          this.mc(Sc.za,  Sc.kc,  Sc.lc,  d.M,  true);
       }

        this.Tc(Oc.Mc,  Pc);
     }
   },

    Tc:  function(za,  Uc)
   {
      if  (Uc.toValue  !=  Uc.fromValue)
     {
        d.pa.qa(d.m,  za,  Uc);

        for  (var   i=0;  i<this.Tb.length;  i++)
       {
          var   Vc  =  this.Tb[i];
          if  (Uc.addCNh[Vc.pb])
            Vc.ja.apply(Vc.Y  ||  window, [Uc,  d.Wc.Xc()])
       }
     }
   },

    Yc:  function(za,  Ec)
   {
      for  (var   name   in   Ec)
     {
        var   Zc  =  Ec[name];
        switch  (name)
       {
          case   "add":
            for  (var   i=0;  i<Zc.length;  i++)
              this.add(za,  Zc[i]);
            break;
          case   "remove":
            this.remove(za,  Zc);
            break;
          case   "replace":
            this.replace(za,  Zc[0],  Zc[1]);
            break;
          case   "set":
            this.fa(za,  Zc);
            break;
          case   "clear":
          case   "empty":
            this.fa(za,  "");
            break;
       }
     }
   },
    gc:  function(pb)
   {
      return   this.Rb[pb] || (this.Rb[pb] =  new   RegExp("(?:^|\\b)"  +  pb  +  "(?:\\b|$)",  "g"));
   },
    mc:  function(za,  kc,  lc,  ic,  _d)
   {
      lc  =  lc.replace(/^\s+|\s+$/g,  "");
      if  (lc  !=  kc)
     {
        if  (this.Kc)
       {
          var   ad  =  d.wa.Gb(this.Kc.Mc,  za);
          if  (ad  !=  this.Kc.Mc)
         {
            this.Kc.Mc  =  ad;
            this.Kc.Rc  =  this.cc(ad);
         }

          this.Kc.setData.push(
           {
              za:za,
              kc:kc,
              lc:lc 
           }
         );
       }
        else 
       {
          if  (!ic)
         {
            var   Uc  =  this.Qc(kc,  lc,  _d);
            d.pa.qa(d.l,  za,  Uc);
         }

          if  (!za.__originalClassName)
            za.__originalClassName  =  za.className;
            
          za.className  =  lc;
          if  (!ic)
            this.Tc(za,  Uc);

          if  (d.R)
         {
            
            
            
            
            if  (za.getAttribute("tabIndex",  2) ==  0)
           {
              za.tabIndex  = -1;
              setTimeout(function(){  za.tabIndex  =  0; },  0);
           }
         }
       }
     }
   },
    jc:  function(za,  nc,  pb,  bd,  ic)
   {
      var   data  =  this.Sb[pb];
      var   Yb  =  data.Yb;

      var   hc  =  Yb[bd] +  "-"  +  pb;

      d.ha.ab(za,  d.w,  data.na);

      if  (nc  &&  this.contains(za,  nc))
        this.replace(za,  nc,  hc,  ic,  true);
      else 
        this.add(za,  hc,  ic,  true);

      var   cd  =  this;
      if  (bd  <  Yb.length-1)
        d.ha.ia(function(){  cd.jc(za,  hc,  pb,  bd+1,  ic); },  data.na);
      else 
        d.ha.ia(function(){  if  (cd.contains(za,  hc))  cd.replace(za,  hc,  pb,  ic,  true); },  data.na);
   },
    
    Qc:  function(kc,  lc,  _d)
   {
 
      var   ed  =  kc.split(this.Qb);
      var   fd  = {};
      for  (var   i=0;  i<ed.length;  i++)
        fd[ed[i]] =  1;
      
      var   gd    =  lc.split(this.Qb);

      var   addCNs  = [];
      var   addCNh  = {};
      for  (var   i=0;  i<gd.length;  i++)
     {
        if  (!fd[gd[i]])
       {
          addCNs.push(gd[i]);
          addCNh[gd[i]] =  1;
       }
        var   hd  =  gd[i].split(/[-_]/);
        for  (var   jd=0;  jd<hd.length;  jd++)
       {
          addCNs.push(hd[jd]);
          addCNh[hd[jd]] =  1;
       }
     }

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

      return  {  fromValue:  kc,  toValue:lc,  delCNs:delCNs,  addCNs:addCNs,  addCNh:addCNh,  _d:_d  };
   }
};

 d.X(d.Ha);

 d["ClassNameAbstraction"] =  d.Ha;
 d.Ha["addAfterChangeClassNameListener"] =  d.Ha.Wb;
 d.Ha["addClassNameSequence"] =  d.Ha.Xb;
 d.Ha["contains"] =  d.Ha.contains;
 d.Ha["add"] =  d.Ha.add;
 d.Ha["replace"] =  d.Ha.replace;
 d.Ha["swap"] =  d.Ha.vc;
 d.Ha["toggle"] =  d.Ha.tc;
 d.Ha["remove"] =  d.Ha.remove;
 d.Ha["set"] =  d.Ha.fa;

 d.Ha["addClassNameAlias"] =  d.Ha._c;
 
 
 

 
 
 
 
 
 
 
 
 

 
 
 

 
 
 
 
 
 
 

 d.Wc  = {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

    kd:  false,
    ld: {},
    md:{},
    nd:[],
    od:  null,
    
    pd:  function(qd,  rd,  ja,  Y,  pb)
   {
      var   sd  = {ja:ja,  Y:Y,  pb:pb};
      var   ud  =  d.wa.kb(qd) +  "-"  +  pb  +  "-"  +  rd;

      var   vd  =  this.ld[ud];
      if  (this.md[ud] ==  qd  &&  vd)
        vd.push(sd);
      else 
     {
        this.md[ud] =  qd;
        vd  =  this.ld[ud] = [sd];

        this.nd.push(qd);
        var   oa  =  this.wd(ud,  this.nd.length-1);

        if  (qd.addEventListener)
          qd.addEventListener(rd,  oa,  false);
        else 
       {
          if  (rd  ==  "DOMMouseScroll")
            rd  =  "mousewheel";
          qd.attachEvent("on"  +  rd,  oa);
       }
     }
   },

    xd:  function(pb,  rd,  ja,  Y)
   {
      this.pd(document.documentElement,  rd,  ja,  Y,  pb);
   },

    Xc:  function()
   {
      return   this.od;
   },
    
    wd:  function(ud,  yd)
   {
      return   function(zd)
     {
        
        
        
        
        if  ((typeof(d) !=  "undefined") && (!d.T  ||  document.defaultView))
       {
          d.wa.Lb();

          zd  =  d.Wc.Ad(zd);

          d.Wc.od  =  zd;

          
          d.pa.qa(d.j,  zd);

          
          
          if  (zd.type  ==  d.D  &&  d.T  &&  zd.Bd)
            return   false;

          var   hb  =  false;

          var   qd  =  d.Wc.nd[yd];
          var   vd  =  d.Wc.ld[ud];
          var   ka  = [zd,  qd];
          for  (var   i=0;  i<vd.length;  i++)
         {
            var   sd  =  vd[i];
            
            if  (sd.pb)
           {
              ka[1] =  null;
              var   za  =  zd.subject;
              while  (za)
             {
                if  (d.Ha.contains(za,  sd.pb))
               {
                  ka[1] =  za;
                  hb  =  sd.ja.apply(sd.Y  ||  ka[1],  ka) &&  hb;
               }
                za  =  za.parentNode;
             }
           }
            else 
           {
              ka[1] =  qd;
              hb  =  sd.ja.apply(sd.Y  ||  ka[1],  ka) &&  hb;
           }
         }

          if  (zd.Cd  ==  true)
            d.Wc.Dd(zd);

          
          d.pa.qa(d.k,  zd);

          d.wa.Ob();

          d.Wc.od  =  null;

          return   hb;
       }
     };
   },

    Ed:  function()
   {
      this.Cd  =  true;
   },
    Dd:  function(zd)
   {
      zd.preventDefault();
      zd.stopPropagation();

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

        if  (za)
       {
          za.Fd  =  za.href;
          za.href  =  "javascript://";
          setTimeout(function(){  za.href  =  za.Fd; },  10);
       }
     }
   },
    Gd:  function()
   {
      this.returnValue  =  false;
   },
    Hd:  function()
   {
      this.cancelBubble  =  true;
   },

    Ad:  function(zd)
   {
 
      if  (d.R)
     {
        zd.subject  =  zd.srcElement;
        zd.preventDefault   =  this.Gd;
        zd.stopPropagation  =  this.Hd;
     }
      else 
     {
        zd.subject  =  zd.target  ||  zd.currentTarget;
        if  (zd.subject  &&  zd.subject.nodeType  ==  3)
          zd.subject  =  zd.subject.parentNode;
     }

      zd.cancel  =  this.Ed;

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

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

      return   zd;
   }
};

 d["DOMEvents"] =  d.Wc;
 d.Wc["attach"] =  d.Wc.pd;
 d.Wc["attachToClassName"] =  d.Wc.xd;
 d.Wc["getEvent"] =  d.Wc.Xc;
 d.pa  = {
    Kd: {},
    Ld:  function(rd,  ja,  Y)
   {
      var   Md  =  this.Kd[rd] =  this.Kd[rd] || [];

      Md[Md.length] = {ja:ja,  Y:Y};
   },
    qa:  function(rd,  subject,  Jc)
   {
      var   hb  =  true;

      var   Md  =  this.Kd[rd];
      if  (Md)
     {
        var   zd  =  Jc  || {};
        zd.type  =  rd;
        zd.subject  =  subject;

        for  (var   i=Md.length-1;  i>=0;  i--)
          hb  = (Md[i].ja.apply(Md[i].Y  ||  subject, [zd]) !=  false) &&  hb;
     }
    
      return   hb;
   }
};

 d["CustomEvents"] =  d.pa;
 d.pa["listen"] =  d.pa.Ld;
 d.pa["fire"] =  d.pa.qa;
 
 
 
 
 
 
 
 
 


 d.Nd  = {
    Z:  function()
   {
      d.pa.Ld(d.m,  this.Od,  this);
      d.pa.Ld(d.o,  this.Pd,  this);
      d.Wc.pd(document.documentElement,  "DOMMouseScroll",    this.Qd,  this);
   },
    Od:  function(zd)
   {
      if  (zd.addCNs.length  >  0  &&  d.pa.qa(d.r,  zd.subject))
        this.Rd(zd.subject,  zd.addCNs);
   },
    Pd:  function(zd)
   {
      if  (d.pa.qa(d.r,  zd.subject))
        this.Rd(zd.subject, [d.C]);
   },
    Rd:  function(Sd,  Td,  context)
   {
      var   Ud  =  false;

      
      for  (var   i=0;  i<Td.length;  i++)
        d.pa.qa("on"  +  Td[i],  Sd);

      var   Vd  =  "\\bon"  +  Td.join("\\b|\\bon") +  "\\b";
      for  (var   Wd  =  Sd.firstChild;  Wd;  Wd  =  Wd.nextSibling)
        if  (Wd.nodeName  ==  "A"  &&  d.Ha.contains(Wd,  Vd))
       {
          d.pa.qa(d.v,  Wd, {  context:context  });
          Ud  =  true;
       }

      return   Ud;
   },
    Qd:  function(zd)
   {
      var   Xd  =  false;
      var   rd  = ["mousescroll"  + (zd.detail>0?"down":"up")];
      for  (var   za  =  zd.subject;  za;  za  =  za.parentNode)
        Xd  =  Xd  ||  this.Rd(za,  rd,  null);

      if  (Xd)
        zd.cancel();
   }
};

 d.X(d.Nd);
 
 
 
 
 
 
 
 
 
 
 
 
 

 d.Yd  = {
    Zd:[],
    _e:  null,
    ae:{},
    be:{},
    od:  null,
    ce:  null,
    de:  false,
    Z:  function()
   {
      d.Wc.pd(document.documentElement,  d.D,    this.ee,  this);

      
      
      
      d.Wc.pd(document.documentElement, (d.R?d.F:d.G),  this.ee,  this);
   },
    fe:  function(pb,  ja,  Y)
   {
      this.ge(pb,  ja,  Y,  true);
   },
    he:  function(pb,  ja,  Y)
   {
      this.ge(pb,  ja,  Y,  false);
      this.de  =  true;
   },
    ge:  function(pb,  ja,  Y,  ie)
   {
      this.Zd[this.Zd.length] =  pb;
      this.ae[pb] = {  ja:ja,  Y:Y  };
      this.be[pb] =  ie;

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

      this._e  =  new   RegExp("(\\b"  +  this.Zd.join("\\b)|(\\b") +  "\\b)|(\\b[\\w\\-]+\\b|\\s+)",  "g");
   },
    ee:  function(zd)
   {
      this.ce  = (zd.type  ==  d.D  ||  zd.keyCode  ==  13  ||  zd.keyCode  ==  32);

      if  (!this.de  && !this.ce)
        return;

      this.od  =  zd;
      var   nb  = [];

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

      for  (var   i=0;  i<nb.length;  i++)
     {
        this.je  =  nb[i];
        if  (this.je.className)
          this.je.className.replace(this._e,  this.ke);
     }
   },
    ke:  function()
   {
      if  (!arguments[arguments.length-3])
     {
        var   cd  =  d.Yd;
        for  (var   i=1;  i<arguments.length-3;  i++)
          if  (arguments[i])
         {
            var   pb  =  cd.Zd[i-1];
            if  (cd.ce  || !cd.be[pb])
           {
              if  (d.pa.qa(d.r,  cd.je))
             {
                var   ja  =  cd.ae[pb];
                ja.ja.apply(ja.Y  ||  cd.je, [cd.je,  arguments[i],  cd.od]);
             }
              return;
           }
         }
     }
   }
};

 d.X(d.Yd);
 
 
 


 d.le  = {
    me:[],
    ne:"",
    oe:{},
    pe:{},
    qe:[],

    Z:  function()
   {
      d.Wc.pd(document.documentElement,  d.D,      this.re,  this);
      d.Wc.pd(document.documentElement,  "dblclick",      this.re,  this);
      d.Wc.pd(document.documentElement,  "keyup",   this.se,  this);
      d.pa.Ld(d.v,  this.te,  this);
   },
    ue:  function(ve,  Y)
   {
      this.qe.push({ja:ve,  Y:Y});
   },
    we:  function(pb,  ve,  Y)
   {
      this.xe([pb], [],  ve,  Y)
   },
    xe:  function(ye,  ze,  ve,  Y)
   {
      var   Ae  =  "("  +  ze.join("|") +  ")";
      for  (var   i=0;  i<ye.length;  i++)
     {
        var   Cc  =  ye[i];
        this.me[this.me.length] =  Cc;
        this.oe[Cc] =  Ae;
        this.pe[Cc] = {  ja:ve,  Y:Y};
     }

      this.ne  =  "(\\b"  +  this.me.join("\\b|\\b") +  "\\b)";
   },
    re:  function(zd)
   {
      this.te(zd);
   },
    se:  function(zd)
   {
      if  (zd.keyCode  ==  32  ||  zd.keyCode  ==  13)
        this.te(zd);
   },
    te:  function(zd)
   {
 
      var   ye;
      var   za  =  zd.subject;

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

        if  ((ye  =  d.Ha.match(za,  this.ne)) &&  d.pa.qa(d.r,  za))
       {
          var   Be  = {};

          for  (var   i=0;  i<ye.length;  i++)
         {
            var   Cc  =  ye[i];
            if  (Cc  && !Be[Cc])
           {
              var   Ce  =  d.Ha.Ia(za,  Cc);
              if  (
               (!Ce["require"] ||  d.wa.xa(za,  Ce["require"]))
               &&
               (!Ce["disallow"] || !d.wa.xa(za,  Ce["disallow"]))
             )
             {
                var   De  =  this.Ee(za,  Cc,  zd.context);
                if  (!De  || !De.za  || !d.pa.qa(d.r,  De.za))
                  continue;

                var   Fe  =  d.Ha.Ia(De.za,  De.Ge);
                if  (
                  Fe 
 
 
 
 
 
               )
                  Be[Cc] = {
                    He:  this.pe[Cc],
                    De:  De,
                    Ce:  Ce,
                    Fe:  Fe 
                 };
           }
           }
         }

          for  (Cc   in   Be)
         {
            var   Ie  =  Be[Cc];
            d.ha.ia(this.Je(zd,  za,  Cc,  Ie),  1*Ie.Ce.delay||-1);
         }
       }

        if  (za.nodeName  ==  "INPUT"  &&  za.type  ==  "submit")
          while  (za.nodeName  !=  "FORM")
            za  =  za.parentNode;

        if  (za.nodeName  ==  "A"  ||  za.nodeName  ==  "FORM")
       {
          for  (var   i=0;  i<this.qe.length;  i++)
         {
            var   ja  =  this.qe[i];
            ja.ja.apply(ja.Y  ||  za, [za,  zd]);
         }
          
          
          if  (zd.cancel  &&  ye  &&  ye.length  >  0  &&  za.getAttribute("href",  2).charAt(0) ==  "#")
            zd.cancel();
       }

        za  =  za.parentNode;
     }
   },

    Je:  function(zd,  za,  Cc,  Ie)
   {
      return   function()
     {
        Ie.He.ja.apply(Ie.He.Y  ||  za, [za,  Cc,  Ie.De.za,  Ie.De.Ge,  zd,  Ie.Ce,  Ie.Fe]);
     };
   },

    Ee:  function(sa,  Cc,  context)
   {
      var   Ke  =  this.Le(sa,  Cc,  context);

      if  (Ke)
     {
        var   Me  =  d.Ha.match(Ke,  this.oe[Cc]);
        return  {  za:Ke,  Ge:(Me?Me[0]:null) };
     }
   },
    Le:  function(sa,  Cc,  context)
   {
      var   ua  =  sa.href;
      if  (ua)
        var   va  =  ua.split("#")[1];
      
      if  (va)
        return   document.getElementById(va);

      
      for  (var   za  =  context  ||  sa;  za  !=  document.documentElement;  za  =  za.parentNode)
        if  (d.Ha.match(za,  this.oe[Cc]))
          return   za;
   }
};

 d.X(d.le);

 d["ActionManager"] =  d.le;
 d.le["addClassNameActionListener"] =  d.le.we;
(function(){
 d.Ne  = {
    Oe:"exclusive_",
    Pe:"allExclusive_",
    Qe:"delayExclusive_",
    Re:"exclusive-reset",

    Se:1,
    Te:{},
    Ue:{},
    Ve:{},
    We:{},
    Xe:{},
    Ye:{},
    Ze:{},
    _f: {},

    Z:  function()
   {
      d.pa.Ld(d.j,  this.af,  this);
      d.pa.Ld(d.m,  this.Od,  this);
   },

    bf:  function(ye,  cf,  df,  ef,  ff)
   {
      var   id  =  this.Se++;
      var   gf  =  cf[cf.length  -  1];
      for  (var   i=0;  i<ye.length;  i++)
     {
        var   Cc  =  ye[i];
        var   hf  =  cf[i];

        this.Ve[gf] =  hf;
        this.We[hf] =  gf;

        gf  =  hf;

        this.Te[Cc] =  hf;
        this.Ue[hf] =  Cc;
        this.Xe[Cc] =  id;
     }

      if  (df)
     {
        for  (var   i=0;  i<df.length;  i++)
       {
          ye[ye.length] =  df[i];
          this.Ye[df[i]] =  true;
          this.Te[df[i]] =  cf[0];
       }
     }
      if  (ef)
     {
        for  (var   i=0;  i<ef.length;  i++)
       {
          ye[ye.length] =  ef[i];
          this.Ze[ef[i]] =  true;
          this.Te[ef[i]] =  cf[0];
       }
     }

      d.le.xe(ye,  cf,  this.jf,  this);

      if  (ff)
        for  (var   i=0;  i<ff.length;  i++)
          this.kf(ff[i],  cf[i]);
   },

    kf:  function(lf,  hf)
   {
      d[lf] =  function(za)
     {
        d.Ha.replace(za,  d.Ne.We[hf],  hf);
     };
   },

    af:  function()
   {
      this._f  = {};
   },
    Od:  function(zd)
   {
      var   mf  = [];

      for  (var   i=0;  i<zd.addCNs.length;  i++)
        this.nf(zd.subject,  zd.addCNs[i],  mf);

      for  (var   i=mf.length-1;  i>=0;  i--)
        this.of(mf[i]);
   },
    jf:  function(sa,  Cc,  Ke,  pf)
   {
      var   mf  = [];
      this.qf(mf,  Cc,  Ke,  pf);

      d.Ha.Lc();
      for  (var   i=mf.length-1;  i>=0;  i--)
        this.of(mf[i]);
      d.Ha.Nc();
   },     
    qf:  function(mf,  Cc,  Ke,  pf)
   {
      var   rf  =  this.Te[Cc];

      if  (this.Ye[Cc])
     {
        rf  =  this.Ve[pf];
        Cc  =  this.Ue[rf];
     }
      else   if  (this.Ze[Cc])
     {
        rf  =  this.We[pf];
        Cc  =  this.Ue[rf];
     }

      if  (!d.Ha.contains(Ke,  rf))
     {
        mf[mf.length] = {
          Cc:Cc,
          Ke:Ke,
          sf:pf,
          rf:rf,
          delay:-1 
       };

        this.nf(Ke,  rf,  mf);
     }
   },

    nf:  function(Ke,  rf,  mf)
   {
      var   tf;
      
      if  (Ke.parentNode  &&  Ke.parentNode.nodeType  ==  1)
     {
        var   uf  =  Ke.parentNode;
        
        if  (!d.Ha.contains(Ke.parentNode,  "has_"  +  rf))
          d.Ha.remove(uf,  "has_\\w+");

        if  (d.Ha.contains(Ke.parentNode,  this.Oe  +  rf))
          tf  =  uf.childNodes;
        else   if  (uf  =  d.wa.xa(Ke,  this.Pe  +  rf,  this.Re))
          tf  =  d.wa.getElementsByTagName(uf,  d.f);

        if  (tf)
       {
          var   vf  =  this.Ve[rf];
          var   wf  =  this.Ue[vf];

          var   xf  =  false;
          var   yf  =  tf.length;
          for  (var   i=0;  i<yf;  i++)
         {
            var   zf  =  tf[i];

            if  (zf.nodeType  ==  1)
           {
              var   Af  =  d.Ha.contains(zf,  rf);
              xf  =  xf  ||  Af;
              if  (zf  !=  Ke  &&  Af  &&  d.pa.qa(d.r,  zf))
             {
                if  (mf.length  >  0  &&  mf[mf.length-1].delay  == -1)
                  mf[mf.length-1].delay  =  d.ha.Wa(Ke.parentNode,  this.Qe, -1);

                this.qf(mf,  wf,  zf,  rf);
             }
           }
         }

          if  (xf)
            d.Ha.add(uf,  "has_"  +  rf);
          else 
            d.Ha.remove(uf,  "has_"  +  rf);
       }
     }
   },
    
    of:  function(Bf)
   {
      var   Cf  =  d.wa.kb(Bf.Ke) +  "-"  +  this.Xe[Bf.Cc];
      if  (!this._f[Cf])
     {
        this._f[Cf] =  true;
        
        d.ha.ia(
          function()
         {
            
            d.Ha.replace(Bf.Ke,  Bf.sf,  Bf.rf,  d.M);
         },
          Bf.delay 
       );
   }
   }
};

 d.X(d.Ne);

 d["Behaviors"] =  d.Ne;
 d.Ne["addStateSequence"] =  d.Ne.bf;

 
 d.Ne.bf(["collapser",  "expander"],    ["collapsed",  "expanded"],   ["expandedToggle",  "expandcollapser"],  null, ["collapse",  "expand"]);
 d.Ne.bf(["opener",     "closer"],      ["open",       "close"],      ["openToggle"],  null, ["open",  "close"]);
 d.Ne.bf(["selector",   "unselector"],  ["selected",   "unselected"], ["selectedToggle"],  null, ["select",  "unselect"]);
 d.Ne.bf(["shower",     "hider"],       ["shown",      "hidden"],     ["shownToggle",  "showswitch"],  null, ["show",  "hide"]);
 d.Ne.bf(["focuser",    "blurrer"],     ["focus",      "blur"],       ["focusToggle"],  null, ["focus",  "blur"]);
 d.Ne.bf(["onswitch",   "offswitch"],   ["on",         "off"],        ["onToggle"],  null, ["turnOn",  "turnOff"]);
 d.Ne.bf(["enabler",    "disabler"],    ["enabled",    "disabled"],   ["enabledToggle"],  null, ["enable",  "disable"]);
 d.Ne.bf(["checker",    "unchecker"],   ["checked",    "unchecked"],  ["checkedToggle"],  null, ["check",  "uncheck"]);
})();
 d.le.xe(
   ["classchanger"],
   [],
    function(sa,  x,  Ke,  pf,  zd,  Ce,  Fe)
   {
      d.ha.ia(
        function()
       {
          d.Ha.Yc(Ke,  Ce);
       },
        Ce["delay"]
     );
   }
);
 d.Df  =
{
    Ef:  "activation-inert",
    Ff:  "delayOn",
    Gf:  "delayOff",
    Hf:  "delaySwitch",
    If: [],
    Jf: [],
    Kf:{},
    Lf: [],
    Mf: {},
    Nf: {},
    Of: {},

    Pf: {},
    Qf: {},
    Rf: {},
    Sf: {},
    Tf: {},
    Uf: {},

    Z:  function()
   {
      
      this.Vf("unhover",  "hover");
      this.Vf("mouseout",  "mouseover");
      this.Vf("neverhovered",  "");

      
      this.Wf("inactive",  "active",  "activator",  "inactivator",  "activate",  "inactivate");
      this.Wf("blurred",  "focused",  "focuser",  "blurrer",  "focus",  "blur");

      d.Wc.pd(document.documentElement,  "mouseover",  this.Xf,  this);

      d.Wc.pd(document.documentElement,  d.D,  this.te,  this);
      d.Wc.pd(document.documentElement,  "contextmenu",  this.te,  this);
      d.Wc.pd(document.documentElement,  "keyup",  this.te,  this);

      d.pa.Ld(d.m,  this.Od,  this);
   },
    Vf:  function(Yf,  Zf)
   {
      if  (Yf)
     {
        this.If.push(Yf);
        this.Kf[Yf] =  Zf;
     }
      if  (Zf)
     {
        this.If.push(Zf);
        this.Kf[Zf] =  Zf;
     }
      this._g  =  "("  +  this.If.join("\\b|\\b") +  ")";
      this.Of[Yf] =  Zf;
      this.Of[Zf] =  Yf;
      
      if  (Yf  &&  Zf)
     {
        this.kf(Zf,  Zf,  Yf);
        this.kf(Yf,  Yf,  Zf);
     }
   },

    kf:  function(lf,  hf,  ag)
   {
      d[lf] =  function(za)
     {
        d.Ha.replace(za,  ag,  hf);
     };
   },

    Wf:  function(bg,  cg,  dg,  eg,  fg,  gg)
   {
      if  (bg)
        this.Lf.push(bg);
      if  (cg)
     {
        this.Kf[cg] =  cg;
        if  (bg)
          this.Kf[bg] =  cg;
        this.Jf.push(cg);
     }
      this.hg  =  "("  +  this.Jf.join("\\b|\\b") +  ")";
      this.ig  =  "("  +  this.Lf.join("\\b|\\b") +  ")";
      this.jg  =  "("  +  this.Jf.join("\\b|\\b") +  "\\b|\\b"  +  this.Lf.join("\\b|\\b") +  ")";
      this.Of[bg] =  cg;
      this.Of[cg] =  bg;

      if  (eg)
        this.Nf[eg] =  eg;
      if  (dg  &&  eg)
     {
        this.Mf[dg] =  dg;
        d.le.xe([dg,  eg], [cg,  bg],  this.kg,  this);
     }

      if  (fg)
        this.kf(fg,  cg,  bg);
      if  (gg)
        this.kf(gg,  bg,  cg);
   },

    kg:  function(sa,  Cc,  Ke,  pf)
   {
      var   dc  =  d.wa.kb(Ke);
      var   Ec  =  d.Ha.Ia(Ke,  this.jg);
      var   data  = {  za:Ke,  Ec:Ec  };

 this.lg  = (Cc  ==  "inactivator"  &&  d.Ha.contains(Ke,  "active"));
 
      if  (this.Mf[Cc])
        this.mg(dc,  data,  this.Tf,  this.Sf,  this.Uf);
      else 
     {
        Ec.Hc  =  this.Of[Ec.Hc];
        this.ng(dc,  data,  this.Tf,  this.Sf,  this.Uf);
     }
   },

    Xf:  function(zd)
   {
      this.og(zd,  this._g,  this.Qf,  this.Pf,  this.Rf);
   },

    te:  function(zd)
   {
      var   za  =  zd.subject;
      
      if  (!d.wa.xa(za,  this.Ef))
     {
        this.og(
          zd,
          this.jg,
          this.Tf,
          this.Sf,
          this.Uf,
          d.wa.xa(za,  this.Ef) !=  null,
          zd.ctrlKey  ||  d.wa.xa(za,  this.Ef) !=  null,
          d.wa.xa(za,  "activation-box")
       );

        d.pa.qa("afterActivationChange",  zd.subject);
     }
   },

    Od:  function(zd)
   {
      if  (!d.Ha.fc(zd.fromValue,  this.hg) &&  d.Ha.fc(zd.toValue,  this.hg))
        
        this.te(zd);
      else   if  (d.Ha.fc(zd.fromValue,  this.hg) && !d.Ha.fc(zd.toValue,  this.hg))
     {
        
        
        
        var   dc  =  d.wa.kb(zd.subject);
        var   cd  =  this;
        setTimeout(function(){
          delete   cd.Pf[dc];
          delete   cd.Sf[dc];
       },  0);
     }
   },

    og:  function(zd,  pg,  qg,  rg,  sg,  tg,  ug,  vg)
   {
      
      
      if  (this.lg)
     {
        this.lg  =  false;
        return;
     }
      this.lg  =  false;

      var   wg  = {};

 
 
      var   za  =  zd.subject;
      while  (za  &&  za.nodeType  ==  1)
     {
        var   Ec  =  d.Ha.Ia(za,  pg);
        if  (
          Ec 
         && (!Ec["require"]  ||   d.wa.xa(za,  Ec["require"]))
         && (!Ec["disallow"] || !d.wa.xa(za,  Ec["disallow"]))
       )
          wg[d.wa.kb(za)] = {  za:za,  Ec:Ec  };

        za  =  za.parentNode;
     }   

      this.xg  =  false;

 
 
      if  (!ug)
        for  (var   dc   in   rg)
          if  (!wg[dc] && (!vg  ||  d.wa.Db(vg,  rg[dc].za)))
            this.ng(dc,  rg[dc],  qg,  rg,  sg);

      if  (!tg)
        for  (var   dc   in   wg)
          if  (!rg[dc] && (!vg  ||  d.wa.Db(vg,  wg[dc].za)))
            this.mg(dc,  wg[dc],  qg,  rg,  sg);
   },
    
    mg:  function(dc,  data,  qg,  rg,  sg)
   {
 
      if  (!rg[dc] &&  d.pa.qa(d.r,  data.za))
     {
        if  (sg[dc])
          this.yg(dc,  sg);
        else 
       {
          var   delay  = (this.xg?data.Ec[this.Hf]:0) ||  data.Ec[this.Ff];
          if  (delay)
         {
            qg[dc] =  data;
            data.zg  =  d.ha.ia(this.Ag,  delay,  this, [dc,  data,  qg,  sg]);
         }
          else 
            this.Bg(dc,  data,  sg);
       }
        rg[dc] =  data;
     }
   },
    ng:  function(dc,  data,  qg,  rg,  sg)
   {
 
      if  (rg[dc] &&  d.pa.qa(d.r,  data.za))
     {
        if  (qg[dc])
          this.Cg(dc,  qg[dc],  qg,  rg);
        else 
       {
          this.xg  =  true  &&  data.Ec[this.Hf];
          if  (data.Ec[this.Gf])
         {
            sg[dc] =  data;
            data.zg  =  d.ha.ia(this.Dg,  data.Ec[this.Gf],  this, [dc,  sg]);
         }
          else 
            this.Eg(dc,  data);

          delete   rg[dc];
       }
     }
   },
    Cg:  function(dc,  data,  qg,  rg)
   {
      clearTimeout(data.zg);
      delete   qg[dc];
      delete   rg[dc];
   },
    Ag:  function(dc,  data,  qg,  sg)
   {
      delete   qg[dc];
      this.Bg(dc,  data,  sg);
   },
    Bg:  function(dc,  data,  sg)
   {
      if  (d.wa.Cb(data.za))
     {
        d.Ha.replace(data.za,  this.Of[this.Kf[data.Ec.Hc]],  this.Kf[data.Ec.Hc]);

        var   Fg  =  d.wa.xa(data.za,  "exclusive"  +  this.Of[data.Ec.Hc]);
        for  (var   dc   in   sg)
          if  (Fg  &&  d.wa.xa(sg[dc].za,  "exclusive"  +  this.Of[data.Ec.Hc]) ==  Fg)
         {
            this.Eg(dc,  sg[dc]);
            this.yg(dc,  sg);
         }
       }
     },
    Dg:  function(dc,  sg)
   {
      this.Eg(dc,  sg[dc]);
      delete   sg[dc];
   },
    yg:  function(dc,  sg)
   {
      clearTimeout(sg[dc].zg);
      delete   sg[dc];
   },
    Eg:  function(dc,  data)
   {
      if  (d.wa.Cb(data.za))
        d.Ha.replace(data.za,  this.Kf[data.Ec.Hc],  this.Of[this.Kf[data.Ec.Hc]]);
   }
};

 d.X(d.Df);

 
 
 
 

 

 d.Gg  = {
    Hg:1,
    Ig:2,
    Jg:3,
    Kg:4,
    Lg:5,
    Mg:6,
    Ng:7,
    Og:8,
    Pg:9,
    Qg:null,
    Z:  function()
   {
      if  (d.R)
     {
        this.Rg  =  this.Sg;
        this.Tg  =  this.Ug;
     }
      d.Gg["getRawComputedStyleProperty"] =  d.Gg.Rg;

      this.Qg  = {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        "borderWidth":this.Ig,
        "borderTopWidth":this.Ig,
        "borderRightWidth":this.Ig,
        "borderBottomWidth":this.Ig,
        "borderLeftWidth":this.Ig,
        "width":this.Jg,
        "height":this.Jg,
        "scrollTop":this.Kg,
        "scrollLeft":this.Kg,
        "color":this.Lg,
        "backgroundColor":this.Lg,
        "borderColor":this.Lg,
        "borderTopColor":this.Lg,
        "borderRightColor":this.Lg,
        "borderBottomColor":this.Lg,
        "borderLeftColor":this.Lg,
        "opacity":this.Mg,
        "zoom":this.Ng,
        "display":this.Og,
        "float":this.Og,
        "overflow":this.Og,
        "position":this.Og,
        "visibility":this.Og,
        "zIndex":this.Pg 
     };

      this.Vg  = {};
      this.Vg[this.Hg] =  "px";
      this.Vg[this.Ig] =  "px";
      this.Vg[this.Jg] =  "px";
      this.Vg[this.Kg] =  "px";
      this.Vg[this.Lg] =  "";
      this.Vg[this.Mg] =  "%";
      this.Vg[this.Ng] =  "%";
      this.Vg[this.Og] =  "";
      this.Vg[this.Pg] =  "";
   },
    Wg:{
      "width":["offsetWidth"],
      "height":["offsetHeight"]
   },
    Xg:{
      "width":["height",  "offsetHeight"],
      "height":["width",  "offsetWidth"]
   },

    Yg:  function(za,  bb)
   {
      var   Zg  =  this.Rg(za,  bb);
      return   this.Tg(za,  bb,  Zg).value;
   },

    Rg:  function(za,  bb,  _h)
   {
      var   ah  =  this.bh(bb);
      var   ch  =  document.defaultView.getComputedStyle(za,  "");

      if  (ch)
        switch  (this.dh(bb))
       {
          case   this.Jg:
            if  (d.Q)
           {
              var   eh  =  this.Wg[bb];
              var   cb  =  za[eh[0]];
              for  (var   i=1;  i<eh.length;  i++)
                cb  -=  parseInt(za.currentStyle[eh[i]]);
              return   Math.max(0,  cb);
           }
          case   this.Ig:
            if  (ch.getPropertyValue(ah.replace(/width/,  "style")) ==  d.h)
              return   0;
          case   this.Pg:
          case   this.Hg:
          case   this.Ng:
          case   this.Mg:
            return   ch.getPropertyValue(ah);
          case   this.Kg:
            return   za[bb];
            break;
          case   this.Lg:
            if  (
              ah.indexOf("border") != -1 
             &&  ch.getPropertyValue(ah.replace(/color/,  "style")) ==  d.h 
           )
              return   null;
            
          case   this.Og:
            return   ch.getPropertyValue(ah);
       }

      return   null;
   },
    Tg:  function(za,  bb,  Zg)
   {
      var   fh  =  this.dh(bb);

      var   Y  = {  value:  Zg  };

      switch  (fh)
     {
        case   this.Pg:
        case   this.Hg:
        case   this.Ng:
          var   gh  =  parseInt(Zg);
          if  (isNaN(gh))
            switch  (Zg)
           {
              case   "auto":  Y.value  =  0;  break;
              default:  Y.value  =  null;
           }
          else 
            Y.hh  = (""  +  Zg).replace(/^[-\d]+/,  "") ||  null;
          Y.value  =  gh;
          break;
        case   this.Mg:
          Y.value  =  Math.round(100*Zg);
          break;
        case   this.Lg:
          Y.value  =  this.ih(Zg);
          break;
        case   this.Jg:
        case   this.Kg:
          Y.value  =  parseInt(Zg);
     }

      return   Y;
   },


    Sg:  function(za,  bb)
   {
      
      if  (!za.currentStyle)
        return   null;

      switch  (this.dh(bb))
     {
        case   this.Jg:
 
 
 
            
            
            var   jh  =  za[this.Xg[bb][1]] ==  0;
            if  (jh)
              za.runtimeStyle[this.Xg[bb][0]] =  "1px";

            var   cb  =  za[this.Wg[bb]];

 za.runtimeStyle[bb] =  cb;
 cb  +=  cb  -  za[this.Wg[bb]];
 za.runtimeStyle[bb] =  "";

            if  (jh)
              za.runtimeStyle[this.Xg[bb][0]] =  "";
 

          return   cb;
        case   this.Kg:
          return   za[bb];
          break;
        case   this.Mg:
          try 
         {
            return   za.filters.item(d.K).opacity;
         }
          catch(kh)
         {
            return   100;
         }
          break;
        case   this.Hg:
        case   this.Ng:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        default:
          if  (bb  ==  "float")
            bb  =  "styleFloat";

          return   za.currentStyle[bb];
     }
   },

    Ug:  function(za,  bb,  Zg)
   {
      var   fh  =  this.dh(bb);

      var   Y  = {  value:  Zg  };
      var   gh  =  null;

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

      switch  (fh)
     {
        case   this.Jg:

 gh  =  parseInt(Zg);

          Y.hh  = (""  +  Zg).replace(/^[-\d\.]+/,  "") ||  null;
          Y.value  =  Math.max(0,  gh);
          break;
        case   this.Lg:
          Y.value  =  this.ih(Zg);
          break;
        case   this.Ig:
        case   this.Pg:
        case   this.Hg:
        case   this.Ng:
          gh  =  parseInt(Zg);
          if  (isNaN(gh))
            switch  (Zg)
           {
              case   "auto":  gh  =  0;  break;
              case   "thin":  gh  =  2;  break;
              case   "medium":  gh  =  4;  break;
              case   "thick":gh  =  6;  break;
              default:  gh  =  parseInt(Zg);
           }
          else 
            Y.hh  = (""  +  Zg).replace(/^[-\d\.]+/,  "") ||  null;

          Y.value  =  gh;
          break;
     }

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

      return   Y;
   },

    lh:  function(za,  bb,  cb)
   {
      switch  (this.dh(bb))
     {
        case   this.Lg:
          za.style[bb] =  "rgb("  +  cb.join(",") +  ")";
          break;
        case   this.Og:
        case   this.Pg:
          za.style[bb] =  cb;
          break;
        case   this.Jg:
        case   this.Ng:
        case   this.Ig:
        case   this.Hg:
          za.style[bb] =  cb  +  "px";
          break;
        case   this.Kg:
          za[bb] =  cb  +  "px";
          break;
     }
   },

    mh:  function(za,  bb)
   {
      za.style[bb] =  "";
   },

    dh:  function(bb)
   {
      return   this.Qg[bb] ||  this.Hg;
   },

    bh:  function(bb)
   {
      return   bb.replace(/([A-Z])/g,  function(nh){  return   "-"  +  nh.toLowerCase(); });
   },
    oh: {
      "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" 
    },

    ih:  function(c)
   {
      c  =  this.oh[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   ph  =  c.substring(4,  c.length  -  1).split(",");
        return  [
          parseInt(ph[0]),
          parseInt(ph[1]),
          parseInt(ph[2])
       ];
     }

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

 d.X(d.Gg);

 d["StyleUtils"] =  d.Gg;
 d.Gg["getComputedStyleProperty"] =  d.Gg.Yg;
 
 
 d.Animator  =  _a  = {
    qh:{},
    animate:  function(rh,  sh)
   {
      var   uh  =  rh.length;

 
 
 
 
 
 
 
 
 
 
 
      var   vh  =  10;
      var   wh  =  1  <<  vh;

      var   xh  =  7;
      var   yh  =  1  <<  xh;

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

      var   Ah  = [];
      var   Bh  = [];
      var   Ch  = [];

      for  (var   i=0;  i<uh;  i++)
     {
        var   Dh  =  rh[i];
        var   za  =  Dh.element;
        var   id  =  d.wa.kb(za);
        var   Eh  =  Dh.targetState;

 
 

        for  (var   Fh   in   Eh)
       {
          var   Gh  =  Fh;
          if  (!d.R)
            Gh  =  Fh.replace(/([A-Z])/g,  function(nh){  return   "-"  +  nh.toLowerCase(); });

          var   Hh  =  Eh[Fh];

          
          var   Ih  = (Dh.currentState&&typeof(Dh.currentState[Fh])!=d.e)?Dh.currentState[Fh]:d.Gg.Yg(za,  Fh);

          if  (Fh  ==  "zoom")
         {
            
            Ih  *=  100;
            Hh  *=  10000;
         }

          
          _a[id  +  "el"] =  za;
          switch  (d.Gg.dh(Fh))
         {
            case   d.Gg.Kg:
                _a[id  +  "elscroll"] = (za  !=  document.body  ||  document.compatMode  ==  "BackCompat")?za:document.documentElement;
              break;
            case   d.Gg.Mg:
              if  (d.R)
             {
                _a[id  +  "opacity"] =  za.filters.item(d.K);
                break;
             }
              
            default:
              _a[id  +  "elStyle"] =  za.style;

              if  (sh.removeAfterwards)
 
                Ch.push("_a[\"",  id,  "elStyle\"]."  +  Fh  +  "='';\n");
         }

          
          if  (d.Gg.dh(Fh) ==  "rgb")
            Hh  =  d.Gg.ih(Hh);

          if  (Hh.constructor  ==  Array)
         {
            var   Jh  = [];
            for  (var   jd=0;  jd<Hh.length;  jd++)
              Jh[jd] =  Math.floor(Hh[jd] -  Ih[jd]);
         }
          else   if  (!isNaN(Hh))
         {
            var   Jh  =  Math.floor(Hh-Ih);
         }

          var   Kh  = (Dh.units  &&  Dh.units[Fh])?" + '"  +  Dh.units[Fh] +  "';\n":_a.Lh;

          
          switch  (d.Gg.dh(Fh))
         {
            case   d.Gg.Lg:
              if  (d.R)
             {
                if  (Fh  ==  "borderColor")
                  Bh.push(
                    '_a["',  id,  'elStyle"].',  Fh,  '=["rgb(",',
                    '(',  Math.floor(yh*(Ih[0]+0.5)),  '+cP*',  Jh[0],  ')>>',  xh,  ',",", ',
                    '(',  Math.floor(yh*(Ih[1]+0.5)),  '+cP*',  Jh[1],  ')>>',  xh,  ',",", ',
                    '(',  Math.floor(yh*(Ih[2]+0.5)),  '+cP*',  Jh[2],  ')>>',  xh,  ', ")"].join("");\n' 
                 );
                else 
                  Bh.push(
                    '_a["',  id,  'elStyle"].',  Fh,  '=',
                    '((',  Math.floor(yh*(Ih[0]+0.5)),  '+cP*',  Jh[0],  ')>>',  xh,  '<<16) | ',
                    '((',  Math.floor(yh*(Ih[1]+0.5)),  '+cP*',  Jh[1],  ')>>',  xh,  '<<8) | ',
                    '((',  Math.floor(yh*(Ih[2]+0.5)),  '+cP*',  Jh[2],  ')>>',  xh,  ');\n' 
                 );
             }
              else 
                Bh.push(
                  '_a["',  id,  'elStyle"].',  Fh,  '=["rgb(",',
                  '(',  Math.floor(yh*(Ih[0]+0.5)),  '+cP*',  Jh[0],  ')>>',  xh,  ',",", ',
                  '(',  Math.floor(yh*(Ih[1]+0.5)),  '+cP*',  Jh[1],  ')>>',  xh,  ',",", ',
                  '(',  Math.floor(yh*(Ih[2]+0.5)),  '+cP*',  Jh[2],  ')>>',  xh,  ', ")"].join("");\n' 
               );
              break;
            case   d.Gg.Mg:
              Bh.push('try{_a["',  id, (d.R?'opacity"].opacity=(':'elStyle"].opacity=(('),  yh*(Ih+0.5),  '+cP*',  Jh,  ')>>',  xh, (d.R?';':')/100;'),  "}catch(e){};\n");
              break;
            case   d.Gg.Kg:
              Ah.push('_a["',  id,  'elscroll"].',  Fh,  '=(',  wh*(Ih+0.5),  '+normalPhase*',  Jh,  ')>>',  vh,  ';\n');
              break;
            case   d.Gg.Ng:
              Ah.push('_a["',  id,  'elStyle"].',  Fh,  '=((',  Math.floor(wh*(Ih+0.5)),  '+normalPhase*',  Jh,  ')>>',  vh,  ')/10000;\n');
            case   d.Gg.Og:
              switch  (Fh)
             {
                case   "visibility":
                  za.style.visibility  =  "visible";
                  break;
                case   "display":
                  za.style.display  = (Hh=='none'?Ih:Hh);
                  break;
                case   "overflow":
                  za.style.overflow  =  "hidden";
                  break;
 
 
 
 
 
 
             }
              break;
            case   d.Gg.Pg:
              Ah.push('_a["',  id,  'elStyle"].',  Fh,  '=((',  Math.floor(wh*(Ih+0.5)),  '+normalPhase*',  Jh,  ')>>',  vh,  ')\n');
              break;
            default:
              Ah.push('_a["',  id,  'elStyle"].',  Fh,  '=((',  Math.floor(wh*(Ih+0.5)),  '+normalPhase*',  Jh,  ')>>',  vh,  ')', (Fh=='zoom'?'/10000':''),  Kh,  ";\n");
         }

       }
     }

 

      if  (Ah.length  >  0)
     {
        code.push(
          "var normalPhase=Math.round(",  wh,  "*f);\n",
          Ah.join("")
       );
     }
      if  (Bh.length  >  0)
     {
        code.push(
          'var cP=Math.round(',  yh,  '*f);\n',
         Bh.join("")
       );
     }

 

      if  (sh.repeat)
        code.push(
          "",
          "if(t==TSTOP)",
          "{",
          "}\n");

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

      code.push("}\n\nSpif.HtmlDomUtils._restoreScrollState();");

      _a.Mh(code,  sh.delay,  sh.duration,  rh,  sh.onFinish,  sh.repeat);
   },

    zh: [
      '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)))',
      '(1-Math.sin('  +  5*Math.PI  +  '*tPhase)/(0.0001 + '  +  5*Math.PI  +  '*tPhase))',
      '(1-Math.cos('  +  2*Math.PI  +  '*tPhase))' 
   ],

    Lh: (document.defaultView?" + 'px';\n":";\n"),
    Nh:  0,
    Oh:  null,
    Ph:  1,
    Qh:  0,
    Rh:  Infinity,
    Sh:  500,
    Th:  "",
    Mh:  function(Uh,  delay,  duration,  rh,  onFinish,  repeat)
   {
      _a.Nh++;
      _a.Ph++;

      for  (var   i=0;  i<rh.length;  i++)
        _a.qh[rh[i].element.id] =  _a.Ph++;

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

      Vh  = [
        "/*** ",  _a.Ph,  " ***/\n",
       (repeat?"var t=TSTART+((tNow-TSTART) % DURATION);\n":"var t=Math.min(tNow, TSTOP);\n"),
        "try {",
        Uh.join(""),
        "} catch(e){ t=TSTOP; }",
        "if(t==TSTOP)\n",
        "{\n",
        "_a.__rC(",  _a.Ph,  ");\n",
       (onFinish?("_a.__onFinish"  +  _a.Ph  +  "(_a.__anims"  +  _a.Ph  +  ");"):""),
        "\n}\n",
        "/*** /",  _a.Ph,  " ***/\n"].join("");

      var   Wh  = +new   Date() +  delay  -  _a.Qh;
      var   Xh  =  Wh  +  duration;
      if  (repeat)
        Xh  =  Infinity;
      Vh  =  Vh.replace(/TSTART/g,  Wh);
      Vh  =  Vh.replace(/DURATION/g,  duration);
      Vh  =  Vh.replace(/TSTOP/g,  Xh);
      Vh  =  Vh.replace(/RUNINDEX/g,  _a.Ph);

      if  (_a.Oh)
        _a.Yh(rh);

      _a.Th  =  _a.Th  +  Vh;

 

      _a.Zh  =  Function("tNow",  _a.Th);

 

      if  (!_a.Oh)
     {
        _a.Qh  =  0;
        _a.Rh  =  Infinity;

 
 

        _a.Oh  =  setInterval(_a._i,  1);
 _a.ai  =  true;
        _a._i();
 _a.ai  =  false;
     }
   },
    _i:  function()
   {
      var   bi  = +new   Date() -  _a.Qh;

      var   ci  =  bi  -  _a.Rh;
      if  (ci  >  _a.Sh)
     {
        _a.Qh  +=  ci;
        bi  -=  ci;
     }

      _a.Rh  =  bi;

 
 

      _a.Zh(bi);
   },
    "__rC":  function(di)
   {
      var   ei  =  "/*** "  +  di  +  " ***/";
      var   fi    =  "/*** /"  +  di  +  " ***/";
      _a.Th  =  _a.Th.substring(0,  _a.Th.indexOf(ei)) +  _a.Th.substring(_a.Th.indexOf(fi) +  fi.length);

      _a.Zh  =  Function("tNow",  _a.Th);

      _a.gi(di);

      _a.Nh--;
      if  (_a.Nh  ==  0)
     {
        clearInterval(_a.Oh);
        _a.qh  = {};
        _a.Oh  =  null;
     }
   },
    gi:  function(di)
   {
      for  (var   id   in   _a.qh)
        if  (_a.qh[id] ==  di)
          delete   _a.qh[id];
   },
   Yh:  function(rh)
   {
      var   hi  = [];
      var   uh  =  rh.length;
      for  (var   i=0;  i<uh;  i++)
     {
        var   Dh  =  rh[i];
        var   za  =  Dh.element;
        var   id  =  Dh.element.id.replace(/(\W)/g,  "\\$1");
        var   Eh  =  Dh.targetState;

 
 

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

      if  (hi.length  >  0)
     {
 
        _a.Th  =  _a.Th.replace(new   RegExp(hi.join("").substr(1),  "g"),  "");
 
     }
   },
    ii:  function(ji)
   {
 
 
 
 
 
 
 
 
 
 
 
 
   }
};


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

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

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


 
 
 
 
 
 
 
 
 
 
 
 

 
 
 


 



 d.ki  = {
    mi:"display",
    ni:"block",
    oi:"morph",
    pi:"shallow",


    qi:  true,
    ri:[
      "display",
      "overflow",
      "backgroundColor",
 
 
 
 
 
      "color",
      "fontSize",
      "height",
      "left",
      "marginTop",
 
 
      "marginLeft",
      "opacity",
 
 
 
 
 
      "top",
      "bottom",
      "width",
      "zIndex" 
   ],
    si:{},
    ti:  false,
    ui:  false,
    vi:  {  BODY:1,  DIV:1,  wi:1,  xi: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  },
    Z:  function()
   {
      d.pa.Ld(d.k,  this.yi,  this);
      d.pa.Ld(d.l,  this.zi,  this);
      d.pa.Ld(d.n,  this.zi,  this);
   },

    Ai:  function()
   {
      this.qi  =  true;
   },
    Bi:  function()
   {
      this.qi  =  false;
   },
    Ci:  function()
   {
      this.ui  =  false;
   },
    Di:  function(Ei)
   {
      d.w  =  Ei;
   },
    Fi:  function(Gi)
   {
      var   Hi  = {};
      for  (var   i=0;  i<Gi.length;  i++)
        Hi[Gi[i].toUpperCase()] =  1;
      this.vi  =  Hi;
   },
    Ii:  function(Ji)
   {
      this.ri  =  Ji;
   },
    zi:  function(zd)
   {
      if  (d.ki.qi  && !zd._d)
        this.Ki(zd.subject);
   },
    Ki:function(Sd)
   {
 
      var   Li  = {};

      var   Ec  =  d.Ha.Ia(Sd,  this.oi, {"delay":0,  "duration":d.w});
      if  (!Ec  || (!Ec["not"] && (!Ec["require"] ||  d.Ha.contains(Sd,  Ec["require"]))))
     {
        if  (Ec)
          this.Mi(Li,  Sd,  Ec);
        else   if  (!this.ui)
          this.Ni(Sd,  Li);

        if  (this.ti)
       {
          this.Oi(Li,  true);

          for  (var   dc   in   Li)
            this.si[dc] =  Li[dc];
       }
     }
 
   },

    Mi:  function(ji,  za,  Ec)
   {
      var   dc  =  d.wa.kb(za);
      if  (!this.si[dc])
     {
        ji[dc] = {
          element:za,
          Ec:Ec,
          db:Ec[this.Pi]||this.ri 
       };

        this.ti  =  true;
     }

      if  (!this.ui  ||  Ec["deep"])
        this.Ni(za,  ji);
   },

    Ni:  function(za,  Li)
   {
      for  (var   Wd  =  za.firstChild;  Wd;  Wd  =  Wd.nextSibling)
        if  (Wd.nodeType  ==  1)
       {
          var   Ec  =  null;
          var   Qi  =  false;
          if  (this.vi[Wd.nodeName])
         {
            Ec  =  d.Ha.Ia(Wd,  this.oi, {"delay":0,  "duration":d.w});
            if  (Ec  && !Ec["not"])
           {
              this.Mi(Li,  Wd,  Ec);
              Qi  =  true;
           }
         }

          if  (!Qi)
         {
            var   Ri  =  d.Gg.Rg(Wd,  "display");
            if  (Ri  !=  d.h  && (!Ec  || !Ec[this.pi]))
              this.Ni(Wd,  Li);
         }
       }
   },

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

      if  (this.ti)
     {
        
        
        for  (var   dc   in   this.si)
          if  (!d.wa.Cb(this.si[dc].element))
         {
            var   za  =  document.getElementById(dc);
            if  (za)
              this.si[dc].element  =  document.getElementById(dc);
            else 
              delete   this.si[dc];
         }

 
        this.Si(this.si);
 
        this.Oi(this.si,  false);
 
        this.Ti(this.si);
 

        var   Ui  =  this.Vi();
 

        this.ti  =  false;
        this.si  = {};
 

        this.Wi(Ui);
 

        
        
        
        
        
        
        
        if  (d.T)
          document.body.offsetWidth;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
     }
   },
    Si:  function(ji)
   {
 
 
 
 
 

      for  (var   dc   in   ji)
        if  (d.Animator.qh[dc])
       {
          var   Xi  =  ji[dc];
          var   za  =  Xi.element;

          if  (d.R)
         {
            Xi.Yi  =  za.style.cssText;
            za.style.cssText  =  "";
         }
          else 
            for  (var   bb   in   Xi.Zi)
           {
              var   cb  =  za.style[bb];
              if  (cb)
             {
                Xi._j[bb] =  cb;
                za.style[bb] =  "";
             }
           }
       }
   },
    Ti:  function(ji)
   {
      for  (var   dc   in   ji)
     {
        if  (d.Animator.qh[dc])
       {
          var   Xi  =  ji[dc];
          var   za  =  Xi.element;
          if  (d.R)
            za.style.cssText  =  Xi.Yi;
          else 
            for  (var   bb   in   Xi._j)
              za.style[bb] =  Xi._j[bb];
       }
     }
   },
    Oi:  function(ji,  aj)
   {
      var   bj  = [];
      var   cj  = [];
      var   dj  =  null;

      for  (var   dc   in   ji)
     {
        var   Xi  =  ji[dc];
        var   za  =  Xi.element;

 
 
 
 if  (!za  || !za.parentNode  || (za.offsetWidth  ==  0  && (!za.parentNode  ||  za.parentNode.offsetWidth  ==  0)))
{
    delete   ji[dc];
    continue;
}
        if  (aj)
       {
          Xi._j  = {};
          Xi.Zi  = {};
          Xi.ej  = {};
       }

        
        if  (!aj  &&  dj  &&  d.wa.Db(dj,  za) && (dj.style.display  ==  d.h))
       {
          delete   ji[dc];
          continue;
       }

        var   fj  = (aj?Xi.Zi:Xi.ej);

        for  (var   i=0;  i<Xi.db.length;  i++)
       {
          var   bb  =  Xi.db[i];
 

          fj[bb] =  d.Gg.Rg(za,  bb);

          if  (bb  ==  this.mi  &&  fj[bb] ==  d.h)
         {
 
 
 
 
 
            
            if  (!aj  &&  Xi.Zi.display  ==  d.h)
           {
              delete   ji[dc];
              break;
           }

            dj  =  za;
            bj.push(dj);
            cj.push(dj.style.display);
            dj.style.display  =  this.ni;
         }
       }
     }

      for  (var   i=0;  i<bj.length;  i++)
        bj[i].style.display  =  cj[i];
   },
    Vi:  function()
   {
      var   Ui  = {};
      var   gj  = {};
      for  (var   dc   in   this.si)
     {
        var   Xi  =  this.si[dc];
        var   za  =  Xi.element;
        var   currentState  = {};
        var   units  = {};
        var   targetState  = {};
        var   hj  =  false;
        for  (var   bb   in   Xi.ej)
       {
          var   ij  =  Xi.Zi[bb];
          var   jj  =  Xi.ej[bb];

          if  (jj  !=  null)
         {
            
 
 
 
 
            if  (ij  !=  jj)
           {
              hj  =  true;
              var   kj  =  d.Gg.Tg(za,  bb,  ij);
              var   lj    =  d.Gg.Tg(za,  bb,  jj);
              currentState[bb] =  kj.value;
              targetState[bb] =  lj.value;
              units[bb] =  kj.hh  ||  lj.hh;
           }
         }
       }

        if  (hj)
       {
          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   mj  =  Ui[Xi.Ec["profile"]] =  Ui[Xi.Ec["profile"]] || {};
          var   nj  =  mj[Xi.Ec["delay"]] =  mj[Xi.Ec["delay"]] || {};
          var   rh  =  nj[Xi.Ec["duration"]] =  nj[Xi.Ec["duration"]] || [];

          rh[rh.length] = {
            element:za,
            currentState:currentState,
            targetState:targetState,
            units:units 
         };
       }
     }
      return   Ui;
   },
    Wi:  function(Ui)
   {
      for  (var   profile   in   Ui)
     {
        var   oj  =  Ui[profile];
        for  (var   delay   in   oj)
       {
          delay  *=  1;
          for  (var   duration   in   oj[delay])
         {
            duration  *=  1;
            var   rh  =  oj[delay][duration];
            for  (var   i=0;  i<rh.length;  i++)
           {
              var   Dh  =  rh[i];
              var   za  =  Dh.element;

 
 
            
              for  (var   bb   in   Dh.currentState)
             {
 
 
                d.Gg.lh(za,  bb,  Dh.currentState[bb]);
             }
           }

 
 
 
 
 
 
 
 
 

            var   sh  =  new   d.Modifiers();
            sh.delay  =  delay;
            sh.duration  =  duration;
            sh.profile  =  sh[(profile=="undefined"?"FAST":profile)];
 
 
            sh.removeAfterwards  =  true;

 
 
            d.Animator.animate(rh,  sh);
 
         }
       }
     }
   },
    pj:  function(qj,  rj)
   {
      for  (var   i=0;  i<qj.length;  i++)
        if  (qj[i] !=  rj[i])
          return   false;

      return   true;
   }
};
 d.X(d.ki);

 d["StyleMorpher"] =  d.ki;
 d.ki["enableDeepMorphing"] =  d.ki.Ci;
 d.ki["setMorphDuration"] =  d.ki.Di;
 d.ki["setMorphableNodeNames"] =  d.ki.Fi;
 d.ki["setMorphableProperties"] =  d.ki.Ii;
 d.ki["enable"] =  d.ki.Ai;
 d.ki["disable"] =  d.ki.Bi;

 d.ki["morph"] =  d.ki.yi;
 d.ki["beforeClassNameChange"] =  d.ki.zi;
 
 
 
 
 


 d.sj  = {
    tj:  null,
    uj:  null,
    Z:  function()
   {
      d.Wc.pd(document.documentElement,  d.H,  this.vj,  this);
      d.Wc.pd(document.documentElement,  d.I,  this.wj,  this);
      d.Wc.pd(document.documentElement,  d.J,    this.xj,  this);
      d.Wc.pd(document.documentElement,  "DOMMouseScroll",    this.Qd,  this);

      d.pa.Ld("persist-pos",  this.yj,  this);
   },
    
    yj:  function(zd)
   {
      var   za  =  zd.subject;
      if  (d.Ha.contains(za,  "movable"))
     {
        var   zj  = {  x:  parseInt(za.style.left),  y:  parseInt(za.style.top) };
        if  (!isNaN(zj.x) || !isNaN(zj.y))
       {
          var   Ja  =  d.Ha.Ia(za,  "movable");
          if  (Ja[d.N])
            Ja[d.N](za,  zj);
       }
     }
   },

    vj:  function(zd)
   {
      this.xj();

      this.Aj  =  d.ha.ya(zd.subject,  "mover",  "movable");
      if  (this.Aj.object)
     {
        this.Aj.box  =  this.Aj.object.offsetParent  ||  d.W;

        this.Bj  =  d.W.scrollTop;
        this.Cj  =  this.Aj.object.offsetLeft  -  zd.clientX  -  d.Gg.Yg(this.Aj.object,  "marginLeft");
        this.Dj  =  this.Aj.object.offsetTop  -  zd.clientY  -  d.Gg.Yg(this.Aj.object,  "marginTop");

        this.Ej();

        this.Fj  =  false;

        
        
        zd.cancel();
     }
      else 
        this.Aj  =  null;
   },
    wj:  function(zd)
   {
      this.uj  =  zd.clientY;

      if  (this.Aj)
        if  (zd.Id)
       {
          if  (!this.Fj)
         {
            d.Wc.kd  =  true;

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

            d.Ha.replace(this.Aj.box,  "notMoving",  "moving");
            d.Ha.replace(this.Aj.object,  "notMoving",  "moving");
            d.Ha.replace(this.Aj.Fa,  "notMoving",  "moving");

            this.tj  =  d.ha.ma(this.Gj,  15,  this);

 this.Hj  =  document.body.style.MozUserSelect;
 document.body.style.MozUserSelect  =  "none";

            this.Fj  =  true;
         }

          this.Ij  = {  x:  this.Cj  +  zd.clientX,  y:  this.Dj  +  zd.clientY  +  d.W.scrollTop  -  this.Bj  };
          this.Jj();

          if  (this.Aj.Ja[d.N])
         {
            this.Aj.Ja[d.N](this.Aj.object,  this.Ij);
            this.Jj();
         }

          if  (this.Aj.Ga.dir  !=  "vertical")
            d.Gg.lh(this.Aj.object,  "left",  this.Ij.x);
          if  (this.Aj.Ga.dir  !=  "horizontal")
            d.Gg.lh(this.Aj.object,  "top",   this.Ij.y);
       }
        else 
          this.xj();
   },
    Qd:  function(zd)
   {
      this.xj();

      var   Kj  =  d.wa.xa(zd.subject,  "move");
      if  (Kj)
     {
        var   Ec  =  d.Ha.Ia(Kj,  "move");

        if  (Ec["onMouseScroll"])
       {
          if  (this.Lj)
            clearTimeout(this.Lj);

          var   Mj  =  document.getElementById(Ec["onMouseScroll"]);
          this.Aj  = {
            box:  Mj.offsetParent  ||  d.W,
            object:  Mj,
            Ja:  d.Ha.Ia(Mj,  "movable")
         };
          
          this.Ej();

          var   Nj  =  this.Aj.object.offsetTop;

          var   Oj  =  Ec["delta"] ||  Math.abs(zd.detail);

          this.Ij  = {  x:0,  y:Nj  +  Oj  *  zd.detail  /  Math.abs(zd.detail) };
          this.Jj();

          if  (this.Aj.Ja[d.N])
         {
            this.Aj.Ja[d.N](this.Aj.object,  this.Ij);
            this.Jj();
         }

          d.Gg.lh(this.Aj.object,  "top",   this.Ij.y);

          var   Pj  =  d.sj.Aj.Ja[d.O];
          if  (this.Aj.Ja[d.O])
         {
            var   Y  =  d.sj.Aj.object;
            var   zj  =  d.sj.Ij;
            this.Lj  =  d.ha.ia(function() {  Pj(Y,  zj); },  500);
         }

          this.xj();
          
          zd.cancel();
       }
     }
   },

    Ej:  function()
   {
      
      
      
      var   Qj   = -1;
      var   Rj  = -1;
      var   Sj  =  this.Aj.box;
      while  (Qj  <=  1  ||  Rj  <=  1)
     {
        Qj  = (document.compatMode  !=  "BackCompat"  ||  Sj  !=  d.W)?Sj.offsetWidth:Sj.clientWidth;
        Rj  =  Sj.offsetHeight;
        Sj  =  Sj.offsetParent  ||  d.W;
     }
      

      if  (this.Aj.Ja["restricted"])
     {
        this.Tj  =  Qj   -  d.Gg.Yg(this.Aj.object,  "width") -  d.Gg.Yg(this.Aj.object,  "marginRight") - (Sj  ==  d.W?2:0);
        this.Uj  =  Rj  -  d.Gg.Yg(this.Aj.object,  "height") -  d.Gg.Yg(this.Aj.object,  "marginBottom");
     }
   },

    Jj:  function()
   {
      if  (this.Aj.Ja["restricted"])
     {
        this.Ij.x  =  Math.max(0,  Math.min(this.Ij.x,  this.Tj)),
        this.Ij.y  =  Math.max(0,  Math.min(this.Ij.y,  this.Uj))
     }
   },
    xj:  function()
   {
      if  (this.Aj)
     {
        if  (this.Fj)
       {
          document.body.style.MozUserSelect  =  this.Hj;

          if  (this.Aj.box)
            d.Ha.replace(this.Aj.box,  "moving",  "notMoving");
          if  (this.Aj.object)
            d.Ha.replace(this.Aj.object,  "moving",  "notMoving");
          if  (this.Aj.Fa)
            d.Ha.replace(this.Aj.Fa,  "moving",  "notMoving");

          if  (this.Aj.Ja[d.O])
            this.Aj.Ja[d.O](this.Aj.object,  this.Ij);

          d.Wc.kd  =  false;

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

          this.uj  =  null;
          clearTimeout(this.tj);
          this.tj  =  null;
       }

        this.Aj  =  null;
     }

      this.Vj  =  d.W.scrollHeight  -  d.W.offsetHeight;
   },
    Gj:  function()
   {
      if  (this.Ij  &&  this.Aj.Ga.dir  !=  "horizontal")
     {
        var   Wj  =  d.W.scrollTop;
      
        if  (this.uj  <  50)
          d.W.scrollTop  -=  Math.round(10  -  this.uj/5);

        if  (this.uj  >  d.W.offsetHeight  -  50)
          d.W.scrollTop  =  Math.min(d.W.scrollTop  +  Math.round(10  - (d.W.offsetHeight  -  this.uj)/5),  this.Vj);

        if  (d.W.scrollTop  !=  Wj)
       {
          this.Ij.y  +=  d.W.scrollTop  -  Wj;
          this.Jj();

          if  (this.Aj.Ja[d.N])
         {
            this.Aj.Ja[d.N](this.Aj.object,  this.Ij);
            this.Jj();
         }
          d.Gg.lh(this.Aj.object,  "top",   this.Ij.y);
       }
     }
   }
};

 d.X(d.sj);
 d.Xj  = {
    Z:  function()
   {
      d.Wc.pd(document.documentElement,  d.H,  this.vj,  this);
      d.Wc.pd(document.documentElement,  d.I,  this.wj,  this);
      d.Wc.pd(document.documentElement,  d.J,    this.xj,  this);

      d.pa.Ld("persist-dim",  this.yj,  this);
   },

    yj:  function(zd)
   {
      var   za  =  zd.subject;
      if  (d.Ha.contains(za,  "resizable"))
     {
        var   Yj  = {  width:  parseInt(za.style.width),  height:  parseInt(za.style.height) };
        if  (!isNaN(Yj.width) || !isNaN(Yj.height))
       {
          var   Ja  =  d.Ha.Ia(za,  "resizable");
          if  (Ja[d.N])
            Ja[d.N](za,  Yj);
       }
     }
   },

    
    Zj:  function(zd)
   {
      zd.cancel();
   },
    vj:  function(zd)
   {
 
      
      this.xj();

      this._k  =  d.ha.ya(zd.subject,  "resizer",  "resizable");
      if  (this._k.object)
     {
        var   ja  =  this._k.Fa;

        
        if  (ja.nodeName  ==  "A")
          if  (d.R)
            d.Wc.pd(ja,  "dragstart",  this.Zj,  this);
          else 
            zd.cancel();

        
        this.ak  =  d.Gg.Yg(this._k.object,  "width");
        this.bk  =  d.Gg.Yg(this._k.object,  "minWidth") ||  0;
        this.ck  =  d.Gg.Yg(this._k.object,  "maxWidth") ||  Infinity;

        this.dk  =  d.Gg.Yg(this._k.object,  "height");
        this.ek  =  d.Gg.Yg(this._k.object,  "minHeight") ||  0;
        this.fk  =  d.Gg.Yg(this._k.object,  "maxHeight") ||  Infinity;

        this.Cj  =  zd.clientX;
        this.Dj  =  zd.clientY;

        this.gk  =  false;
     }
      else 
        this._k  =  null;
   },
    
    wj:  function(zd)
   {
      if  (this._k)
        if  (zd.Id)
       {
          if  (!this.gk)
         {
            d.Wc.kd  =  true;

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

            d.Ha.replace(this._k.object,  "notResizing",  "resizing");
            d.Ha.replace(this._k.Fa,  "notResizing",  "resizing");
            this.gk  =  true;
         }

          this.hk  = {
            width:this.ak  +  zd.clientX  -  this.Cj,
            height:this.dk  +  zd.clientY  -  this.Dj 
         };
          this.Jj();

          if  (this._k.Ja[d.N])
         {
            this._k.Ja[d.N](this._k.object,  this.hk);
            this.Jj();
         }

          if  (this._k.Ga.ik  !=  "height")
            this._k.object.style.width   =  this.hk.width   +  "px";
          if  (this._k.Ga.ik  !=  "width")
            this._k.object.style.height  =  this.hk.height  +  "px";
       }
        else 
          this.xj();
   },
    Jj:  function()
   {
      this.hk.width   =  Math.max(this.bk,  Math.min(this.ck,  this.hk.width));
      this.hk.height  =  Math.max(this.ek,  Math.min(this.fk,  this.hk.height));
   },

    xj:  function()
   {
      if  (this._k)
     {
        if  (this.gk)
       {
          d.Ha.replace(this._k.object,  "resizing",  "notResizing");
          d.Ha.replace(this._k.Fa,  "resizing",  "notResizing");

          if  (this._k.Ja[d.O])
            this._k.Ja[d.O](this._k.object,  this.hk);

          d.Wc.kd  =  false;

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

        this._k  =  null;
     }
   }
};

 d.Xj.Z();
 
 
 
 
 
 
 
 
 
 
 
 
 

 d.jk  = {
    si: {},

    Z:  function()
   {
     this.kk();

      d.Wc.pd(window,  "unload",  this.lk,  this);

      d.pa.Ld(d.n,  this.lk,  this);
      d.pa.Ld(d.o,   this.mk,  this);
   },
    lk:  function(zd)
   {
      var   za  =  zd.subject  ||  document.body;
      if  (za  ==  window  ||  za  ==  document)
        za  =  document.body;

      var   mb  =  d.wa.lb(za);
      
      for  (var   i=0;  i<mb.length;  i++)
     {
        var   za  =  mb[i];
        var   Ec  =  d.Ha.Ia(za,  "persist");

        for  (var   action   in   Ec)
       {
          var   Ge  =  this.si[za.id] || (this.si[za.id] = {});

          switch  (action)
         {
            case   "pos":
              Ge[action] =  d.Gg.Rg(za,  "top") +  "|"  +  d.Gg.Rg(za,  "left");
              break;
            case   "dim":
              Ge[action] =  d.Gg.Rg(za,  "width") +  "|"  +  d.Gg.Rg(za,  "height");
              break;
            case   "class":
              Ge["className"] =  za.className;
         }
       }
     }

      this.nk();
   },
    kk:  function()
   {
      
      var   s  =  d.aa.get("persist");
 
      if  (s)
        this.si  =  this.ok(s);
   },
    nk:  function()
   {
      var   s  =  this.pk(this.si);
 

 
      d.aa.fa("persist",  s);
   },
    mk:  function()
   {
      for  (var   id   in   this.si)
     {
        var   za  =  document.getElementById(id);
        
        if  (za  &&  d.Ha.contains(za,  "persist"))
       {
          var   qk  =  this.si[id];
          for  (var   Fh   in   qk)
            if  (Fh)
           {
              switch  (Fh)
             {
                case   "pos":
                  var   rk  =  qk[Fh].split("|");
                  za.style.top   =  rk[0];
                  za.style.left  =  rk[1];
                  break;
                case   "dim":
                  var   rk  =  qk[Fh].split("|");
                  za.style.width   =  rk[0];
                  za.style.height  =  rk[1];
                  break;
                case   "className":
                  d.Ha.fa(za,  qk[Fh]);
                  break;
                default:
                  za.setAttribute(Fh,  qk[Fh]);
             }

              d.pa.qa("persist-"  +  Fh,  za);
           }

          delete   this.si[id];
       }
     }
   },
    pk:  function(ji)
   {
      var   s  =  "";

      for  (var   id   in   ji)
     {
        var   sk  =  "";
        var   Ge  =  ji[id];
        for  (var   Fh   in   Ge)
          sk  +=  Fh  +  ":'"  +  Ge[Fh] +  "',";
        if  (sk)
          s  +=  id  +  "={"  +  sk.substring(0,  sk.length-1) +  "}¬";
     }
      s  =  s.substring(0,  s.length-1);
      
      return   s.replace(/\s+/g,  " ");
   },
    ok:  function(s)
   {
      var   x;
      var   ji  = {};

      var   tk  =  s.split("¬");
      for  (var   i=0;  i<tk.length;  i++)
     {
        var   uk  =  tk[i].split("=");
 try 
{
        eval("x = "  +  uk[1]);
        ji[uk[0]] =  x;
}
 catch(kh)
{
}
     }
      return   ji;
   }
};

 d.X(d.jk);
 d.vk  = {
    wk:"dragging",
    xk:"notDragging",
    yk:"dropping",
    zk:"notDropping",
    Z:  function()
   {
      d.Wc.pd(document.documentElement,  d.H,  this.vj,  this);
      d.Wc.pd(document.documentElement,  d.I,  this.wj,  this);
      d.Wc.pd(document.documentElement,  d.J,    this.Ak,  this);
   },
    
    vj:  function(zd)
   {
      
      this.xj();

      
      var   Bk  =  d.wa.xa(zd.subject,  "dragger");
      if  (Bk)
     {
        
        var   Ck  =  d.wa.xa(zd.subject,  "draggable");

        
        if  (Ck)
       {
          
          if  (!d.wa.xa(zd.subject,  "dragging-disabled"))
            
            this.Dk(Ck,  Bk);

          
          
          zd.cancel();
       }
     }
   },
    
    wj:  function(zd)
   {
      this.uj  =  zd.clientY;

      if  (this.Ek)
        if  (zd.Id)
       {
          this.Fk();

          
          zd.cancel();

          
          this.Gk.style.left  = (d.W.scrollLeft  +  zd.clientX) +  "px";
          this.Gk.style.top  = (d.W.scrollTop  +  5  +  this.uj) +  "px";

          
          
          
          var   Ck  =  d.wa.xa(zd.subject,  "draggable");
          if  (Ck  !=  this.Gk)
         {
            
            var   Hk  =  d.wa.xa(zd.subject,  "dropBox");
            if  (Hk  &&  Hk  !=  this.Ik)
           {
              
              var   Jk  =  d.ha.Ta(Hk,  "dropType",  "",  true);
              for  (var   i=0;  i<Jk.length;  i++)
                if  (!isNaN(this.Kk[Jk[i]]))
                  break;
              
              if  (i  >=  Jk.length)
                Hk  =  null;
           }

            var   Lk  =  null;

            if  (
              d.wa.xa(zd.subject,  "noDrop",  "dropBox")
             ||
             (Hk  &&  d.wa.Db(this.Ek,  Hk))
           )
              Hk  =  null;

            if  (Hk)
           {
              var   Mk  =  d.R?zd.clientX:(zd.clientX  +  d.W.scrollLeft);
              if  (d.Q)
             {
                Mk  =  zd.offsetX;
                var   za  =  zd.subject;
                while  (za  !=  Hk)
               {
                  Mk  +=  za.offsetLeft;
                  za  =  za.offsetParent  ||  d.W;
               }
             }
              var   Nk  =  d.R?zd.clientY:(zd.clientY  +  d.W.scrollTop);
              if  (d.Q)
             {
                Nk  =  zd.offsetY;
                var   za  =  zd.subject;
                while  (za  !=  Hk)
               {
                  Nk  +=  za.offsetTop;
                  za  =  za.offsetParent  ||  d.W;
               }
             }

 this.Ok.style.display  =  "none";
              for  (var   i=0; !Lk  &&  i<Hk.childNodes.length;  i++)
             {
                var   Ab  =  Hk.childNodes[i];

                if  (Ab  ==  this.Ok  ||  Ab  ==  this.Gk  ||  d.Ha.contains(Ab,  "noDropBefore"))
                  continue;
                else   if  (Ab.nodeType  ==  1)
               {
                  var   zb  =  d.wa.getBoxObjectFor(Ab);
                  if  (Nk  <=  zb.y  +  zb.height  &&  Mk  <=  zb.x  +  zb.width)
                    Lk  =  Ab;
               }
             }
 this.Ok.style.display  =  "";
           }
            this.Pk(Hk,  Lk);
         }
       }
        else 
          this.Ak();
   },

 uj:  null,
 Qk:  null,
 Rk:  null,
        
    Dk:  function(Ck,  Bk)
   {
      this.Sk  =  Bk;
      this.Ek  =  Ck;
      this.Tk  =  Ck.parentNode;
      this.Uk  =  Ck.nextSibling;

      
      this.Vk  =  d.ha.Ta(this.Ek,  "dragType",  "",  true);
      this.Kk  =  d.ha.Za(this.Vk);

      this.Wk  =  false;

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


    Fk:  function()
   {
      if  (this.Wk)
        return;

      this.Wk  =  true;

      d.Wc.kd  =  true;

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

      
      var   Xk  =  d.wa.rb(this.Ek,  "dragPlaceholder");
      if  (Xk)
        this.Gk  =  Xk.cloneNode(true);
      else 
     {
        this.Gk  =  this.Ek.cloneNode(true);
        this.Gk.style.width  =  this.Ek.offsetWidth  +  "px";
     }

      d.Ha.add(this.Gk,  "dragPlaceholder");
      d.Ha.replace(this.Gk,  this.xk,  this.wk);
      this.Ek.parentNode.insertBefore(this.Gk,  this.Ek);

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

      
      var   Yk  =  d.wa.rb(this.Ek,  "dropPlaceholder");
      if  (Yk)
        this.Ok  =  Yk.cloneNode(true);
      else 
     {
        this.Ok  =  this.Ek.cloneNode(true);
 
     }
      d.Ha.add(this.Ok,  "dropPlaceholder");
      d.Ha.remove(this.Ok,  this.xk);

      
      d.Ha.replace(this.Ek,  this.xk,  this.wk);

      this.tj  =  d.ha.ma(this.Gj,  15,  this);
   },
    Pk:  function(Hk,  Lk)
   {
      if  (Hk  !=  this.Ik  ||  Lk  !=  this.Zk)
     {
        
        if  (this.Ik  &&  Hk  !=  this.Ik)
          d.Ha.replace(this.Ik,  this.yk,  this.zk);

        
        this.Ik  =  Hk;
        this.Zk  =  Lk;

        if  (!Hk)
          this.Ok.parentNode.removeChild(this.Ok);
        else 
       {
          d.Ha.replace(Hk,  this.zk,  this.yk);
          Hk.insertBefore(this.Ok,  Lk  ||  null);
       }
     }
   },

    Ak:  function()
   {
      if  (this.Ek  &&  this.Ik)
     {
        var   Ck  =  this.Ek;
        var   _l  =  this.Ok.parentNode;
        var   al  =  this.Ok.nextSibling;

        this.xj();

        var   bl  =  d.Ha.contains(this.Tk,  "clone-box") &&  _l  !=  this.Tk;
        if  (_l  !=  this.Tk  ||  al  !=  this.Uk)
       {
          var   Lk  =  bl?Ck.cloneNode(true):Ck;

          _l.insertBefore(Lk,  al);

          var   cl  =  d.Ha.Ia(_l,  "dropBox");
          if  (cl[d.O])
            if  (cl[d.O](Lk,  this.Tk,  this.Uk,  _l,  al) ==  false)
              this.Tk.insertBefore(Lk,  this.Uk);
       }
     }

      this.xj();
   },

    xj:  function()
   {
      if  (this.Ek)
     {
        d.Ha.remove(document.body,  "dragging-"  +  this.Vk.join(" dragging-"));

        if  (this.Wk)
       {
          d.Ha.replace(this.Ek.parentNode,  this.wk,  this.xk);
          d.Ha.replace(this.Ek,  this.wk,  this.xk);
          if  (this.Ik)
            d.Ha.replace(this.Ik,  this.yk,  this.zk);

          
          this.Gk.parentNode.removeChild(this.Gk);
          if  (this.Ok.parentNode)
            this.Ok.parentNode.removeChild(this.Ok);
       }

        d.Wc.kd  =  false;

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

        this.Sk  =  null;
        this.Ek  =  null;
        this.Ik  =  null;
        this.uj  =  null;
        clearTimeout(this.tj);
        this.tj  =  null;
     }
      this.Vj  =  d.W.scrollHeight  -  d.W.offsetHeight;
   },
    
    Gj:  function()
   {
      var   Wj  =  d.W.scrollTop;
      
      if  (this.uj  <  50)
        d.W.scrollTop  -=  Math.round(10  -  this.uj/5);

      if  (this.uj  >  d.W.offsetHeight  -  50)
        d.W.scrollTop  =  Math.min(d.W.scrollTop  +  Math.round(10  - (d.W.offsetHeight  -  this.uj)/5),  this.Vj);

      if  (d.W.scrollTop  !=  Wj)
        this.Gk.style.top  = (d.W.scrollTop  +  5  +  this.uj) +  "px";
   }
};

 d.X(d.vk);


 
 
 
 
 
 
 
 
 d.el  = {
    fl:null,
    gl:  null,
    Z:  function()
   {
 
 
 
 
 
 
 
 

      d.Wc.pd(document.documentElement,  "mousedown",  this.vj,  this);
      d.Wc.pd(document.documentElement,  "mouseup",  this.hl,  this);
      d.Wc.pd(document.documentElement,  "mousemove",  this.wj,  this);
      d.Wc.pd(document.documentElement,  "dragstart",  this.Zj,  this);
   },
    
    vj:  function(zd)
   {
      if  (d.pa.qa(d.r,  zd.subject))
        for  (var   za  =  zd.subject;  za  &&  za.nodeType  ==  1;  za  =  za.parentNode)
          if  (d.Ha.contains(za,  "button"))
         {
            if  (!this.fl)
              this.fl  = [];

            this.fl.push(za);
            d.Ha.replace(za,  "up",  "down");
         }
   },

    hl:  function(zd)
   {
      if  (d.pa.qa(d.r,  zd.subject))
        if  (this.fl)
       {
          for  (var   i=0;  i<this.fl.length;  i++)
            d.Ha.replace(this.fl[i],  "down",  "up");

          this.fl  =  null;
       }
   },

    Zj:  function(zd)
   {
      if  (d.pa.qa(d.r,  zd.subject))
        if  (this.fl)
          for  (var   i=0;  i<this.fl.length;  i++)
            if  (zd.subject  ==  this.fl[i])
              zd.cancel();
   },

    wj:  function(zd)
   {
      if  (this.fl  &&  d.pa.qa(d.r,  zd.subject) &&  zd.subject  !=  this.gl)
     {
        this.gl  =  zd.subject;

        for  (var   i=0;  i<this.fl.length;  i++)
          if  (d.wa.Db(this.fl[i],  zd.subject))
            d.Ha.replace(this.fl[i],  "up",  "down");
          else 
            d.Ha.replace(this.fl[i],  "down",  "up");
     }
   }
};

 d.el.Z();
 
 d.Ha.add(document.documentElement,  "spiffy "  +  d.ha.platform,  d.L);

 d.Wc.pd(
    window,
    d.C,
    function()
   {
      if  (document.compatMode  ==  "BackCompat"  ||  d.V)
        d.W  =  document.body;

 
 
 
 
 
 
 

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

      d.pa.qa(d.o,  document.body);
   }
);

 if  (d.R)
{
    
    
    
 

 
 

    
    
    
    

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

 d.pa.qa("spifLoaded");

 d["documentScrollElement"] =  d.W;