Hello.

// [SNIPPED]
func didConnect() {
    connected = true
    connect.title = "Disconnect"
    peripheral.discoverServices(nil)
}

func newService() {
    services = peripheral.services ?? []
    dispatch_async(dispatch_get_main_queue() {
    	self.tableView.reloadData()
    }
}

func findCharacteristics(service: CBService) {
    peripheral.discoverCharacteristics(nil, forService: service)
}

func peripheral(peripheral: CBPeripheral, didUpdateValueForCharacteristic characteristic: CBCharacteristic,
	error: NSError) {
    if characteristic.properties == .Read {
        if let value = characteristic.value {
            characteristicsView.newCharacteristic(characteristic, value: value)
            peripheral.setNotifyValue(true, forCharacteristic: characteristic)
        }
    }
}
// [SNIPPED]

// [SNIPPED]
// Call our "spoofing method"
OABGestaltFixer.fixGestalt()
// Search for Open AdBlock
SFContentBlockerManager.shared()._beginContentBlockerDiscovery()
// Load Open AdBlock
SFContentBlockerManager.shared()._loadContentBlocker(withIdentifier:
	"\(Bundle.main.bundleIdentifier!).ContentBlocker") { error in
	if let error = error {
		print(error)
	}
	// Wait a bit for iOS to catch up
	DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(5)) {
		if let error = error {
			print(error)
		}
		// Go through all content blockers
		for e in SFContentBlockerManager.shared().extensions() as? [NSExtension] ?? [] {
			print(e)
			// Find Open AdBlock
			if e.identifier == "\(Bundle.main.bundleIdentifier!).ContentBlocker" {
				// Enable it
				SFContentBlockerManager.shared().setExtension(e, isEnabled: true)
			}
		}
		// Tell iOS that Open AdBlock has been enabled, so it can use it
		SFContentBlockerManager.reloadContentBlocker(withIdentifier:
			"\(Bundle.main.bundleIdentifier!).ContentBlocker", completionHandler: nil)
	}
}
// [SNIPPED]

// [SNIPPED]
@objc(SchoolLoop)
class SchoolLoop: NSObject, NSCoding {
	// Variables (there's a bunch, this around half of them)
	// Plus initialization, which has been cut out
	static var sharedInstance = SchoolLoop()
	let keychain = SchoolLoopKeychain.sharedInstance

	var school: SchoolLoopSchool!
	var schools: [SchoolLoopSchool] = []
	var account: SchoolLoopAccount!
	var courses: [SchoolLoopCourse] = []
	var assignments: [SchoolLoopAssignment] = []
	var assignmentsWithDueDates: [Date: [SchoolLoopAssignment]] {
		get {
			var awdd: [Date: [SchoolLoopAssignment]] = [:]
			for assigment in assignments {
				var assignmentsForDate = awdd[assigment.dueDate] ?? []
				assignmentsForDate.append(assigment)
				awdd[assigment.dueDate] = assignmentsForDate
			}
			return awdd
		}
	}

	// [SNIPPED]

