/*
	*===============================*
	|     uTorrent Monitor v1.2     |
	|  by Henrik 'TwoD' Danielsson  |
	|  the_dragonwizard@hotmail.com |
	*===============================*

	This script lists all the torrents in the bitTorrent client uTorrent by reading the resume.dat file.
	The functions ListTorrents(format) and ListTorrentsByLabel(format) take a string with tags as an argument.
	The allowed tags are listed below.

	To make this work, you must enter the path to the folder with resume.dat in the variable resumeDatPath,
	otherwise the file won't be found. Ex. "C:\\Documents and Settings\\username\\Application Data\\uTorrent"

	getTotalDown(labels) Returns how much has been totally downloaded. Does not include wasted data for uTorrent 1.6 and above.
	getTotalUp(labels) Returns how much has been totally uploaded.
	getTotalRatio(labels) Returns the overall ratio. Excludes wasted data in uTorrent 1.6 and above.
	getTotalWaste(labels) Returns the amount of waste data. Only in uTorrent 1.6 and above.
	getNumOfTorrents(labels) Return the total number of torrents.
	getNumOfStartedTorrents(labels) Returns the number of started torrents.
	getNumOfDownloadingTorrents(labels) Returns the number of torrents with "downloading" status.
	getNumOfSeedingTorrents(labels) Returns the number of torrents with "seeding" status.
       	getNumOfCompletedTorrents(labels) Returns the number of torrents with "completed" status.
        getNumOfNotCompletedTorrents(labels) Returns the number of torrents with "not completed" status.

	The labels argument is a list of labels which can be used if you only want data from some torrents.
	If labels is left blank, data is collected from all torrents.
	Ex. getNumOfTorrents("Movies|Games") will show the number of torrents in with the label "Movies" or "Games".
	================================================================================================================================
	Stat Tags:
		<label> - The label assigned to the torrent.
		<torrentname> - The filename of the torrent, w/o ".torrent"
		<name> - The name of the downloaded file or folder.
		<caption> - The original name of the release, only available in uTorrent 1.6 and above.
		<ratio> - The ratio in up to 3 decimals. (uploaded/downloaded)
		<path> - The path to the downloaded files.
		<downloaded> - The downloaded amount in bytes, Kb, Mb etc. Excludes waste downloaded data.
		<waste> - Shows the amount of downloaded waste data in bytes, Kb, Mb etc.
		<uploaded> - The uploaded amount in bytes, Kb, Mb etc.
		<runtime> - How long the torrent has been active in weeks, days, minutes, hours and seconds.
		<seedtime> - How long the torrent has been seeding in weeks, days, minutes, hours and seconds.
		<speed up> - The average upload speed in b/s, Kb/s, etc. (uploaded/runtime)
		<speed down> - The average download speed in b/s, Kb/s, etc. (downloaded/(runtime-seedtime))
		<done> - How complete the download is in %. (A bit inaccurate since it counts blocks, not bytes)
		<eta> - Estimatet Time of Arrival. A rough estimate of the time left until 100% downloaded.
		<hash> - The hash.
		<peers> - The total number of peers and seeders available, sorry but I can't split them up.
		<added> - Shows the date when the torrent was added.
		<break> - Adds a linebreak.
		<tab> - Adds a tab.

	The [show] and [hide] Tags:
		Attributes:
		        labels="Label A|Label B|Label C..."
		        mode="started stopped seeding leeching active inactive complete incomplete"

		A [show] or [hide] tag can be placed anywhere in the format string and will be completely removed during parsing.
		Only the first encountered tag will be used, any other are simply removed.
		[show] - Only lists torrents with the specified labels and mode.
		[hide] - Only lists torrents without the specified labels and mode.
		The [show] and [hide] tags must have atleast one of the two attributes to be effective.
                ********************************************************************************************************************
		label is a list of label names which should be shown or hidden, separated by "|".
		********************************************************************************************************************
		mode is used to set which types of torrents should be shown or hidden.
		It can have on or more of these values:
			"started"       Torrent has been started (forced start also counts).
			"stopped"       Torrent is not started.
			"active"        Torrent has peers and is currently downloding blocks (unless seeding).
			"inactive"      Torrent has no peers or is currently not downloading any blocks (or is seeding).
			"complete"      Torrent has been marked as completed, if not all files has been downloaded it will not count as seeding.
			"incomplete"    Torrent has not been marked as completed.
			"leeching"      Torrent is reported to the tracker in leeching mode.
			"seeding"       Torrent is reported to the tracker in seeding mode. If not all files are downloded it will not count as seeding.

		If more than one of the values is used, separate them with spaces. If two conflicting values such as "seeding" and "leeching" is set, both will be ignored.
		Note that uTorrent says a torrent is active when it has either up- or down-speed above 0. Resume.dat contains no info about the current speeds (only the limits)
		so a torrent is considered active if it has peers and is currently downloading blocks unless seeding.
		There is no way of knowing if a seeding torrent should be active or not by looking at resume.dat alone.
		********************************************************************************************************************

		If BOTH a label and mode attribute has been set, ONLY torrents matching BOTH requierments will be shown/hidden.
                Ex.
		[show labels="A" mode="leeching"] will show all leeching torrent with label "A".
                [hide labels="A" mode="leeching"] will hide all leeching torrents with label "A",
  		 seeding torrents with label "Label A" will still be shown. All torrents without label "A" will also be shown.
                [show labels="A|B" mode="seeding started"] will show all seeding and started torrents with labels "A" or "B".
		 If a torrent with label "A" or "B" hasn't been started, or is leeching, it will not be shown.
		********************************************************************************************************************

	The [date] Tag:
		[date="yyyy-MM-dd hh:mm:ss"] - Sets the date formatting. ("yyyy-MM-dd hh:mm:ss" is the default value)
		yyyy		- full year (2006)
		yy		- long year (06)
		y		- short year (6)
		MMMM/dddd       - long month/day name (Jan/Fri)
		MMM/ddd         - short month/day name (January/Friday)
		MM/dd/hh/mm/ss	- long month/day/hour/minute/second (05/11)
		M/d/h/m/s	-  short month/day/hour/minute/second (5/11)
                ********************************************************************************************************************
	The [sort] Tag:
		Attributes:
		        asc="criteria"
		        desc="criteria"

		The [sort] tag can sort your torrents in ascending or descending order after a set criteria.
		If both asc="" and desc="" is used, only the first one is valid.
		The default sorting action is [sort asc="added_on"] (sorts by the added_on date, newest last).
		The criterias are:
		        added_on - when the torrent was added
			caption - the original name, only in uTorrent 1.6 and above
		        label - sorts by label name
			path - the path to where the data is saved
		        completed_on - when the torrent was completed
		        downloaded - the amount of downloaded data (not progress, bytes)
		        uploaded - the amount of uploaded data
		        hashfails - only in uTorrent 1.6 and above
		        waste - wasted data, only in uTorrent 1.6 and above
			runtime - how long the torrent has been runnig
                ********************************************************************************************************************
	The [max] tag:
	        [max=#] - Sets the max number of torrents to show where # is a positive whole number.
		When used with ListTorrentsByLabel the number of shown torrents will be # times The number of label groups.
	================================================================================================================================

	Changelog:
	v1.2
	+ Added started, stopped, complete, incomplete, active and inactive values to the mode attribute in [show] and [hide] tags.
	+ Added a quicker "level 1" cache to speed up multiple file reads in the same meter call.
	+ Added <caption> tag, it has the original name of the release.
	+ Added [sort] tag and set default sorting action to latest torrent last.
	+ Added the labels argument to all functions.
	+ Added getNumOfCompletedTorrents(labels), getNumOfNotCompletedTorrents(labels).
	+ Added [max] tag, default value is Infinity.
	* Changed, getNumOfStartedTorrents replaces getNumOfActiveTorrents. (It does the same thing)
	* Changed, set the default format value to "<name><break>"
	* Fixed, text between [ and ] will not be removed unless recognized as a tag.
	* Fixed, values can now have custom value if infinite or N/A ("N/A" by default).
	* Fixed, removed unneccessary code in ListTorrentsByLabel().
	* Fixed some minor things...

        v1.1
	+ Added getNumOfTorrents(),getNumOfActiveTorrents(),getNumOfDownloadingTorrents(),getNumOfSeedingTorrents()
	+ Added [show] and [hide] tags to filter by labels and mode (seeding/leeching).
	+ Added <peers> tag.
	* Changed <name> so it takes the name from the folder/file which is downloaded.
	+ Added <torrentname>, works like <name> did in v 1.0.
	* Fixed crash caused by international characters.
	* Fixed the "label" on unlabeled torrents being undefined, is now customizable via the empyLabel variable.
	+ Added weeks to the time counters.
	* Changed, you now enter the whole path to resume.dat.
	* Fixed <downspeed>, included seedtime when calculating average speed which meant the average down speed would drop as you seeded.
	+ Added <down> tag.
	+ Added <eta> tag.
	+ Added [date=""] tag.
	* Fixed some minor things..

	A big thanks to all who have helped making this script better!
*/

