function scoreOFF(tbbbb,ybbbb) {
	ybbbb = parseFloat(ybbbb);
	tbbbb = parseFloat(tbbbb);
	if(!ybbbb) {ybbbb = 0;};
	if(!tbbbb) {tbbbb = 0;};
	points = 0;
	var passing = statl[8].split("-"); 
	var rushing = statl[9].split("-"); 
	var receiving = statl[10].split("-");
	
	if(!passing[0]) {passing[0] = 0;} else {passing[0] = parseFloat(passing[0]);}
	if(!passing[1]) {passing[1] = 0;} else {passing[1] = parseFloat(passing[1]);}
	if(!passing[2]) {passing[2] = 0;} else {passing[2] = parseFloat(passing[2]);}
	if(!passing[3]) {passing[3] = 0;} else {passing[3] = parseFloat(passing[3]);}
	if(!passing[4]) {passing[4] = 0;} else {passing[4] = parseFloat(passing[4]);}
	if(!passing[3]) {passing[3] = -(passing[4]);}
	if(!rushing[0]) {rushing[0] = 0;} else {rushing[0] = parseFloat(rushing[0]);}
	if(!rushing[2]) {rushing[2] = 0;} else {rushing[2] = parseFloat(rushing[2]);}
	if(!rushing[1]) {rushing[1] = -(rushing[2]);} else{rushing[1] = parseFloat(rushing[1]);}
	if(!receiving[0]) {receiving[0] = 0;} else {receiving[0] = parseFloat(receiving[0]);}
	if(!receiving[2]) {receiving[2] = 0;} else {receiving[1] = parseFloat(receiving[1]);}
	if(!receiving[1]) {receiving[1] = -(receiving[2]);} else{receiving[1] = parseFloat(receiving[1]);}
	if(receiving[1] >= rules[tbbbb + 74]) {points += rules[tbbbb + 73];}
	if(receiving[1] >= rules[tbbbb + 76]) {points += rules[tbbbb + 75];}
	if(receiving[1] >= rules[tbbbb + 78]) {points += rules[tbbbb + 77];}
	if(rules[ybbbb+859].indexOf("Rec") >= 0) {
		var combined = rushing[1] + receiving[1] + passing[2];
		if(combined >= rules[tbbbb + 62]) {points += rules[tbbbb + 61];}
		if(combined >= rules[tbbbb + 64]) {points += rules[tbbbb + 63];}
		if(combined >= rules[tbbbb + 66]) {points += rules[tbbbb + 65];}
	} 
	else{
		if(passing[2] >= rules[tbbbb + 62]) {points += rules[tbbbb + 61];}
		if(passing[2] >= rules[tbbbb + 64]) {points += rules[tbbbb + 63];}
		if(passing[2] >= rules[tbbbb + 66]) {points += rules[tbbbb + 65];}
	}
	if(rules[ybbbb + 860].indexOf("Rec") >= 0) {
		var combined = rushing[1] + receiving[1];
		if(combined >= rules[tbbbb + 68]) {points += rules[tbbbb + 67];}
		if(combined >= rules[tbbbb + 70]) {points += rules[tbbbb + 69];}
		if(combined >= rules[tbbbb + 72]) {points += rules[tbbbb + 71];}
	} 
	else{
		if(rushing[1] >= rules[tbbbb + 68]) {points += rules[tbbbb + 67];}
		if(rushing[1] >= rules[tbbbb + 70]) {points += rules[tbbbb + 69];}
		if(rushing[1] >= rules[tbbbb + 72]) {points += rules[tbbbb + 71];}
	}
	if(passing[3] >= 1 && rules[94]) {points += (rules[94] * passing[3]);}
	if(passing[0] >= 1 && rules[tbbbb+85]) {points += (Math.floor(passing[0]/rules[tbbbb+86]) * rules[tbbbb+85]);}
	if(rushing[0] >= 1 && rules[tbbbb+87]) {points += (Math.floor(rushing[0]/rules[tbbbb + 88]) * rules[tbbbb + 87]);}
	if(receiving[0] >= 1 && rules[tbbbb+89]) {points += (Math.floor(receiving[0]/rules[tbbbb + 90]) * rules[tbbbb + 89]);}
	if(rules[ybbbb + 859] == "Pass" || !rules[ybbbb + 859]) {
		if(passing[2] >= rules[ybbbb + 851] && rules[tbbbb+53]) {
			points += rules[ybbbb + 852] + (Math.floor((passing[2] - rules[ybbbb + 851])/rules[tbbbb + 54]) * rules[tbbbb + 53]);
		}
		else if(!rules[ybbbb+851] && rules[tbbbb+53]) {
			points += (Math.floor(passing[2]/rules[tbbbb + 54]) * rules[tbbbb + 53]);
		}
	}
	else if(rules[ybbbb + 859] == "Pass+Rush+Rec") {
		if((passing[2] + rushing[1] + receiving[1]) >= rules[ybbbb + 851] && rules[tbbbb+53]) {
			points += rules[ybbbb + 852] + (Math.floor(((passing[2] + rushing[1] + receiving[1]) - rules[ybbbb + 851])/rules[tbbbb + 54]) * rules[tbbbb + 53]);
		}
		else if(!rules[ybbbb+851] && rules[tbbbb+53]) {
			points += (Math.floor((passing[2] + rushing[1] + receiving[1])/rules[tbbbb + 54]) * rules[tbbbb + 53]);
		}
	}
	if(rules[ybbbb + 860] == "Rush" || !rules[ybbbb + 860]) {
		if(rushing[1] >= rules[ybbbb + 853] && rules[tbbbb+55]) {
			points += rules[ybbbb + 854] + (Math.floor((rushing[1] - rules[ybbbb + 853])/rules[tbbbb + 56]) * rules[tbbbb + 55]);
		}
		else if(!rules[ybbbb+853] && rules[tbbbb+55]) {
			points += (Math.floor(rushing[1]/rules[tbbbb + 56]) * rules[tbbbb + 55]);
		}
	}
	else if(rules[ybbbb + 860].indexOf("Rec") >= 0) {
		if((rushing[1] + receiving[1]) >= rules[ybbbb + 853] && rules[tbbbb+55]) {
			points += rules[ybbbb + 854] + (Math.floor(((rushing[1] + receiving[1]) - rules[ybbbb + 853])/rules[tbbbb + 56]) * rules[tbbbb + 55]);
		}
		else if(!rules[ybbbb+853] && rules[tbbbb+55]) {
			points += (Math.floor((rushing[1] + receiving[1])/rules[tbbbb + 56]) * rules[tbbbb + 55]);
		}
	}
	if(receiving[1] >= rules[ybbbb + 855] && rules[tbbbb+57]) {
		points += rules[ybbbb + 856] + (Math.floor((receiving[1] - rules[ybbbb + 855])/rules[tbbbb + 58]) * rules[tbbbb + 57]);
	} 
	else if(!rules[ybbbb+855] && rules[tbbbb+57]) {
		points += (Math.floor(receiving[1]/rules[tbbbb + 58]) * rules[tbbbb + 57]);
	}
	if(statl[14].length <=0) {statl[14] = 0;} else {statl[14] = parseFloat(statl[14]);}
	var returnyds = parseFloat(statl[14]); 
	if(returnyds >= rules[ybbbb + 857] && rules[tbbbb+59]) {
		points += rules[ybbbb + 858] + (Math.floor((returnyds - rules[ybbbb + 857])/rules[tbbbb + 60]) * rules[tbbbb + 59]);
	} 
	if(returnyds >= rules[tbbbb + 80]) {points += rules[tbbbb + 79];}
	if(returnyds >= rules[tbbbb + 82]) {points += rules[tbbbb + 81];}
	if(returnyds >= rules[tbbbb + 84]) {points += rules[tbbbb + 83];}
	
	var tds = statl[11].split(","); 
	for(x=0;x<=7;x++) {
		if(tds[x]) {
			var length = parseFloat(tds[x].substr(1));
			if(tds[x].indexOf("p") >= 0) {
				points += rules[0];
				if(rules[tbbbb + 5]) {
					if(length <= rules[tbbbb + 5] && length >= rules[tbbbb + 4]) {points += rules[tbbbb + 6];}
					else if(length <= rules[tbbbb + 8] && length >= rules[tbbbb + 7]) {points += rules[tbbbb + 9];}
					else if(length <= rules[tbbbb + 11] && length >= rules[tbbbb + 10]) {points += rules[tbbbb + 12];}
					else if(length <= rules[tbbbb + 14] && length >= rules[tbbbb + 13]) {points += rules[tbbbb + 15];}
					else if(length <= rules[tbbbb + 1411] && length >= rules[tbbbb + 1410]) {points += rules[tbbbb + 1412];}
					else if(length <= rules[tbbbb + 1414] && length >= rules[tbbbb + 1413]) {points += rules[tbbbb + 1415];}
					else if(length <= rules[tbbbb + 1417] && length >= rules[tbbbb + 1416]) {points += rules[tbbbb + 1418];}
					else if(length <= rules[tbbbb + 1420] && length >= rules[tbbbb + 1419]) {points += rules[tbbbb + 1421];}
					else if(length <= rules[tbbbb + 1423] && length >= rules[tbbbb + 1422]) {points += rules[tbbbb + 1424];}
					else if(length <= rules[tbbbb + 1426] && length >= rules[tbbbb + 1425]) {points += rules[tbbbb + 1427];}
					else if(length <= rules[tbbbb + 1429] && length >= rules[tbbbb + 1428]) {points += rules[tbbbb + 1430];}
					else if(length <= rules[tbbbb + 1432] && length >= rules[tbbbb + 1431]) {points += rules[tbbbb + 1433];}
				}
			}
		
			if(tds[x].indexOf("r") >= 0) {
				points += rules[tbbbb + 1];
				if(rules[tbbbb + 17]) {
					if(length <= rules[tbbbb + 17] && length >= rules[tbbbb + 16]) {points += rules[tbbbb + 18];}
					else if(length <= rules[tbbbb + 20] && length >= rules[tbbbb + 19]) {points += rules[tbbbb + 21];}
					else if(length <= rules[tbbbb + 23] && length >= rules[tbbbb + 22]) {points += rules[tbbbb + 24];}
					else if(length <= rules[tbbbb + 26] && length >= rules[tbbbb + 25]) {points += rules[tbbbb + 27];}
					else if(length <= rules[tbbbb + 1435] && length >= rules[tbbbb + 1434]) {points += rules[tbbbb + 1436];}
					else if(length <= rules[tbbbb + 1438] && length >= rules[tbbbb + 1437]) {points += rules[tbbbb + 1439];}
					else if(length <= rules[tbbbb + 1441] && length >= rules[tbbbb + 1440]) {points += rules[tbbbb + 1442];}
					else if(length <= rules[tbbbb + 1444] && length >= rules[tbbbb + 1443]) {points += rules[tbbbb + 1445];}
					else if(length <= rules[tbbbb + 1447] && length >= rules[tbbbb + 1446]) {points += rules[tbbbb + 1448];}
					else if(length <= rules[tbbbb + 1450] && length >= rules[tbbbb + 1449]) {points += rules[tbbbb + 1451];}
					else if(length <= rules[tbbbb + 1453] && length >= rules[tbbbb + 1452]) {points += rules[tbbbb + 1454];}
					else if(length <= rules[tbbbb + 1456] && length >= rules[tbbbb + 1455]) {points += rules[tbbbb + 1457];}
				}
			}
		
			if(tds[x].indexOf("c") >= 0) {
				points += rules[tbbbb + 2];
				if(rules[tbbbb + 29]) {
					if(length <= rules[tbbbb + 29] && length >= rules[tbbbb + 28]) {points += rules[tbbbb + 30];}
					else if(length <= rules[tbbbb + 32] && length >= rules[tbbbb + 31]) {points += rules[tbbbb + 33];}
					else if(length <= rules[tbbbb + 35] && length >= rules[tbbbb + 34]) {points += rules[tbbbb + 36];}
					else if(length <= rules[tbbbb + 38] && length >= rules[tbbbb + 37]) {points += rules[tbbbb + 39];}
					else if(length <= rules[tbbbb + 1459] && length >= rules[tbbbb + 1458]) {points += rules[tbbbb + 1460];}
					else if(length <= rules[tbbbb + 1462] && length >= rules[tbbbb + 1461]) {points += rules[tbbbb + 1463];}
					else if(length <= rules[tbbbb + 1465] && length >= rules[tbbbb + 1464]) {points += rules[tbbbb + 1466];}
					else if(length <= rules[tbbbb + 1468] && length >= rules[tbbbb + 1467]) {points += rules[tbbbb + 1469];}
					else if(length <= rules[tbbbb + 1471] && length >= rules[tbbbb + 1470]) {points += rules[tbbbb + 1472];}
					else if(length <= rules[tbbbb + 1474] && length >= rules[tbbbb + 1473]) {points += rules[tbbbb + 1475];}
					else if(length <= rules[tbbbb + 1477] && length >= rules[tbbbb + 1476]) {points += rules[tbbbb + 1478];}
					else if(length <= rules[tbbbb + 1480] && length >= rules[tbbbb + 1479]) {points += rules[tbbbb + 1481];}
				}
			}
		
			if(tds[x].indexOf("k") >= 0) {
				points += rules[tbbbb + 3];
				if(rules[tbbbb + 41]) {
					if(length <= rules[tbbbb + 41] && length >= rules[tbbbb + 40]) {points += rules[tbbbb + 42];}
					else if(length <= rules[tbbbb + 44] && length >= rules[tbbbb + 43]) {points += rules[tbbbb + 45];}
					else if(length <= rules[tbbbb + 47] && length >= rules[tbbbb + 46]) {points += rules[tbbbb + 48];}
					else if(length <= rules[tbbbb + 50] && length >= rules[tbbbb + 49]) {points += rules[tbbbb + 51];}
					else if(length <= rules[tbbbb + 1483] && length >= rules[tbbbb + 1482]) {points += rules[tbbbb + 1484];}
					else if(length <= rules[tbbbb + 1486] && length >= rules[tbbbb + 1485]) {points += rules[tbbbb + 1487];}
					else if(length <= rules[tbbbb + 1489] && length >= rules[tbbbb + 1488]) {points += rules[tbbbb + 1490];}
					else if(length <= rules[tbbbb + 1492] && length >= rules[tbbbb + 1491]) {points += rules[tbbbb + 1493];}
					else if(length <= rules[tbbbb + 1495] && length >= rules[tbbbb + 1494]) {points += rules[tbbbb + 1496];}
					else if(length <= rules[tbbbb + 1498] && length >= rules[tbbbb + 1497]) {points += rules[tbbbb + 1499];}
					else if(length <= rules[tbbbb + 1501] && length >= rules[tbbbb + 1500]) {points += rules[tbbbb + 1502];}
					else if(length <= rules[tbbbb + 1504] && length >= rules[tbbbb + 1503]) {points += rules[tbbbb + 1505];}
				}
			}
		}
	}
	
	var fumbles = statl[12].split("-"); 
	if(!fumbles[0]) {fumbles[0] = 0;} else {fumbles[0] = parseFloat(fumbles[0]);}
	if(!fumbles[1]) {fumbles[1] = 0;} else {fumbles[1] = parseFloat(fumbles[1]);}
	points += (fumbles[1] * rules[95]); 
	
	var sacks = statl[13].split("-"); 
	if(!sacks[0]) {sacks[0] = 0;} else {sacks[0] = parseFloat(sacks[0]);}
	if(!sacks[1]) {sacks[1] = 0;} else {sacks[1] = parseFloat(sacks[1]);}
	points += (sacks[0] * rules[96]); 
	
	var twopoints = statl[15].split(","); 
	if(twopoints[0]) {
		if(twopoints[0].indexOf("p") >= 0) {points += rules[tbbbb + 92];}
		else if(twopoints[0].indexOf("r") >= 0) {points += rules[tbbbb + 91];}
		else if(twopoints[0].indexOf("c") >= 0) {points += rules[tbbbb + 93];}
	}
	if(twopoints[1]) {
		if(twopoints[1].indexOf("p")) {points += rules[tbbbb + 92];}
		else if(twopoints[1].indexOf("r") >= 0) {points += rules[tbbbb + 91];}
		else if(twopoints[1].indexOf("c") >= 0) {points += rules[tbbbb + 93];}
	}
	if(twopoints[2]) {
		if(twopoints[2].indexOf("p") >= 0) {points += rules[tbbbb + 92];}
		else if(twopoints[2].indexOf("r") >= 0) {points += rules[tbbbb + 91];}
		else if(twopoints[2].indexOf("c") >= 0) {points += rules[tbbbb + 93];}
	}
	return points;
	
}