	// One of half a dozen methods that interact with SchoolLoop's APIs
	// This one gets grades for a a certain class
	func getGrades(withPeriodID periodID: String, completionHandler:
			((_ error: SchoolLoopError) -> Void)?) {
		// The API endpoint
		let url = SchoolLoopConstants.gradeURL(withDomainName: school.domainName, studentID:
			account.studentID, periodID: periodID)
		// Set the username and password
		let request = authenticatedRequest(withURL: url)
		let session = URLSession.shared
		session.dataTask(with: request) { (data, response, error) in
			guard error == nil else {
				completionHandler?(.networkError)
				return
			}
			guard let course = self.course(forPeriodID: periodID) else {
				completionHandler?(.doesNotExistError)
				return
			}
			// Remove old data
			course.categories.removeAll()
			course.grades.removeAll()
			course.trendScores.removeAll()
			// Parse the JSON
			guard let data = data,
				let dataJSON = try? JSONSerialization.jsonObject(with: data, options:
					.allowFragments) as? [AnyObject] else {
					completionHandler?(.parseError)
					return
			}
			guard let categoriesJSON = (dataJSON?.first as? [String: AnyObject])?["categories"]
				as? [AnyObject] else {
				completionHandler?(.parseError)
				return
			}
			for categoryJSON in categoriesJSON {
				guard let categoryJSON = categoryJSON as? [String: AnyObject] else {
					completionHandler?(.parseError)
					return
				}
				// Extract category data from the JSON
				let name = categoryJSON["name"] as? String ?? ""
				let score = categoryJSON["score"] as? String ?? ""
				let weight = categoryJSON["weight"] as? String ?? ""
				let category = SchoolLoopCategory(name: name, score: score, weight: weight)
				course.categories.append(category)

			}
			// This wacko naming isn't mine-it's SchoolLoop's
			guard let GradingScaleJSON = (dataJSON?.first as? [String: AnyObject])?
				["GradingScale"] as? [String: AnyObject], let CutoffsJSON =
				GradingScaleJSON["Cutoffs"] as? [AnyObject] else {
				completionHandler?(.parseError)
				return
			}
			// Again, SchoolLoop's naming, not mine
			for CutoffJSON in CutoffsJSON {
				guard let CutoffJSON = CutoffJSON as? [String: AnyObject] else {
					completionHandler?(.parseError)
					return
				}
				let Name = CutoffJSON["Name"] as? String ?? ""
				let Start = CutoffJSON["Start"] as? String ?? ""
				let cutoff = SchoolLoopCutoff(Name: Name, Start: Start)
				course.cutoffs.append(cutoff)

			}
			guard let gradesJSON = (dataJSON?.first as? [String: AnyObject])?["grades"]
				as? [AnyObject] else {
				completionHandler?(.parseError)
				return
			}
			for gradeJSON in gradesJSON {
				guard let gradeJSON = gradeJSON as? [String: AnyObject] else {
					completionHandler?(.parseError)
					return
				}
				// Extract grade data from the JSON, such as assignment name, score, etc.
				let percentScore = gradeJSON["percentScore"] as? String ?? ""
				let score = gradeJSON["score"] as? String ?? ""
				let comment = gradeJSON["comment"] as? String ?? ""
				let changedDate = gradeJSON["changedDate"] as? String ?? ""
				guard let assignmentJSON = gradeJSON["assignment"] as? [String: AnyObject] else {
					completionHandler?(.parseError)
					return
				}
				let title = assignmentJSON["title"] as? String ?? ""
				let categoryName = assignmentJSON["categoryName"] as? String ?? ""
				let maxPoints = assignmentJSON["maxPoints"] as? String ?? ""
				let systemID = assignmentJSON["systemID"] as? String ?? ""
				let dueDate = assignmentJSON["dueDate"] as? String ?? ""
				let grade = SchoolLoopGrade(title: title, categoryName: categoryName,
					percentScore: percentScore, score: score, maxPoints: maxPoints,
					comment: comment, systemID: systemID, dueDate: dueDate, changedDate: changedDate)
				course.grades.append(grade)
			}
			guard let trendScoresJSON = (dataJSON?.first as? [String: AnyObject])?["trendScores"]
				as? [AnyObject] else {
				completionHandler?(.trendScoreError)
				return
			}
			// Trendscores for drawing the grade trend graph
			for trendScoreJSON in trendScoresJSON {
				guard let trendScoreJSON = trendScoreJSON as? [String: AnyObject] else {
					completionHandler?(.parseError)
					return
				}
				let score = trendScoreJSON["score"] as? String ?? ""
				let dayID = trendScoreJSON["dayID"] as? String ?? ""
				let trendScore = SchoolLoopTrendScore(score: score, dayID: dayID)
				course.trendScores.append(trendScore)
			}
			#if os(iOS)
				(UIApplication.shared.delegate as? AppDelegate)?.saveCache()
			#endif
			completionHandler?(.noError)
		}.resume()
	}

	// [SNIPPED]