var resumeDatPath = ""; // The path to the folder containing resume.dat. Use either / or \\
var emptyLabel = "No label"; // The label given to torrents without a label.
var infiniteValue = "N/A"; // What to show if a value is infinite.
var dateFormat = "yyyy-MM-dd hh:mm:ss"; // The date format, highly customizable! :)
var longMonths = ["January","February","March","April","May","June","July","August","September","October","November","December"]; // Go ahead and customize these too!
var shortMonths = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
var longDays = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];
var shortDays = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"];

function ListTorrents(format){
	// Lists torrents...
	if(resumeDatPath==""){
		return "Please set the variable resumeDatPath in the script.";
	}
	var out="",torrentList=TorrentList_(format)
	var maxT=Infinity;
	var currT=0;
	if(/\[max=(\d+)\]/i.test(format)){
	        maxT=parseInt(RegExp.$1);
	}
	for(i in torrentList){
		currT++
		if(currT>maxT){break;}
		out+=torrentList[i][0]
	}
	return out;
}

function ListTorrentsByLabels(format){
	// Lists torrents in groups defined by their labels.
	if(resumeDatPath==""){
		return "Please set the variable resumeDatPath in the script.";
	}
	var torrentList=TorrentList_(format);
	var labels={}
	for(var torrentId in torrentList){      // Loop through all torrents to get a list of all labels, also sort the torrents into those groups.
		theTorrent=torrentList[torrentId][1];
		if(!labels[theTorrent.label]){
			labels[theTorrent.label]=[];
		}
		labels[theTorrent.label].push(torrentList[torrentId][0]);
	}
	var out="";
       	var maxT=Infinity;
	var currT=0;
	if(/\[max=(\d+)\]/i.test(format)){
	        maxT=parseInt(RegExp.$1);
	}
	for(var label in labels){       // Loop through each group and list the torrents.
		out+=(out.length>0?"\n":"")+label+"\n";
		torrents=labels[label];
		for(torrentId in torrents){
			currT++
			if(currT>maxT){break;}
			out+=torrents[torrentId];
		}
		currT=0;
	}
	return out;
}