function scoreDF() {
	points = 0;
	var plays = statl[9].split("-"); 
	if(!plays[0]) {plays[0] = 0;} else {plays[0] = parseFloat(plays[0]);}
	if(!plays[1]) {plays[1] = 0;} else {plays[1] = parseFloat(plays[1]);}
	if(!plays[2]) {plays[2] = 0;} else {plays[2] = parseFloat(plays[2]);}
	if(!statl[12]) {statl[12] = 0;} else {statl[12] = parseFloat(statl[12]);}
	if(!statl[20]) {statl[20] = 0;} else {statl[20] = parseFloat(statl[20]);}
	if(!statl[18]) {statl[18] = 0;} else {statl[18] = parseFloat(statl[18]);}
	points = points + (plays[0] * rules[795]) + (plays[1] * rules[791]) + (plays[2] * rules[792]) + (statl[12] * rules[793]) + (statl[20]*rules[794]);
	
	if(statl[18] >= 1) {points = points + rules[796];}


	var blocks = statl[13].split("-"); 
	if(!blocks[0]) {blocks[0] = 0;} else {blocks[0] = parseFloat(blocks[0]);}
	if(!blocks[1]) {blocks[1] = 0;} else {blocks[1] = parseFloat(blocks[1]);}
	if(!blocks[2]) {blocks[2] = 0;} else {blocks[2] = parseFloat(blocks[2]);}
	points = points + (blocks[0] * rules[1048]) +(blocks[1] * rules[1049]) + (blocks[2] * rules[1050]);

	var ptsallowed = statl[10].split("-"); 
	if(!ptsallowed[0]) {ptsallowed[0] = 0;} else {ptsallowed[0] = parseFloat(ptsallowed[0]);}
	if(!ptsallowed[1]) {ptsallowed[1] = 0;} else {ptsallowed[1] = parseFloat(ptsallowed[1]);}
	
	var ydsallowed = statl[8].split("-");
	if(!ydsallowed[0]) {ydsallowed[0] = 0;} else {ydsallowed[0] = parseFloat(ydsallowed[0]);}
	if(!ydsallowed[1]) {ydsallowed[1] = 0;} else {ydsallowed[1] = parseFloat(ydsallowed[1]);}
	if(!ydsallowed[2]) {ydsallowed[2] = 0;} else {ydsallowed[2] = parseFloat(ydsallowed[2]);}
	
	if(ydsallowed[2] >= 1) {
		if(ptsallowed[0] <= rules[763]) {points = points + parseFloat(rules[764]);} 
		else if(ptsallowed[0] <= rules[766]) {points = points + parseFloat(rules[767]);} 
		else if(ptsallowed[0] <= rules[769]) {points = points + parseFloat(rules[770]);} 
		else if(ptsallowed[0] <= rules[772]) {points = points + parseFloat(rules[773]);} 
		else if(ptsallowed[0] <= rules[775]) {points = points + parseFloat(rules[797]);} 
		else if(ptsallowed[0] <= rules[777]) {points = points + parseFloat(rules[778]);} 
		else if(ptsallowed[0] <= rules[780]) {points = points + parseFloat(rules[781]);} 
		else if(ptsallowed[0] <= rules[783]) {points = points + parseFloat(rules[784]);} 
		else if(ptsallowed[0] <= rules[786]) {points = points + parseFloat(rules[787]);} 
		else if(ptsallowed[0] <= rules[789]) {points = points + parseFloat(rules[790]);}
		if(ptsallowed[1] <= rules[733]) {points = points + parseFloat(rules[734]);} 
		else if(ptsallowed[1] <= rules[736]) {points = points + parseFloat(rules[737]);} 
		else if(ptsallowed[1] <= rules[739]) {points = points + parseFloat(rules[740]);} 
		else if(ptsallowed[1] <= rules[742]) {points = points + parseFloat(rules[743]);} 
		else if(ptsallowed[1] <= rules[745]) {points = points + parseFloat(rules[746]);} 
		else if(ptsallowed[1] <= rules[748]) {points = points + parseFloat(rules[749]);} 
		else if(ptsallowed[1] <= rules[751]) {points = points + parseFloat(rules[752]);} 
		else if(ptsallowed[1] <= rules[754]) {points = points + parseFloat(rules[755]);} 
		else if(ptsallowed[1] <= rules[757]) {points = points + parseFloat(rules[758]);} 
		else if(ptsallowed[1] <= rules[760]) {points = points + parseFloat(rules[761]);} 

		if(ydsallowed[0] <= rules[589]) {points = points + parseFloat(rules[590]);} 
		else if(ydsallowed[0] <= rules[592]) {points = points + parseFloat(rules[593]);} 
		else if(ydsallowed[0] <= rules[595]) {points = points + parseFloat(rules[596]);} 
		else if(ydsallowed[0] <= rules[598]) {points = points + parseFloat(rules[599]);} 
		else if(ydsallowed[0] <= rules[601]) {points = points + parseFloat(rules[602]);} 
		else if(ydsallowed[0] <= rules[604]) {points = points + parseFloat(rules[605]);} 
		else if(ydsallowed[0] <= rules[607]) {points = points + parseFloat(rules[608]);} 
		else if(ydsallowed[0] <= rules[610]) {points = points + parseFloat(rules[611]);} 
		else if(ydsallowed[0] <= rules[613]) {points = points + parseFloat(rules[614]);} 
		else if(ydsallowed[0] <= rules[616]) {points = points + parseFloat(rules[617]);} 
		else if(ydsallowed[0] <= rules[619]) {points = points + parseFloat(rules[620]);} 
		else if(ydsallowed[0] <= rules[622]) {points = points + parseFloat(rules[623]);} 
		else if(ydsallowed[0] <= rules[625]) {points = points + parseFloat(rules[626]);} 
		else if(ydsallowed[0] <= rules[628]) {points = points + parseFloat(rules[629]);} 
		else if(ydsallowed[0] <= rules[631]) {points = points + parseFloat(rules[632]);} 
		else if(ydsallowed[0] <= rules[634]) {points = points + parseFloat(rules[635]);} 
		
		if(ydsallowed[1] <= rules[541]) {points = points + parseFloat(rules[542]);} 
		else if(ydsallowed[1] <= rules[544]) {points = points + parseFloat(rules[545]);} 
		else if(ydsallowed[1] <= rules[547]) {points = points + parseFloat(rules[548]);} 
		else if(ydsallowed[1] <= rules[550]) {points = points + parseFloat(rules[551]);} 
		else if(ydsallowed[1] <= rules[553]) {points = points + parseFloat(rules[554]);} 
		else if(ydsallowed[1] <= rules[556]) {points = points + parseFloat(rules[557]);} 
		else if(ydsallowed[1] <= rules[559]) {points = points + parseFloat(rules[560]);} 
		else if(ydsallowed[1] <= rules[562]) {points = points + parseFloat(rules[563]);} 
		else if(ydsallowed[1] <= rules[565]) {points = points + parseFloat(rules[566]);} 
		else if(ydsallowed[1] <= rules[568]) {points = points + parseFloat(rules[569]);} 
		else if(ydsallowed[1] <= rules[571]) {points = points + parseFloat(rules[572]);} 
		else if(ydsallowed[1] <= rules[574]) {points = points + parseFloat(rules[575]);} 
		else if(ydsallowed[1] <= rules[577]) {points = points + parseFloat(rules[578]);} 
		else if(ydsallowed[1] <= rules[580]) {points = points + parseFloat(rules[581]);} 
		else if(ydsallowed[1] <= rules[583]) {points = points + parseFloat(rules[584]);} 
		else if(ydsallowed[1] <= rules[586]) {points = points + parseFloat(rules[587]);} 

		if(ydsallowed[2] <= rules[1341]) {points = points + parseFloat(rules[1342]);} 
		else if(ydsallowed[2] <= rules[1344]) {points = points + parseFloat(rules[1345]);} 
		else if(ydsallowed[2] <= rules[1347]) {points = points + parseFloat(rules[1348]);} 
		else if(ydsallowed[2] <= rules[1350]) {points = points + parseFloat(rules[1351]);} 
		else if(ydsallowed[2] <= rules[1353]) {points = points + parseFloat(rules[1354]);} 
		else if(ydsallowed[2] <= rules[1356]) {points = points + parseFloat(rules[1357]);} 
		else if(ydsallowed[2] <= rules[1359]) {points = points + parseFloat(rules[1360]);} 
		else if(ydsallowed[2] <= rules[1362]) {points = points + parseFloat(rules[1363]);} 
		else if(ydsallowed[2] <= rules[1365]) {points = points + parseFloat(rules[1366]);} 
		else if(ydsallowed[2] <= rules[1368]) {points = points + parseFloat(rules[1369]);} 
		else if(ydsallowed[2] <= rules[1371]) {points = points + parseFloat(rules[1372]);} 
		else if(ydsallowed[2] <= rules[1374]) {points = points + parseFloat(rules[1375]);} 
		else if(ydsallowed[2] <= rules[1377]) {points = points + parseFloat(rules[1378]);} 
		else if(ydsallowed[2] <= rules[1380]) {points = points + parseFloat(rules[1381]);} 
		else if(ydsallowed[2] <= rules[1383]) {points = points + parseFloat(rules[1384]);} 
		else if(ydsallowed[2] <= rules[1386]) {points = points + parseFloat(rules[1387]);}
	}

	var returnyds = statl[15].split("-"); 
	if(!returnyds[0]) {returnyds[0] = 0;} else {returnyds[0] = parseFloat(returnyds[0]);}
	if(!returnyds[1]) {returnyds[1] = 0;} else {returnyds[1] = parseFloat(returnyds[1]);}

	if(returnyds[0] <= rules[685]) {points = points + parseFloat(rules[686]);} 
	else if(returnyds[0] <= rules[688]) {points = points + parseFloat(rules[689]);} 
	else if(returnyds[0] <= rules[691]) {points = points + parseFloat(rules[692]);} 
	else if(returnyds[0] <= rules[694]) {points = points + parseFloat(rules[695]);} 
	else if(returnyds[0] <= rules[697]) {points = points + parseFloat(rules[698]);} 
	else if(returnyds[0] <= rules[700]) {points = points + parseFloat(rules[701]);} 
	else if(returnyds[0] <= rules[703]) {points = points + parseFloat(rules[704]);} 
	else if(returnyds[0] <= rules[706]) {points = points + parseFloat(rules[707]);} 
	else if(returnyds[0] <= rules[709]) {points = points + parseFloat(rules[710]);} 
	else if(returnyds[0] <= rules[712]) {points = points + parseFloat(rules[713]);} 
	else if(returnyds[0] <= rules[715]) {points = points + parseFloat(rules[716]);} 
	else if(returnyds[0] <= rules[718]) {points = points + parseFloat(rules[719]);} 
	else if(returnyds[0] <= rules[721]) {points = points + parseFloat(rules[722]);} 
	else if(returnyds[0] <= rules[724]) {points = points + parseFloat(rules[725]);} 
	else if(returnyds[0] <= rules[727]) {points = points + parseFloat(rules[728]);} 
	else if(returnyds[0] <= rules[730]) {points = points + parseFloat(rules[731]);} 

	if(returnyds[1] <= rules[637]) {points = points + parseFloat(rules[638]);} 
	else if(returnyds[1] <= rules[640]) {points = points + parseFloat(rules[641]);} 
	else if(returnyds[1] <= rules[643]) {points = points + parseFloat(rules[644]);} 
	else if(returnyds[1] <= rules[646]) {points = points + parseFloat(rules[647]);} 
	else if(returnyds[1] <= rules[649]) {points = points + parseFloat(rules[650]);} 
	else if(returnyds[1] <= rules[652]) {points = points + parseFloat(rules[653]);} 
	else if(returnyds[1] <= rules[655]) {points = points + parseFloat(rules[656]);} 
	else if(returnyds[1] <= rules[658]) {points = points + parseFloat(rules[659]);} 
	else if(returnyds[1] <= rules[661]) {points = points + parseFloat(rules[662]);} 
	else if(returnyds[1] <= rules[664]) {points = points + parseFloat(rules[665]);} 
	else if(returnyds[1] <= rules[667]) {points = points + parseFloat(rules[668]);} 
	else if(returnyds[1] <= rules[670]) {points = points + parseFloat(rules[671]);} 
	else if(returnyds[1] <= rules[673]) {points = points + parseFloat(rules[674]);} 
	else if(returnyds[1] <= rules[676]) {points = points + parseFloat(rules[677]);} 
	else if(returnyds[1] <= rules[679]) {points = points + parseFloat(rules[680]);} 
	else if(returnyds[1] <= rules[682]) {points = points + parseFloat(rules[683]);}

	var tds = statl[11].split(","); 
	for(x=0;x<=7;x++) {
		if(tds[x]) {
			var length = parseFloat(tds[x].substr(1));
			if(tds[x].indexOf("f") >= 0) {
				points += rules[500];
				if(rules[505]) {
					if(length <= rules[505] && length >= rules[504]) {points += rules[506];}
					else if(length <= rules[508] && length >= rules[507]) {points += rules[509];}
					else if(length <= rules[511] && length >= rules[510]) {points += rules[512];}
					else if(length <= rules[514] && length >= rules[513]) {points += rules[515];}
					else if(length <= rules[1807] && length >= rules[1806]) {points += rules[1808];}
					else if(length <= rules[1810] && length >= rules[1809]) {points += rules[1811];}
					else if(length <= rules[1813] && length >= rules[1812]) {points += rules[1814];}
					else if(length <= rules[1816] && length >= rules[1815]) {points += rules[1817];}
					else if(length <= rules[1819] && length >= rules[1818]) {points += rules[1820];}
					else if(length <= rules[1822] && length >= rules[1821]) {points += rules[1823];}
					else if(length <= rules[1825] && length >= rules[1824]) {points += rules[1826];}
					else if(length <= rules[1828] && length >= rules[1827]) {points += rules[1829];}
				}
			}
		
			if(tds[x].indexOf("i") >= 0) {
				points += rules[501];
				if(rules[517]) {
					if(length <= rules[517] && length >= rules[516]) {points += rules[518];}
					else if(length <= rules[520] && length >= rules[519]) {points += rules[521];}
					else if(length <= rules[523] && length >= rules[522]) {points += rules[524];}
					else if(length <= rules[526] && length >= rules[525]) {points += rules[527];}
					else if(length <= rules[1831] && length >= rules[1830]) {points += rules[1832];}
					else if(length <= rules[1834] && length >= rules[1833]) {points += rules[1835];}
					else if(length <= rules[1837] && length >= rules[1836]) {points += rules[1838];}
					else if(length <= rules[1840] && length >= rules[1839]) {points += rules[1841];}
					else if(length <= rules[1843] && length >= rules[1842]) {points += rules[1844];}
					else if(length <= rules[1846] && length >= rules[1845]) {points += rules[1847];}
					else if(length <= rules[1849] && length >= rules[1848]) {points += rules[1850];}
					else if(length <= rules[1852] && length >= rules[1851]) {points += rules[1853];}
				}
			}
	
			if(tds[x].indexOf("k") >= 0) {
				points += rules[502];
				if(rules[529]) {
					if(length <= rules[529] && length >= rules[528]) {points += rules[530];}
					else if(length <= rules[532] && length >= rules[531]) {points += rules[533];}
					else if(length <= rules[535] && length >= rules[534]) {points += rules[536];}
					else if(length <= rules[538] && length >= rules[537]) {points += rules[539];}
					else if(length <= rules[1855] && length >= rules[1854]) {points += rules[1856];}
					else if(length <= rules[1858] && length >= rules[1857]) {points += rules[1859];}
					else if(length <= rules[1861] && length >= rules[1860]) {points += rules[1862];}
					else if(length <= rules[1864] && length >= rules[1863]) {points += rules[1865];}
					else if(length <= rules[1867] && length >= rules[1866]) {points += rules[1868];}
					else if(length <= rules[1870] && length >= rules[1869]) {points += rules[1871];}
					else if(length <= rules[1873] && length >= rules[1872]) {points += rules[1874];}
					else if(length <= rules[1876] && length >= rules[1875]) {points += rules[1877];}
				}
			}
		}
	}

	return points;
}


