 			os_log(.debug, log: self.log, "Done refreshing missing articles.")
 			completion()
 		}
-		
 	}
 
 	func refreshArticles(_ account: Account, page: String?, completion: @escaping (() -> Void)) {

	}
	
	func syncArticleReadState(account: Account, articleIDs: [Int]?) {
		
		guard let articleIDs = articleIDs else {
			return
		}

		let unreadArticleIDs = Set(articleIDs.map { String($0) } )
		let currentUnreadArticleIDs = account.fetchUnreadArticleIDs()
		
		// Mark articles as unread
		let deltaUnreadArticleIDs = unreadArticleIDs.subtracting(currentUnreadArticleIDs)
		let markUnreadArticles = account.fetchArticles(.articleIDs(deltaUnreadArticleIDs))
		DispatchQueue.main.async {
			_ = account.update(markUnreadArticles, statusKey: .read, flag: false)
		}
	
		// Save any unread statuses for articles we haven't yet received
		let markUnreadArticleIDs = Set(markUnreadArticles.map { $0.articleID })
		let missingUnreadArticleIDs = deltaUnreadArticleIDs.subtracting(markUnreadArticleIDs)
		if !missingUnreadArticleIDs.isEmpty {
			DispatchQueue.main.async {
				account.ensureStatuses(missingUnreadArticleIDs, .read, false)
			}
		}
		
		// Mark articles as read
		let deltaReadArticleIDs = currentUnreadArticleIDs.subtracting(unreadArticleIDs)
		let markReadArticles = account.fetchArticles(.articleIDs(deltaReadArticleIDs))
		DispatchQueue.main.async {
			_ = account.update(markReadArticles, statusKey: .read, flag: true)
		}
	
		// Save any read statuses for articles we haven't yet received
		let markReadArticleIDs = Set(markReadArticles.map { $0.articleID })
		let missingReadArticleIDs = deltaReadArticleIDs.subtracting(markReadArticleIDs)
		if !missingReadArticleIDs.isEmpty {
			DispatchQueue.main.async {
				account.ensureStatuses(missingReadArticleIDs, .read, true)
			}
		}
	
	}
	
	func syncArticleStarredState(account: Account, articleIDs: [Int]?) {

		}

		let starredArticleIDs = Set(articleIDs.map { String($0) } )
		account.fetchStarredArticleIDs { (currentStarredArticleIDs) in
			// Mark articles as starred
			let deltaStarredArticleIDs = starredArticleIDs.subtracting(currentStarredArticleIDs)
			account.fetchArticlesAsync(.articleIDs(deltaStarredArticleIDs)) { (markStarredArticles) in
				account.update(markStarredArticles, statusKey: .starred, flag: true)

				// Save any starred statuses for articles we haven't yet received
				let markStarredArticleIDs = Set(markStarredArticles.map { $0.articleID })
				let missingStarredArticleIDs = deltaStarredArticleIDs.subtracting(markStarredArticleIDs)
				account.ensureStatuses(missingStarredArticleIDs, .starred, true)
			}

			// Mark articles as unstarred
			let deltaUnstarredArticleIDs = currentStarredArticleIDs.subtracting(starredArticleIDs)
			account.fetchArticlesAsync(.articleIDs(deltaUnstarredArticleIDs)) { (markUnstarredArticles) in
				account.update(markUnstarredArticles, statusKey: .starred, flag: false)

				// Save any unstarred statuses for articles we haven't yet received
				let markUnstarredArticleIDs = Set(markUnstarredArticles.map { $0.articleID })
				let missingUnstarredArticleIDs = deltaUnstarredArticleIDs.subtracting(markUnstarredArticleIDs)
				account.ensureStatuses(missingUnstarredArticleIDs, .starred, false)
			}
		}
	}

	func deleteTagging(for account: Account, with feed: Feed, from container: Container?, completion: @escaping (Result<Void, Error>) -> Void) {