function getTotalDown(labels){
	// Returns how much has been totally downloaded. Does not include wasted data for uTorrent 1.6 and above.
	if(resumeDatPath==""){
		return "Please set the variable resumeDatPath in the script.";
	}
	return convertSize_(getTotal_('downloaded',labels));

}

function getTotalUp(labels){
	// Returns how much has been totally uploaded, counting all torrents.
	if(resumeDatPath==""){
		return "Please set the variable resumeDatPath in the script.";
	}
	return convertSize_(getTotal_('uploaded',labels));
}

function getTotalRatio(labels){
	// Returns the overall ratio, counting all torrents. Excludes wasted data in uTorrent 1.6 and above.
	if(resumeDatPath==""){
		return "Please set the variable resumeDatPath in the script.";
	}
	var down=getTotal_('downloaded',labels)
	var up=getTotal_('uploaded',labels)
	return down==0?infiniteValue:(up/down);
}

function getTotalWaste(labels){
	// Returns how much waste data has been downloaded, counting all torrents.
	if(resumeDatPath==""){
		return "Please set the variable resumeDatPath in the script.";
	}
	return convertSize_(getTotal_('waste',labels));
}

function getNumOfTorrents(labels){
	return getNumTorrents_(labels)[0];
}

function getNumOfStartedTorrents(labels){
	return getNumTorrents_(labels)[3];
}