function scoreST() {
	points = 0;
	var blocks = statl[12].split("-"); 
	if(!blocks[0]) {blocks[0] = 0;} else {blocks[0] = parseFloat(blocks[0]);}
	if(!blocks[1]) {blocks[1] = 0;} else {blocks[1] = parseFloat(blocks[1]);}
	if(!blocks[2]) {blocks[2] = 0;} else {blocks[2] = parseFloat(blocks[2]);}
	points = points + (blocks[0] * rules[1232]) +(blocks[1] * rules[1233]) + (blocks[2] * rules[1234]);
	
	if(!statl[8]) {statl[8] = 0;} else {statl[8] = parseFloat(statl[8]);}
	if(!statl[9]) {statl[9] = 0;} else {statl[9] = parseFloat(statl[9]);}
	if(statl[8] <= rules[1185]) {points = points + rules[1186];}
	else if(statl[8] <= rules[1188]) {points = points + rules[1189];}
	else if(statl[8] <= rules[1191]) {points = points + rules[1192];}
	else if(statl[8] <= rules[1194]) {points = points + rules[1195];}
	else if(statl[8] <= rules[1197]) {points = points + rules[1198];}
	else if(statl[8] <= rules[1200]) {points = points + rules[1201];}
	else if(statl[8] <= rules[1203]) {points = points + rules[1204];}
	else if(statl[8] <= rules[1206]) {points = points + rules[1207];}
	else if(statl[8] <= rules[1209]) {points = points + rules[1210];}
	else if(statl[8] <= rules[1212]) {points = points + rules[1213];}
	else if(statl[8] <= rules[1215]) {points = points + rules[1216];}
	else if(statl[8] <= rules[1218]) {points = points + rules[1219];}
	else if(statl[8] <= rules[1221]) {points = points + rules[1222];}
	else if(statl[8] <= rules[1224]) {points = points + rules[1225];}
	else if(statl[8] <= rules[1227]) {points = points + rules[1228];}
	else if(statl[8] <= rules[1230]) {points = points + rules[1231];}

	if(statl[9] <= rules[1137]) {points = points + rules[1138];}
	else if(statl[9] <= rules[1140]) {points = points + rules[1141];}
	else if(statl[9] <= rules[1143]) {points = points + rules[1144];}
	else if(statl[9] <= rules[1146]) {points = points + rules[1147];}
	else if(statl[9] <= rules[1149]) {points = points + rules[1150];}
	else if(statl[9] <= rules[1152]) {points = points + rules[1153];}
	else if(statl[9] <= rules[1155]) {points = points + rules[1156];}
	else if(statl[9] <= rules[1158]) {points = points + rules[1159];}
	else if(statl[9] <= rules[1161]) {points = points + rules[1162];}
	else if(statl[9] <= rules[1164]) {points = points + rules[1165];}
	else if(statl[9] <= rules[1167]) {points = points + rules[1168];}
	else if(statl[9] <= rules[1170]) {points = points + rules[1171];}
	else if(statl[9] <= rules[1173]) {points = points + rules[1174];}
	else if(statl[9] <= rules[1176]) {points = points + rules[1177];}
	else if(statl[9] <= rules[1179]) {points = points + rules[1180];}
	else if(statl[9] <= rules[1182]) {points = points + rules[1183];}


	var tds = statl[11].split(","); 
	for(x=0;x<=3;x++) {
		if(tds[x]) {
			var length = parseFloat(tds[x].substr(1));
			if(tds[x].indexOf("k") >= 0) {
				points += rules[1100];
				if(rules[1105]) {
					if(length <= rules[1102] && length >= rules[1101]) {points += rules[1103];}
					else if(length <= rules[1105] && length >= rules[1104]) {points += rules[1106];}
					else if(length <= rules[1108] && length >= rules[1107]) {points += rules[1109];}
					else if(length <= rules[1111] && length >= rules[1110]) {points += rules[1112];}
					else if(length <= rules[1114] && length >= rules[1113]) {points += rules[1115];}
					else if(length <= rules[1117] && length >= rules[1116]) {points += rules[1118];}
					else if(length <= rules[1120] && length >= rules[1119]) {points += rules[1121];}
					else if(length <= rules[1123] && length >= rules[1122]) {points += rules[1124];}
					else if(length <= rules[1126] && length >= rules[1125]) {points += rules[1127];}
					else if(length <= rules[1129] && length >= rules[1128]) {points += rules[1130];}
					else if(length <= rules[1132] && length >= rules[1131]) {points += rules[1133];}
				}
			}
		}
	}
	return points;
}


