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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"));