function getNumOfCompletedTorrents(labels){
	return getNumTorrents_(labels)[4];
}

function getNumOfNotCompletedTorrents(labels){
	return getNumTorrents_(labels)[5];
}


function getNumOfDownloadingTorrents(labels){
	return getNumTorrents_(labels)[1];
}

function getNumOfSeedingTorrents(labels){
	return getNumTorrents_(labels)[2];
}

/*
	=================
	Private functions
	=================
*/

var memCache  // Used as a quick cache by parseData_()

function TorrentList_(format){
	// Creates the list of torrents and generates their display strings...
	if(resumeDatPath==""){
		return "Please set the variable resumeDatPath in the script.";
	}
	if(format==""){format="<name><break>"}
	var fTorrentList=[],fTorrentListObjects=[];
	var show=true,rules,mode="all",labelRegExp=/.*/,torrentList=parseData_(),out="",theTorrent;
	var activeSet, inActiveSet, completeSet, inCompleteSet, seedingSet, leechingSet, startedSet, stoppedSet, modeText, seedLeechMatch, activeMatch, startedMatch, dontCareSeedLeech=true, dontCareActive=true, dontCareComplete=true, dontCareStarted=true, noLabel=false, sortBy="added_on", sortOrder=1;
	if(/\[(show|hide)([^\]]+)\]/i.test(format)){ // Check if the user specified which torrents to show or hide.
		show=RegExp.$1=="show"?true:false;  // Show the defined labels?
		rules=RegExp.$2;
		if(/labels="([^"]+)"/i.test(rules)){
			labelRegExp=new RegExp("^"+RegExp.$1.split("|").join("$|^")+"$"); // Generate a RegExp which will match only labels exactly like those defined.
		}
		else{
		        noLabel=true;
		}
		if(/mode="([^"]+)"/i.test(rules)){
			modeText=RegExp.$1
			activeSet=/\bactive/i.test(modeText);
			inActiveSet=/inactive/i.test(modeText);
			completeSet=/\bcomplete/i.test(modeText);
			inCompleteSet=/incomplete/i.test(modeText);
			seedingSet=/seed/i.test(modeText);
			leechingSet=/leech/i.test(modeText);
			startedSet=/started/i.test(modeText);
			stoppedSet=/stopped/i.test(modeText);
			dontCareSeedLeech=!leechingSet&&!seedingSet||leechingSet&&seedingSet;
			dontCareStarted=!startedSet&&!stoppedSet||startedSet&&stoppedSet;
			dontCareActive=!activeSet&&!inActiveSet||activeSet&&inActiveSet;
			dontCareComplete=!completeSet&&!inCompleteSet||completeSet&&inCompleteSet;
		}
	}
	if(/\[sort (asc|desc)="([^"\]]+)"\]/i.test(format)){  // Check any specified sorting options.
		 sortOrder=RegExp.$1=="asc"?-1:1;
		 sortBy=RegExp.$2;
	}
	format=format.replace(/\[(?:sort|show|hide|date|max)[^\]]*\]/ig,""); // Remove all display tags.

	for(var torrentId in torrentList){      // Loop through all torrents to determine if they should be included or not.
		theTorrent=torrentList[torrentId];
		labelMatch=noLabel||(show&&labelRegExp.test(theTorrent.label)||!show&&!labelRegExp.test(theTorrent.label));
		seedLeechMatch=dontCareSeedLeech||(show&&(seedingSet&&theTorrent.trackermode==3||leechingSet&&theTorrent.trackermode==1))||(!show&&(seedingSet&&theTorrent.trackermode!=3||leechingSet&&theTorrent.trackermode!=1));
		startedMatch=dontCareStarted||(show&&(startedSet&&theTorrent.started>0||stoppedSet&&theTorrent.started==0)||!show&&(startedSet&&theTorrent.trackermode==0||stoppedSet&&theTorrent.trackermode>0));
		activeMatch=dontCareActive||show&&(activeSet&&theTorrent.peers>0&&(theTorrent.blocks.length>0||theTorrent.order==-1)||inActiveSet&&(theTorrent.peers==0||theTorrent.blocks.length==0&&theTorrent.order>-1))||!show&&(activeSet&&(theTorrent.peers==0||(theTorrent.blocks.length==0&&theTorrent.order>-1))||inActiveSet&&(theTorrent.peers>0||theTorrent.blocks.length>0));
		completeMatch=dontCareComplete||(show&&(completeSet&&theTorrent.order==-1||inCompleteSet&&theTorrent.order>-1)||(!show&&(completeSet&&theTorrent.order>-1||inCompleteSet&&theTorrent.order==-1)));
		if(labelMatch && seedLeechMatch && startedMatch && activeMatch && completeMatch){ // If all match, include the torrent.
				fTorrentList.push([replaceTags_(format,theTorrent,torrentId),theTorrent]);
		}
	}
	// Do the sorting
	function compareTorrents_(a,b){
		var objA=a[1][sortBy];
		var objB=b[1][sortBy];
		if(!objA || !objB){return 0}
		if(objA=="number"){
		        return (objA-objB)*sortOrder;
		}
		return (objA<objB?-1:(objA>objB?1:0))*sortOrder;
	}
	return fTorrentList.sort(compareTorrents_);
}