function scoreHC() {
	points = 0;
	if(!statl[8]) {statl[8] = 0;} else {statl[8] = parseFloat(statl[8]);}
	if(statl[8] >= 1) {points = points + rules[1300];}
	return points;
}


function scoreDB() {
	points = 0;
	var tackles = statl[8].split("-");
	if(!tackles[0]) {tackles[0] = 0;} else {tackles[0] = parseFloat(tackles[0]);}
	if(!tackles[1]) {tackles[1] = 0;} else {tackles[1] = parseFloat(tackles[1]);}
	if(!tackles[2]) {tackles[2] = 0;} else {tackles[2] = parseFloat(tackles[2]);}
	if(!statl[9]) {statl[9] = 0;} else {statl[9] = parseFloat(statl[9]);}
	if(!statl[10]) {statl[10] = 0;} else {statl[10] = parseFloat(statl[10]);}
	if(!statl[12]) {statl[12] = 0;} else {statl[12] = parseFloat(statl[12]);}
	if(!statl[13]) {statl[13] = 0;} else {statl[13] = parseFloat(statl[13]);}
	if(!statl[15]) {statl[15] = 0;} else {statl[15] = parseFloat(statl[15]);}
	points = points + (tackles[0] * rules[840]) + (tackles[1] * rules[841]) + (tackles[2] * rules[842]) + (statl[9] * rules[843]) + (statl[10] * rules[845]) + (statl[12] * rules[847]) + (statl[13] * rules[846]) + (statl[15] * rules[844]);

	var blocks = statl[18].split("-");
	if(!blocks[0]) {blocks[0] = 0;} else {blocks[0] = parseFloat(blocks[0]);}
	if(!blocks[1]) {blocks[1] = 0;} else {blocks[1] = parseFloat(blocks[1]);}
	if(!blocks[2]) {blocks[2] = 0;} else {blocks[2] = parseFloat(blocks[2]);}
	points = points + (blocks[0] * rules[1048]) +(blocks[1] * rules[1049]) + (blocks[2] * rules[1050]);
	
	var tds = statl[11].split(","); 
	for(x=0;x<=3;x++) {
		if(tds[x]) {
			var length = parseFloat(tds[x].substr(1));
			if(tds[x].indexOf("f") >= 0) {
				points += rules[800];
				if(rules[805]) {
					if(length <= rules[805] && length >= rules[804]) {points += rules[806];}
					else if(length <= rules[808] && length >= rules[807]) {points += rules[809];}
					else if(length <= rules[811] && length >= rules[810]) {points += rules[812];}
					else if(length <= rules[814] && length >= rules[813]) {points += rules[815];}
					else if(length <= rules[1907] && length >= rules[1906]) {points += rules[1908];}
					else if(length <= rules[1910] && length >= rules[1909]) {points += rules[1911];}
					else if(length <= rules[1913] && length >= rules[1912]) {points += rules[1914];}
					else if(length <= rules[1916] && length >= rules[1915]) {points += rules[1917];}
					else if(length <= rules[1919] && length >= rules[1918]) {points += rules[1920];}
					else if(length <= rules[1922] && length >= rules[1921]) {points += rules[1923];}
					else if(length <= rules[1925] && length >= rules[1924]) {points += rules[1926];}
					else if(length <= rules[1928] && length >= rules[1927]) {points += rules[1929];}
				}
			}
		
			if(tds[x].indexOf("i") >= 0) {
				points += rules[801];
				if(rules[817]) {
					if(length <= rules[817] && length >= rules[816]) {points += rules[818];}
					else if(length <= rules[820] && length >= rules[819]) {points += rules[821];}
					else if(length <= rules[823] && length >= rules[822]) {points += rules[824];}
					else if(length <= rules[826] && length >= rules[825]) {points += rules[827];}
					else if(length <= rules[1931] && length >= rules[1930]) {points += rules[1932];}
					else if(length <= rules[1934] && length >= rules[1933]) {points += rules[1935];}
					else if(length <= rules[1937] && length >= rules[1936]) {points += rules[1938];}
					else if(length <= rules[1940] && length >= rules[1939]) {points += rules[1941];}
					else if(length <= rules[1943] && length >= rules[1942]) {points += rules[1944];}
					else if(length <= rules[1946] && length >= rules[1945]) {points += rules[1947];}
					else if(length <= rules[1949] && length >= rules[1948]) {points += rules[1950];}
					else if(length <= rules[1952] && length >= rules[1951]) {points += rules[1953];}
				}
			}
	
			if(tds[x].indexOf("k") >= 0) {
				points += rules[802];
				if(rules[829]) {
					if(length <= rules[829] && length >= rules[828]) {points += rules[830];}
					else if(length <= rules[832] && length >= rules[831]) {points += rules[833];}
					else if(length <= rules[835] && length >= rules[834]) {points += rules[836];}
					else if(length <= rules[838] && length >= rules[837]) {points += rules[839];}
					else if(length <= rules[1955] && length >= rules[1954]) {points += rules[1956];}
					else if(length <= rules[1958] && length >= rules[1957]) {points += rules[1959];}
					else if(length <= rules[1961] && length >= rules[1960]) {points += rules[1962];}
					else if(length <= rules[1964] && length >= rules[1963]) {points += rules[1965];}
					else if(length <= rules[1967] && length >= rules[1966]) {points += rules[1968];}
					else if(length <= rules[1970] && length >= rules[1969]) {points += rules[1971];}
					else if(length <= rules[1973] && length >= rules[1972]) {points += rules[1974];}
					else if(length <= rules[1976] && length >= rules[1975]) {points += rules[1977];}
				}
			}
		}
	}
	return points;
}


