if (typeof atob == "undefined"){
              function atob(str) {
                  var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
                  var invalid = {
                      strlen: (str.length % 4 != 0),
                      chars:  new RegExp('[^' + chars + ']').test(str),
                      equals: (/=/.test(str) && (/=[^=]/.test(str) || /={3}/.test(str)))
                  };
                  if (invalid.strlen || invalid.chars || invalid.equals)
                      throw new Error("Invalid base64 data");
                  var decoded = [];
                  var c = 0;
                  while (c < str.length) {
                      var i0 = chars.indexOf(str.charAt(c++));
                      var i1 = chars.indexOf(str.charAt(c++));
                      var i2 = chars.indexOf(str.charAt(c++));
                      var i3 = chars.indexOf(str.charAt(c++));
                      var buf = (i0 << 18) + (i1 << 12) + ((i2 & 63) << 6) + (i3 & 63);
                      var b0 = (buf & (255 << 16)) >> 16;
                      var b1 = (i2 == 64) ? -1 : (buf & (255 << 8)) >> 8;
                      var b2 = (i3 == 64) ? -1 : (buf & 255);
                      decoded[decoded.length] = String.fromCharCode(b0);
                      if (b1 >= 0) decoded[decoded.length] = String.fromCharCode(b1);
                      if (b2 >= 0) decoded[decoded.length] = String.fromCharCode(b2);
                  }
                  return decoded.join('');
              }
          }
        
          function kickFloatDivUp(){
           if((parseInt(document.getElementById("nne_reader_floatdiv").style.top)+100)>0) document.getElementById("nne_reader_floatdiv").style.top = 0+"px";
           else {
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",30,"up"); },1);
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },50);
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },150);
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },250);
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },350);
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },450);
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },550);
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },750);
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },1000);
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },1250);
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },1500);
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"up"); },1750);
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"up"); },2000);
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"up"); },2250);
             window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"up");  },2500);
           }
          }

          function kickFloatDivDown(){
           //if(!floatDiv) floatDiv = document.getElementById("nne_reader_floatdiv");
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",30,"down"); },1);
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },50);
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },150);
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },250);
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },350);
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },450);
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },550);
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },750);
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },1000);
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },1250);
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },1500);
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"down"); },1750);
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"down"); },2000);
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"down"); },2250);
           window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"down");  },2500);
          }  
          
          function moveDiv(id,dist,direction){
            var obj = document.getElementById(id);
            switch(direction){
               case "up"   :
                if(parseInt(obj.style.top)>1) obj.style.top = 0+"px";
                else                          obj.style.top = (parseInt(obj.style.top)+dist)+"px";
               break;
               case "down" : obj.style.top = (parseInt(obj.style.top)-dist)+"px"; break;
            }
          }document.write(atob("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"));