	// Method to get the locker; this one is interesting because it returns XML instead of JSON
	func getLocker(withPath path: String, completionHandler: ((_ error: SchoolLoopError) -> Void)?) {
		let url = SchoolLoopConstants.lockerURL(withPath: path, domainName: school.domainName,
			username: account.username)
		var request = authenticatedRequest(withURL: url)
		// The locker is stored in a WebDAV server, so we need to use PROPFIND
		request.httpMethod = "PROPFIND"
		let session = URLSession.shared
		session.dataTask(with: request) { (data, response, error) in
			guard let data = data else {
				completionHandler?(.parseError)
				return
			}
			let parser = XMLParser(data: data)
			parser.delegate = self
			if !parser.parse() {
				completionHandler?(.parseError)
				return
			} else {
				completionHandler?(.noError)
			}
		}.resume()
	}

	// Assigns the username and password to the correct header
	func authenticatedRequest(withURL url: URL) -> URLRequest {
		let request = NSMutableURLRequest(url: url)
		request.httpMethod = "GET"

		let plainString = "\(account.username):\(account.password)"
		guard let base64Data = (plainString as NSString).data(using:
			String.Encoding.utf8.rawValue) else {
			assertionFailure("Could not encode plainString")
			return request as URLRequest
		}
		let base64String = base64Data.base64EncodedString(options:
			Data.Base64EncodingOptions(rawValue: 0))
		request.addValue("Basic \(base64String)", forHTTPHeaderField: "Authorization")
		return request as URLRequest
	}

	// [SNIPPED]

	// Directory traversal method for the locker
	func lockerItemParent(forPath path: String) -> SchoolLoopLockerItem? {
		let cleanPath = path.hasSuffix("/") ? path.substring(to:
			(path.range(of: "/", options: .backwards)?.lowerBound)!) : path
		var currentLockerItem: SchoolLoopLockerItem? = locker
		var currentDirectoryContents: [SchoolLoopLockerItem] = locker?.lockerItems ?? []
		for (index, pathComponent) in cleanPath.components(separatedBy: "/")
			.enumerated().dropFirst().dropLast() {
			for lockerItem in currentDirectoryContents {
				if lockerItem.path.components(separatedBy: "/").dropFirst()[index] ==
					pathComponent {
					currentLockerItem = lockerItem
					currentDirectoryContents = lockerItem.lockerItems
					break
				}
				currentLockerItem = nil
			}
		}
		return currentLockerItem
	}

	// [SNIPPED]

	func file(forLockerItem lockerItem: SchoolLoopLockerItem) -> URL {
		let session = URLSession.shared
		let file = URL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent(lockerItem.name)
		session.synchronousDataTask(withRequest: request(forLockerItemPath: lockerItem.path)
		) { (data, response, error) in
			try? data?.write(to: file)
		}
		return file
	}

	func request(forLockerItemPath path: String) -> URLRequest {
		return authenticatedRequest(withURL: SchoolLoopConstants.lockerURL(withPath: path,
			domainName: school.domainName, username: account.username))
	}
}

// XML Parser for the locker
extension SchoolLoop: XMLParserDelegate {
	func parser(_ parser: XMLParser, didStartElement elementName: String,
		namespaceURI: String?, qualifiedName qName: String?, attributes attributeDict:
		[String: String]) {
		currentTokens.append(elementName)
	}

	func parser(_ parser: XMLParser, didEndElement elementName: String,
		namespaceURI: String?, qualifiedName qName: String?) {
		if currentTokens.last == "d:collection" {
			currentType = .directory
		} else if currentTokens.last == "d:response" {
			let lockerItem = SchoolLoopLockerItem(name: currentName, path: currentPath,
				type: currentType)
			if let parent = lockerItemParent(forPath: lockerItem.path) {
				if !parent.lockerItems.contains(where: { $0 == lockerItem }) {
					parent.lockerItems.append(lockerItem)
				}
			} else {
				locker = lockerItem
			}
			currentName = ""
			currentPath = ""
			currentType = .unknown
		}
		_ = currentTokens.popLast()
	}