function scoreDL(realtime2) {
	points = 0;
	var tackles = statl[8].split("-");
	if(!statl[9]) {statl[9] = 0;} else {statl[9] = parseFloat(statl[9]);}
	if(!statl[10]) {statl[10] = 0;} else {statl[10] = parseFloat(statl[10]);}
	if(!statl[12]) {statl[12] = 0;} else {statl[12] = parseFloat(statl[12]);}
	if(!statl[13]) {statl[13] = 0;} else {statl[13] = parseFloat(statl[13]);}
	if(!statl[15]) {statl[15] = 0;} else {statl[15] = parseFloat(statl[15]);}
	if(!tackles[0]) {tackles[0] = 0;} else {tackles[0] = parseFloat(tackles[0]);}
	if(!tackles[1]) {tackles[1] = 0;} else {tackles[1] = parseFloat(tackles[1]);}
	if(!tackles[2]) {tackles[2] = 0;} else {tackles[2] = parseFloat(tackles[2]);}
	points = points + (tackles[0] * rules[940]) + (tackles[1] * rules[941]) + (tackles[2] * rules[942]) + (statl[9] * rules[943]) + (statl[10] * rules[945]) + (statl[12] * rules[947]) + (statl[13] * rules[946]) + (statl[15] * rules[944]);

	var blocks = statl[18].split("-");
	if(!blocks[0]) {blocks[0] = 0;} else {blocks[0] = parseFloat(blocks[0]);}
	if(!blocks[1]) {blocks[1] = 0;} else {blocks[1] = parseFloat(blocks[1]);}
	if(!blocks[2]) {blocks[2] = 0;} else {blocks[2] = parseFloat(blocks[2]);}
	points = points + (blocks[0] * rules[1048]) +(blocks[1] * rules[1049]) + (blocks[2] * rules[1050]);

	var tds = statl[11].split(","); 
	for(x=0;x<=3;x++) {
		if(tds[x]) {
			var length = parseFloat(tds[x].substr(1));
			if(tds[x].indexOf("f") >= 0) {
				points += rules[900];
				if(rules[905]) {
					if(length <= rules[905] && length >= rules[904]) {points += rules[906];}
					else if(length <= rules[908] && length >= rules[907]) {points += rules[909];}
					else if(length <= rules[911] && length >= rules[910]) {points += rules[912];}
					else if(length <= rules[914] && length >= rules[913]) {points += rules[915];}
					else if(length <= rules[2007] && length >= rules[2006]) {points += rules[2008];}
					else if(length <= rules[2010] && length >= rules[2009]) {points += rules[2011];}
					else if(length <= rules[2013] && length >= rules[2012]) {points += rules[2014];}
					else if(length <= rules[2016] && length >= rules[2015]) {points += rules[2017];}
					else if(length <= rules[2019] && length >= rules[2018]) {points += rules[2020];}
					else if(length <= rules[2022] && length >= rules[2021]) {points += rules[2023];}
					else if(length <= rules[2025] && length >= rules[2024]) {points += rules[2026];}
					else if(length <= rules[2028] && length >= rules[2027]) {points += rules[2029];}
				}
			}
		
			if(tds[x].indexOf("i") >= 0) {
				points += rules[901];
				if(rules[917]) {
					if(length <= rules[917] && length >= rules[916]) {points += rules[918];}
					else if(length <= rules[920] && length >= rules[919]) {points += rules[921];}
					else if(length <= rules[923] && length >= rules[922]) {points += rules[924];}
					else if(length <= rules[926] && length >= rules[925]) {points += rules[927];}
					else if(length <= rules[2031] && length >= rules[2030]) {points += rules[2032];}
					else if(length <= rules[2034] && length >= rules[2033]) {points += rules[2035];}
					else if(length <= rules[2037] && length >= rules[2036]) {points += rules[2038];}
					else if(length <= rules[2040] && length >= rules[2039]) {points += rules[2041];}
					else if(length <= rules[2043] && length >= rules[2042]) {points += rules[2044];}
					else if(length <= rules[2046] && length >= rules[2045]) {points += rules[2047];}
					else if(length <= rules[2049] && length >= rules[2048]) {points += rules[2050];}
					else if(length <= rules[2052] && length >= rules[2051]) {points += rules[2053];}
				}
			}
	
			if(tds[x].indexOf("k") >= 0) {
				points += rules[902];
				if(rules[929]) {
					if(length <= rules[929] && length >= rules[928]) {points += rules[930];}
					else if(length <= rules[932] && length >= rules[931]) {points += rules[933];}
					else if(length <= rules[935] && length >= rules[934]) {points += rules[936];}
					else if(length <= rules[938] && length >= rules[937]) {points += rules[939];}
					else if(length <= rules[2055] && length >= rules[2054]) {points += rules[2056];}
					else if(length <= rules[2058] && length >= rules[2057]) {points += rules[2059];}
					else if(length <= rules[2061] && length >= rules[2060]) {points += rules[2062];}
					else if(length <= rules[2064] && length >= rules[2063]) {points += rules[2065];}
					else if(length <= rules[2067] && length >= rules[2066]) {points += rules[2068];}
					else if(length <= rules[2070] && length >= rules[2069]) {points += rules[2071];}
					else if(length <= rules[2073] && length >= rules[2072]) {points += rules[2074];}
					else if(length <= rules[2076] && length >= rules[2075]) {points += rules[2077];}
				}
			}
		}
	}
	return points;
}


