             requestClosure(request, done)
         })
 
-        searchController.searchBar
-            .rx.text
-            .debounce(0.5, scheduler: MainScheduler.instance)
-            .filter(filterSearch)
+        _ = table.rx
+            .itemSelected
+            .subscribe(onNext: handleSelectedItem)
+        
+        searchStream
             .flatMapLatest(makeNormalizationRequest)
             .subscribe(onNext: handleResults, onError: handleError)
             .addDisposableTo(disposeBag)
-
-        _ = table
-            .rx.itemSelected
-            .subscribe(onNext: handleSelectedItem)
     }
 
     private func setInitialValue() {

            )

            unrankedResults.append(address)

            if !forceNormalization {
                let searchText = searchController.searchBar.textField?.text?.trimmingCharacters(in: whitespace).uppercased()

                if searchText == address.address.replacingOccurrences(of: addressSufix, with: "") {
                    isEqual = true

                    if showPin ? (rowsInFirstSection == 2) : (rowsInFirstSection == 1) {
                        deleteRow = !hideForceNormalizationCell
                    }
                }
            }
        }
        
        self.results = self.ranker.rank(unrankedResults)

        if !forceNormalization {
            insertRow = !isEqual && !deleteRow && shouldHaveRowsInFirstSection()
        }

        if insertRow || deleteRow {
            DispatchQueue.main.async { [unowned self] in
                self.table.reloadSections(IndexSet(integer: 1), with: .none)

                if insertRow {
                    self.hideForceNormalizationCell = false
                    self.table.insertRows(at: [IndexPath(row: self.rowsInFirstSection - 1, section: 0)], with: .automatic)
                }
                else {
                    self.hideForceNormalizationCell = true
                    self.table.deleteRows(at: [IndexPath(row: self.rowsInFirstSection - 1, section: 0)], with: .automatic)
                }
            }
        }
        else {
            reloadTable()
        }
    }

    private func handleError(_ error: Swift.Error) {

        return provider
            .request(request)
            .mapJSON()
            .catchErrorJustReturn(["error": true])
    }

    private func makeEpokSearchRequest(_ query: String?) -> Observable<Any> {
