2014-05-17 18:52:07 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys
  
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								if  ( ! Object . keys )  {  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  Object . keys  =  ( function  ( )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    var  hasOwnProperty  =  Object . prototype . hasOwnProperty , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        hasDontEnumBug  =  ! ( { toString :  null } ) . propertyIsEnumerable ( 'toString' ) , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        dontEnums  =  [ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								          'toString' , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								          'toLocaleString' , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								          'valueOf' , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								          'hasOwnProperty' , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								          'isPrototypeOf' , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								          'propertyIsEnumerable' , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								          'constructor' 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        ] , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        dontEnumsLength  =  dontEnums . length ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    return  function  ( obj )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      if  ( typeof  obj  !==  'object'  &&  typeof  obj  !==  'function'  ||  obj  ===  null )  throw  new  TypeError ( 'Object.keys called on non-object' ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								      var  result  =  [ ] ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								      for  ( var  prop  in  obj )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        if  ( hasOwnProperty . call ( obj ,  prop ) )  result . push ( prop ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      } 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								      if  ( hasDontEnumBug )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        for  ( var  i = 0 ;  i  <  dontEnumsLength ;  i ++ )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								          if  ( hasOwnProperty . call ( obj ,  dontEnums [ i ] ) )  result . push ( dontEnums [ i ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      return  result ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  } ) ( ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								}  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2014-05-17 18:52:07 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
  
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								if  ( ! Array . prototype . filter )  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								{  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  Array . prototype . filter  =  function ( fun  /*, thisp */ ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    "use strict" ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    if  ( this  ==  null ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      throw  new  TypeError ( ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    var  t  =  Object ( this ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    var  len  =  t . length  >>>  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    if  ( typeof  fun  !=  "function" ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      throw  new  TypeError ( ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    var  res  =  [ ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    var  thisp  =  arguments [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    for  ( var  i  =  0 ;  i  <  len ;  i ++ ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      if  ( i  in  t ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        var  val  =  t [ i ] ;  // in case fun mutates this
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        if  ( fun . call ( thisp ,  val ,  i ,  t ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								          res . push ( val ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    return  res ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								}  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2014-05-17 18:52:07 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								if  ( ! String . prototype . trim )  {  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  String . prototype . trim  =  function  ( )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    return  this . replace ( /^\s+|\s+$/g ,  '' ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								}  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								if  ( ! Array . prototype . forEach )  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								{  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  Array . prototype . forEach  =  function ( fun  /*, thisArg */ ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    "use strict" ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    if  ( this  ===  void  0  ||  this  ===  null ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      throw  new  TypeError ( ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    var  t  =  Object ( this ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    var  len  =  t . length  >>>  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    if  ( typeof  fun  !==  "function" ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      throw  new  TypeError ( ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    var  thisArg  =  arguments . length  >=  2  ?  arguments [ 1 ]  :  void  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    for  ( var  i  =  0 ;  i  <  len ;  i ++ ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      if  ( i  in  t ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        fun . call ( thisArg ,  t [ i ] ,  i ,  t ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								}  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								// Production steps of ECMA-262, Edition 5, 15.4.4.19
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								// Reference: http://es5.github.com/#x15.4.4.19
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								if  ( ! Array . prototype . map )  {  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  Array . prototype . map  =  function ( callback ,  thisArg )  { 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    var  T ,  A ,  k ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    if  ( this  ==  null )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      throw  new  TypeError ( " this is null or not defined" ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    // 1. Let O be the result of calling ToObject passing the |this| value as the argument.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    var  O  =  Object ( this ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    // 2. Let lenValue be the result of calling the Get internal method of O with the argument "length".
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    // 3. Let len be ToUint32(lenValue).
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    var  len  =  O . length  >>>  0 ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    // 4. If IsCallable(callback) is false, throw a TypeError exception.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    // See: http://es5.github.com/#x9.11
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    if  ( typeof  callback  !==  "function" )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      throw  new  TypeError ( callback  +  " is not a function" ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    if  ( thisArg )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      T  =  thisArg ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    // 6. Let A be a new array created as if by the expression new Array(len) where Array is
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    // the standard built-in constructor with that name and len is the value of len.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    A  =  new  Array ( len ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    // 7. Let k be 0
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    k  =  0 ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    // 8. Repeat, while k < len
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    while ( k  <  len )  { 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								      var  kValue ,  mappedValue ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								      // a. Let Pk be ToString(k).
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      //   This is implicit for LHS operands of the in operator
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      // b. Let kPresent be the result of calling the HasProperty internal method of O with argument Pk.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      //   This step can be combined with c
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      // c. If kPresent is true, then
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      if  ( k  in  O )  { 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								        // i. Let kValue be the result of calling the Get internal method of O with argument Pk.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        kValue  =  O [  k  ] ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								        // ii. Let mappedValue be the result of calling the Call internal method of callback
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        // with T as the this value and argument list containing kValue, k, and O.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        mappedValue  =  callback . call ( T ,  kValue ,  k ,  O ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								        // iii. Call the DefineOwnProperty internal method of A with arguments
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        // Pk, Property Descriptor {Value: mappedValue, : true, Enumerable: true, Configurable: true},
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        // and false.
 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								        // In browsers that support Object.defineProperty, use the following:
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        // Object.defineProperty(A, Pk, { value: mappedValue, writable: true, enumerable: true, configurable: true });
 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								        // For best browser support, use the following:
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        A [  k  ]  =  mappedValue ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      // d. Increase k by 1.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      k ++ ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    // 9. return A
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    return  A ; 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								  } ; 
							 
						 
					
						
							
								
									
										
										
										
											2012-12-03 19:47:44 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								}  
						 
					
						
							
								
									
										
										
										
											2014-02-17 21:45:37 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2014-05-17 18:52:07 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								if  ( ! Array . prototype . indexOf )  {  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  Array . prototype . indexOf  =  function  ( searchElement ,  fromIndex )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    if  (  this  ===  undefined  ||  this  ===  null  )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      throw  new  TypeError (  '"this" is null or not defined'  ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    var  length  =  this . length  >>>  0 ;  // Hack to convert object.length to a UInt32
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    fromIndex  =  + fromIndex  ||  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    if  ( Math . abs ( fromIndex )  ===  Infinity )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      fromIndex  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    if  ( fromIndex  <  0 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      fromIndex  +=  length ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      if  ( fromIndex  <  0 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        fromIndex  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    for  ( ; fromIndex  <  length ;  fromIndex ++ )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      if  ( this [ fromIndex ]  ===  searchElement )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        return  fromIndex ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    return  - 1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								}  
						 
					
						
							
								
									
										
										
										
											2014-07-22 16:28:39 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								// Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray
  
						 
					
						
							
								
									
										
										
										
											2014-05-17 18:52:07 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2014-07-22 16:28:39 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								if  ( !  Array . isArray )  {  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    Array . isArray  =  function ( obj )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        return  Object . prototype . toString . call ( obj )  ===  "[object Array]" ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								}  
						 
					
						
							
								
									
										
										
										
											2014-05-17 18:52:07 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2014-02-17 21:45:37 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								// https://github.com/ttaubert/node-arraybuffer-slice
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								// (c) 2013 Tim Taubert <tim@timtaubert.de>
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								// arraybuffer-slice may be freely distributed under the MIT license.
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								"use strict" ;  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2014-05-17 18:52:07 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								if  ( typeof  ArrayBuffer  !==  'undefined'  &&  ! ArrayBuffer . prototype . slice )  {  
						 
					
						
							
								
									
										
										
										
											2014-02-17 21:45:37 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								  ArrayBuffer . prototype . slice  =  function  ( begin ,  end )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    begin  =  ( begin | 0 )  ||  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    var  num  =  this . byteLength ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    end  =  end  ===  ( void  0 )  ?  num  :  ( end | 0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    // Handle negative values.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    if  ( begin  <  0 )  begin  +=  num ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    if  ( end  <  0 )  end  +=  num ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    if  ( num  ===  0  ||  begin  >=  num  ||  begin  >=  end )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      return  new  ArrayBuffer ( 0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    var  length  =  Math . min ( num  -  begin ,  end  -  begin ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    var  target  =  new  ArrayBuffer ( length ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    var  targetArray  =  new  Uint8Array ( target ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    targetArray . set ( new  Uint8Array ( this ,  begin ,  length ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    return  target ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								}  
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								// https://github.com/davidchambers/Base64.js
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								// (C) 2015 David Chambers
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								// Base64.js may be freely distributed under the Apache 2.0 License.
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								; ( function  ( )  {  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2017-03-25 22:38:26 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								  var  object  = 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    typeof  exports  !=  'undefined'  ?  exports  : 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    typeof  self  !=  'undefined'  ?  self  :  // #8: web workers
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    $ . global ;  // #31: ExtendScript
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								  var  chars  =  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=' ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  function  InvalidCharacterError ( message )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    this . message  =  message ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  InvalidCharacterError . prototype  =  new  Error ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  InvalidCharacterError . prototype . name  =  'InvalidCharacterError' ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  // encoder
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  // [https://gist.github.com/999166] by [https://github.com/nignag]
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  object . btoa  ||  ( 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  object . btoa  =  function  ( input )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    var  str  =  String ( input ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    for  ( 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      // initialize result and counter
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      var  block ,  charCode ,  idx  =  0 ,  map  =  chars ,  output  =  '' ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      // if the next str index does not exist:
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      //   change the mapping table to "="
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      //   check if d has no fractional digits
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      str . charAt ( idx  |  0 )  ||  ( map  =  '=' ,  idx  %  1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      // "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      output  +=  map . charAt ( 63  &  block  >>  8  -  idx  %  1  *  8 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      charCode  =  str . charCodeAt ( idx  +=  3 / 4 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      if  ( charCode  >  0xFF )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        throw  new  InvalidCharacterError ( "'btoa' failed: The string to be encoded contains characters outside of the Latin1 range." ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      block  =  block  <<  8  |  charCode ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    return  output ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  } ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  // decoder
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  // [https://gist.github.com/1020396] by [https://github.com/atk]
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  object . atob  ||  ( 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  object . atob  =  function  ( input )  { 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-25 22:38:26 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								    var  str  =  String ( input ) . replace ( /[=]+$/ ,  '' ) ;  // #31: ExtendScript bad parse of /=
 
							 
						 
					
						
							
								
									
										
										
										
											2017-03-22 17:55:32 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								    if  ( str . length  %  4  ==  1 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      throw  new  InvalidCharacterError ( "'atob' failed: The string to be decoded is not correctly encoded." ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    for  ( 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      // initialize result and counters
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      var  bc  =  0 ,  bs ,  buffer ,  idx  =  0 ,  output  =  '' ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      // get next character
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      buffer  =  str . charAt ( idx ++ ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      // character found in table? initialize bit storage and add its ascii value;
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      ~ buffer  &&  ( bs  =  bc  %  4  ?  bs  *  64  +  buffer  :  buffer , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        // and if not first of each 4 characters,
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        // convert the first 8 bits to one ascii character
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        bc ++  %  4 )  ?  output  +=  String . fromCharCode ( 255  &  bs  >>  ( - 2  *  bc  &  6 ) )  :  0 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      // try to find character in table (0-63, not found => -1)
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      buffer  =  chars . indexOf ( buffer ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    return  output ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  } ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								} ( ) ) ;  
						 
					
						
							
								
									
										
										
										
											2017-03-23 01:56:21 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								if  ( ! Date . prototype . toISOString )  {  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  ( function ( )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    function  pad ( number )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      if  ( number  <  10 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        return  '0'  +  number ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      return  number ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    Date . prototype . toISOString  =  function ( )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      return  this . getUTCFullYear ( )  + 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        '-'  +  pad ( this . getUTCMonth ( )  +  1 )  + 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        '-'  +  pad ( this . getUTCDate ( ) )  + 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        'T'  +  pad ( this . getUTCHours ( ) )  + 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        ':'  +  pad ( this . getUTCMinutes ( ) )  + 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        ':'  +  pad ( this . getUTCSeconds ( ) )  + 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        '.'  +  ( this . getUTCMilliseconds ( )  /  1000 ) . toFixed ( 3 ) . slice ( 2 ,  5 )  + 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        'Z' ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  } ( ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								}  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2017-09-30 06:19:01 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								// note: MDN shim will not work in IE
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								if ( typeof  Uint8Array  !==  'undefined'  &&  ! Uint8Array . prototype . slice )  Uint8Array . prototype . slice  =  function ( start ,  end )  {  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									if ( start  <  0 )  {  start  +=  this . length ;  if ( start  <  0 )  start  =  0 ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									if ( start  >=  this . length )  return  new  Uint8Array ( 0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									if ( end  ==  null )  end  =  this . length ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									if ( end  <  0 )  {  end  +=  this . length ;  if ( end  <  0 )  end  =  0 ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									if ( end  >  this . length )  end  =  this . length ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									var  out  =  new  Uint8Array ( end  -  start ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									while ( start  <=  -- end )  out [ end  -  start ]  =  this [ end ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									return  out ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								} ;  
						 
					
						
							
								
									
										
										
										
											2018-02-03 20:43:07 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								// VBScript + ActiveX fallback for IE5+
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								var  IE _SaveFile  =  ( function ( )  {  try  {  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									if ( typeof  IE _SaveFile _Impl  ==  "undefined" )  document . write ( [ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								'<script type="text/vbscript" language="vbscript">' ,  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								'IE_GetProfileAndPath_Key = "HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders\\"' ,  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								'Function IE_GetProfileAndPath(key): Set wshell = CreateObject("WScript.Shell"): IE_GetProfileAndPath = wshell.RegRead(IE_GetProfileAndPath_Key & key): IE_GetProfileAndPath = wshell.ExpandEnvironmentStrings("%USERPROFILE%") & "!" & IE_GetProfileAndPath: End Function' ,  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								'Function IE_SaveFile_Impl(FileName, payload): Dim data, plen, i, bit: data = CStr(payload): plen = Len(data): Set fso = CreateObject("Scripting.FileSystemObject"): fso.CreateTextFile FileName, True: Set f = fso.GetFile(FileName): Set stream = f.OpenAsTextStream(2, 0): For i = 1 To plen Step 3: bit = Mid(data, i, 2): stream.write Chr(CLng("&h" & bit)): Next: stream.Close: IE_SaveFile_Impl = True: End Function' ,  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								'|/script>' . replace ( "|" , "<" )  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									] . join ( "\r\n" ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									if ( typeof  IE _SaveFile _Impl  ==  "undefined" )  return  void  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									var  IE _GetPath  =  ( function ( )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
										var  DDP1  =  "" ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
										try  {  DDP1  =  IE _GetProfileAndPath ( "{374DE290-123F-4565-9164-39C4925E467B}" ) ;  }  catch ( e )  {  try  {  DDP1  =  IE _GetProfileAndPath ( "Personal" ) ;  }  catch ( e )  {  try  {  DDP1  =  IE _GetProfileAndPath ( "Desktop" ) ;  }  catch ( e )  {  throw  e ;  } } } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
										var  o  =  DDP1 . split ( "!" ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
										DDP  =  o [ 1 ] . replace ( "%USERPROFILE%" ,  o [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
										return  function ( path )  {  return  DDP  +  "\\"  +  path ;  } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									} ) ( ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									function  fix _data ( data )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
										var  out  =  [ ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
										var  T  =  typeof  data  ==  "string" ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
										for ( var  i  =  0 ;  i  <  data . length ;  ++ i )  out . push ( ( "00" + ( T  ?  data . charCodeAt ( i )  :  data [ i ] ) . toString ( 16 ) ) . slice ( - 2 ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
										var  o  =  out . join ( "|" ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
										return  o ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									return  function ( data ,  filename )  {  return  IE _SaveFile _Impl ( IE _GetPath ( filename ) ,  fix _data ( data ) ) ;  } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								}  catch ( e )  {  return  void  0 ;  } } ) ( ) ;  
						 
					
						
							
								
									
										
										
										
											2018-02-14 05:26:28 +00:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								var  IE _LoadFile  =  ( function ( )  {  try  {  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									if ( typeof  IE _LoadFile _Impl  ==  "undefined" )  document . write ( [ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								'<script type="text/vbscript" language="vbscript">' ,  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								'Function IE_LoadFile_Impl(FileName): Dim out(), plen, i, cc: Set fso = CreateObject("Scripting.FileSystemObject"): Set f = fso.GetFile(FileName): Set stream = f.OpenAsTextStream(1, 0): plen = f.Size: ReDim out(plen): For i = 1 To plen Step 1: cc = Hex(Asc(stream.read(1))): If Len(cc) < 2 Then: cc = "0" & cc: End If: out(i) = cc: Next: IE_LoadFile_Impl = Join(out,""): End Function' ,  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								'|/script>' . replace ( "|" , "<" )  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									] . join ( "\r\n" ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									if ( typeof  IE _LoadFile _Impl  ==  "undefined" )  return  void  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									function  fix _data ( data )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
										var  out  =  [ ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
										for ( var  i  =  0 ;  i  <  data . length ;  i += 2 )  out . push ( String . fromCharCode ( parseInt ( data . slice ( i ,  i + 2 ) ,  16 ) ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
										var  o  =  out . join ( "" ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
										return  o ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
									return  function ( filename )  {  return  fix _data ( IE _LoadFile _Impl ( filename ) ) ;  } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								}  catch ( e )  {  return  void  0 ;  } } ) ( ) ;