function scoreLB() {
	points = 0;
	var tackles = statl[8].split("-"); 
	if(!statl[9]) {statl[9] = 0;} else {statl[9] = parseFloat(statl[9]);}
	if(!statl[10]) {statl[10] = 0;} else {statl[10] = parseFloat(statl[10]);}
	if(!statl[12]) {statl[12] = 0;} else {statl[12] = parseFloat(statl[12]);}
	if(!statl[13]) {statl[13] = 0;} else {statl[13] = parseFloat(statl[13]);}
	if(!statl[15]) {statl[15] = 0;} else {statl[15] = parseFloat(statl[15]);}
	if(!tackles[0]) {tackles[0] = 0;} else {tackles[0] = parseFloat(tackles[0]);}
	if(!tackles[1]) {tackles[1] = 0;} else {tackles[1] = parseFloat(tackles[1]);}
	if(!tackles[2]) {tackles[2] = 0;} else {tackles[2] = parseFloat(tackles[2]);}
	points = points + (tackles[0] * rules[1040]) + (tackles[1] * rules[1041]) + (tackles[2] * rules[1042]) + (statl[9] * rules[1043]) + (statl[10] * rules[1045]) + (statl[12] * rules[1047]) + (statl[13] * rules[1046]) + (statl[15] * rules[1044]);

	var blocks = statl[18].split("-");
	if(!blocks[0]) {blocks[0] = 0;} else {blocks[0] = parseFloat(blocks[0]);}
	if(!blocks[1]) {blocks[1] = 0;} else {blocks[1] = parseFloat(blocks[1]);}
	if(!blocks[2]) {blocks[2] = 0;} else {blocks[2] = parseFloat(blocks[2]);}
	points = points + (blocks[0] * rules[1048]) +(blocks[1] * rules[1049]) + (blocks[2] * rules[1050]);

	var tds = statl[11].split(","); 
	for(x=0;x<=3;x++) {
		if(tds[x]) {
			var length = parseFloat(tds[x].substr(1));
			if(tds[x].indexOf("f") >= 0) {
				points += rules[1000];
				if(rules[1005]) {
					if(length <= rules[1005] && length >= rules[1004]) {points += rules[1006];}
					else if(length <= rules[1008] && length >= rules[1007]) {points += rules[1009];}
					else if(length <= rules[1011] && length >= rules[1010]) {points += rules[1012];}
					else if(length <= rules[1014] && length >= rules[1013]) {points += rules[1015];}
					else if(length <= rules[2107] && length >= rules[2106]) {points += rules[2108];}
					else if(length <= rules[2110] && length >= rules[2109]) {points += rules[2111];}
					else if(length <= rules[2113] && length >= rules[2112]) {points += rules[2114];}
					else if(length <= rules[2116] && length >= rules[2115]) {points += rules[2117];}
					else if(length <= rules[2119] && length >= rules[2118]) {points += rules[2120];}
					else if(length <= rules[2122] && length >= rules[2121]) {points += rules[2123];}
					else if(length <= rules[2125] && length >= rules[2124]) {points += rules[2126];}
					else if(length <= rules[2128] && length >= rules[2127]) {points += rules[2129];}
				}
			}
		
			if(tds[x].indexOf("i") >= 0) {
				points += rules[1001];
				if(rules[1017]) {
					if(length <= rules[1017] && length >= rules[1016]) {points += rules[1018];}
					else if(length <= rules[1020] && length >= rules[1019]) {points += rules[1021];}
					else if(length <= rules[1023] && length >= rules[1022]) {points += rules[1024];}
					else if(length <= rules[1026] && length >= rules[1025]) {points += rules[1027];}
					else if(length <= rules[2131] && length >= rules[2130]) {points += rules[2132];}
					else if(length <= rules[2134] && length >= rules[2133]) {points += rules[2135];}
					else if(length <= rules[2137] && length >= rules[2136]) {points += rules[2138];}
					else if(length <= rules[2140] && length >= rules[2139]) {points += rules[2141];}
					else if(length <= rules[2143] && length >= rules[2142]) {points += rules[2144];}
					else if(length <= rules[2146] && length >= rules[2145]) {points += rules[2147];}
					else if(length <= rules[2149] && length >= rules[2148]) {points += rules[2150];}
					else if(length <= rules[2152] && length >= rules[2151]) {points += rules[2153];}
				}
			}
	
			if(tds[x].indexOf("k") >= 0) {
				points += rules[1002];
				if(rules[1029]) {
					if(length <= rules[1029] && length >= rules[1028]) {points += rules[1030];}
					else if(length <= rules[1032] && length >= rules[1031]) {points += rules[1033];}
					else if(length <= rules[1035] && length >= rules[1034]) {points += rules[1036];}
					else if(length <= rules[1038] && length >= rules[1037]) {points += rules[1039];}
					else if(length <= rules[2155] && length >= rules[2154]) {points += rules[2156];}
					else if(length <= rules[2158] && length >= rules[2157]) {points += rules[2159];}
					else if(length <= rules[2161] && length >= rules[2160]) {points += rules[2162];}
					else if(length <= rules[2164] && length >= rules[2163]) {points += rules[2165];}
					else if(length <= rules[2167] && length >= rules[2166]) {points += rules[2168];}
					else if(length <= rules[2170] && length >= rules[2169]) {points += rules[2171];}
					else if(length <= rules[2173] && length >= rules[2172]) {points += rules[2174];}
					else if(length <= rules[2176] && length >= rules[2175]) {points += rules[2177];}
				}
			}
		}
	}
	return points;
}