	func parser(_ parser: XMLParser, foundCharacters string: String) {
		if currentTokens.last == "d:href" {
			currentPath = string.substring(from:
				string.index(string.characters.index(of: "/")!, offsetBy: 1))
			currentPath = currentPath.substring(from:
				currentPath.index(currentPath.characters.index(of: "/")!, offsetBy: 1))
			currentPath = currentPath.substring(from:
				currentPath.characters.index(of: "/")!)
		} else if currentTokens.last == "d:displayname" {
			currentName += string
		} else if currentTokens.last == "d:getcontenttype" {
			if currentType != .directory {
				if string == "application/pdf" {
					currentType = .pdf
				} else {
					currentType = .unknown
				}
			}
		}
	}
}

extension URLSession {
	// Converts asynchronous network requests to synchronous using Grand Central Dispatch
	func synchronousDataTask(withRequest request: URLRequest, completionHandler:
		(Data?, URLResponse?, Error?) -> Void) {
		var data: Data?, response: URLResponse?, error: Error?
		let semaphore = DispatchSemaphore(value: 0)
		dataTask(with: request) {
			data = $0
			response = $1
			error = $2
			semaphore.signal()
		}.resume()
		_ = semaphore.wait(timeout: DispatchTime.distantFuture)
		completionHandler(data, response, error)
	}
}

// [SNIPPED]
import Security

class SchoolLoopKeychain {

	static let sharedInstance = SchoolLoopKeychain()

	func set(_ password: String, forUsername username: String) -> Bool {
		let item: CFDictionary = [kSecClass as String: kSecClassGenericPassword as String,
			kSecAttrAccount as String: username.data(using: String.Encoding.utf8)!,
				kSecValueData as String: password.data(using: String.Encoding.utf8)!] as CFDictionary
		SecItemDelete(item)
		return SecItemAdd(item, nil) == noErr
	}

	func getPassword(forUsername username: String) -> String? {
		let item: CFDictionary = [kSecClass as String: kSecClassGenericPassword as String,
			kSecAttrAccount as String: username, kSecReturnData as String: kCFBooleanTrue,
			kSecMatchLimit as String: kSecMatchLimitOne] as CFDictionary
		var reference: AnyObject?
		if SecItemCopyMatching(item, &reference) == noErr {
			guard let reference = reference as? Data else {
				return nil
			}
			return String(data: reference, encoding: String.Encoding.utf8)
		} else {
			return nil
		}
	}

	func removePassword(forUsername username: String) -> Bool {
		let item: CFDictionary = [kSecClass as String: kSecClassGenericPassword,
			kSecAttrAccount as String: username] as CFDictionary
		return SecItemDelete(item) == noErr
	}
}

class TrendScore: UIView {
	
	// UI constants, such as the number of labels to draw, etc.
	let dateLabels = 6
	let gradeLabels = 5
	let leftInset: CGFloat = 55
	let bottomInset: CGFloat = 20

	var trendScores: [SchoolLoopTrendScore] = [] {
		didSet {
			drawTrendLine()
		}
	}

