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

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

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

    K:"DXImageTransform.Microsoft.Alpha",

    L:  true,
    M:  false,

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

    P:"-delay",


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

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

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

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

      delete   ea[name];

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

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

      delete   ea[name];

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

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

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

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

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

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

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

 
      document.cookie  =  c;
   }
};

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

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

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

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

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

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

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

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

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



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

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

 d.W(d.oa);

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

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

      return   za.id;
   },

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

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

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

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

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

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

    Cb:  function(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;
   },

    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)
   {
      if  (d.R)
        return   za.style.cssText;
      else 
        return   za.getAttribute("style");
   },
    Kb:  function(za,  s)
   {
      if  (d.R)
        za.style.cssText  =  s;
      else 
        za.setAttribute("style",  s);
   }
};

 d.W(d.Ga);

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

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


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

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

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

      return   dc;
   },
    ec:  function(za,  qb,  fc,  Ub)
   {
      if  (fc)
        this.add(za,  qb,  Ub);
      else 
        this.remove(za,  qb,  Ub);
   },
    gc:  function(za,  hc,  ic,  Ub,  _c)
   {
      var   jc  =  this.contains(za,  hc);
      this.replace(za, (jc?hc:ic), (jc?ic:hc),  Ub,  _c);
   },
    remove:  function(za,  Zb,  Ub)
   {
      if  (this.Nb[Zb])
        Zb  =  this.Nb[Zb].Qb;

      this.Yb(za,  za.className,  za.className.replace(this.Sb(Zb),  ""),  Ub);
   },
    ga:  function(za,  Xb,  Ub)
   {
      this.Yb(za,  za.className,  Xb,  Ub);

      var   qb;
      var   kc  =  Xb.split(this.Lb);
      for  (var   i=0;  i<kc.length;  i++,  qb=kc[i])
        if  (this.Nb[qb])
       {
          this.Vb(za,  qb,  qb,  0,  Ub);
          return;
       }
   },

    lc:  new   RegExp("(-[^_-]+)|(_-\\d+)|(_\\w+)",  "g"),
    mc:{
      "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",
      "replace":"array",
      "target":"array" 
   },
    Ka:  function(za,  nc,  oc)
   {
      var   pc  =  null;
      var   qc  =  this.Sb(nc  +  "\\b-?([\\w\\-\\_]*)\\b");

      var   matches  =  za.className.match(qc);
      if  (matches)
     {
        pc  = {};
        if  (oc)
          for  (var   ma   in   oc)
            pc[ma] =  oc[ma];

        pc.rc  =  matches[0].split("-")[0];

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

      return   pc;
   },



    tc:  null,
    uc:  function()
   {
      this.tc  = {
        vc:null,
        setData:[]
     };
   },
    
    wc:  function()
   {
      var   xc  =  this.tc;

      this.tc  =  null;

      if  (xc.setData.length  >  0)
     {
        var   yc  =  this.zc(xc.Ac,  xc.vc.className,  false);

        d.wa.xa(d.l,  xc.vc,  yc);

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

        d.wa.xa(d.m,  xc.vc,  yc);
     }
   },

    Cc:  function(za,  pc)
   {
      for  (var   name   in   pc)
        switch  (name)
       {
          case   "add":
            this.add(za,  pc[name]);
            break;
          case   "remove":
            this.remove(za,  pc[name]);
            break;
          case   "replace":
            this.replace(za,  pc[name][0],  pc[name][1]);
            break;
          case   "set":
            this.ga(za,  pc[name]);
            break;
          case   "empty":
            this.ga(za,  "");
            break;
       }
   },
    Sb:  function(qb)
   {
      return   this.Mb[qb] || (this.Mb[qb] =  new   RegExp("(?:^|\\b)"  +  qb  +  "(?:\\b|$)",  "g"));
   },
    Yb:  function(za,  Wb,  Xb,  Ub,  Dc)
   {
      Xb  =  Xb.replace(/^\s+|\s+$/g,  "");
      if  (Xb  !=  Wb)
     {
        if  (this.tc)
       {
          var   Ec  =  d.Ga.Gb(this.tc.vc,  za);
          if  (Ec  !=  this.tc.vc)
         {
            this.tc.vc  =  Ec;
            this.tc.Ac  =  Ec.className;
         }

          this.tc.setData.push(
           {
              za:za,
              Wb:Wb,
              Xb:Xb 
           }
         );
       }
        else 
       {
          if  (!Ub)
         {
            var   Fc  =  this.zc(Wb,  Xb,  Dc);
            d.wa.xa(d.l,  za,  Fc);
         }
          za.className  =  Xb;
          if  (!Ub)
            d.wa.xa(d.m,  za,  Fc);

          if  (d.R)
         {
            
            
            
            
            if  (za.getAttribute("tabIndex",  2) ==  0)
           {
              za.tabIndex  = -1;
              setTimeout(function(){  za.tabIndex  =  0; },  0);
           }
         }
       }
     }
   },
    Vb:  function(za,  Zb,  qb,  Gc,  Ub)
   {
      var   data  =  this.Nb[qb];
      var   Pb  =  data.Pb;

      var   Tb  =  Pb[Gc] +  "-"  +  qb;

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

      if  (Zb  &&  this.contains(za,  Zb))
        this.replace(za,  Zb,  Tb,  Ub,  true);
      else 
        this.add(za,  Tb,  Ub,  true);

      var   Hc  =  this;
      if  (Gc  <  Pb.length-1)
        d.oa.pa(function(){  Hc.Vb(za,  Tb,  qb,  Gc+1,  Ub); },  data.ua);
      else 
        d.oa.pa(function(){  if  (Hc.contains(za,  Tb))  Hc.replace(za,  Tb,  qb,  Ub,  true); },  data.ua);
   },
    
    zc:  function(Wb,  Xb,  Dc)
   {
      var   Ic  =  Wb.split(this.Lb);
      var   Jc    =  Xb.split(this.Lb);

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

        var   Lc  =  Ic[i].split(/[-_]/);
        for  (var   Mc=0;  Mc<Lc.length;  Mc++)
          Kc[Lc[Mc]]=  1;
     }

      var   addCNs  = [];
      for  (var   i=0;  i<Jc.length;  i++)
     {
        if  (!Kc[Jc[i]])
          addCNs.push(Jc[i]);
        var   Nc  =  Jc[i].split(/[-_]/);
        for  (var   Mc=0;  Mc<Nc.length;  Mc++)
          if  (!Kc[Nc[Mc]])
            addCNs.push(Nc[Mc]);
     }

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

      return  {  fromValue:  Wb,  toValue:Xb,  delCNs:delCNs,  addCNs:addCNs,  Dc:Dc  };
   }
};

 d.W(d.Ja);

 d["ClassNameAbstraction"] =  d.Ja;
 d.Ja["addClassNameSequence"] =  d.Ja.Ob;
 d.Ja["contains"] =  d.Ja.contains;
 d.Ja["add"] =  d.Ja.add;
 d.Ja["replace"] =  d.Ja.replace;
 d.Ja["swap"] =  d.Ja.gc;
 d.Ja["toggle"] =  d.Ja.ec;
 d.Ja["remove"] =  d.Ja.remove;
 d.Ja["set"] =  d.Ja.ga;
 
 
 

 
 
 
 
 
 
 
 
 

 
 
 

 
 
 
 
 
 
 

 d.Oc  = {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

    Pc:  false,
    Qc: {},
    Rc:{},
    
    Sc:  function(Tc,  Uc,  qa,  X)
   {
      var   Vc  = {qa:qa,  X:X};
      var   Wc  =  d.Ga.lb(Tc) +  "-"  +  Uc;

      var   Xc  =  this.Qc[Wc];
      if  (this.Rc[Wc] ==  Tc  &&  Xc)
        Xc.push(Vc);
      else 
     {
        this.Rc[Wc] =  Tc;
        Xc  =  this.Qc[Wc] = [Vc];

        var   va  =  function(Yc)
       {
          
          
          
          
          if  ((typeof(d) !=  "undefined") && (!d.T  ||  document.defaultView))
         {
 

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

            Yc  =  d.Oc.Zc(Yc);

            
            
            if  (Yc.type  ==  d.D  &&  d.T  &&  Yc._d)
              return   false;

            var   ib  =  false;

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

            if  (Yc.ad  ==  true)
              d.Oc.bd(Yc);

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

            return   ib;
         }
       };
        if  (d.Y)
       {
          var   X  = {  cd:va  };
          d.Y.ed(X,  "eventHandler",  "Spif.DOMEvents."  +  Uc);
          va  =  X.cd;
       }

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

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

    fd:  function()
   {
      this.ad  =  true;
   },
    bd:  function(Yc)
   {
      Yc.preventDefault();
      Yc.stopPropagation();

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

        if  (za)
       {
          za.gd  =  za.href;
          za.href  =  "javascript://";
          setTimeout(function(){  za.href  =  za.gd; },  10);
       }
     }
   },
    hd:  function()
   {
      this.returnValue  =  false;
   },
    jd:  function()
   {
      this.cancelBubble  =  true;
   },

    Zc:  function(Yc)
   {
 
      if  (d.R)
     {
        Yc.subject  =  Yc.srcElement;
        Yc.preventDefault   =  this.hd;
        Yc.stopPropagation  =  this.jd;
     }
      else 
     {
        Yc.subject  =  Yc.target  ||  Yc.currentTarget;
        if  (Yc.subject  &&  Yc.subject.nodeType  ==  3)
          Yc.subject  =  Yc.subject.parentNode;
     }

      Yc.cancel  =  this.fd;

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

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

      return   Yc;
   }
};

 d["DOMEvents"] =  d.Oc;
 d.Oc["attach"] =  d.Oc.Sc;
 d.wa  = {
    md: {},
    nd:  function(Uc,  qa,  X)
   {
      var   od  =  this.md[Uc] =  this.md[Uc] || [];

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

      var   od  =  this.md[Uc];
      if  (od)
     {
        var   Yc  =  ea  || {};
        Yc.type  =  Uc;
        Yc.subject  =  subject;

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

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


 d.pd  = {
    ba:  function()
   {
      d.wa.nd(d.m,  this.qd,  this);
      d.wa.nd(d.o,  this.rd,  this);
      d.Oc.Sc(document.documentElement,  "DOMMouseScroll",    this.sd,  this);
   },
    qd:  function(Yc)
   {
      if  (Yc.addCNs.length  >  0  &&  d.wa.xa(d.r,  Yc.subject))
        this.ud(Yc.subject,  Yc.addCNs);
   },
    rd:  function(Yc)
   {
      if  (d.wa.xa(d.r,  Yc.subject))
        this.ud(Yc.subject, [d.C]);
   },
    ud:  function(vd,  wd,  context)
   {
      var   xd  =  false;

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

      var   yd  =  "\\bon"  +  wd.join("\\b|\\bon") +  "\\b";
      for  (var   zd  =  vd.firstChild;  zd;  zd  =  zd.nextSibling)
        if  (zd.nodeName  ==  "A"  &&  d.Ja.contains(zd,  yd))
       {
          d.wa.xa(d.v,  zd, {  context:context  });
          xd  =  true;
       }

      return   xd;
   },
    sd:  function(Yc)
   {
      var   Ad  =  false;
      var   Uc  = ["mousescroll"  + (Yc.detail>0?"down":"up")];
      for  (var   za  =  Yc.subject;  za;  za  =  za.parentNode)
        Ad  =  Ad  ||  this.ud(za,  Uc,  null);

      if  (Ad)
        Yc.cancel();
   }
};

 d.W(d.pd);
 
 
 
 
 
 
 
 
 
 
 
 
 

 d.Bd  = {
    Cd:[],
    Dd:  null,
    Ed:{},
    Fd:{},
    Gd:  null,
    Hd:  null,
    Id:  false,
    ba:  function()
   {
      d.Oc.Sc(document.documentElement,  d.D,    this.Jd,  this);

      
      
      
      d.Oc.Sc(document.documentElement, (d.R?d.F:d.G),  this.Jd,  this);
   },
    Kd:  function(qb,  qa,  X)
   {
      this.Ld(qb,  qa,  X,  true);
   },
    Md:  function(qb,  qa,  X)
   {
      this.Ld(qb,  qa,  X,  false);
      this.Id  =  true;
   },
    Ld:  function(qb,  qa,  X,  Nd)
   {
      this.Cd[this.Cd.length] =  qb;
      this.Ed[qb] = {  qa:qa,  X:X  };
      this.Fd[qb] =  Nd;

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

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

      if  (!this.Id  && !this.Hd)
        return;

      this.Gd  =  Yc;
      var   ob  = [];

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

      for  (var   i=0;  i<ob.length;  i++)
     {
        this.Od  =  ob[i];
        if  (this.Od.className)
          this.Od.className.replace(this.Dd,  this.Pd);
     }
   },
    Pd:  function()
   {
      if  (!arguments[arguments.length-3])
     {
        var   Hc  =  d.Bd;
        for  (var   i=1;  i<arguments.length-3;  i++)
          if  (arguments[i])
         {
            var   qb  =  Hc.Cd[i-1];
            if  (Hc.Hd  || !Hc.Fd[qb])
           {
              if  (d.wa.xa(d.r,  Hc.Od))
             {
                var   qa  =  Hc.Ed[qb];
                qa.qa.apply(qa.X  ||  Hc.Od, [Hc.Od,  arguments[i],  Hc.Gd]);
             }
              return;
           }
         }
     }
   }
};

 d.W(d.Bd);
 
 
 


 d.Qd  = {
    Rd:[],
    Sd:"",
    Td:{},
    Ud:{},
    Vd:[],

    ba:  function()
   {
      d.Oc.Sc(document.documentElement,  d.D,      this.Wd,  this);
      d.Oc.Sc(document.documentElement,  "dblclick",      this.Wd,  this);
      d.Oc.Sc(document.documentElement,  "keyup",   this.Xd,  this);
      d.wa.nd(d.v,  this.Yd,  this);
   },
    Zd:  function(_e,  X)
   {
      this.Vd.push({qa:_e,  X:X});
   },
    ae:  function(be,  ce,  _e,  X)
   {
      var   de  =  "("  +  ce.join("|") +  ")";
      for  (var   i=0;  i<be.length;  i++)
     {
        var   nc  =  be[i];
        this.Rd[this.Rd.length] =  nc;
        this.Td[nc] =  de;
        this.Ud[nc] = {  qa:_e,  X:X};
     }

      this.Sd  =  "(\\b"  +  this.Rd.join("\\b|\\b") +  "\\b)";
   },
    Wd:  function(Yc)
   {
      this.Yd(Yc);
   },
    Xd:  function(Yc)
   {
      if  (Yc.keyCode  ==  32  ||  Yc.keyCode  ==  13)
        this.Yd(Yc);
   },
    Yd:  function(Yc)
   {
 
      var   be;
      var   za  =  Yc.subject;

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

        if  ((be  =  d.Ja.match(za,  this.Sd)) &&  d.wa.xa(d.r,  za))
       {
          var   ee  = {};

          for  (var   i=0;  i<be.length;  i++)
         {
            var   nc  =  be[i];
            if  (nc  && !ee[nc])
           {
              var   fe  =  d.Ja.Ka(za,  nc);
              if  (
               (!fe["require"] ||  d.Ga.Ha(za,  fe["require"]))
               &&
               (!fe["disallow"] || !d.Ga.Ha(za,  fe["disallow"]))
             )
             {
                var   ge  =  this.he(za,  nc,  Yc.context);
                if  (!ge  || !ge.za  || !d.wa.xa(d.r,  ge.za))
                  continue;

                var   ie  =  d.Ja.Ka(ge.za,  ge.je);
                if  (
                  ie 
                 &&
                 (!ie["require"] ||  d.Ga.Ha(za,  ie["require"]))
                 &&
                 (!ie["disallow"] || !d.Ga.Ha(za,  ie["disallow"]))
               )
                  ee[nc] = {
                    ke:  this.Ud[nc],
                    ge:  ge,
                    fe:  fe,
                    ie:  ie 
                 };
           }
           }
         }

          for  (nc   in   ee)
         {
            var   le  =  ee[nc];
            d.oa.pa(this.me(Yc,  za,  nc,  le),  1*le.fe.delay||-1);
         }
       }

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

        za  =  za.parentNode;
     }
   },

    me:  function(Yc,  za,  nc,  le)
   {
      return   function()
     {
        le.ke.qa.apply(le.ke.X  ||  za, [za,  nc,  le.ge.za,  le.ge.je,  Yc,  le.fe,  le.ie]);
     };
   },

    he:  function(ne,  nc,  context)
   {
      var   oe  =  this.pe(ne,  nc,  context);

      if  (oe)
     {
        var   qe  =  d.Ja.match(oe,  this.Td[nc]);
        return  {  za:oe,  je:(qe?qe[0]:null) };
     }
   },
    pe:  function(ne,  nc,  context)
   {
      var   re  =  ne.href;
      if  (re)
        var   se  =  re.split("#")[1];
      
      if  (se)
        return   document.getElementById(se);

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

 d.W(d.Qd);
 
 
 
 
 
 
 
 
 
 
 

 d.wa.nd(
    d.r,
    function(Yc)
   {
      return  !d.Ga.Ha(Yc.subject,  "(^|\\s)disabled(\\s|$)");
   }
);
(function(){
 d.te  = {
    ue:"exclusive-",
    ve:"(allexclusive-|exclusive-)",
    we:"delayexclusive",
    xe:"exclusive-reset",

    ye:1,
    ze:{},
    Ae:{},
    Be:{},
    Ce:{},
    De:{},
    Ee:{},
    Fe:{},
    Ge: {},

    ba:  function()
   {
      d.wa.nd(d.j,  this.He,  this);
      d.wa.nd(d.m,  this.qd,  this);
   },

    Ie:  function(be,  Je,  Ke,  Le)
   {
      var   id  =  this.ye++;
      var   Me  =  Je[Je.length  -  1];
      for  (var   i=0;  i<be.length;  i++)
     {
        var   nc  =  be[i];
        var   Ne  =  Je[i];

        this.Be[Me] =  Ne;
        this.Ce[Ne] =  Me;

        Me  =  Ne;

        this.ze[nc] =  Ne;
        this.Ae[Ne] =  nc;
        this.De[nc] =  id;
     }

      if  (Ke)
     {
        for  (var   i=0;  i<Ke.length;  i++)
       {
          be[be.length] =  Ke[i];
          this.Ee[Ke[i]] =  true;
          this.ze[Ke[i]] =  Je[0];
       }
     }
      if  (Le)
     {
        for  (var   i=0;  i<Le.length;  i++)
       {
          be[be.length] =  Le[i];
          this.Fe[Le[i]] =  true;
          this.ze[Le[i]] =  Je[0];
       }
     }

      d.Qd.ae(be,  Je,  this.Oe,  this);
   },

    He:  function()
   {
      this.Ge  = {};
   },
    qd:  function(Yc)
   {
      var   Pe  = [];

      for  (var   i=0;  i<Yc.addCNs.length;  i++)
        this.Qe(Yc.subject,  Yc.addCNs[i],  Pe);

      for  (var   i=Pe.length-1;  i>=0;  i--)
        this.Re(Pe[i]);
   },
    Oe:  function(ne,  nc,  oe,  Se)
   {
      var   Pe  = [];
      this.Te(Pe,  nc,  oe,  Se);

      d.Ja.uc();
      for  (var   i=Pe.length-1;  i>=0;  i--)
        this.Re(Pe[i]);
      d.Ja.wc();
   },     
    Te:  function(Pe,  nc,  oe,  Se)
   {
      var   Ue  =  this.ze[nc];

      if  (this.Ee[nc])
     {
        Ue  =  this.Be[Se];
        nc  =  this.Ae[Ue];
     }
      else   if  (this.Fe[nc])
     {
        Ue  =  this.Ce[Se];
        nc  =  this.Ae[Ue];
     }

      if  (!d.Ja.contains(oe,  Ue))
     {
        Pe[Pe.length] = {
          nc:nc,
          oe:oe,
          Ve:Se,
          Ue:Ue,
          delay:-1 
       };

        this.Qe(oe,  Ue,  Pe);
     }
   },

    Qe:  function(oe,  Ue,  Pe)
   {
      var   We,  Xe;
      
      if  (We  =  d.Ga.Ha(oe,  this.ve  +  Ue,  this.xe))
        if  (d.Ja.contains(We,  this.ue  +  Ue))
          Xe  =  oe.parentNode.childNodes;
        else 
          Xe  =  d.Ga.getElementsByTagName(We,  d.f);
      
      if  (Xe)
     {
        var   Ye  =  this.Be[Ue];
        var   Ze  =  this.Ae[Ye];

        var   _f  =  Xe.length;
        for  (var   i=0;  i<_f;  i++)
       {
          var   af  =  Xe[i];

          if  (af.nodeType  ==  1  &&  af  !=  oe  &&  d.Ja.contains(af,  Ue))
            if  (d.wa.xa(d.r,  af))
           {
              if  (Pe.length  >  0  &&  Pe[Pe.length-1].delay  == -1)
                Pe[Pe.length-1].delay  =  d.oa.Ya(oe.parentNode,  this.we, -1);

              this.Te(Pe,  Ze,  af,  Ue);
           }
       }
     }
   },
    
    Re:  function(bf)
   {
      var   cf  =  d.Ga.lb(bf.oe) +  "-"  +  this.De[bf.nc];
      if  (!this.Ge[cf])
     {
        this.Ge[cf] =  true;
        
        d.oa.pa(
          function()
         {
            
            d.Ja.replace(bf.oe,  bf.Ve,  bf.Ue,  d.M);
         },
          bf.delay 
       );
   }
   }
};

 d.W(d.te);

 d["Behaviors"] =  d.te;
 d.te["addStateSequence"] =  d.te.Ie;

 
 d.te.Ie(["collapser",  "expander"],    ["collapsed",  "expanded"],   ["expandedToggle",  "expandcollapser"]);
 d.te.Ie(["opener",     "closer"],      ["open",       "close"],      ["openToggle"]);
 d.te.Ie(["selector",   "unselector"],  ["selected",   "unselected"], ["selectedToggle"]);
 d.te.Ie(["shower",     "hider"],       ["shown",      "hidden"],     ["shownToggle",  "showswitch"]);
 d.te.Ie(["focuser",    "blurrer"],     ["focus",      "blur"],       ["focusToggle"]);
 d.te.Ie(["onswitch",   "offswitch"],   ["on",         "off"],        ["onToggle"]);
 d.te.Ie(["enabler",    "disabler"],    ["enabled",    "disabled"],   ["enabledToggle"]);
 d.te.Ie(["checker",    "unchecker"],   ["checked",    "unchecked"],  ["checkedToggle"]);
})();
 d.Qd.ae(
   ["classchanger"],
   [],
    function(ne,  x,  oe,  Se,  Yc,  fe,  ie)
   {
      d.oa.pa(
        function()
       {
          d.Ja.Cc(oe,  fe);
       },
        fe["delay"]
     );
   }
);
 d.Qd.ae(
   ["execute"],
   [],
    function(ne,  nc,  oe,  Se,  Yc,  fe,  ie)
   {
      var   ra  =  fe[fe.action];
      ra  = (ra!=true?ra.split("_"):null);
      d.oa.Ma(fe.action)(ne,  oe,  ra);
   }
);
 d.df  =
{
    ef:  "activation-inert",
    ff:  "delayOn",
    gf:  "delayOff",
    hf:  "delaySwitch",
    jf: [],
    kf: [],
    lf:{},
    mf: [],
    nf: {},
    of: {},
    pf:  null,

    qf: {},
    rf: {},
    sf: {},
    tf: {},
    uf: {},
    vf: {},

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

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

      d.Oc.Sc(document.documentElement,  "mouseover",  this.yf,  this);

      d.Oc.Sc(document.documentElement,  d.D,  this.Yd,  this);
      d.Oc.Sc(document.documentElement,  "contextmenu",  this.Yd,  this);
      d.Oc.Sc(document.documentElement,  "keyup",  this.Yd,  this);

      d.wa.nd(d.m,  this.qd,  this);
   },
    wf:  function(zf,  Af)
   {
      if  (zf)
     {
        this.jf.push(zf);
        this.lf[zf] =  Af;
     }
      if  (Af)
     {
        this.jf.push(Af);
        this.lf[Af] =  Af;
     }
      this.Bf  =  "("  +  this.jf.join("\\b|\\b") +  ")";
      this.of[zf] =  Af;
      this.of[Af] =  zf;
   },
    xf:  function(Cf,  Df,  Ef,  Ff)
   {
      if  (Cf)
        this.mf.push(Cf);
      if  (Df)
     {
        this.lf[Df] =  Df;
        if  (Cf)
          this.lf[Cf] =  Df;
        this.kf.push(Df);
     }
      this.Gf  =  "("  +  this.kf.join("\\b|\\b") +  ")";
      this.Hf  =  "("  +  this.mf.join("\\b|\\b") +  ")";
      this.If  =  "("  +  this.kf.join("\\b|\\b") +  "\\b|\\b"  +  this.mf.join("\\b|\\b") +  ")";
      this.of[Cf] =  Df;
      this.of[Df] =  Cf;

      if  (Ef  &&  Ff)
     {
        this.nf[Ef] =  Ef;
        d.Qd.ae([Ef,  Ff], [Df,  Cf],  this.Jf,  this);
     }
   },

    Jf:  function(ne,  nc,  oe,  Se)
   {
      var   Kf  =  d.Ga.lb(oe);
      var   pc  =  d.Ja.Ka(oe,  this.If);
      var   data  = {  za:oe,  pc:pc  };
      if  (this.nf[nc])
        this.Lf(Kf,  data,  this.uf,  this.tf,  this.vf);
      else 
     {
        pc.rc  =  this.of[pc.rc];
        this.Mf(Kf,  data,  this.uf,  this.tf,  this.vf);
     }
   },

    yf:  function(Yc)
   {
      this.Nf(Yc,  this.Bf,  this.rf,  this.qf,  this.sf);
   },

    Yd:  function(Yc)
   {
      var   za  =  Yc.subject;
      
      if  (za  !=  this.pf)
     {
        this.pf  =  za;

        if  (!d.Ga.Ha(za,  this.ef))
       {
          this.Nf(
            Yc,
            this.If,
            this.uf,
            this.tf,
            this.vf,
            d.Ga.Ha(za,  this.ef) !=  null,
            Yc.ctrlKey  ||  d.Ga.Ha(za,  this.ef) !=  null,
            d.Ga.Ha(za,  "activation-box")
         );

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

    qd:  function(Yc)
   {
      if  (!d.Ja.Rb(Yc.fromValue,  this.Gf) &&  d.Ja.Rb(Yc.toValue,  this.Gf))
        
        this.Yd(Yc);
      else   if  (d.Ja.Rb(Yc.fromValue,  this.Gf) && !d.Ja.Rb(Yc.toValue,  this.Gf))
     {
        var   Kf  =  d.Ga.lb(Yc.subject);
        delete   this.qf[Kf];
     }
   },

    Nf:  function(Yc,  Of,  Pf,  Qf,  Rf,  Sf,  Tf,  Uf)
   {
      var   Vf  = {};

 
 
      var   za  =  Yc.subject;
      while  (za  &&  za.nodeType  ==  1)
     {
        var   pc  =  d.Ja.Ka(za,  Of);
        if  (
          pc 
         && (!pc["require"]  ||   d.Ga.Ha(za,  pc["require"]))
         && (!pc["disallow"] || !d.Ga.Ha(za,  pc["disallow"]))
       )
          Vf[d.Ga.lb(za)] = {  za:za,  pc:pc  };

        za  =  za.parentNode;
     }   

      this.Wf  =  false;

 
 
      if  (!Tf)
        for  (var   Kf   in   Qf)
          if  (!Vf[Kf] && (!Uf  ||  d.Ga.Db(Uf,  Qf[Kf].za)))
            this.Mf(Kf,  Qf[Kf],  Pf,  Qf,  Rf);

      if  (!Sf)
        for  (var   Kf   in   Vf)
          if  (!Qf[Kf] && (!Uf  ||  d.Ga.Db(Uf,  Vf[Kf].za)))
            this.Lf(Kf,  Vf[Kf],  Pf,  Qf,  Rf);
   },
    
    Lf:  function(Kf,  data,  Pf,  Qf,  Rf)
   {
 
      if  (!Qf[Kf] &&  d.wa.xa(d.r,  data.za))
     {
        if  (Rf[Kf])
          this.Xf(Kf,  Rf);
        else 
       {
          var   delay  = (this.Wf?data.pc[this.hf]:0) ||  data.pc[this.ff];
          if  (delay)
         {
            Pf[Kf] =  data;
            data.Yf  =  d.oa.pa(this.Zf,  delay,  this, [Kf,  data,  Pf,  Rf]);
         }
          else 
            this._g(Kf,  data,  Rf);
       }
        Qf[Kf] =  data;
     }
   },
    Mf:  function(Kf,  data,  Pf,  Qf,  Rf)
   {
 
      if  (Qf[Kf] &&  d.wa.xa(d.r,  data.za))
     {
        if  (Pf[Kf])
          this.ag(Kf,  Pf[Kf],  Pf,  Qf);
        else 
       {
          this.Wf  =  true  &&  data.pc[this.hf];
          if  (data.pc[this.gf])
         {
            Rf[Kf] =  data;
            data.Yf  =  d.oa.pa(this.bg,  data.pc[this.gf],  this, [Kf,  Rf]);
         }
          else 
            this.cg(Kf,  data);

          delete   Qf[Kf];
       }
     }
   },
    ag:  function(Kf,  data,  Pf,  Qf)
   {
      clearTimeout(data.Yf);
      delete   Pf[Kf];
      delete   Qf[Kf];
   },
    Zf:  function(Kf,  data,  Pf,  Rf)
   {
      delete   Pf[Kf];
      this._g(Kf,  data,  Rf);
   },
    _g:  function(Kf,  data,  Rf)
   {
      d.Ja.replace(data.za,  this.of[this.lf[data.pc.rc]],  this.lf[data.pc.rc]);

      var   We  =  d.Ga.Ha(data.za,  "exclusive"  +  this.of[data.pc.rc]);
      for  (var   Kf   in   Rf)
        if  (We  &&  d.Ga.Ha(Rf[Kf].za,  "exclusive"  +  this.of[data.pc.rc]) ==  We)
       {
          this.cg(Kf,  Rf[Kf]);
          this.Xf(Kf,  Rf);
       }
   },
    bg:  function(Kf,  Rf)
   {
      this.cg(Kf,  Rf[Kf]);
      delete   Rf[Kf];
   },
    Xf:  function(Kf,  Rf)
   {
      clearTimeout(Rf[Kf].Yf);
      delete   Rf[Kf];
   },
    cg:  function(Kf,  data)
   {
      d.Ja.replace(data.za,  this.lf[data.pc.rc],  this.of[this.lf[data.pc.rc]]);
   }
};

 d.W(d.df);

 
 
 
 

 

 d.dg  = {
    eg:1,
    fg:2,
    gg:3,
    hg:4,
    ig:5,
    jg:6,
    kg:7,
    lg:8,
    mg:9,
    ng:null,
    ba:  function()
   {
      if  (d.R)
     {
        this.og  =  this.pg;
        this.qg  =  this.rg;
     }
      d.dg["getRawComputedStyleProperty"] =  d.dg.og;

      this.ng  = {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        "borderWidth":this.fg,
        "borderTopWidth":this.fg,
        "borderRightWidth":this.fg,
        "borderBottomWidth":this.fg,
        "borderLeftWidth":this.fg,
        "width":this.gg,
        "height":this.gg,
        "scrollTop":this.hg,
        "scrollLeft":this.hg,
        "color":this.ig,
        "backgroundColor":this.ig,
        "borderColor":this.ig,
        "borderTopColor":this.ig,
        "borderRightColor":this.ig,
        "borderBottomColor":this.ig,
        "borderLeftColor":this.ig,
        "opacity":this.jg,
        "zoom":this.kg,
        "display":this.lg,
        "overflow":this.lg,
        "position":this.lg,
        "visibility":this.lg,
        "zIndex":this.mg 
     };

      this.sg  = {};
      this.sg[this.eg] =  "px";
      this.sg[this.fg] =  "px";
      this.sg[this.gg] =  "px";
      this.sg[this.hg] =  "px";
      this.sg[this.ig] =  "";
      this.sg[this.jg] =  "%";
      this.sg[this.kg] =  "%";
      this.sg[this.lg] =  "";
      this.sg[this.mg] =  "";
   },
    tg:{
      "width":["offsetWidth"],
      "height":["offsetHeight"]
   },
    ug:{
      "width":["height",  "offsetHeight"],
      "height":["width",  "offsetWidth"]
   },

    vg:  function(za,  Z)
   {
      var   wg  =  this.og(za,  Z);
      return   this.qg(za,  Z,  wg).value;
   },

    og:  function(za,  Z,  xg)
   {
      var   yg  =  this.zg(Z);
      var   Ag  =  document.defaultView.getComputedStyle(za,  "");

      if  (Ag)
        switch  (this.Bg(Z))
       {
          case   this.gg:
            if  (d.Q)
           {
              var   Cg  =  this.tg[Z];
              var   db  =  za[Cg[0]];
              for  (var   i=1;  i<Cg.length;  i++)
                db  -=  parseInt(za.currentStyle[Cg[i]]);
              return   Math.max(0,  db);
           }
          case   this.fg:
            if  (Ag.getPropertyValue(yg.replace(/width/,  "style")) ==  d.h)
              return   0;
          case   this.mg:
          case   this.eg:
          case   this.kg:
          case   this.jg:
            return   Ag.getPropertyValue(yg);
          case   this.hg:
            return   za[Z];
            break;
          case   this.ig:
            if  (
              yg.indexOf("border") != -1 
             &&  Ag.getPropertyValue(yg.replace(/color/,  "style")) ==  d.h 
           )
              return   null;
            
          case   this.lg:
            return   Ag.getPropertyValue(yg);
       }

      return   null;
   },
    qg:  function(za,  Z,  wg)
   {
      var   Dg  =  this.Bg(Z);

      var   X  = {  value:  wg  };

      switch  (Dg)
     {
        case   this.mg:
        case   this.eg:
        case   this.kg:
          var   Eg  =  parseInt(wg);
          if  (isNaN(Eg))
            switch  (wg)
           {
              case   "auto":  X.value  =  0;  break;
              default:  X.value  =  null;
           }
          else 
            X.Fg  = (""  +  wg).replace(/^[-\d]+/,  "") ||  null;
          X.value  =  Eg;
          break;
        case   this.jg:
          X.value  =  Math.round(100*wg);
          break;
        case   this.ig:
          X.value  =  this.Gg(wg);
          break;
        case   this.gg:
        case   this.hg:
          X.value  =  parseInt(wg);
     }

      return   X;
   },


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

      switch  (this.Bg(Z))
     {
        case   this.gg:
 
 
 
            
            
            var   Hg  =  za[this.ug[Z][1]] ==  0;
            if  (Hg)
              za.runtimeStyle[this.ug[Z][0]] =  "1px";

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

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

            if  (Hg)
              za.runtimeStyle[this.ug[Z][0]] =  "";
 

          return   db;
        case   this.hg:
          return   za[Z];
          break;
        case   this.jg:
          try 
         {
            return   za.filters.item(d.K).opacity;
         }
          catch(Ig)
         {
            return   100;
         }
          break;
        case   this.eg:
        case   this.kg:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        default:
          return   za.currentStyle[Z];
     }
   },

    rg:  function(za,  Z,  wg)
   {
      var   Dg  =  this.Bg(Z);

      var   X  = {  value:  wg  };
      var   Eg  =  null;

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

      switch  (Dg)
     {
        case   this.gg:

 Eg  =  parseInt(wg);

          X.Fg  = (""  +  wg).replace(/^[-\d\.]+/,  "") ||  null;
          X.value  =  Math.max(0,  Eg);
          break;
        case   this.ig:
          X.value  =  this.Gg(wg);
          break;
        case   this.fg:
        case   this.mg:
        case   this.eg:
        case   this.kg:
          Eg  =  parseInt(wg);
          if  (isNaN(Eg))
            switch  (wg)
           {
              case   "auto":  Eg  =  0;  break;
              case   "thin":  Eg  =  2;  break;
              case   "medium":  Eg  =  4;  break;
              case   "thick":Eg  =  6;  break;
              default:  Eg  =  parseInt(wg);
           }
          else 
            X.Fg  = (""  +  wg).replace(/^[-\d\.]+/,  "") ||  null;

          X.value  =  Eg;
          break;
     }

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

      return   X;
   },

    Jg:  function(za,  Z,  db)
   {
      switch  (this.Bg(Z))
     {
        case   this.ig:
          za.style[Z] =  "rgb("  +  db.join(",") +  ")";
          break;
        case   this.lg:
        case   this.mg:
          za.style[Z] =  db;
          break;
        case   this.gg:
        case   this.kg:
        case   this.fg:
        case   this.eg:
          za.style[Z] =  db  +  "px";
          break;
        case   this.hg:
          za[Z] =  db  +  "px";
          break;
     }
   },

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

    Bg:  function(Z)
   {
      return   this.ng[Z] ||  this.eg;
   },

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

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

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

 d.W(d.dg);

 d["StyleUtils"] =  d.dg;
 d.dg["getComputedStyleProperty"] =  d.dg.vg;
 
 
 d.Animator  =  _a  = {
    Og:{},
    animate:  function(Pg,  Qg)
   {
      var   Rg  =  Pg.length;

 
 
 
 
 
 
 
 
 
 
 
      var   Sg  =  10;
      var   Tg  =  1  <<  Sg;

      var   Ug  =  7;
      var   Vg  =  1  <<  Ug;

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

      var   Xg  = [];
      var   Yg  = [];
      var   Zg  = [];


      for  (var   i=0;  i<Rg;  i++)
     {
        var   _h  =  Pg[i];
        var   za  =  _h.element;
        var   id  =  d.Ga.lb(za);
        var   ah  =  _h.targetState;

        for  (var   bh   in   ah)
       {
          var   ch  =  bh;
          if  (!d.R)
            ch  =  bh.replace(/([A-Z])/g,  function(Lg){  return   "-"  +  Lg.toLowerCase(); });

          var   dh  =  ah[bh];

          
          var   eh  = (_h.currentState&&typeof(_h.currentState[bh])!=d.e)?_h.currentState[bh]:d.dg.vg(za,  bh);

          if  (bh  ==  "zoom")
         {
            
            eh  *=  100;
            dh  *=  10000;
         }

          
          _a[id  +  "el"] =  za;
          switch  (d.dg.Bg(bh))
         {
            case   d.dg.hg:
                _a[id  +  "elscroll"] = (za  !=  document.body  ||  document.compatMode  ==  "BackCompat")?za:document.documentElement;
              break;
            case   d.dg.jg:
              if  (d.R)
             {
                _a[id  +  "opacity"] =  za.filters.item(d.K);
                break;
             }
              
            default:
              _a[id  +  "elStyle"] =  za.style;

              if  (Qg.removeAfterwards)
 
                Zg.push("_a[\"",  id,  "elStyle\"]."  +  bh  +  "='';\n");
         }

          
          if  (d.dg.Bg(bh) ==  "rgb")
            dh  =  d.dg.Gg(dh);

          if  (dh.constructor  ==  Array)
         {
            var   fh  = [];
            for  (var   Mc=0;  Mc<dh.length;  Mc++)
              fh[Mc] =  Math.floor(dh[Mc] -  eh[Mc]);
         }
          else   if  (!isNaN(dh))
         {
            var   fh  =  Math.floor(dh-eh);
         }

          var   gh  = (_h.units  &&  _h.units[bh])?" + '"  +  _h.units[bh] +  "';\n":_a.hh;

          
          switch  (d.dg.Bg(bh))
         {
            case   d.dg.ig:
              if  (d.R)
             {
                if  (bh  ==  "borderColor")
                  Yg.push(
                    '_a["',  id,  'elStyle"].',  bh,  '=["rgb(",',
                    '(',  Math.floor(Vg*(eh[0]+0.5)),  '+cP*',  fh[0],  ')>>',  Ug,  ',",", ',
                    '(',  Math.floor(Vg*(eh[1]+0.5)),  '+cP*',  fh[1],  ')>>',  Ug,  ',",", ',
                    '(',  Math.floor(Vg*(eh[2]+0.5)),  '+cP*',  fh[2],  ')>>',  Ug,  ', ")"].join("");\n' 
                 );
                else 
                  Yg.push(
                    '_a["',  id,  'elStyle"].',  bh,  '=',
                    '((',  Math.floor(Vg*(eh[0]+0.5)),  '+cP*',  fh[0],  ')>>',  Ug,  '<<16) | ',
                    '((',  Math.floor(Vg*(eh[1]+0.5)),  '+cP*',  fh[1],  ')>>',  Ug,  '<<8) | ',
                    '((',  Math.floor(Vg*(eh[2]+0.5)),  '+cP*',  fh[2],  ')>>',  Ug,  ');\n' 
                 );
             }
              else 
                Yg.push(
                  '_a["',  id,  'elStyle"].',  bh,  '=["rgb(",',
                  '(',  Math.floor(Vg*(eh[0]+0.5)),  '+cP*',  fh[0],  ')>>',  Ug,  ',",", ',
                  '(',  Math.floor(Vg*(eh[1]+0.5)),  '+cP*',  fh[1],  ')>>',  Ug,  ',",", ',
                  '(',  Math.floor(Vg*(eh[2]+0.5)),  '+cP*',  fh[2],  ')>>',  Ug,  ', ")"].join("");\n' 
               );
              break;
            case   d.dg.jg:
              Yg.push('try{_a["',  id, (d.R?'opacity"].opacity=(':'elStyle"].opacity=(('),  Vg*(eh+0.5),  '+cP*',  fh,  ')>>',  Ug, (d.R?';':')/100;'),  "}catch(e){};\n");
              break;
            case   d.dg.hg:
              Xg.push('_a["',  id,  'elscroll"].',  bh,  '=(',  Tg*(eh+0.5),  '+normalPhase*',  fh,  ')>>',  Sg,  ';\n');
              break;
            case   d.dg.kg:
              Xg.push('_a["',  id,  'elStyle"].',  bh,  '=((',  Math.floor(Tg*(eh+0.5)),  '+normalPhase*',  fh,  ')>>',  Sg,  ')/10000;\n');
            case   d.dg.lg:
              switch  (bh)
             {
                case   "visibility":
                  za.style.visibility  =  "visible";
                  break;
                case   "display":
                  za.style.display  = (dh=='none'?eh:dh);
                  break;
                case   "overflow":
                  za.style.overflow  =  "hidden";
                  break;
 
 
 
 
 
 
             }
              break;
            case   d.dg.mg:
              Xg.push('_a["',  id,  'elStyle"].',  bh,  '=((',  Math.floor(Tg*(eh+0.5)),  '+normalPhase*',  fh,  ')>>',  Sg,  ');\n');
              break;
            default:
              Xg.push('_a["',  id,  'elStyle"].',  bh,  '=((',  Math.floor(Tg*(eh+0.5)),  '+normalPhase*',  fh,  ')>>',  Sg,  ')', (bh=='zoom'?'/10000':''),  gh,  ";\n");
         }

       }
     }

 

      if  (Xg.length  >  0)
     {
        code.push(
          "var normalPhase=Math.round(",  Tg,  "*f);\n",
          Xg.join("")
       );
     }
      if  (Yg.length  >  0)
     {
        code.push(
          'var cP=Math.round(',  Vg,  '*f);\n',
         Yg.join("")
       );
     }

 

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

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

      _a.ih(code,  Qg.delay,  Qg.duration,  Pg,  Qg.onFinish);
   },

    Wg: [
      '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)))' 
   ],

    hh: (document.defaultView?" + 'px';\n":";\n"),
    jh:  0,
    kh:  null,
    lh:  1,
    mh:  0,
    nh:  Infinity,
    oh:  500,
    ph:  "",
    ih:  function(qh,  delay,  duration,  Pg,  onFinish)
   {
      _a.jh++;
      _a.lh++;

      for  (var   i=0;  i<Pg.length;  i++)
        _a.Og[Pg[i].element.id] =  _a.lh++;

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

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

      var   sh  = +new   Date() +  delay  -  _a.mh;
      var   uh  =  sh  +  duration;
      rh  =  rh.replace(/TSTART/g,  sh);
      rh  =  rh.replace(/DURATION/g,  duration);
      rh  =  rh.replace(/TSTOP/g,  uh);
      rh  =  rh.replace(/RUNINDEX/g,  _a.lh);

      if  (_a.kh)
        _a.vh(Pg);

      _a.ph  =  _a.ph  +  rh;

 

      _a.wh  =  Function("tNow",  _a.ph);

 

      if  (!_a.kh)
     {
        _a.mh  =  0;
        _a.nh  =  Infinity;

 
 

        _a.kh  =  setInterval(_a.xh,  1);
 _a.yh  =  true;
        _a.xh();
 _a.yh  =  false;
     }
   },
    xh:  function()
   {
      var   zh  = +new   Date() -  _a.mh;

      var   Ah  =  zh  -  _a.nh;
      if  (Ah  >  _a.oh)
     {
        _a.mh  +=  Ah;
        zh  -=  Ah;
     }

      _a.nh  =  zh;

 
 

      _a.wh(zh);
   },
    "__rC":  function(Bh)
   {
      var   Ch  =  "/*** "  +  Bh  +  " ***/";
      var   Dh    =  "/*** /"  +  Bh  +  " ***/";
      _a.ph  =  _a.ph.substring(0,  _a.ph.indexOf(Ch)) +  _a.ph.substring(_a.ph.indexOf(Dh) +  Dh.length);

      _a.wh  =  Function("tNow",  _a.ph);

      _a.Eh(Bh);

      _a.jh--;
      if  (_a.jh  ==  0)
     {
        clearInterval(_a.kh);
        _a.Og  = {};
        _a.kh  =  null;
     }
   },
    Eh:  function(Bh)
   {
      for  (var   id   in   _a.Og)
        if  (_a.Og[id] ==  Bh)
          delete   _a.Og[id];
   },
   vh:  function(Pg)
   {
      var   Fh  = [];
      var   Rg  =  Pg.length;
      for  (var   i=0;  i<Rg;  i++)
     {
        var   _h  =  Pg[i];
        var   id  =  _h.element.id.replace(/(\W)/g,  "\\$1");
        var   ah  =  _h.targetState;

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

      if  (Fh.length  >  0)
     {
 
        _a.ph  =  _a.ph.replace(new   RegExp(Fh.join("").substr(1),  "g"),  "");
 
     }
   },
    Gh:  function(Hh)
   {
 
 
 
 
 
 
 
 
 
 
 
 
   }
};


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

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

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


 
 
 
 
 
 
 
 
 
 
 
 

 
 
 


 



 d.Ih  = {
    Jh:"display",
    Kh:"block",
    Lh:"morph",
    Mh:"shallow",


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

    Vh:  function()
   {
      this.Nh  =  true;
   },
    Wh:  function()
   {
      this.Nh  =  false;
   },
    Xh:  function()
   {
      this.Rh  =  false;
   },
    Yh:  function(Zh)
   {
      d.w  =  Zh;
   },
    _i:  function(ai)
   {
      var   bi  = {};
      for  (var   i=0;  i<ai.length;  i++)
        bi[ai[i].toUpperCase()] =  1;
      this.Sh  =  bi;
   },
    ci:  function(di)
   {
      this.Oh  =  di;
   },
    Uh:  function(Yc)
   {
      if  (d.Ih.Nh  && !Yc.Dc)
        this.ei(Yc.subject);
   },
    ei:function(vd)
   {
 
      var   fi  = {};

      var   pc  =  d.Ja.Ka(vd,  this.Lh, {"delay":0,  "duration":d.w});
      if  (!pc  || (!pc["not"] && (!pc["require"] ||  d.Ja.contains(vd,  pc["require"]))))
     {
        if  (pc)
          this.gi(fi,  vd,  pc);
        else   if  (!this.Rh)
          this.hi(vd,  fi);

        if  (this.Qh)
       {
          this.ii(fi,  true);

          for  (var   Kf   in   fi)
            this.Ph[Kf] =  fi[Kf];
       }
     }
 
   },

    gi:  function(Hh,  za,  pc)
   {
      var   Kf  =  d.Ga.lb(za);
      if  (!this.Ph[Kf])
     {
        Hh[Kf] = {
          element:za,
          pc:pc,
          eb:pc[this.ji]||this.Oh 
       };

        this.Qh  =  true;
     }

      if  (!this.Rh  ||  pc["deep"])
        this.hi(za,  Hh);
   },

    hi:  function(za,  fi)
   {
      for  (var   zd  =  za.firstChild;  zd;  zd  =  zd.nextSibling)
        if  (zd.nodeType  ==  1)
       {
          var   pc  =  null;
          var   ki  =  false;
          if  (this.Sh[zd.nodeName])
         {
            pc  =  d.Ja.Ka(zd,  this.Lh, {"delay":0,  "duration":d.w});
            if  (pc  && !pc["not"])
           {
              this.gi(fi,  zd,  pc);
              ki  =  true;
           }
         }

          if  (!ki)
         {
            var   mi  =  d.dg.og(zd,  "display");
            if  (mi  !=  d.h  && (!pc  || !pc[this.Mh]))
              this.hi(zd,  fi);
         }
       }
   },

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

      if  (this.Qh)
     {
        
        
        for  (var   Kf   in   this.Ph)
          if  (!this.ni(this.Ph[Kf].element))
         {
            var   za  =  document.getElementById(Kf);
            if  (za)
              this.Ph[Kf].element  =  document.getElementById(Kf);
            else 
              delete   this.Ph[Kf];
         }

 
        this.oi(this.Ph);
 
        this.ii(this.Ph,  false);
 
        this.pi(this.Ph);
 

        var   qi  =  this.ri();
 

        this.Qh  =  false;
        this.Ph  = {};
 

        this.si(qi);
 

        
        
        
        
        
        
        
        if  (d.T)
          document.body.offsetWidth;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
     }
   },
    oi:  function(Hh)
   {
 
 
 
 
 

      for  (var   Kf   in   Hh)
        if  (d.Animator.Og[Kf])
       {
          var   ti  =  Hh[Kf];
          var   za  =  ti.element;

          if  (d.R)
         {
            ti.ui  =  za.style.cssText;
            za.style.cssText  =  "";
         }
          else 
            for  (var   Z   in   ti.vi)
           {
              var   db  =  za.style[Z];
              if  (db)
             {
                ti.wi[Z] =  db;
                za.style[Z] =  "";
             }
           }
       }
   },
    pi:  function(Hh)
   {
      for  (var   Kf   in   Hh)
     {
        if  (d.Animator.Og[Kf])
       {
          var   ti  =  Hh[Kf];
          var   za  =  ti.element;
          if  (d.R)
            za.style.cssText  =  ti.ui;
          else 
            for  (var   Z   in   ti.wi)
              za.style[Z] =  ti.wi[Z];
       }
     }
   },
    ii:  function(Hh,  xi)
   {
      var   yi  = [];
      var   zi  = [];
      var   Ai  =  null;

      for  (var   Kf   in   Hh)
     {
        var   ti  =  Hh[Kf];
        var   za  =  ti.element;

 
 
 
 if  (za.offsetWidth  ==  0  && (!za.parentNode  ||  za.parentNode.offsetWidth  ==  0))
{
    delete   Hh[Kf];
    continue;
}
        if  (xi)
       {
          ti.wi  = {};
          ti.vi  = {};
          ti.Bi  = {};
       }

        
        if  (!xi  &&  Ai  &&  d.Ga.Db(Ai,  za) && (Ai.style.display  ==  d.h))
       {
          delete   Hh[Kf];
          continue;
       }

        var   Ci  = (xi?ti.vi:ti.Bi);

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

          Ci[Z] =  d.dg.og(za,  Z);

          if  (Z  ==  this.Jh  &&  Ci[Z] ==  d.h)
         {
 
 
 
 
 
            
            if  (!xi  &&  ti.vi.display  ==  d.h)
           {
              delete   Hh[Kf];
              break;
           }

            Ai  =  za;
            yi.push(Ai);
            zi.push(Ai.style.display);
            Ai.style.display  =  this.Kh;
         }
       }
     }

      for  (var   i=0;  i<yi.length;  i++)
        yi[i].style.display  =  zi[i];
   },
    ri:  function()
   {
      var   qi  = {};
      var   Di  = {};
      for  (var   Kf   in   this.Ph)
     {
        var   ti  =  this.Ph[Kf];
        var   za  =  ti.element;
        var   currentState  = {};
        var   units  = {};
        var   targetState  = {};
        var   Ei  =  false;
        for  (var   Z   in   ti.Bi)
       {
          var   Fi  =  ti.vi[Z];
          var   Gi  =  ti.Bi[Z];

          if  (Gi  !=  null)
         {
            
 
 
 
 
            if  (Fi  !=  Gi)
           {
              Ei  =  true;
              var   Hi  =  d.dg.qg(za,  Z,  Fi);
              var   Ii    =  d.dg.qg(za,  Z,  Gi);
              currentState[Z] =  Hi.value;
              targetState[Z] =  Ii.value;
              units[Z] =  Hi.Fg  ||  Ii.Fg;
           }
         }
       }

        if  (Ei)
       {
          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   Ji  =  qi[ti.pc["delay"]] =  qi[ti.pc["delay"]] || {};
          var   Pg  =  Ji[ti.pc["duration"]] =  Ji[ti.pc["duration"]] || [];

          Pg[Pg.length] = {
            element:za,
            currentState:currentState,
            targetState:targetState,
            units:units 
         };
       }
     }
      return   qi;
   },
    si:  function(qi)
   {
      for  (var   delay   in   qi)
     {
        delay  *=  1;
        for  (var   duration   in   qi[delay])
       {
          duration  *=  1;
          var   Pg  =  qi[delay][duration];
          for  (var   i=0;  i<Pg.length;  i++)
         {
            var   _h  =  Pg[i];
            var   za  =  _h.element;
            
 
 
            
            for  (var   Z   in   _h.currentState)
           {
 
 
              d.dg.Jg(za,  Z,  _h.currentState[Z]);
           }
         }

 
 
 
 
 
 
 
 
 

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

 
 
          d.Animator.animate(Pg,  Qg);
 
       }
     }
   },
    ni:  function(za)
   {
      if  (d.R)
        return   za.parentTextEdit  !=  null;
      else   if  (d.Q)
        return   za.sourceIndex  != -1;
      else 
        return   za.offsetParent  !=  null;
   },
    Ki:  function(Li,  Mi)
   {
      for  (var   i=0;  i<Li.length;  i++)
        if  (Li[i] !=  Mi[i])
          return   false;

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

 d["StyleMorpher"] =  d.Ih;
 d.Ih["enableDeepMorphing"] =  d.Ih.Xh;
 d.Ih["setMorphDuration"] =  d.Ih.Yh;
 d.Ih["setMorphableNodeNames"] =  d.Ih._i;
 d.Ih["setMorphableProperties"] =  d.Ih.ci;
 d.Ih["enable"] =  d.Ih.Vh;
 d.Ih["disable"] =  d.Ih.Wh;

 d.Ih["morph"] =  d.Ih.Th;
 d.Ih["beforeClassNameChange"] =  d.Ih.Uh;
 
 
 
 
 


 d.Ni  = {
    Oi:  null,
    Pi:  null,
    ba:  function()
   {
      d.Oc.Sc(document.documentElement,  d.H,  this.Qi,  this);
      d.Oc.Sc(document.documentElement,  d.I,  this.Ri,  this);
      d.Oc.Sc(document.documentElement,  d.J,    this.Si,  this);
      d.Oc.Sc(document.documentElement,  "DOMMouseScroll",    this.sd,  this);

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

    Qi:  function(Yc)
   {
      this.Si();

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

        this.Wi  =  d.V.scrollTop;
        this.Xi  =  this.Vi.object.offsetLeft  -  Yc.clientX  -  d.dg.vg(this.Vi.object,  "marginLeft");
        this.Yi  =  this.Vi.object.offsetTop  -  Yc.clientY  -  d.dg.vg(this.Vi.object,  "marginTop");

        this.Zi();

        this._j  =  false;
     }
      else 
        this.Vi  =  null;
   },
    Ri:  function(Yc)
   {
      this.Pi  =  Yc.clientY;

      if  (this.Vi)
        if  (Yc.kd)
       {
          if  (!this._j)
         {
            d.Oc.Pc  =  true;

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

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

            this.Oi  =  d.oa.ta(this.aj,  15,  this);

            this._j  =  true;
         }

          this.bj  = {  x:  this.Xi  +  Yc.clientX,  y:  this.Yi  +  Yc.clientY  +  d.V.scrollTop  -  this.Wi  };
          this.cj();

          if  (this.Vi.La[d.N])
         {
            this.Vi.La[d.N](this.Vi.object,  this.bj);
            this.cj();
         }

          if  (this.Vi.Ia.dir  !=  "vertical")
            d.dg.Jg(this.Vi.object,  "left",  this.bj.x);
          if  (this.Vi.Ia.dir  !=  "horizontal")
            d.dg.Jg(this.Vi.object,  "top",   this.bj.y);
       }
        else 
          this.Si();
   },
    sd:  function(Yc)
   {
      this.Si();

      var   dj  =  d.Ga.Ha(Yc.subject,  "move");
      if  (dj)
     {
        var   pc  =  d.Ja.Ka(dj,  "move");

        if  (pc["onMouseScroll"])
       {
          if  (this.ej)
            clearTimeout(this.ej);

          var   fj  =  document.getElementById(pc["onMouseScroll"]);
          this.Vi  = {
            box:  fj.offsetParent  ||  d.V,
            object:  fj,
            La:  d.Ja.Ka(fj,  "movable")
         };
          
          this.Zi();

          var   gj  =  this.Vi.object.offsetTop;

          var   hj  =  pc["delta"] ||  Math.abs(Yc.detail);

          this.bj  = {  x:0,  y:gj  +  hj  *  Yc.detail  /  Math.abs(Yc.detail) };
          this.cj();

          if  (this.Vi.La[d.N])
         {
            this.Vi.La[d.N](this.Vi.object,  this.bj);
            this.cj();
         }

          d.dg.Jg(this.Vi.object,  "top",   this.bj.y);

          var   ij  =  d.Ni.Vi.La[d.O];
          if  (this.Vi.La[d.O])
         {
            var   X  =  d.Ni.Vi.object;
            var   Ui  =  d.Ni.bj;
            this.ej  =  d.oa.pa(function() {  ij(X,  Ui); },  500);
         }

          this.Si();
          
          Yc.cancel();
       }
     }
   },

    Zi:  function()
   {
      
      
      
      var   jj   = -1;
      var   kj  = -1;
      var   lj  =  this.Vi.box;
      while  (jj  <=  1  ||  kj  <=  1)
     {
        jj  = (document.compatMode  !=  "BackCompat"  ||  lj  !=  d.V)?lj.offsetWidth:lj.clientWidth;
        kj  =  lj.offsetHeight;
        lj  =  lj.offsetParent  ||  d.V;
     }
      

      if  (this.Vi.La["restricted"])
     {
        this.mj  =  jj   -  d.dg.vg(this.Vi.object,  "width") -  d.dg.vg(this.Vi.object,  "marginRight") - (lj  ==  d.V?2:0);
        this.nj  =  kj  -  d.dg.vg(this.Vi.object,  "height") -  d.dg.vg(this.Vi.object,  "marginBottom");
     }
   },

    cj:  function()
   {
      if  (this.Vi.La["restricted"])
     {
        this.bj.x  =  Math.max(0,  Math.min(this.bj.x,  this.mj)),
        this.bj.y  =  Math.max(0,  Math.min(this.bj.y,  this.nj))
     }
   },
    Si:  function()
   {
      if  (this.Vi)
     {
        if  (this._j)
       {
          if  (this.Vi.box)
            d.Ja.replace(this.Vi.box,  "moving",  "notMoving");
          if  (this.Vi.object)
            d.Ja.replace(this.Vi.object,  "moving",  "notMoving");
          if  (this.Vi.Fa)
            d.Ja.replace(this.Vi.Fa,  "moving",  "notMoving");

          if  (this.Vi.La[d.O])
            this.Vi.La[d.O](this.Vi.object,  this.bj);

          d.Oc.Pc  =  false;

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

          this.Pi  =  null;
          clearTimeout(this.Oi);
          this.Oi  =  null;
       }

        this.Vi  =  null;
     }

      this.oj  =  d.V.scrollHeight  -  d.V.offsetHeight;
   },
    aj:  function()
   {
      if  (this.bj  &&  this.Vi.Ia.dir  !=  "horizontal")
     {
        var   pj  =  d.V.scrollTop;
      
        if  (this.Pi  <  50)
          d.V.scrollTop  -=  Math.round(10  -  this.Pi/5);

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

        if  (d.V.scrollTop  !=  pj)
       {
          this.bj.y  +=  d.V.scrollTop  -  pj;
          this.cj();

          if  (this.Vi.La[d.N])
         {
            this.Vi.La[d.N](this.Vi.object,  this.bj);
            this.cj();
         }
          d.dg.Jg(this.Vi.object,  "top",   this.bj.y);
       }
     }
   }
};

 d.W(d.Ni);
 d.qj  = {
    ba:  function()
   {
      d.Oc.Sc(document.documentElement,  d.H,  this.Qi,  this);
      d.Oc.Sc(document.documentElement,  d.I,  this.Ri,  this);
      d.Oc.Sc(document.documentElement,  d.J,    this.Si,  this);

      d.wa.nd("persist-dim",  this.Ti,  this);
   },

    Ti:  function(Yc)
   {
      var   za  =  Yc.subject;
      if  (d.Ja.contains(za,  "resizable"))
     {
        var   rj  = {  width:  parseInt(za.style.width),  height:  parseInt(za.style.height) };
        if  (!isNaN(rj.width) || !isNaN(rj.height))
       {
          var   La  =  d.Ja.Ka(za,  "resizable");
          if  (La[d.N])
            La[d.N](za,  rj);
       }
     }
   },
    
    Qi:  function(Yc)
   {
      
      this.Si();

      this.sj  =  d.oa.ya(Yc.subject,  "resizer",  "resizable");
      if  (this.sj.object)
     {
        
        this.tj  =  d.dg.vg(this.sj.object,  "width");
        this.uj  =  d.dg.vg(this.sj.object,  "minWidth") ||  0;
        this.vj  =  d.dg.vg(this.sj.object,  "maxWidth") ||  Infinity;

        this.wj  =  d.dg.vg(this.sj.object,  "height");
        this.xj  =  d.dg.vg(this.sj.object,  "minHeight") ||  0;
        this.yj  =  d.dg.vg(this.sj.object,  "maxHeight") ||  Infinity;

        this.Xi  =  Yc.clientX;
        this.Yi  =  Yc.clientY;

        this.zj  =  false;
     }
      else 
        this.sj  =  null;
   },
    
    Ri:  function(Yc)
   {
      if  (this.sj)
        if  (Yc.kd)
       {
          if  (!this.zj)
         {
            d.Oc.Pc  =  true;

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

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

          this.Aj  = {
            width:this.tj  +  Yc.clientX  -  this.Xi,
            height:this.wj  +  Yc.clientY  -  this.Yi 
         };
          this.cj();

          if  (this.sj.La[d.N])
         {
            this.sj.La[d.N](this.sj.object,  this.Aj);
            this.cj();
         }

          if  (this.sj.Ia.Bj  !=  "height")
            this.sj.object.style.width   =  this.Aj.width   +  "px";
          if  (this.sj.Ia.Bj  !=  "width")
            this.sj.object.style.height  =  this.Aj.height  +  "px";
       }
        else 
          this.Si();
   },
    cj:  function()
   {
      this.Aj.width   =  Math.max(this.uj,  Math.min(this.vj,  this.Aj.width));
      this.Aj.height  =  Math.max(this.xj,  Math.min(this.yj,  this.Aj.height));
   },

    Si:  function()
   {
      if  (this.sj)
     {
        if  (this.zj)
       {
          d.Ja.replace(this.sj.object,  "resizing",  "notResizing");
          d.Ja.replace(this.sj.Fa,  "resizing",  "notResizing");

          if  (this.sj.La[d.O])
            this.sj.La[d.O](this.sj.object,  this.Aj);

          d.Oc.Pc  =  false;

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

        this.sj  =  null;
     }
   }
};

 d.qj.ba();
 d.Cj  = {
    pf:  null,
    Dj:  Math.pow(2,  15),
    ba:  function()
   {
      d.Oc.Sc(document.documentElement,  "mousedown",  this.Ej,  this);
      d.Oc.Sc(document.documentElement,  "keyup",  this.Ej,  this);
      d.wa.nd(d.m,  this.Ej,  this);
   },
    
    Ej:  function(Yc)
   {
      var   za  =  Yc.subject;

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

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


 d.Cj.ba();
 d.Fj  = {
    Gj:"dragging",
    Hj:"notDragging",
    Ij:"dropping",
    Jj:"notDropping",
    ba:  function()
   {
      d.Oc.Sc(document.documentElement,  d.H,  this.Qi,  this);
      d.Oc.Sc(document.documentElement,  d.I,  this.Ri,  this);
      d.Oc.Sc(document.documentElement,  d.J,    this.Kj,  this);
   },
    
    Qi:  function(Yc)
   {
      
      this.Si();

      
      var   Lj  =  d.Ga.Ha(Yc.subject,  "dragger");
      if  (Lj)
     {
        
        var   Mj  =  d.Ga.Ha(Yc.subject,  "draggable");

        
        if  (Mj)
       {
          
          if  (!d.Ga.Ha(Yc.subject,  "dragging-disabled"))
            
            this.Nj(Mj,  Lj);

          
          
          Yc.cancel();
       }
     }
   },
    
    Ri:  function(Yc)
   {
      this.Pi  =  Yc.clientY;

      if  (this.Oj)
        if  (Yc.kd)
       {
          this.Pj();

          
          this.Qj.style.left  = (d.V.scrollLeft  +  Yc.clientX) +  "px";
          this.Qj.style.top  = (d.V.scrollTop  +  5  +  this.Pi) +  "px";

          
          
          
          var   Mj  =  d.Ga.Ha(Yc.subject,  "draggable");
          if  (Mj  !=  this.Qj)
         {
            
            var   Rj  =  d.Ga.Ha(Yc.subject,  "dropBox");
            if  (Rj  &&  Rj  !=  this.Sj)
           {
              
              var   Tj  =  d.oa.Va(Rj,  "dropType",  "",  true);
              for  (var   i=0;  i<Tj.length;  i++)
                if  (!isNaN(this.Uj[Tj[i]]))
                  break;
              
              if  (i  >=  Tj.length)
                Rj  =  null;
           }

            var   Vj  =  null;

            if  (d.Ga.Ha(Yc.subject,  "noDrop",  "dropBox"))
              Rj  =  null;

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

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

          
          Yc.cancel();
       }
        else 
          this.Kj();
   },

 Pi:  null,
 Zj:  null,
 _k:  null,
        
    Nj:  function(Mj,  Lj)
   {
      this.ak  =  Lj;
      this.Oj  =  Mj;
      this.bk  =  Mj.parentNode;
      this.ck  =  Mj.nextSibling;

      
      this.dk  =  d.oa.Va(this.Oj,  "dragType",  "",  true);
      this.Uj  =  d.oa.ab(this.dk);

      this.ek  =  false;

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


    Pj:  function()
   {
      if  (this.ek)
        return;

      this.ek  =  true;

      d.Oc.Pc  =  true;

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

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

      d.Ja.add(this.Qj,  "dragPlaceholder");
      d.Ja.replace(this.Qj,  this.Hj,  this.Gj);
      this.Oj.parentNode.insertBefore(this.Qj,  this.Oj);

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

      
      var   gk  =  d.Ga.sb(this.Oj,  "dropPlaceholder");
      if  (gk)
        this.Xj  =  gk.cloneNode(true);
      else 
     {
        this.Xj  =  this.Oj.cloneNode(true);
 
     }
      d.Ja.add(this.Xj,  "dropPlaceholder");
      d.Ja.remove(this.Xj,  this.Hj);

      
      d.Ja.replace(this.Oj,  this.Hj,  this.Gj);
      d.Ja.replace(this.Oj.parentNode,  this.Hj,  this.Gj);

      this.Oi  =  d.oa.ta(this.aj,  15,  this);
   },
    Yj:  function(Rj,  Vj)
   {
      if  (Rj  !=  this.Sj  ||  Vj  !=  this.hk)
     {
        
        if  (this.Sj  &&  Rj  !=  this.Sj)
          d.Ja.replace(this.Sj,  this.Ij,  this.Jj);

        
        this.Sj  =  Rj;
        this.hk  =  Vj;

        if  (!Rj)
          this.Xj.parentNode.removeChild(this.Xj);
        else 
       {
          d.Ja.replace(Rj,  this.Jj,  this.Ij);
          Rj.insertBefore(this.Xj,  Vj  ||  null);
       }
     }
   },

    Kj:  function()
   {
      if  (this.Oj  &&  this.Sj)
     {
        var   Mj  =  this.Oj;
        var   ik  =  this.Xj.parentNode;
        var   jk  =  this.Xj.nextSibling;

        this.Si();

        var   kk  =  d.Ja.contains(this.bk,  "clone-box") &&  ik  !=  this.bk;
        if  (ik  !=  this.bk  ||  jk  !=  this.ck)
       {
          var   Vj  =  kk?Mj.cloneNode(true):Mj;

          ik.insertBefore(Vj,  jk);

          var   lk  =  d.Ja.Ka(ik,  "dropBox");
          if  (lk[d.O])
            if  (lk[d.O](Vj,  this.bk,  this.ck,  ik,  jk) ==  false)
              this.bk.insertBefore(Vj,  this.ck);
       }
     }

      this.Si();
   },

    Si:  function()
   {
      if  (this.Oj)
     {
        d.Ja.remove(document.body,  "dragging-"  +  this.dk.join(" dragging-"));

        if  (this.ek)
       {
          d.Ja.replace(this.Oj.parentNode,  this.Gj,  this.Hj);
          d.Ja.replace(this.Oj,  this.Gj,  this.Hj);
          if  (this.Sj)
            d.Ja.replace(this.Sj,  this.Ij,  this.Jj);

          
          this.Qj.parentNode.removeChild(this.Qj);
          if  (this.Xj.parentNode)
            this.Xj.parentNode.removeChild(this.Xj);
       }

        d.Oc.Pc  =  false;

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

        this.ak  =  null;
        this.Oj  =  null;
        this.Sj  =  null;
        this.Pi  =  null;
        clearTimeout(this.Oi);
        this.Oi  =  null;
     }
      this.oj  =  d.V.scrollHeight  -  d.V.offsetHeight;
   },
    
    aj:  function()
   {
      var   pj  =  d.V.scrollTop;
      
      if  (this.Pi  <  50)
        d.V.scrollTop  -=  Math.round(10  -  this.Pi/5);

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

      if  (d.V.scrollTop  !=  pj)
        this.Qj.style.top  = (d.V.scrollTop  +  5  +  this.Pi) +  "px";
   }
};

 d.W(d.Fj);


 
 
 
 
 
 
 
 
 d.mk  =
{
    nk:0,
    ok:1,
    pk:2,
    qk:-1,
    rk:-2,
    sk: {},
    ba:  function()
   {
      d.Qd.ae(["classShifter"], ["classShiftee",  "classChain"],  this.Oe,  this);
      d.Bd.Kd("classChain",  this.tk,  this);
   },
    
    uk:  function(za)
   {
      var   Kf  =  d.Ga.lb(za);
      var   ie  =  d.Ja.Ka(za,  "classChain");
      var   data  =  this.vk(Kf,  document.body,  za,  "classChain", {},  ie);

      data.wk  =  this.qk;
      d.Ja.add(data.oe,  "sliding");
      this.xk(data);
   },
    reset:  function(za)
   {
      var   Kf  =  d.Ga.lb(za);
      delete   this.sk[Kf];
   },

    tk:  function(oe,  yk,  Yc)
   {
      var   za  =  Yc.subject;
      while  (za  &&  za.parentNode  !=  oe)
        za  =  za.parentNode;

      var   Kf  =  d.Ga.lb(oe);
      var   ie  =  d.Ja.Ka(oe,  "classChain");
      var   data  =  this.vk(Kf,  oe,  oe,  "classChain", {},  ie);

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

          if  (data.zk  ==  data.Ak)
            break;

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

          this.Bk(data);
        
          d.pd.ud(data.oe, ["jump"],  data.oe);

          data.Yf  =  d.oa.pa(this.xk,  data.ua,  this, [data]);
    
          break;
       }
   },
    Oe:  function(ne,  nc,  oe,  Se,  Yc,  fe,  ie)
   {
      var   Kf  =  d.Ga.lb(oe);
      var   data  =  this.vk(Kf,  ne,  oe,  Se,  fe,  ie);

      var   Ck  =  false;
      var   Dk  =  false;
      var   Ek  =  false;

      var   Fk  =  data.wk;

      if  (fe["pause"] &&  data.wk  !=  null)
     {
        data.Gk  =  true;
        Dk  =  true;
        d.Ja.ec(data.oe,  "pausing",  true);
     }

      if  (fe["resume"])
        Ck  =  true;

      if  (fe["stop"])
     {
        Dk  =  true;
        data.wk  =  null;
        d.Ja.remove(data.oe,  "sliding");
        if  (data.Gk)
          d.Ja.remove(data.oe,  "pausing");
     }

      if  (fe["slideToStart"])
     {
        data.wk  =  0;
        Ck  =  true;
     }
      if  (fe["slideToEnd"])
     {
        data.wk  =  data.Hk;
 
        Ck  =  true;
     }
      if  (fe["slideToNext"] ||  fe["jumpToNext"])
     {
        this.Ik(data,  1);
        Ek  =  true;
     }
      if  (fe["slideToPrevious"] ||  fe["jumpToPrevious"])
     {
        this.Ik(data, -1);
        Ek  =  true;
     }
      if  (fe["slideForward"])
     {
        data.wk  =  this.qk;
        Ck  =  true;
     }
      if  (fe["slideBackward"])
     {
        data.wk  =  this.rk;
        Ck  =  true;
     }
      if  (fe["slideTo"])
     {
        if  (data.Jk)
          data.wk  =  this.Kk(data,  fe["slideTo"]);
        else 
          data.wk  =  data.Lk[fe["slideTo"]];
        Ck  =  true;
     }

      if  (fe["jumpToStart"])
     {
        data.zk  =  0;
        Ek  =  true;
     }
      if  (fe["jumpToEnd"])
     {
        data.zk  =  data.Hk;
        Ek  =  true;
     }
      if  (fe["jumpTo"])
     {
        if  (data.Jk)
          data.zk  =  this.Kk(data,  fe["jumpTo"]);
        else 
          data.zk  =  data.Lk[fe["jumpTo"]];
        Ek  =  true;
     }

      if  (Ek  &&  data.zk  ==  data.Ak)
        Ek  =  false;

      if  (!data.Gk  &&  Ck  &&  data.wk  ==  Fk)
        Ck  =  false;

      if  (data.Yf  && (Dk  ||  Ck  ||  Ek))
     {
        clearTimeout(data.Yf);
        data.Yf  =  null;
     }

      if  (Ck  &&  data.Ak  ==  data.wk)
        Ck  =  false;

      if  (Ck)
     {
        data.Gk  =  false;
        data.dir  =  1;
        d.Ja.ec(data.oe,  "pausing",  false);
     }

      if  (Ek)
     {
        this.Bk(data);
        
        d.pd.ud(data.oe, ["jump"],  data.oe);
     }

      if  (Ek)
        data.Yf  =  d.oa.pa(this.xk,  data.ua,  this, [data]);
      else   if  (Ck)
     {
        d.Ja.add(data.oe,  "sliding");
        this.xk(data);
     }
   },
    vk:  function(Kf,  ne,  oe,  Se,  fe,  ie)
   {
      var   data  =  this.sk[Kf];

      if  (!data)
     {
        data  =  this.sk[Kf] = {
          Kf:Kf,
          ne:ne,
          oe:oe,
          Se:Se,
          Jk:(Se  ==  "classChain"),
          Mk:(ie["wrap"]?this.ok:(ie["bounce"]?this.pk:this.nk)),
          dir:1,
          Nk:ie["classes"],
          Lk:d.oa.ab(ie["classes"]),
          Ok:ie["classes"].join("\\b|\\b"),
          wk:null,
          ua:(fe["interval"] ||  ie["interval"] ||  d.w),
          Pk:d.oa.Ma(ie["onbeforechange"],  null)
       };
        if  (data.Jk)
       {
          data.Qk  =  ie["mainClass"];
          data.children  =  this.Rk(data.oe,  data.Ok);
          data.Sk  =  data.Lk[data.Qk];
       }
        data.Hk  = (data.Jk?data.children.length-1:data.Nk.length-1),
        data.Ak  =  this.Tk(data);
     }

      return   data;
   },
    Tk:  function(data)
   {
      for  (var   i=0;  i<=data.Hk;  i++)
        if  (
         (data.Jk  &&  d.Ja.contains(data.children[i],  data.Qk))
         ||
         (!data.Jk  &&  d.Ja.contains(data.oe,  data.Nk[i]))
       )
          return   i;
   },
    Kk:  function(data,  qb)
   {
      for  (var   i=0;  i<data.children.length;  i++)
        if  (d.Ja.contains(data.children[i],  qb))
          return   i;
   },
    Rk:  function(za,  Ok)
   {
      var   Ng  = [];
      for  (var   Uk  =  za.firstChild;  Uk;  Uk  =  Uk.nextSibling)
        if  (d.Ja.contains(Uk,  Ok))
          Ng.push(Uk);
      return   Ng;
   },
    Ik:  function(data,  hj)
   {
      data.zk  =  data.Ak  +  data.dir*hj;
      if  (data.zk  <  0)
     {
        if  (data.Mk  ==  this.ok)
          data.zk  =  data.Hk;
        else   if  (data.Mk  ==  this.pk)
       {
          data.zk  =  1;
          data.dir  *= -1;
       }
        else 
          data.zk  =  0;
     }
      else   if  (data.zk  >  data.Hk)
     {
        if  (data.Mk  ==  this.ok)
          data.zk  =  0;
        else   if  (data.Mk  ==  this.pk)
       {
          data.zk  =  data.Hk  -  1;
          data.dir  *= -1;
       }
        else 
          data.zk  =  data.Hk;
     }
   },
    xk:  function(data)
   {
      if  (!data.Gk  &&  data.wk  !=  null)
     {
        if  (data.wk  ==  this.qk)
          this.Ik(data,  1);
        else   if  (data.wk  ==  this.rk)
          this.Ik(data, -1);
        else   if  (data.Ak  !=  data.wk)
       {
          var   Vk  =  data.wk  -  data.Ak;
          this.Ik(data,  Vk  /  Math.abs(Vk));
       }

        this.Bk(data);

        d.pd.ud(data.oe, ["slide"],  data.oe);

        if  (data.Ak  !=  data.wk)
       {
          var   fe  =  d.Ja.Ka(data.ne,  "classShifter");
          var   ie  =  d.Ja.Ka(data.oe,  data.Se);
          var   ua  = (fe?fe["interval"]:null) ||  ie["interval"] ||  data.ua  ||  d.w;

          data.Yf  =  d.oa.pa(this.xk,  ua,  this, [data]);
       }
        else 
       {
          data.wk  =  null;
          d.Ja.remove(data.oe,  "sliding");
       }
     }
   },
    Bk:  function(data)
   {
      if  (data.zk  !=  data.Ak)
     {
        if  (!data.Pk  || (data.Pk(data.oe) !=  false))
       {
          if  (data.Jk)
         {
 

            if  (data.Hk  >=  data.Nk.length)
           {
              var   Wk  =  0;
              var   Xk  =  data.Nk.length  -  1;
           }
            else 
           {
              var   Wk  =  data.Sk  -  Math.floor(data.Hk/2);
              var   Xk  =  Wk  +  data.Hk;
           }

            var   Nk  = [];
            for  (var   i=0;  i<data.Nk.length;  i++)
              Nk[i] =  i;
            var   Yk  = (data.Mk  ==  this.ok?Xk:Wk);
            for  (var   i=-1;  i<Wk;  i++)
              Nk[i] =  Yk;
            Yk  = (data.Mk  ==  this.ok?Wk:Xk);
            for  (var   i=Xk  +  1;  i<=  data.Nk.length;  i++)
              Nk[i] =  Yk;

 

            var   Zk  = [];
            for  (var   i=0;  i<=data.Hk;  i++)
              Zk[i] =  data.Lk[d.Ja.match(data.children[i],  data.Ok)];

            var   _l  =  data.zk  -  data.Ak;
            var   al  =  _l/Math.abs(_l);
            for  (var   bl  =  1;  bl  <=  Math.abs(_l);  bl++)
           {
              Zk[-1] =  Zk[data.Hk];
              Zk[data.Hk+1] =  Zk[0];

              var   cl  = [];

              if  (al  ==  1)
                for  (var   i  =  0;  i  <=  data.Hk;  i++)
                  cl[i] =  Nk[Zk[i] - (Zk[i] !=  Zk[i-data.dir]?al:0)];
              else 
                for  (var   i  =  data.Hk;  i>=0;  i--)
                  cl[i] =  Nk[Zk[i] - (Zk[i] !=  Zk[i+data.dir]?al:0)];

              Zk  =  cl;
 
           }

            for  (var   i=0;  i<=data.Hk;  i++)
              d.Ja.replace(data.children[i],  data.Ok,  data.Nk[Zk[i]]);
         }
          else 
            d.Ja.replace(data.oe,  data.Ok,  data.Nk[data.zk]);

          data.Ak  =  data.zk;
       }
     }
   }
};

 d.W(d.mk);

 d["ClassShifter"] =  d.mk;
 d.mk["play"] =  d.mk.uk;
 d.mk["reset"] =  d.mk.reset;

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

      d.Oc.Sc(document.documentElement,  "mousedown",  this.Qi,  this);
      d.Oc.Sc(document.documentElement,  "mouseup",  this.hl,  this);
      d.Oc.Sc(document.documentElement,  "mousemove",  this.Ri,  this);
      d.Oc.Sc(document.documentElement,  "dragstart",  this.il,  this);
   },
    
    Qi:  function(Yc)
   {
      if  (d.wa.xa(d.r,  Yc.subject))
        for  (var   za  =  Yc.subject;  za;  za  =  za.parentNode)
          if  (d.Ja.contains(za,  "button"))
         {
            if  (!this.fl)
              this.fl  = [];

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

    hl:  function(Yc)
   {
      if  (d.wa.xa(d.r,  Yc.subject))
        if  (this.fl)
       {
          for  (var   i=0;  i<this.fl.length;  i++)
            d.Ja.replace(this.fl[i],  "down",  "up");

          this.fl  =  null;
       }
   },

    il:  function(Yc)
   {
      if  (d.wa.xa(d.r,  Yc.subject))
        if  (this.fl)
          for  (var   i=0;  i<this.fl.length;  i++)
            if  (Yc.subject  ==  this.fl[i])
              Yc.cancel();
   },

    Ri:  function(Yc)
   {
      if  (d.wa.xa(d.r,  Yc.subject) &&  this.fl  &&  Yc.subject  !=  this.gl)
     {
        this.gl  =  Yc.subject;

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

 d.el.ba();d.jl  = {
    ba:  function()
   {
      d.Oc.Sc(document.documentElement,  d.D,  this.Jd,  this);
      d.Oc.Sc(document.documentElement,  "keyup",  this.Jd,  this);
   },
    
    Jd:  function(Yc)
   {
      var   za  =  Yc.subject;
      if  (za.name)
     {
        var   value  =  d.Ga.Cb(za);

        if  (value  ||  za.kl)
       {
          var   ll  =  za.kl?document.getElementById(za.kl):d.Ga.Ha(za,  "reflector");

          if  (ll)
         {
            if  (!za.kl)
           {
              za.kl  =  d.Ga.lb(ll);
              d.Oc.Sc(za,  "paste",  this.ml,  this);
           }

            d.Ja.replace(ll,  za.name  +  "-[^\\s]*",  za.name  +  "-"  +  value);
         }
       }
     }
   },
    
    ml:  function(Yc)
   {
      d.oa.pa(this.Jd,  0,  this, [Yc])
   }
};

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

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

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

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

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

 if  (d.R)
{
    
    
    
 

 
 

    
    
    
    

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

 d.wa.xa("spifLoaded");

 d["documentScrollElement"] =  d.V;


function MenuComponent()
  {    
  };
  
  MenuComponent.prototype = 
  {
    __initialized: false,
    xsl : null,
    menuXml : null,
    firstDraw : null,
    
    doMovePage : function(id,direction)
    {
      var pageId = document.getElementById("pageId").value;
      var error = "";
    
      if ((id != null || id != "") && (direction != null || direction != ""))
        error = proxies.EditMode.ChangeMenuItemPosition(id, direction, pageId);
        
      if(error != ""){
        alert(error);
        window.location.reload();
      }
      else
      {
        window.location.reload();
      }
    },
    
    deletePage : function(pageId)
    {
      var error = "";
      if (!confirm("Weet u zeker dat u dit bestand wilt verwijderen?"))
        return;
    
      if (pageId != null || pageId != "")
        error = proxies.EditMode.DeletePage(pageId);
        
      if(error != "")
      {
        if (error == "link")
        { 
          window.location.href = "/_actions/Redirect.aspx?type=loggedinuser&id="+CURRENT_USER_ID;
        }
        else
        {
          alert(error);
          window.location.reload();
        }
      }
      else
      {
        this.drawNavigation(this.firstDraw);
      }
    },
    
    initNavigation : function (pageId)
    {
      if (this.xsl==null)
        this.xsl = "navigation.xsl";
        
      var el = document.getElementById("navigationDialog");
      if (Spif.ClassNameAbstraction.contains(el, "hidden"))
        Spif.ClassNameAbstraction.replace(el, "hidden", "shown");  
      
      this.drawNavigation(pageId);
    }, 
    
    drawNavigation : function (pageId)
    {
      try {
        this.menuXml = proxies.EditMode.getNavXmlByPageId(pageId);  
        this.firstDraw = selectSingleNode(this.menuXml, "page/@id").value;

        if (this.menuXml != null)
        {
          var el = document.getElementById("navigatieBox");
          transformXml(this.menuXml, this.xsl, el);
        }
      }
      catch (err) {
        alert(err.message)
      }
    },
    
    doMoveUp : function (pageId)
    {
      try
      {
        proxies.EditMode.movePageUpinNavByPageId(pageId);
        this.initNavigation(pageId);
      }
      catch (err)
      {
        alert(err.message)
      }
    },
    
    doMoveDown : function (pageId)
    {
      try
      {
        proxies.EditMode.movePageDowninNavByPageId(pageId);
        this.initNavigation(pageId);
      }
      catch (err)
      {
        alert(err.message)
      }
    },
    
    doIndent : function (pageId)
    {
      try
      {
        proxies.EditMode.movePageIndentByPageId(pageId);
        this.initNavigation(pageId);
      }
      catch (err)
      {
        alert(err.message)
      }
    },
    
    doOutdent : function (pageId)
    {
      try
      {
        proxies.EditMode.movePageOutdentByPageId(pageId);
        this.initNavigation(pageId);
      }
      catch (err)
      {
        alert(err.message)
      }
    },
    
    closeNavChange : function ()
    {
      var el = document.getElementById("navigationDialog");
      document.getElementById("navigatieBox").innerHTML = "";

      if (Spif.ClassNameAbstraction.contains(el,"shown"))
        Spif.ClassNameAbstraction.add(el, "hidden");        
    }
  }

var menu = new MenuComponent();





function doShownAssetDialog()
{
  // Stub for absence of assetManager
}

function doShownContactDialog()
{
  // Stub for absence of contactManager
}

function doShownPropertiesDialog()
{}

function doShownSettingsDialog()
{}


function doDropComponent(droppedEl, oldParent, oldNextSibling, newParent, newNextSibling)
{
  
  // Replace dropped element with the dropPlaceholder
  for (var i=0; i<droppedEl.childNodes.length; i++)
    if (Spif.ClassNameAbstraction.contains(droppedEl.childNodes[i], "dropPlaceholder"))
    {
      newParent.insertBefore(droppedEl.childNodes[i], droppedEl);
      newParent.removeChild(droppedEl);
      break;
    }

  //stops page from reloading when element id dropped on the place it came from.
  if (oldParent == newParent && oldNextSibling == newNextSibling)
    return;
  
  var error = null
  if (!Spif.ClassNameAbstraction.contains(document.getElementById("body"), "editMode"))
    error = "You're not in editmode"
  
  if (error == null)
  {
    /*
    **nieuw component
    */ 
    if (Spif.ClassNameAbstraction.contains(oldParent,"clone-box"))
    {
      // get placeholder nummer
      var placeholder = newParent.id;
      // get id's van object en component
      var thisComponentId = droppedEl.id;
          
      if (newNextSibling == null)
        newNextSibling = -1;
      else 
        newNextSibling = newNextSibling.id;
        
      // haal type op
      var componentClass = droppedEl.className.match(/(\w+)Component/)[1];
      
      // initial content
      var xmlDoc = initXML("<initialcontent></initialcontent>");
      if (Spif.ClassNameAbstraction.contains(droppedEl, "asset-image"))
      {
        var asset = xmlDoc.documentElement.appendChild(xmlDoc.createElement("asset"));
        var assetId = asset.appendChild(xmlDoc.createElement("id"));
        assetId.text = oldParent.id.replace("asset-","");
        var assetName = asset.appendChild(xmlDoc.createElement("name"));
        var el = getElementsByTagNameAttributeValue(oldParent,"span","class","assetName")[0];
        assetName.text = (el.textContent || el.innerText);
      }
      else if (Spif.ClassNameAbstraction.contains(droppedEl, "folder"))
      {
        var asset = xmlDoc.documentElement.appendChild(xmlDoc.createElement("asset"));
        var assetId = asset.appendChild(xmlDoc.createElement("id"));
        
        if (isMozilla)
           assetId.textContent = oldParent.id.replace("folder-","");
        else
          assetId.text = oldParent.id.replace("folder-","");
          
        var assetName = asset.appendChild(xmlDoc.createElement("name"));
        var el = getElementsByTagNameAttributeValue(oldParent,"a","class","asset-label")[0];
        
         if (isMozilla)
           assetName.textContent = (el.textContent || el.innerText);
        else
          assetName.text = (el.textContent || el.innerText);
      }
      else if (Spif.ClassNameAbstraction.contains(droppedEl, "slideshowassetimage"))
      {
        var asset = xmlDoc.documentElement.appendChild(xmlDoc.createElement("asset"));
        var assetId = asset.appendChild(xmlDoc.createElement("id"));
        assetId.text = oldParent.id.replace("asset-","");
        var assetName = asset.appendChild(xmlDoc.createElement("name"));
        var el = document.getElementById("assetSlideShowTitle");
        assetName.text = (el.textContent || el.innerText);
      }
      
      // Een Service aanroepen waarin we de wijziging doorgeven 
      var pageId = document.getElementById("pageId").value;
      var error = proxies.EditMode.CreateComponent(pageId, placeholder, componentClass, newNextSibling, xmlDoc);
      if (error == null)
        window.location.reload();  // reload doen 
      else
      {
        alert(error);
        window.location.reload();
      }
    }
    
    //get placeholder nummer
    var placeholder = newParent.id;
    
    if (newNextSibling == null)
      newNextSibling = -1;
    else 
      newNextSibling = newNextSibling.id;
      
    //get current pageId
    var pageId = document.getElementById("pageId").value;
      
    
    /*check if component is from the deleted tab*/      
    if (Spif.ClassNameAbstraction.contains(droppedEl, "deletedComponentId"))
    {
      //now get id
      var delComponentId = droppedEl.className.match(/\bdeletedComponentId-(\d+)/i)[1]
      
      //place component here
      try
      {
        proxies.ComponentManager.placeDeletedComponentInNewPage(delComponentId, pageId);
        
        var error = proxies.EditMode.MoveComponent(delComponentId, placeholder, newNextSibling);
        if (error == null)
          window.location.reload();  // reload doen 
        else
        {
          alert(error);
          window.location.reload();
        }
      }
      catch (err)
      {
        alert(err.message)
      }
    }
    
    /*check if component is from the deleted tab*/      
    if (Spif.ClassNameAbstraction.contains(droppedEl, "cutComponentId"))
    {
      //now get id
      var cutComponentId = droppedEl.className.match(/\bcutComponentId-(\d+)/i)[1];
      
      //place component here
      try
      {
        proxies.ComponentManager.placeCutComponentInNewPage(cutComponentId, pageId);
        
        var error = proxies.EditMode.MoveComponent(cutComponentId, placeholder, newNextSibling);
        if (error == null)
          window.location.reload();  // reload doen 
        else
        {
          alert(error);
          window.location.reload();
        }
      }
      catch (err)
      {
        alert(err.message)
      }
    }
    
    
    /*
    **verplaatsen component
    */
    if (Spif.ClassNameAbstraction.contains(oldParent,"columnContent"))
    {
      //get id's van object en component
      var thisComponentId = droppedEl.id;
        
      // Een Service aanroepen waarin we de wijziging doorgeven 
      var error = proxies.EditMode.MoveComponent(thisComponentId, placeholder, newNextSibling);
      if (error == null)
        window.location.reload();  // reload doen 
      else
      {
        alert(error);
        window.location.reload();
      }
    }
  }
  else
  {
    alert(error);
    window.location.reload();
  }
  
  // optioneel een "implicit save" aanroepen voor Lime
  
}

/*drop image when using it for style*/
function doDropImageComponentForStyle(droppedEl, oldParent, oldNextSibling, newParent, newNextSibling)
{
  var pageId = document.getElementById("pageId").value;
  var error = null
  if (!Spif.ClassNameAbstraction.contains(document.getElementById("body"), "editMode"))
    error = "You're not in editmode"
    
  if (error != null)
  {
    alert(error)
    newParent.innerHTML = "";
  }
  else
  {
    newParent.innerHTML = "";
    var assetId = oldParent.id.replace("asset-","");
    var link = "/_services/AssetServer.ashx/"+assetId+"?assetserver-small";
    
    newParent.innerHTML = "<img src='"+link+"' />";
        
    //save image in db
    proxies.EditMode.savePageStyleChange(pageId, newParent.id, assetId)
  }
}


/*executes when an image is dropped on another image so we can create or extend te slideshow.*/
function doDropSlideshow(droppedEl, oldParent, oldNextSibling, newParent, newNextSibling)
{
  var error = null
  if (!Spif.ClassNameAbstraction.contains(document.getElementById("body"), "editMode"))
    error = "You're not in editmode"
  
  if (error == null)
  {
    // get parameterd
    var assetId = oldParent.id.replace("asset-","").replace("folder-","");
    var componentId = getParentElementByTagNameAttributeValue(newParent, "div", "class", "component").id;
    var pageId = document.getElementById("pageId").value;
    
    // submit parameters to server
    var error = proxies.EditMode.AddAssetToMMComponent(componentId, assetId, pageId);

    if (error != null)
      alert(error);
  }
  else
    alert(error);

  window.location.reload();
}

function doDropTextImage(droppedEl, oldParent, oldNextSibling, newParent, newNextSibling)
{
  var img = null;
  if (droppedEl.firstChild)
   img = droppedEl.firstChild
  else
    img = droppedEl
    
  //set new className
  img.className = "lime-image";
  
  //set src to match component size
  var size = doGetCompView(newParent);
  img.src = img.src.split("?")[0]+"?multimediacomponent-"+size;
  
  if (isMozilla)
  {
    var tempDiv = document.createElement("p");
    tempDiv.appendChild(img);
    newNextSibling.appendChild(tempDiv);
  }
  else if (Spif.ClassNameAbstraction.contains(newParent,"richtextContent"))
  {
    newParent.childNodes[1].innerHTML += img.outerHTML;
  }
  else
    newParent.childNodes[2].innerHTML += img.outerHTML;

  ActionSave.execute();
  window.location.reload();
}

function doGetCompView(el)
{
  if (Spif.ClassNameAbstraction.contains(el, "view-small"))
    size =  "small";
  else if (Spif.ClassNameAbstraction.contains(el, "view-large"))
     size = "large";
  else if (Spif.ClassNameAbstraction.contains(el, "view-fullwidth"))
     size = "fullwidth";
  else
    doGetCompView(el.parentNode)
    
  return size;
}

/**
 * CMS functies (alleen editmode)
 */
function CMS()
{

};

/*
* Here an extra item is added to an exsisting component
* voorbeeld: Een weblog artikel
*/

CMS.prototype.doCreateNewItem = function (componentId)
{
  var error = null;
  var pageId = CURRENT_PAGE_ID;
  
  if (!Spif.ClassNameAbstraction.contains(document.getElementById("body"), "editMode"))
    error = "You're not in editmode"

  if (error == null) 
    error = proxies.EditMode.AddExtraItemToComponent(pageId, componentId);
  if (error == null)
    window.location.reload();  // reload doen 
  else
  {
    alert(error);
    window.location.reload();
  }
}

CMS.prototype.doRemoveItem = function (objectType, componentId, objectId)
{
  var error = null;
  var pageId = CURRENT_PAGE_ID;
  
  if (!Spif.ClassNameAbstraction.contains(document.getElementById("body"), "editMode"))
  {
    alert("You're not in editmode");
    return;
  }

  if (!confirm("Weet u zeker dat u dit artikel wilt verwijderen?")) return;  

  error = proxies.EditMode.DeleteItem(pageId, componentId, objectId);
    
  if (error == null)
    window.location.reload();  // reload doen 
  else
  {
    alert(error);
    window.location.reload();
  }
}

CMS.prototype.doRemoveComponent = function(componentId, componentType)
{
  var error = null;
  var pageId = CURRENT_PAGE_ID;
  var componentId = componentId;
  
  var prompt;
  switch (componentType)
  {
    case "weblog": prompt= "Weet u zeker dat u uw GEHELE Weblog wilt verwijderen? Al uw artikelen in dit weblog worden dan verwijderd."; break;
    case "map": prompt= "Weet u zeker dat u deze kaart wilt verwijderen? Al uw ingevoerde lokaties op deze kaart worden dan ook verwijderd."; break;
    case "menu": prompt= "Weet u zeker dat u dit menu wilt verwijderen van deze pagina?"; break;
    default:
     prompt = "Weet u zeker dat u deze GEHELE component wilt verwijderen?";
     break;
  }
  
  if (!confirm(prompt)) return;

  if (!Spif.ClassNameAbstraction.contains(document.getElementById("body"), "editMode"))
    error = "You're not in editmode"

  if (error == null)
    error = proxies.EditMode.DeleteComponent(pageId, componentId);
  if (error == null)
  {
    //instead of a reload, remove from DOM
    var elToRemove = document.getElementById(componentId);
    elToRemove.parentNode.removeChild(elToRemove);
  }
  else
    alert(error);
}

CMS.prototype.doCutComponent = function(componentId, componentType)
{
  var error = null;
  var pageId = CURRENT_PAGE_ID;
  var componentId = componentId;
  
  if (!confirm("Weet u zeker dat u deze component wilt knippen")) return;
   
  if (!Spif.ClassNameAbstraction.contains(document.getElementById("body"), "editMode"))
    error = "You're not in editmode"
    
  try
  {
    proxies.ComponentManager.CutComponent(pageId, componentId);
    window.location.reload();
  }
  catch (err)
  {
    alert(err.message);
  }
}

CMS.prototype.reloadWeblogComponent = function(componentId, extraVarname,  extraVarValue)
{
   var variableObject = new Array( {name:extraVarname, value:extraVarValue} );
   this.reloadComponent(componentId, variableObject)
}

/*
  define variableObject as var variableObject = new Array( {name:"currentAssetId", value:currentAssetId} );
*/
CMS.prototype.reloadComponent = function(componentId, variableObject)
{
  //check
  if (componentId == null || componentId < 1) return;
  
  //disable all componenttoolbars that are still on
  componentToolbar.__doDeactivateComponent();
  
  //find component
  var componentEl  = document.getElementById(componentId);
  var height = componentEl.offsetHeight;
  
  //empty component
  componentEl.innerHTML = "";
  
  //place div with same height
  var tempDiv = document.createElement("div");
  tempDiv.className = "tempElLoading standardContent";
  tempDiv.style.height = height+"px";
  tempDiv.innerHTML = "Een ogenblik geduld...";
  componentEl.appendChild(tempDiv);
  
  //anti cache
  var now = new Date();
  
  //get the view
  //alert(componentEl.parentNode.parentNode.className)
  var currentView = componentEl.parentNode.className.match(/\bview-(\w+)/i)[1];
  if (!currentView)
    currentView = "small";
    
  //make string out of variableObject
  var objectString = "";
  if (variableObject)
  {
    for (var i = 0 ; i < variableObject.length; i++)
    {
      var object = variableObject[i];
      objectString += "&"+ object["name"] + "=" + object["value"];
    }
  }
  
  //get content (xmlhttp)
  var contentXML = xmlhttp.request("/_fragments/Fragment.aspx?componentId="+componentId+"&view="+currentView+"&xml=true"+objectString+"&now="+now).responseXML;
  
  /*contentXML = contentXML.getElementById(componentId);
  var b = document.createElement("div");
  b.appendChild(contentXML)
  alert(b.innerHTML);;*/

  
  
  contentXML = contentXML.selectSingleNode("//*[@id='"+componentId+"']")
  
  if (isMozilla && contentXML)
  {
  
    componentEl.innerHTML = serializeXMLDoc(contentXML.firstChild);
  }
  else if (contentXML && contentXML.childNodes)
  {
    var newXML = "";
    for (var q = 0; q < contentXML.childNodes.length; q++)
    {
      newXML += contentXML.childNodes[q].xml;
    }
    componentEl.innerHTML = newXML
  }
  else if(contentXML)
  {
    componentEl.innerHTML = contentXML.xml
  }
  else
  {
    componentEl.innerHTML = "Niet gelukt nieuwe deel op te halen. Gelieve de pagina te herladen.";
  }
}


function displayStatus(name, value)
{
  switch (name) 
  {
    case "lime":
      if (value=="saving")
        status="Uw wijzigingen worden opgeslagen...";
      else
        status="";
      break;
  }
}


var prevEl = null;
function doPotentialFocusChange(evt)
{
  var box = document.getElementById("limeButtons");
  if (!box)
    return;

  if (componentToolbar.isInsideUI(evt.subject))
    return;

  var el = evt.subject;
  if (el == prevEl)
    return;

  var wasEditable = prevEl && prevEl.isContentEditable;
  prevEl = el;

  var box = document.getElementById("limeButtons");
  var btns = box.getElementsByTagName("a");

  if (wasEditable)
  {
    for (var i=0; i<btns.length; i++)
    {
      var btn = btns[i];
      if (Spif.ClassNameAbstraction.contains(btn, "lime-action"))
        Spif.ClassNameAbstraction.replace(btn, "enabled", "disabled");
    }
  }

  if (!el.isContentEditable)
    return;

  var isRichEdit = false;
  for (var tmp = el; tmp; tmp = tmp.parentNode)
    if (Spif.ClassNameAbstraction.contains(tmp, "lime-text-richtext"))
    {
      isRichEdit = true;
      break;
    }

  if (isRichEdit)
  {
    for (var i=0; i<btns.length; i++)
    {
      var btn = btns[i];
      if (Spif.ClassNameAbstraction.contains(btn, "lime-action"))
        Spif.ClassNameAbstraction.replace(btn, "disabled", "enabled");
    }
  }
  cms.isRichEdit = isRichEdit;
}


var cms = new CMS();

Spif.DOMEvents.attach(document.documentElement, "click", doPotentialFocusChange);
Spif.DOMEvents.attach(document.documentElement, "keyup", doPotentialFocusChange);

function Reaction()
{    
};

Reaction.prototype = 
{ 
  lastRating : null,

  setReactionUrl : function(reactionSort, id, tab)
  {
    if (!id || !reactionSort)
      return;
    
    Iframe = document.getElementById("reactionFrame");
    var IframeUrl = Iframe.src.split("?");
    
    //variable to prevent cache 
    var now = new Date();
    
    if (IframeUrl[0])
    {
      if (tab == 1)
        Iframe.src = IframeUrl[0] + "?sort="+ reactionSort + "&id="+ id + "&start=0&numberofrows=0&antiCache="+now;
      else if (tab == 2)
        Iframe.src = IframeUrl[0] + "?sort="+ reactionSort + "&id="+ id + "&start=0&numberofrows=0&beoordeling=mijn&antiCache="+now;
    }
      
    //open dialog
    dialog = document.getElementById("reactionDialog");
    Spif.ClassNameAbstraction.replace(dialog, "hidden", "shown");
  },
  
  checkReactionForm : function()
  {
    var name = null;
    var email = null;
    
    if (document.getElementById("reaction_name") != null)
      name = document.getElementById("reaction_name").value;
     
    if (document.getElementById("reaction_email") != null)
      email = document.getElementById("reaction_email").value; 
    
    var error = proxies.Validation.checkReactionForm(name, email);
    if (error == "" || error == null || error == "\n")
    {
      return true
    }
    else
    {
      alert(error);
      return false 
    }
  },
  
  getRating : function (evt) 
  {
    el = document.getElementById("giveRating");
    var percentage = (evt.clientX - findPos(el)[0]) / el.offsetWidth;
    return Math.ceil(percentage * 5);
  },
  
  setRating : function (evt)
  {
    el = document.getElementById("giveRating");
    //get rating
    var rating = this.getRating(evt)
    //set right class
    el.className = "ratingBox rated-"+(rating*2);
    //rumble the alement, otherwise className change won't have effect on layout
    el.parentNode.appendChild(el);
    document.getElementById("rating").value = rating*2;
  },
  
  getLastRating : function()
  {
    if (!this.mouseIn)
    {
      el = document.getElementById("giveRating");
      var className = el.className;
      this.lastRating = className.split("-")[1];
//document.title = this.lastRating;
      this.mouseIn = true;
    }
  },
  
  getPotentialRating : function(evt)
  {
  
    this.getLastRating();
    this.setRating(evt);
  },
  
  setOldRating : function ()
  {
    //el = document.getElementById("giveRating");
    //el.className = "ratingBox rated-"+this.lastRating;
  }
}
  
var reaction = new Reaction();  
    



function doShownPropertiesDialog()
{
  dialog.drawProperties();
}




function Dialog()
  {    
  };
  
  Dialog.prototype = 
  {
    colorNumberEl:null,
  
    userInEditmode : function()
    {
      return Spif.ClassNameAbstraction.contains(document.getElementById("body"), "editMode");
    },
  
    changePageLayout : function()
    {
      var el = getElementsByTagNameAttributeValue(document.getElementById("pickLayouts"), "div", "class", "selected")[0];
            
      //check of er wel op een layout is geklikt
      if (el == null)
        return;
      
      //check of user rechten heeft
      if (!this.userInEditmode())
        return;

      //check of id gevuld is
      if (el.id == null)
        el.id = "layout-basic";
        
      //ok; haal layoutnaam op
      var layoutnaam = el.id.substr(7,el.id.length);
      var pageId = document.getElementById("pageId").value;
      
      //haal op toepassigsgebied op
      var apply = "";
      var applyToAll = document.getElementById("applyToAll").checked;
      if (applyToAll)
        apply = "all";
      else
        apply = "this"
      
      var error = proxies.EditMode.ChangeLayoutOfPage(pageId, layoutnaam, apply);
      if (error == "")
        window.location.reload();
      else
      {
        alert(error);
        window.location.reload();
      }
    },
    
    changePageStyle : function()
    {
      var el = getElementsByTagNameAttributeValue(document.getElementById("styleBox"), "img", "class", "selected")[0];
      var advancedSettingsEl = document.getElementById("advancedStyleSettingsTab");
      var pageId = document.getElementById("pageId").value;
      var stylenaam = "basic";
      
      //check of user rechten heeft
      if (!this.userInEditmode())
        return;  
      
      //check of er wel op een layout is geklikt
      if (el == null && Spif.ClassNameAbstraction.contains(advancedSettingsEl, "collapsed-tab"))
        return;
      else
        stylenaam = "personalized";
      
      //haal op toepassigsgebied op
      var apply = "";
      var applyToAll = document.getElementById("styleApplyToAll").checked;
      if (applyToAll)
        apply = "all";
      else
        apply = "this"

      //haal stylenaam op
      if (el && el.id != null)
        stylenaam = el.id.substr(6,el.id.length);

      //opslaan nieuwe stijl
      var error = proxies.EditMode.ChangePageStyle(pageId, stylenaam, apply);
      if (error == "")
        window.location.reload();
      else
      {
        alert(error);
        window.location.reload();
      }
    },
    
    openColorPicker : function (colorNumberId)
    {      
      this.colorNumberEl = document.getElementById(colorNumberId);
    },
    
    returnPickedColor : function(el) 
    {    
      if (Spif.ClassNameAbstraction.contains(document.getElementById("colorpickerDialog"), "shown"))
        Spif.ClassNameAbstraction.replace(document.getElementById("colorpickerDialog"), "shown", "hidden")
        
      var value;
      if (el.style.backgroundColor == null || el.style.backgroundColor == "")
        value = "Transparent";
      else
        value = el.style.backgroundColor;
        
      this.colorNumberEl.value = value;
      this.colorNumberEl.parentNode.firstChild.style.backgroundColor = el.style.backgroundColor;
      
      this.saveStyleChange(this.colorNumberEl.id, value)
    },
    
    styleselectbox : function(el)
    {
      this.saveStyleChange(el.id, el.value)
    },
    
    stylecheckbox : function (el)
    {
      var checked = "no-repeat";
      if (el.checked)
        checked = "repeat";
        
      this.saveStyleChange(el.id, checked)  
    },
    
    saveStyleChange : function(name, value)
    {
      //save change with service
      var pageId = document.getElementById("pageId").value;
      var error = proxies.EditMode.savePageStyleChange(pageId, name, value)
      if (error != "")
        alert(error);
      else
        setTimeout( this.resetCss, 500);
        
      this.deletebuttonActivator();
    },
    
    resetCss : function() 
    {
      var pageId = document.getElementById("pageId").value;
      
      var currentCss = document.getElementById("personalizedCss");
      if (currentCss != null)
        currentCss.parentNode.removeChild(currentCss);        
      
      var link = document.createElement("link");
      link.id = "personalizedCss";
      link.setAttribute("type", "text/css");
      link.setAttribute("rel", "stylesheet");
      link.setAttribute("href", "/_css/skins/personalized.aspx?pageId="+pageId+"&"+new Date());
      document.getElementsByTagName("head")[0].appendChild(link);
    },
    
    setPickedColors : function()
    {
      //pickedColor
      var els = getElementsByTagNameAttributeValue(document.getElementById("styleDialog"), "span", "class", "pickedColor")
      for (i=0; i < els.length; i++)
      {
        var el = els[i];
        el.style.backgroundColor = el.nextSibling.value;
      }
      
      this.deletebuttonActivator();
    },
    
    deletebuttonActivator : function()
    {
      var els = getElementsByTagNameAttributeValue(document.getElementById("styleDialog"), "div", "class", "clearRule")
      for (i=0; i < els.length; i++)
      {
        el = els[i];
        var valueId = el.className.split(" ")[1].replace("deletefor-","");
        var valueEl = document.getElementById(valueId);
        
        if (Spif.ClassNameAbstraction.contains(valueEl, "colorNumber"))
        {
          if (valueEl.value == "")
            Spif.ClassNameAbstraction.add(el, "hidden")
          else
            Spif.ClassNameAbstraction.remove(el, "hidden")
        }
        if (Spif.ClassNameAbstraction.contains(valueEl, "placeholder"))
        {
          if (valueEl.innerHTML == "")
            Spif.ClassNameAbstraction.add(el, "hidden")
          else
            Spif.ClassNameAbstraction.remove(el, "hidden")
        }
      }
    },
    
    deleteStyleSetting : function(evt)
    {
      el = evt.srcElement || evt.target;
      
      if (Spif.ClassNameAbstraction.contains(el, "clearRule"))
      {
        var pageId = document.getElementById("pageId").value;
        var nameToDelete = el.className.split(" ")[1].replace("deletefor-","");
        proxies.EditMode.removePageStyle(pageId, nameToDelete)
        this.emptyStyleSetting(document.getElementById(nameToDelete));
      }
      
      this.deletebuttonActivator();
    },
    
    emptyStyleSetting : function(el)
    {
      if (el)
      {
        if (Spif.ClassNameAbstraction.contains(el, "colorNumber"))
        {
          el.value = "";
          el.parentNode.firstChild.style.background = "none";
        }
        if (Spif.ClassNameAbstraction.contains(el, "placeholder"))
        {
          el.innerHTML = "";
        }
        
      }
      setTimeout( this.resetCss, 500);
    },
    
    openAssetManager : function()
    {
      var assetEl = document.getElementById("assetmanagerDialog");
      var styleEl = document.getElementById("styleDialog");
      
      //position dialogs
      styleEl.style.top = "98px";
      styleEl.style.left = "10px";
      assetEl.style.top = "98px";
      assetEl.style.left = "420px";
    },
    
    
    /*send a message functions*/
    setMessageSettings : function (userId)
    {
      //if not a loggedin user, show extra inputfields
      bodyEl = document.getElementById("body")
      if (!Spif.ClassNameAbstraction.contains(bodyEl, "loggedIn"))
        Spif.ClassNameAbstraction.remove(document.getElementById("sendMessageBox").firstChild, "hideSendersInfo");
      
      this.sendMessageToId = userId;
      this.openMessageDialog();
    },
    
    openMessageDialog : function ()
    {
      var el = document.getElementById("sendAMessageDialog");
      if (Spif.ClassNameAbstraction.contains(el,"hidden"))
        Spif.ClassNameAbstraction.replace(el, "hidden", "shown");
    },
    
    closeMessageDialog : function ()
    {
      var el = document.getElementById("sendAMessageDialog");
      document.getElementById("messageText").innerHTML = "";
      
      if (Spif.ClassNameAbstraction.contains(el,"shown"))
        Spif.ClassNameAbstraction.add(el, "hidden");        
    },
    
    sendMessage : function ()
    {
      try
      {
        var message = document.getElementById("messageText").value;
        var subject = "Je hebt een bericht ontvangen";
        bodyEl = document.getElementById("body")
        if (!Spif.ClassNameAbstraction.contains(bodyEl, "loggedIn"))
        {
          var email =  document.getElementById("sendersEmail").value;
          if (email.indexOf("@") == -1 || email.indexOf(".") == -1)
          {
            alert("Emailadres is incorrect");
            return;
          }
          else
            proxies.ContactManager.sendEmailToUserWithEmailadres(this.sendMessageToId, subject, message, email);
        }
        else
          proxies.ContactManager.sendEmailToUser(this.sendMessageToId, subject, message);
        
        this.closeMessageDialog() 
      }
      catch(err)
      {
        alert(err.message)
      }
    },
    
    /*PROPERTY FUNCTIONS*/
    drawProperties : function()
    {
      this.groups =  proxies.EditMode.getAllGroupInformation(CURRENT_PAGE_ID);
      if (this.groups != null)
      {
        try
        {
          var el = document.getElementById("propertiesContentDialog");
          transformXml(this.groups, "propertyDialog.xsl", el);
        }
        catch (err)
        {
          alert(err.message)
        }
      }
    },
    
    /*this.contacts = proxies.Co