function scoreOL() {
	return points;
}

function scorePK() {
	points = 0;
	if(statl[17].indexOf(",") >= 0) {
		var missed = statl[17].split(",");
		for(x=0;x<=missed.length;x++) {
			if(missed[x]) {
				var mislength = parseFloat(missed[x]);
				if(mislength >= 1) {
					if(mislength <= rules[477]) {points += parseFloat(rules[478]);} 
					else if(mislength <= rules[480]) {points += parseFloat(rules[481]);} 
					else if(mislength <= rules[483]) {points += parseFloat(rules[484]);} 
					else if(mislength <= rules[486]) {points += parseFloat(rules[487]);} 
					else if(mislength <= rules[489]) {points += parseFloat(rules[490]);} 
				}
			}
		}
	}
	var distance = statl[11].split(",");
	for(x=0;x<=distance.length;x++) {
		if(distance[x]) {
			var length = parseFloat(distance[x]);
			if(length <= rules[453]) {points += parseFloat(rules[454]);} 
			else if(length <= rules[456]) {points += parseFloat(rules[457]);} 
			else if(length <= rules[459]) {points += parseFloat(rules[460]);} 
			else if(length <= rules[462]) {points += parseFloat(rules[463]);} 
			else if(length <= rules[465]) {points += parseFloat(rules[466]);} 
			else if(length <= rules[468]) {points += parseFloat(rules[469]);} 
			else if(length <= rules[471]) {points += parseFloat(rules[472]);} 
			else if(length <= rules[474]) {points += parseFloat(rules[475]);} 
		}
	}
	
	var tds = statl[16].split(","); 
	for(x=0;x<=tds.length;x++) {
		if(tds[x]) {
			var length = parseFloat(tds[x].substr(1));
			if(tds[x].indexOf("p") >= 0) {
				points += parseFloat(rules[400]);
				if(length <= rules[405]) {points += parseFloat(rules[406]);}
				else if(length <= rules[408]) {points += parseFloat(rules[409]);}
				else if(length <= rules[411]) {points += parseFloat(rules[412]);}
				else if(length <= rules[414]) {points += parseFloat(rules[415]);}
			}
			if(tds[x].indexOf("r") >= 0) {
				points += parseFloat(rules[401]);
				if(length <= rules[417]) {points += parseFloat(rules[418]);}
				else if(length <= rules[420]) {points += parseFloat(rules[421]);}
				else if(length <= rules[423]) {points += parseFloat(rules[424]);}
				else if(length <= rules[426]) {points += parseFloat(rules[427]);}
			}
			if(tds[x].indexOf("c") >= 0) {
				points += parseFloat(rules[402]);
				if(length <= rules[429]) {points += parseFloat(rules[430]);}
				else if(length <= rules[432]) {points += parseFloat(rules[433]);}
				else if(length <= rules[435]) {points += parseFloat(rules[436]);}
				else if(length <= rules[438]) {points += parseFloat(rules[439]);}
			}
			if(tds[x].indexOf("k") >= 0) {
				points += parseFloat(rules[403]);
				if(length <= rules[441]) {points += parseFloat(rules[442]);}
				else if(length <= rules[444]) {points += parseFloat(rules[445]);}
				else if(length <= rules[447]) {points += parseFloat(rules[448]);}
				else if(length <= rules[450]) {points += parseFloat(rules[451]);}
			}
		}
	}
	var fumbles = statl[12].split("-"); 
	if(!fumbles[1]) {fumbles[1] = 0;} else {fumbles[1] = parseFloat(fumbles[1]);}
	points += (fumbles[1] * rules[95]); 

	var sacks = statl[13].split("-");
	if(!sacks[0]) {sacks[0] = 0;} else {sacks[0] = parseFloat(sacks[0]);}
	points += (sacks[0] * rules[96]); 

	var xps = statl[9].split("-"); 
	if(!xps[0]) {xps[0] = 0;} else {xps[0] = parseFloat(xps[0]);}
	if(!xps[1]) {xps[1] = 0;} else {xps[1] = parseFloat(xps[1]);}
	points += (xps[0] * rules[491]); 
	points += (xps[1] * rules[495]);

	var twopoints = statl[15].split(",");
	if(twopoints[0]) {
		if(twopoints[0].indexOf("p") >= 0) {points += rules[492];}
		else if(twopoints[0].indexOf("r") >= 0) {points += rules[491];}
		else if(twopoints[0].indexOf("c") >= 0) {points += rules[493];}
	}
	if(twopoints[1]) {
		if(twopoints[1].indexOf("p") >= 0) {points += rules[492];}
		else if(twopoints[1].indexOf("r") >= 0) {points += rules[491];}
		else if(twopoints[1].indexOf("c") >= 0) {points += rules[493];}
	}
	if(twopoints[2]) {
		if(twopoints[2].indexOf("p") >= 0) {points += rules[492];}
		else if(twopoints[2].indexOf("r") >= 0) {points += rules[491];}
		else if(twopoints[2].indexOf("c") >= 0) {points += rules[493];}
	}
	return points;
}