function getTotal_(stat,labels){
	// Sums up a stat and returns the sum to the caller.
 	var torrentList=parseData_();
	var theTorrent,amount=0;
	var labelsRegExp=labels?new RegExp("^"+labels.replace(/\|/g,"$|^")+"$"):/.*/;
	for(var torrentId in torrentList){
		theTorrent=torrentList[torrentId];
		if(!labelsRegExp.test(theTorrent.label)){
		        continue;
		}
		if(typeof theTorrent[stat] != "undefined"){
			amount+=theTorrent[stat];
		}
	}
	return (amount==Infinity?infiniteValue:amount);
}

function getNumTorrents_(labels){
	if(resumeDatPath==""){
		return ["Please set the variable resumeDatPath in the script.","Please set the variable resumeDatPath in the script.","Please set the variable resumeDatPath in the script.","Please set the variable resumeDatPath in the script.","Please set the variable resumeDatPath in the script.","Please set the variable resumeDatPath in the script."];
	}
	var torrentList=parseData_();
	var torrents=0;
	var theTorrent;
	var active=0;
	var started=0;
	var seeding=0;
	var downloading=0;
	var complete=0;
	var incomplete=0;
	var labelsRegExp=labels?new RegExp("^"+labels.replace(/\|/g,"$|^")+"$"):/.*/;
	for(var torrentId in torrentList){
		theTorrent=torrentList[torrentId];
		if(!labelsRegExp.test(theTorrent.label)){
		        continue;
		}
		torrents++;
		if(theTorrent.started>0){
			started++;
		}
		if(theTorrent.order>-1){
		        incomplete++;
		}
		else{
			complete++;
		}
		if(theTorrent.trackermode==1){
			downloading++;
		}
		else if(theTorrent.trackermode==3 || theTorrent.order<0){
		        seeding++;
		}
	}
	return [torrents,downloading,seeding,started,complete,incomplete];
}