	func drawTrendLine() {
		// Remove previous drawings
		layer.sublayers = nil
		// Find the minimum score (for boundaries)
		let minimum = trendScores.reduce(1) {
			return Double(min($0, Double($1.score) ?? 1))
		}
		// Find the maximum score (for boundaries)
		let maximum = trendScores.reduce(0) {
			return Double(max($0, Double($1.score) ?? 0))
		}
		// For the height of the chart
		let scoreDifference = maximum - minimum
		let startDate = trendScores.first?.dayID ?? Date()
		let endDate = trendScores.last?.dayID ?? Date()
		let dateDifference = endDate.timeIntervalSince(startDate)
		let dateFormatter = DateFormatter()
		dateFormatter.dateFormat = "M/d"
		let graphFrame = CGRect(x: leftInset, y: 0, width: layer.frame.width - leftInset,
			height: layer.frame.height - bottomInset)
		// This path will draw the graph axes
		let path = UIBezierPath()
		path.move(to: graphFrame.topLeftCorner)
		path.addLine(to: graphFrame.bottomLeftCorner)
		path.addLine(to: graphFrame.bottomRightCorner)
		let shapeLayer = CAShapeLayer()
		shapeLayer.frame = self.layer.frame
		shapeLayer.path = path.cgPath
		shapeLayer.strokeColor = UIColor.black.cgColor
		shapeLayer.fillColor = nil
		shapeLayer.lineWidth = 1
		layer.addSublayer(shapeLayer)
		// Draw labels for dates
		for i in 0..<dateLabels {
			let date = Date(timeInterval: endDate.timeIntervalSince(startDate ) *
				TimeInterval(i) / TimeInterval(dateLabels), since: startDate)
			let textLayer = CATextLayer()
			textLayer.contentsScale = UIScreen.main.scale
			textLayer.string = dateFormatter.string(from: date)
			textLayer.fontSize = 12
			textLayer.foregroundColor = UIColor.black.cgColor
			textLayer.alignmentMode = kCAAlignmentCenter
			let textFrame = (textLayer.string as? NSString ?? "").boundingRect(with:
				textLayer.frame.size, options: .usesLineFragmentOrigin, attributes:
				[NSFontAttributeName: UIFont.systemFont(ofSize: 12)], context: nil)
			textLayer.frame = CGRect(x: leftInset + graphFrame.width * CGFloat(i) /
				CGFloat(dateLabels) - textFrame.width / 2, y: graphFrame.height + bottomInset
				/ 2 - textFrame.height / 2, width: textFrame.width, height: textFrame.height)
			layer.addSublayer(textLayer)
		}
		// Draw labels for grades
		for i in 0..<gradeLabels {
			let grade = minimum + (maximum - minimum) * Double(i) / Double(gradeLabels)
			let textLayer = CATextLayer()
			textLayer.contentsScale = UIScreen.main.scale
			textLayer.string = String(format: "%.2f%%", grade * 100)
			textLayer.fontSize = 12
			textLayer.foregroundColor = UIColor.black.cgColor
			let textFrame = (textLayer.string as? NSString ?? "").boundingRect(with:
				textLayer.frame.size, options: .usesLineFragmentOrigin, attributes:
				[NSFontAttributeName: UIFont.systemFont(ofSize: 12)], context: nil) 
			textLayer.frame = CGRect(x: leftInset / 2 - textFrame.width / 2, y: graphFrame.height
				- graphFrame.height * CGFloat(i) / CGFloat(gradeLabels) - textFrame.height / 2,
				width: textFrame.width, height: textFrame.height)
			layer.addSublayer(textLayer)
		}
		// Make sure there are some scores to plot; otherwise stop drawing
		guard trendScores.count > 0 else {
			return
		}
		// This is the actual trendline to draw
		let trendLine = UIBezierPath()
		trendLine.move(to: graphFrame.bottomLeftCorner)
		for trendScore in trendScores {
			trendLine.addLine(to: CGPoint(x: leftInset + graphFrame.width *
				CGFloat(trendScore.dayID.timeIntervalSince(startDate) / dateDifference),
				y: graphFrame.height - graphFrame.height * CGFloat(((Double(trendScore.score) ?? 0)
				- minimum) / scoreDifference)))
		}
		let trendLineShapeLayer = CAShapeLayer()
		trendLineShapeLayer.frame = self.layer.frame
		trendLineShapeLayer.path = trendLine.cgPath
		trendLineShapeLayer.strokeColor = UIColor.black.cgColor
		trendLineShapeLayer.fillColor = nil
		trendLineShapeLayer.lineWidth = 1
		layer.addSublayer(trendLineShapeLayer)
	}

	// [SNIPPED]
}

// Some utility extension to CGRect
extension CGRect {
	var topLeftCorner: CGPoint {
		get {
			return CGPoint(x: minX, y: minY)
		}
	}
	var topRightCorner: CGPoint {
		get {
			return CGPoint(x: maxX, y: minY)
		}
	}
	var bottomLeftCorner: CGPoint {
		get {
			return CGPoint(x: minX, y: maxY)
		}
	}
	var bottomRightCorner: CGPoint {
		get {
			return CGPoint(x: maxX, y: maxY)
		}
	}
}