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

		}

		let starredArticleIDs = Set(articleIDs.map { String($0) } )
		let currentStarredArticleIDs = account.fetchStarredArticleIDs()
		
		// Mark articles as starred
		let deltaStarredArticleIDs = starredArticleIDs.subtracting(currentStarredArticleIDs)
		let markStarredArticles = account.fetchArticles(.articleIDs(deltaStarredArticleIDs))
		DispatchQueue.main.async {
			_ = 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)
		if !missingStarredArticleIDs.isEmpty {
			DispatchQueue.main.async {
				account.ensureStatuses(missingStarredArticleIDs, .starred, true)
			}
		}
		
		// Mark articles as unstarred
		let deltaUnstarredArticleIDs = currentStarredArticleIDs.subtracting(starredArticleIDs)
		let markUnstarredArticles = account.fetchArticles(.articleIDs(deltaUnstarredArticleIDs))
		DispatchQueue.main.async {
			_ = 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)
		if !missingUnstarredArticleIDs.isEmpty {
			DispatchQueue.main.async {
				account.ensureStatuses(missingUnstarredArticleIDs, .starred, false)
			}
		}
		
	}

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

	func refreshMissingArticles(_ account: Account, completion: @escaping (() -> Void)) {
		
		os_log(.debug, log: log, "Refreshing missing articles...")
		let group = DispatchGroup()

		account.fetchArticleIDsForStatusesWithoutArticles { (fetchedArticleIDs) in
			let articleIDs = Array(fetchedArticleIDs)
			let chunkedArticleIDs = articleIDs.chunked(into: 100)

			for chunk in chunkedArticleIDs {
				group.enter()
				self.caller.retrieveEntries(articleIDs: chunk) { result in

					switch result {
					case .success(let entries):
						self.processEntries(account: account, entries: entries) {
							group.leave()
						}

					case .failure(let error):
						os_log(.error, log: self.log, "Refresh missing articles failed: %@.", error.localizedDescription)
						group.leave()
					}
				}
			}
		}

		group.notify(queue: DispatchQueue.main) {