function replaceTags_(format,theTorrent,torrentId){
	// This is where the tag magic takes place.
	var dateRegExp=/\[date="([^"]+)"\]/ig;
	if(dateRegExp.test(format)){
		dateFormat=RegExp.$1;
		format=format.replace(dateRegExp,"");
	}
	var ratio=Math.round((theTorrent.uploaded/theTorrent.downloaded)*1000)/1000;
	ratio=isNaN(ratio)?"-":ratio;
	if(ratio==Infinity){ratio=infiniteValue}
	var haveBlocks=countBits_(theTorrent.have);
	var speedDown=theTorrent.downloaded/(theTorrent.runtime-theTorrent.seedtime);
	speedDown=speedDown>0?speedDown:1;
	var bytesPerBlock=Math.floor(theTorrent.downloaded/haveBlocks);
	var ETA=Math.round((theTorrent.have.length-haveBlocks)*bytesPerBlock/speedDown/60)*60;
	ETA=ETA==Infinity?infiniteValue:convertTime_(ETA);
	return format.replace(/<torrentname>/ig,UTF8ToUnicode_(torrentId.substring(torrentId.lastIndexOf("\\")+1,torrentId.lastIndexOf(".torrent")))).replace(/<name>/ig,theTorrent.path.substring(theTorrent.path.lastIndexOf("\\")+1)).replace(/<caption>/ig,theTorrent.caption).replace(/<downloaded>/ig,convertSize_(theTorrent.downloaded)).replace(/<waste>/ig,convertSize_(theTorrent.waste)).replace(/<uploaded>/ig,convertSize_(theTorrent.uploaded)).replace(/<label>/ig,theTorrent.label).replace(/<path>/ig,theTorrent.path).replace(/<runtime>/ig,convertTime_(theTorrent.runtime)).replace(/<speed up>/ig,convertSize_(theTorrent.uploaded/theTorrent.runtime)+"/s").replace(/<speed down>/ig,convertSize_(speedDown)+"/s").replace(/<seedtime>/ig,convertTime_(theTorrent.seedtime)).replace(/<hash>/ig,theTorrent.info).replace(/<ratio>/ig,ratio).replace(/<peers>/ig,theTorrent.peers).replace(/<done>/ig,Math.round((haveBlocks/theTorrent.have.length)*100)+"%").replace(/<eta>/ig,ETA).replace(/<added>/ig,convertDate_(theTorrent.added_on)).replace(/<tab>/ig,"\t").replace(/<break>/ig,"\n");
}

function parseData_(){
	// Read the file and decode the BEncoded contents to get the serialized object.
	var result=memCache?memCache:BDecode_(getFileContents_(resumeDatPath.replace(/\//g,"\\").replace(/\\$/,"")+"\\resume.dat"));
	// Fix a few things such as hashes and international characters. Couldn't do this if we had read as ASCII.
	for(i in result){
		for(j in result[i]){
			switch(j){
		 	case "label": case "path": case "caption":
                                result[i][j]=UTF8ToUnicode_(result[i][j]); // There's a chance these strings contain international characters, encoded as UTF-8 (1 to 4 bytes/char)
			        break;
			case "info":
                                result[i][j]=convertHex_(result[i][j]);
	 			break;
			case "peers":
				result[i][j]=result[i][j].length/6;  // A list of the peers ip and port numbers, 6bytes to store each ip+port
				break;
			case "have":
			        result[i][j]=convertBinary_(result[i][j]);
			        break;
			case "prio": case "blocks":
			        result[i][j]="";		// These are not used and cause problems with strings if they contain the byte 0.
  				break;
			default:
			}
		}
		if(!result[i].label){
		        result[i].label=emptyLabel;
		}
	}
	return result;
}

function getFileContents_(file){
	// Reads file contents as Unicode, returns as UTF-8.
	try{
		var str = new ActiveXObject("ADODB.Stream");
		str.Type = 2; //adTypeText
		str.Open();
		str.loadFromFile(file);
		// The data is stored as ASCII, but we need to read it as Unicode (2 bytes/char instead of 8) to get the correct char codes.
		// If we'd read it as ASCII, we would lose the first bit in each byte, leaving us with char codes no higher than 127.
		str.Charset="Unicode"
		var unicodeString=str.readText();
		str.close();
		str = null;
	}
	catch(er){return "ERROR"}
	// Split the 2 bytes for each Unicode char and add them to an array. Convert both bytes from a charcode to a character.
	var UInt8Array = [],charCode;
	while(unicodeString.length){
		charCode = unicodeString.charCodeAt(0);
		UInt8Array.push(String.fromCharCode(charCode&255),String.fromCharCode(charCode>>8));
		unicodeString = unicodeString.substr(1);
	}
	// Join the characters into a string.
	return UInt8Array.join("");
}

function BDecode_(data){
	// Awsome little function, found a PHP version which I converted to JS.
	var offset=0;
        function decodeEntry(){
		if (data.charAt(offset) == 'd'){
			return decodeDict();
		}
		if (data.charAt(offset) == 'l'){
			return decodeList();
		}
		if (data.charAt(offset) == "i"){
			offset++;
			return decodeNumber();
		}
		// String value: decode number, then grab substring
		var stringLength = parseInt(decodeNumber());
		if (stringLength === false){
			return false;
		}
		var ret = data.substr(offset,stringLength);
		offset+=stringLength;
		return ret;
	}
	function decodeDict(){
		if (data.charAt(offset) == 'l'){
			return decodeList();
		}
		if (data.charAt(offset) != 'd'){
			return false;
		}
		var dict = {},value,left;
		offset++;
		while (true){
			if (data.charAt(offset) == 'e' || !data.charAt(offset)){
				offset++;
				break;
			}
			left = decodeEntry();
			if (!left){
				return false;
			}
			if (data.charAt(offset) == 'd'){
				// Recurse
				value = decodeDict();
				if (!value){
					return false;
				}
				dict[left] = value;
				continue;
			}
			else if (data.charAt(offset) == 'l'){
				value = decodeList();
				if (value===false){
					return false;
				}
				dict[left] = value;
			}
			else{
	 			value = decodeEntry();
				if (value===false){
					return false;
				}
				dict[left] = value;
			}
		}
	   	return dict;
	}
	function decodeList(){
		if (data.charAt(offset) != 'l'){
			return [false];
		}
		var list=[];
		offset++
		while(true){
			if (data.charAt(offset) == 'e' || !data.charAt(offset)){
				break;
			}
			var listEntry = decodeEntry();
			if(listEntry === false){
				return [false];
			}
			list.push(listEntry);
		}
		offset++;
		return list;
	}
	function decodeNumber(){
		var num = 0;
		var negative = false;
		if (data.charAt(offset) == '-'){
			negative = true;
			offset++;
		}
		if (data.charAt(offset) == '0'){
			offset++;
			if(negative){
				return false;
			}
			if (data.charAt(offset) == ':' || data.charAt(offset) == 'e' || !data.charAt(offset)){
				offset++;
				return 0;
			}
			return false;
		}
		while(true){
			if (!isNaN(data.charAt(offset))){
				num *= 10;
				num += parseInt(data.charAt(offset));
				offset++;
			}
			// Tolerate : or e because this is a multiuse function
			else if(data.charAt(offset) == 'e' || data.charAt(offset) == ':' || !data.charAt(offset)){
				offset++;
				if(negative){
					if(num == 0){
						return false;
					}
					num=-num;
				}
				return num;
			}
			else{
				return false;
			}
		}
	}
	return decodeEntry();
}

function UTF8ToUnicode_(string){
	// Needed because BEncoding only supports 127 ASCII characters (basic latin set). The 7 last bits in each byte represents a char.
	// To get international chars in torrents, UTF-8 encoding is used. UTF-8 is the same as ASCII for the 127 first characters.
	// To represent more chars than 127, UTF-8 uses more bytes for each char. So if the 1st bit in a byte is set, UTF-8 encoding is assumed.
	// The amount of bytes required to represent the whole character is calculated, and all those bytes are used as a Unicode Code Point, which tells JS which char to use.
	var newString=[],cCode,readAhead,codePoint;
	for(var i=0;i<string.length;i++){
	        cCode=string.charCodeAt(i);
	        readAhead=(0 <= cCode && cCode <= 0x7F ? -1 : (0xC0 <= cCode && cCode <= 0xDF?1: (0xE0 <= cCode && cCode <= 0xEF?2 : (0xF0 <= cCode && cCode <= 0xF7?3:0))));
		codePoint=cCode & (Math.pow(2,6-readAhead)-1);
		for(var reading=1;reading<=readAhead;reading++){
			codePoint=(codePoint<<6)|(string.charCodeAt(i+reading)-0x80);
		}
		i+=reading-1;
		newString.push(String.fromCharCode(codePoint));
	}
	return newString.join("");
}

function convertSize_(bytes){
	//converts bytes to Kb, Mb, etc
	if(isNaN(bytes)){
	        return bytes;
	}
	var prefix=0,prefixes=["","K","M","G","T","P"];
	bytes=parseInt(bytes);
	while(bytes>1024 && prefixes[prefix+1]){
	        bytes/=1024;
	        prefix++;
	}
	return (Math.round(bytes*100)/100)+prefixes[prefix]+"b";
}

function convertDate_(seconds){
	// Converts a UNIX timestamp to a readable format
	if(isNaN(seconds)){
	        return seconds;
	}
	var theDate=new Date(seconds*1000);
	var year=theDate.getYear();
	var monthName=theDate.getMonth();
	var month=monthName+1;
	var day=theDate.getDate();
	var dayName=theDate.getDay();
	var hour=theDate.getHours();
	var minute=theDate.getMinutes();
	var second=theDate.getSeconds();
	return dateFormat.replace(/yyyy/ig,year).replace(/yy/ig,year.toString().substring(2)).replace(/\by\b/ig,year.toString().substring(3)).replace(/MMMM/g,longMonths[monthName]).replace(/MMM/g,shortMonths[monthName]).replace(/\bMM\b/g,(month<10?"0"+month:month)).replace(/\bM\b/g,month).replace(/dddd/g,longDays[dayName]).replace(/ddd/g,shortDays[dayName]).replace(/\bdd\b/ig,(day<10?"0"+day:day)).replace(/\bd\b/ig,day).replace(/hh/ig,(hour<10?"0"+hour:hour)).replace(/\bh\b/ig,hour).replace(/\bmm\b/g,(minute<10?"0"+minute:minute)).replace(/\bm\b/g,minute).replace(/\bss\b/ig,(second<10?"0"+second:second)).replace(/\bs\b/ig,second);
}

function convertTime_(seconds){
	// Converts seconds to days, hours, minutes and seconds.
	if(isNaN(seconds)){
	        return seconds;
	}
	var time="";
	var weeks=Math.floor(seconds/604800);
	seconds%=604800;
        time+=(time==""?"":" ")+(weeks>0?weeks+" week"+(weeks==1?"":"s"):"");
	var days=Math.floor(seconds/86400);
	seconds%=86400;
	time+=(time==""?"":" ")+(days>0?days+" day"+(days==1?"":"s"):"");
	var hours=Math.floor(seconds/3600);
	seconds%=3600;
	time+=(time==""?"":" ")+(hours>0?hours+" hour"+(hours==1?"":"s"):"");
	var minutes=Math.floor(seconds/60);
	seconds%=60;
	time+=(time==""?"":" ")+(minutes>0?minutes+" minute"+(minutes==1?"":"s"):"");
	time+=(time==""?"":" ")+(seconds>0?seconds+" second"+(seconds==1?"":"s"):"");
	return time;
}

function convertBinary_(string){
	// Returns a binary representation of the input string.
	// Note: Doesn't prepend 0's to the set bits in the last byte for better accuracy in ETA!
	var bits="",thisByte;
	for(var c=0;c<string.length;c++){
		thisByte=string.charCodeAt(c).toString(2);
		if(c!=string.length-1){
			thisByte="00000000".substr(0,8-thisByte.length)+thisByte;
		}
		bits+=thisByte;
	}
	return bits;
}

function countBits_(string){
	// Simply counts the number of 1's in a string.
	var match=string.match(/1/g)
	return match && match.length?match.length:0;
}

function convertHex_(string){
	// Returns the HEX value of a string.
	var hex="";
	var code=0;
	for(var k=0;k<string.length;k++){
		code=string.charCodeAt(k);
		hex+=code.toString(16).toUpperCase();
	}
	return hex;
}

function getCharCodes_(string){
	// Returns an array with character codes from the input string.
	var codes=[];
	for(var k=0;k<string.length;k++){
		codes.push(string.charCodeAt(k));
	}
	return codes;
}