diff --git a/index.html b/index.html
index bb14aa7..96bd401 100644
--- a/index.html
+++ b/index.html
@@ -363,6 +363,8 @@ <h3>Report Recovery</h3>
     <script type="text/javascript" language="javascript" src="js/leaflet.js"></script>
     <script type="text/javascript" language="javascript" src="js/Leaflet.fullscreen.min.js"></script>
     <script type="text/javascript" language="javascript" src="js/L.Terminator.js"></script>
+    <script type="text/javascript" language="javascript" src="js/rbush.js"></script>
+    <script type="text/javascript" language="javascript" src="js/leaflet-markers-canvas.min.js"></script>
     <script src="https://xc5dqkj2cgb1.statuspage.io/embed/script.js"></script>
     <script type="text/javascript" language="javascript" src="js/mobile.js"></script>
     <!--
diff --git a/js/leaflet-markers-canvas.min.js b/js/leaflet-markers-canvas.min.js
new file mode 100644
index 0000000..a2d0e36
--- /dev/null
+++ b/js/leaflet-markers-canvas.min.js
@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(require("leaflet"),require("rbush")):"function"==typeof define&&define.amd?define(["leaflet","rbush"],t):t((e=e||self).L,e.RBush)}(this,function(o,e){"use strict";o=o&&Object.prototype.hasOwnProperty.call(o,"default")?o.default:o;var t={_map:null,_canvas:null,_context:null,_markers:[],_markersTree:new(e=e&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e),_positionsTree:new e,_icons:{},addTo:function(e){return e.addLayer(this),this},getBounds:function(){var t=new o.LatLngBounds;return this._markers.forEach(function(e){t.extend(e.getLatLng())}),t},redraw:function(){this._redraw(!0)},clear:function(){this._positionsTree=new e,this._markersTree=new e,this._markers=[],this._redraw(!0)},addMarker:function(e){var t=this._addMarker(e),i=t.markerBox,e=t.positionBox,t=t.isVisible;i&&t&&this._markersTree.insert(i),e&&this._positionsTree.insert(e)},addMarkers:function(e){var s=this,a=[],r=[];e.forEach(function(e){var t=s._addMarker(e),i=t.markerBox,e=t.positionBox,t=t.isVisible;i&&t&&a.push(i),e&&r.push(e)}),this._markersTree.load(a),this._positionsTree.load(r)},removeMarker:function(e){var t=e.getLatLng(),i=this._map.getBounds().contains(t),e={minX:t.lng,minY:t.lat,maxX:t.lng,maxY:t.lat,marker:e};this._positionsTree.remove(e,function(e,t){return e.marker._leaflet_id===t.marker._leaflet_id}),i&&this._redraw(!0)},initialize:function(e){o.Util.setOptions(this,e)},onAdd:function(e){this._map=e,this._initCanvas(),this.getPane().appendChild(this._canvas),e.on("moveend",this._reset,this),e.on("resize",this._reset,this),e.on("click",this._fire,this),e.on("mousemove",this._fire,this),e._zoomAnimated&&e.on("zoomanim",this._animateZoom,this)},onRemove:function(e){this.getPane().removeChild(this._canvas),e.off("click",this._fire,this),e.off("mousemove",this._fire,this),e.off("moveend",this._reset,this),e.off("resize",this._reset,this),e._zoomAnimated&&e.off("zoomanim",this._animateZoom,this)},setOptions:function(e){return o.Util.setOptions(this,e),this.redraw()},_initCanvas:function(){var e=this._map.getSize(),t=e.x,i=e.y,e=this._map.options.zoomAnimation&&o.Browser.any3d;this._canvas=o.DomUtil.create("canvas","leaflet-markers-canvas-layer leaflet-layer"),this._canvas.width=t,this._canvas.height=i,this._context=this._canvas.getContext("2d"),o.DomUtil.addClass(this._canvas,"leaflet-zoom-"+(e?"animated":"hide"))},_addMarker:function(e){if("markerPane"!==e.options.pane||!e.options.icon)return console.error("This is not a marker",e),{markerBox:null,positionBox:null,isVisible:null};e._map=this._map,o.Util.stamp(e);var t=e.getLatLng(),i=this._map.getBounds().contains(t),s=this._map.latLngToContainerPoint(t),a=s.x,r=s.y,n=e.options.icon.options,s=n.iconSize,n=n.iconAnchor,n={minX:a-n[0],minY:r-n[1],maxX:a+s[0]-n[0],maxY:r+s[1]-n[1],marker:e},t={minX:t.lng,minY:t.lat,maxX:t.lng,maxY:t.lat,marker:e};return i&&this._drawMarker(e,{x:a,y:r}),this._markers.push(e),{markerBox:n,positionBox:t,isVisible:i}},_drawMarker:function(e,t){var s=this,i=t.x,a=t.y,r=e.options.icon.options.iconUrl;e.image?this._drawImage(e,{x:i,y:a}):this._icons[r]?(e.image=this._icons[r].image,this._icons[r].isLoaded?this._drawImage(e,{x:i,y:a}):this._icons[r].elements.push({marker:e,x:i,y:a})):((t=new Image).src=r,e.image=t,this._icons[r]={image:t,isLoaded:!1,elements:[{marker:e,x:i,y:a}]},t.onload=function(){s._icons[r].isLoaded=!0,s._icons[r].elements.forEach(function(e){var t=e.marker,i=e.x,e=e.y;s._drawImage(t,{x:i,y:e})})})},_drawImage:function(e,t){var i=t.x,s=t.y,a=e.options.icon.options,r=a.rotationAngle,t=a.iconAnchor,a=a.iconSize,r=r||0;this._context.save(),this._context.translate(i,s),this._context.rotate(r*Math.PI/180),this._context.drawImage(e.image,-t[0],-t[1],a[0],a[1]),this._context.restore()},_redraw:function(e){var r,n=this;e&&this._context.clearRect(0,0,this._canvas.width,this._canvas.height),this._map&&this._positionsTree&&(e={minX:(e=this._map.getBounds()).getWest(),minY:e.getSouth(),maxX:e.getEast(),maxY:e.getNorth()},r=[],this._positionsTree.search(e).forEach(function(e){var t=e.marker,i=t.getLatLng(),s=n._map.latLngToContainerPoint(i),a=s.x,e=s.y,i=t.options.icon.options,s=i.iconSize,i=i.iconAnchor,i={minX:a-i[0],minY:e-i[1],maxX:a+s[0]-i[0],maxY:e+s[1]-i[1],marker:t};r.push(i),n._drawMarker(t,{x:a,y:e})}),this._markersTree.clear(),this._markersTree.load(r))},_reset:function(){var e=this._map.containerPointToLayerPoint([0,0]);o.DomUtil.setPosition(this._canvas,e);var t=this._map.getSize(),e=t.x,t=t.y;this._canvas.width=e,this._canvas.height=t,this._redraw()},_fire:function(e){var t,i;this._markersTree&&(t=(i=e.containerPoint).x,i=i.y,(i=this._markersTree.search({minX:t,minY:i,maxX:t,maxY:i}))&&i.length?(this._map._container.style.cursor="pointer",i=i[0].marker,"click"===e.type&&i.listens("click")&&i.fire("click"),"mousemove"===e.type&&(this._mouseOverMarker&&this._mouseOverMarker!==i&&this._mouseOverMarker.listens("mouseout")&&this._mouseOverMarker.fire("mouseout"),this._mouseOverMarker&&this._mouseOverMarker===i||(this._mouseOverMarker=i).listens("mouseover")&&i.fire("mouseover"))):(this._map._container.style.cursor="","mousemove"===e.type&&this._mouseOverMarker&&(this._mouseOverMarker.listens("mouseout")&&this._mouseOverMarker.fire("mouseout"),delete this._mouseOverMarker)))},_animateZoom:function(e){var t=this._map.getZoomScale(e.zoom),e=this._map._latLngBoundsToNewLayerBounds(this._map.getBounds(),e.zoom,e.center).min;o.DomUtil.setTransform(this._canvas,e,t)}};o.MarkersCanvas=o.Layer.extend(t)});
diff --git a/js/rbush.js b/js/rbush.js
new file mode 100644
index 0000000..4b40722
--- /dev/null
+++ b/js/rbush.js
@@ -0,0 +1,574 @@
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+typeof define === 'function' && define.amd ? define(factory) :
+(global = global || self, global.RBush = factory());
+}(this, function () { 'use strict';
+
+function quickselect(arr, k, left, right, compare) {
+    quickselectStep(arr, k, left || 0, right || (arr.length - 1), compare || defaultCompare);
+}
+
+function quickselectStep(arr, k, left, right, compare) {
+
+    while (right > left) {
+        if (right - left > 600) {
+            var n = right - left + 1;
+            var m = k - left + 1;
+            var z = Math.log(n);
+            var s = 0.5 * Math.exp(2 * z / 3);
+            var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
+            var newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
+            var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
+            quickselectStep(arr, k, newLeft, newRight, compare);
+        }
+
+        var t = arr[k];
+        var i = left;
+        var j = right;
+
+        swap(arr, left, k);
+        if (compare(arr[right], t) > 0) { swap(arr, left, right); }
+
+        while (i < j) {
+            swap(arr, i, j);
+            i++;
+            j--;
+            while (compare(arr[i], t) < 0) { i++; }
+            while (compare(arr[j], t) > 0) { j--; }
+        }
+
+        if (compare(arr[left], t) === 0) { swap(arr, left, j); }
+        else {
+            j++;
+            swap(arr, j, right);
+        }
+
+        if (j <= k) { left = j + 1; }
+        if (k <= j) { right = j - 1; }
+    }
+}
+
+function swap(arr, i, j) {
+    var tmp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = tmp;
+}
+
+function defaultCompare(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+
+var RBush = function RBush(maxEntries) {
+    if ( maxEntries === void 0 ) maxEntries = 9;
+
+    // max entries in a node is 9 by default; min node fill is 40% for best performance
+    this._maxEntries = Math.max(4, maxEntries);
+    this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));
+    this.clear();
+};
+
+RBush.prototype.all = function all () {
+    return this._all(this.data, []);
+};
+
+RBush.prototype.search = function search (bbox) {
+    var node = this.data;
+    var result = [];
+
+    if (!intersects(bbox, node)) { return result; }
+
+    var toBBox = this.toBBox;
+    var nodesToSearch = [];
+
+    while (node) {
+        for (var i = 0; i < node.children.length; i++) {
+            var child = node.children[i];
+            var childBBox = node.leaf ? toBBox(child) : child;
+
+            if (intersects(bbox, childBBox)) {
+                if (node.leaf) { result.push(child); }
+                else if (contains(bbox, childBBox)) { this._all(child, result); }
+                else { nodesToSearch.push(child); }
+            }
+        }
+        node = nodesToSearch.pop();
+    }
+
+    return result;
+};
+
+RBush.prototype.collides = function collides (bbox) {
+    var node = this.data;
+
+    if (!intersects(bbox, node)) { return false; }
+
+    var nodesToSearch = [];
+    while (node) {
+        for (var i = 0; i < node.children.length; i++) {
+            var child = node.children[i];
+            var childBBox = node.leaf ? this.toBBox(child) : child;
+
+            if (intersects(bbox, childBBox)) {
+                if (node.leaf || contains(bbox, childBBox)) { return true; }
+                nodesToSearch.push(child);
+            }
+        }
+        node = nodesToSearch.pop();
+    }
+
+    return false;
+};
+
+RBush.prototype.load = function load (data) {
+    if (!(data && data.length)) { return this; }
+
+    if (data.length < this._minEntries) {
+        for (var i = 0; i < data.length; i++) {
+            this.insert(data[i]);
+        }
+        return this;
+    }
+
+    // recursively build the tree with the given data from scratch using OMT algorithm
+    var node = this._build(data.slice(), 0, data.length - 1, 0);
+
+    if (!this.data.children.length) {
+        // save as is if tree is empty
+        this.data = node;
+
+    } else if (this.data.height === node.height) {
+        // split root if trees have the same height
+        this._splitRoot(this.data, node);
+
+    } else {
+        if (this.data.height < node.height) {
+            // swap trees if inserted one is bigger
+            var tmpNode = this.data;
+            this.data = node;
+            node = tmpNode;
+        }
+
+        // insert the small tree into the large tree at appropriate level
+        this._insert(node, this.data.height - node.height - 1, true);
+    }
+
+    return this;
+};
+
+RBush.prototype.insert = function insert (item) {
+    if (item) { this._insert(item, this.data.height - 1); }
+    return this;
+};
+
+RBush.prototype.clear = function clear () {
+    this.data = createNode([]);
+    return this;
+};
+
+RBush.prototype.remove = function remove (item, equalsFn) {
+    if (!item) { return this; }
+
+    var node = this.data;
+    var bbox = this.toBBox(item);
+    var path = [];
+    var indexes = [];
+    var i, parent, goingUp;
+
+    // depth-first iterative tree traversal
+    while (node || path.length) {
+
+        if (!node) { // go up
+            node = path.pop();
+            parent = path[path.length - 1];
+            i = indexes.pop();
+            goingUp = true;
+        }
+
+        if (node.leaf) { // check current node
+            var index = findItem(item, node.children, equalsFn);
+
+            if (index !== -1) {
+                // item found, remove the item and condense tree upwards
+                node.children.splice(index, 1);
+                path.push(node);
+                this._condense(path);
+                return this;
+            }
+        }
+
+        if (!goingUp && !node.leaf && contains(node, bbox)) { // go down
+            path.push(node);
+            indexes.push(i);
+            i = 0;
+            parent = node;
+            node = node.children[0];
+
+        } else if (parent) { // go right
+            i++;
+            node = parent.children[i];
+            goingUp = false;
+
+        } else { node = null; } // nothing found
+    }
+
+    return this;
+};
+
+RBush.prototype.toBBox = function toBBox (item) { return item; };
+
+RBush.prototype.compareMinX = function compareMinX (a, b) { return a.minX - b.minX; };
+RBush.prototype.compareMinY = function compareMinY (a, b) { return a.minY - b.minY; };
+
+RBush.prototype.toJSON = function toJSON () { return this.data; };
+
+RBush.prototype.fromJSON = function fromJSON (data) {
+    this.data = data;
+    return this;
+};
+
+RBush.prototype._all = function _all (node, result) {
+    var nodesToSearch = [];
+    while (node) {
+        if (node.leaf) { result.push.apply(result, node.children); }
+        else { nodesToSearch.push.apply(nodesToSearch, node.children); }
+
+        node = nodesToSearch.pop();
+    }
+    return result;
+};
+
+RBush.prototype._build = function _build (items, left, right, height) {
+
+    var N = right - left + 1;
+    var M = this._maxEntries;
+    var node;
+
+    if (N <= M) {
+        // reached leaf level; return leaf
+        node = createNode(items.slice(left, right + 1));
+        calcBBox(node, this.toBBox);
+        return node;
+    }
+
+    if (!height) {
+        // target height of the bulk-loaded tree
+        height = Math.ceil(Math.log(N) / Math.log(M));
+
+        // target number of root entries to maximize storage utilization
+        M = Math.ceil(N / Math.pow(M, height - 1));
+    }
+
+    node = createNode([]);
+    node.leaf = false;
+    node.height = height;
+
+    // split the items into M mostly square tiles
+
+    var N2 = Math.ceil(N / M);
+    var N1 = N2 * Math.ceil(Math.sqrt(M));
+
+    multiSelect(items, left, right, N1, this.compareMinX);
+
+    for (var i = left; i <= right; i += N1) {
+
+        var right2 = Math.min(i + N1 - 1, right);
+
+        multiSelect(items, i, right2, N2, this.compareMinY);
+
+        for (var j = i; j <= right2; j += N2) {
+
+            var right3 = Math.min(j + N2 - 1, right2);
+
+            // pack each entry recursively
+            node.children.push(this._build(items, j, right3, height - 1));
+        }
+    }
+
+    calcBBox(node, this.toBBox);
+
+    return node;
+};
+
+RBush.prototype._chooseSubtree = function _chooseSubtree (bbox, node, level, path) {
+    while (true) {
+        path.push(node);
+
+        if (node.leaf || path.length - 1 === level) { break; }
+
+        var minArea = Infinity;
+        var minEnlargement = Infinity;
+        var targetNode = (void 0);
+
+        for (var i = 0; i < node.children.length; i++) {
+            var child = node.children[i];
+            var area = bboxArea(child);
+            var enlargement = enlargedArea(bbox, child) - area;
+
+            // choose entry with the least area enlargement
+            if (enlargement < minEnlargement) {
+                minEnlargement = enlargement;
+                minArea = area < minArea ? area : minArea;
+                targetNode = child;
+
+            } else if (enlargement === minEnlargement) {
+                // otherwise choose one with the smallest area
+                if (area < minArea) {
+                    minArea = area;
+                    targetNode = child;
+                }
+            }
+        }
+
+        node = targetNode || node.children[0];
+    }
+
+    return node;
+};
+
+RBush.prototype._insert = function _insert (item, level, isNode) {
+    var bbox = isNode ? item : this.toBBox(item);
+    var insertPath = [];
+
+    // find the best node for accommodating the item, saving all nodes along the path too
+    var node = this._chooseSubtree(bbox, this.data, level, insertPath);
+
+    // put the item into the node
+    node.children.push(item);
+    extend(node, bbox);
+
+    // split on node overflow; propagate upwards if necessary
+    while (level >= 0) {
+        if (insertPath[level].children.length > this._maxEntries) {
+            this._split(insertPath, level);
+            level--;
+        } else { break; }
+    }
+
+    // adjust bboxes along the insertion path
+    this._adjustParentBBoxes(bbox, insertPath, level);
+};
+
+// split overflowed node into two
+RBush.prototype._split = function _split (insertPath, level) {
+    var node = insertPath[level];
+    var M = node.children.length;
+    var m = this._minEntries;
+
+    this._chooseSplitAxis(node, m, M);
+
+    var splitIndex = this._chooseSplitIndex(node, m, M);
+
+    var newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
+    newNode.height = node.height;
+    newNode.leaf = node.leaf;
+
+    calcBBox(node, this.toBBox);
+    calcBBox(newNode, this.toBBox);
+
+    if (level) { insertPath[level - 1].children.push(newNode); }
+    else { this._splitRoot(node, newNode); }
+};
+
+RBush.prototype._splitRoot = function _splitRoot (node, newNode) {
+    // split root node
+    this.data = createNode([node, newNode]);
+    this.data.height = node.height + 1;
+    this.data.leaf = false;
+    calcBBox(this.data, this.toBBox);
+};
+
+RBush.prototype._chooseSplitIndex = function _chooseSplitIndex (node, m, M) {
+    var index;
+    var minOverlap = Infinity;
+    var minArea = Infinity;
+
+    for (var i = m; i <= M - m; i++) {
+        var bbox1 = distBBox(node, 0, i, this.toBBox);
+        var bbox2 = distBBox(node, i, M, this.toBBox);
+
+        var overlap = intersectionArea(bbox1, bbox2);
+        var area = bboxArea(bbox1) + bboxArea(bbox2);
+
+        // choose distribution with minimum overlap
+        if (overlap < minOverlap) {
+            minOverlap = overlap;
+            index = i;
+
+            minArea = area < minArea ? area : minArea;
+
+        } else if (overlap === minOverlap) {
+            // otherwise choose distribution with minimum area
+            if (area < minArea) {
+                minArea = area;
+                index = i;
+            }
+        }
+    }
+
+    return index || M - m;
+};
+
+// sorts node children by the best axis for split
+RBush.prototype._chooseSplitAxis = function _chooseSplitAxis (node, m, M) {
+    var compareMinX = node.leaf ? this.compareMinX : compareNodeMinX;
+    var compareMinY = node.leaf ? this.compareMinY : compareNodeMinY;
+    var xMargin = this._allDistMargin(node, m, M, compareMinX);
+    var yMargin = this._allDistMargin(node, m, M, compareMinY);
+
+    // if total distributions margin value is minimal for x, sort by minX,
+    // otherwise it's already sorted by minY
+    if (xMargin < yMargin) { node.children.sort(compareMinX); }
+};
+
+// total margin of all possible split distributions where each node is at least m full
+RBush.prototype._allDistMargin = function _allDistMargin (node, m, M, compare) {
+    node.children.sort(compare);
+
+    var toBBox = this.toBBox;
+    var leftBBox = distBBox(node, 0, m, toBBox);
+    var rightBBox = distBBox(node, M - m, M, toBBox);
+    var margin = bboxMargin(leftBBox) + bboxMargin(rightBBox);
+
+    for (var i = m; i < M - m; i++) {
+        var child = node.children[i];
+        extend(leftBBox, node.leaf ? toBBox(child) : child);
+        margin += bboxMargin(leftBBox);
+    }
+
+    for (var i$1 = M - m - 1; i$1 >= m; i$1--) {
+        var child$1 = node.children[i$1];
+        extend(rightBBox, node.leaf ? toBBox(child$1) : child$1);
+        margin += bboxMargin(rightBBox);
+    }
+
+    return margin;
+};
+
+RBush.prototype._adjustParentBBoxes = function _adjustParentBBoxes (bbox, path, level) {
+    // adjust bboxes along the given tree path
+    for (var i = level; i >= 0; i--) {
+        extend(path[i], bbox);
+    }
+};
+
+RBush.prototype._condense = function _condense (path) {
+    // go through the path, removing empty nodes and updating bboxes
+    for (var i = path.length - 1, siblings = (void 0); i >= 0; i--) {
+        if (path[i].children.length === 0) {
+            if (i > 0) {
+                siblings = path[i - 1].children;
+                siblings.splice(siblings.indexOf(path[i]), 1);
+
+            } else { this.clear(); }
+
+        } else { calcBBox(path[i], this.toBBox); }
+    }
+};
+
+function findItem(item, items, equalsFn) {
+    if (!equalsFn) { return items.indexOf(item); }
+
+    for (var i = 0; i < items.length; i++) {
+        if (equalsFn(item, items[i])) { return i; }
+    }
+    return -1;
+}
+
+// calculate node's bbox from bboxes of its children
+function calcBBox(node, toBBox) {
+    distBBox(node, 0, node.children.length, toBBox, node);
+}
+
+// min bounding rectangle of node children from k to p-1
+function distBBox(node, k, p, toBBox, destNode) {
+    if (!destNode) { destNode = createNode(null); }
+    destNode.minX = Infinity;
+    destNode.minY = Infinity;
+    destNode.maxX = -Infinity;
+    destNode.maxY = -Infinity;
+
+    for (var i = k; i < p; i++) {
+        var child = node.children[i];
+        extend(destNode, node.leaf ? toBBox(child) : child);
+    }
+
+    return destNode;
+}
+
+function extend(a, b) {
+    a.minX = Math.min(a.minX, b.minX);
+    a.minY = Math.min(a.minY, b.minY);
+    a.maxX = Math.max(a.maxX, b.maxX);
+    a.maxY = Math.max(a.maxY, b.maxY);
+    return a;
+}
+
+function compareNodeMinX(a, b) { return a.minX - b.minX; }
+function compareNodeMinY(a, b) { return a.minY - b.minY; }
+
+function bboxArea(a)   { return (a.maxX - a.minX) * (a.maxY - a.minY); }
+function bboxMargin(a) { return (a.maxX - a.minX) + (a.maxY - a.minY); }
+
+function enlargedArea(a, b) {
+    return (Math.max(b.maxX, a.maxX) - Math.min(b.minX, a.minX)) *
+           (Math.max(b.maxY, a.maxY) - Math.min(b.minY, a.minY));
+}
+
+function intersectionArea(a, b) {
+    var minX = Math.max(a.minX, b.minX);
+    var minY = Math.max(a.minY, b.minY);
+    var maxX = Math.min(a.maxX, b.maxX);
+    var maxY = Math.min(a.maxY, b.maxY);
+
+    return Math.max(0, maxX - minX) *
+           Math.max(0, maxY - minY);
+}
+
+function contains(a, b) {
+    return a.minX <= b.minX &&
+           a.minY <= b.minY &&
+           b.maxX <= a.maxX &&
+           b.maxY <= a.maxY;
+}
+
+function intersects(a, b) {
+    return b.minX <= a.maxX &&
+           b.minY <= a.maxY &&
+           b.maxX >= a.minX &&
+           b.maxY >= a.minY;
+}
+
+function createNode(children) {
+    return {
+        children: children,
+        height: 1,
+        leaf: true,
+        minX: Infinity,
+        minY: Infinity,
+        maxX: -Infinity,
+        maxY: -Infinity
+    };
+}
+
+// sort an array so that items come in groups of n unsorted items, with groups sorted between each other;
+// combines selection algorithm with binary divide & conquer approach
+
+function multiSelect(arr, left, right, n, compare) {
+    var stack = [left, right];
+
+    while (stack.length) {
+        right = stack.pop();
+        left = stack.pop();
+
+        if (right - left <= n) { continue; }
+
+        var mid = left + Math.ceil((right - left) / n / 2) * n;
+        quickselect(arr, mid, left, right, compare);
+
+        stack.push(left, mid, mid, right);
+    }
+}
+
+return RBush;
+
+}));
diff --git a/js/tracker.js b/js/tracker.js
index a5c0edb..164c7f4 100644
--- a/js/tracker.js
+++ b/js/tracker.js
@@ -21,6 +21,7 @@ var recovery_names = [];
 var recoveries = [];
 
 var launches = null;
+var receiverCanvas = null;
 
 var got_positions = false;
 var zoomed_in = false;
@@ -413,6 +414,9 @@ function load() {
     // update current position if we geolocation is available
     if(currentPosition) updateCurrentPosition(currentPosition.lat, currentPosition.lon);
 
+    //Receiver canvas
+    receiverCanvas = new L.MarkersCanvas();
+    receiverCanvas.addTo(map);
     
     // initalize nite overlay
     nite = new L.terminator();
@@ -2874,11 +2878,13 @@ function updateReceiverMarker(receiver) {
         icon: receiverIcon,
         title: receiver.name,
         zIndexOffset: Z_STATION, 
-    }).addTo(map);
+    });
     
     receiver.infobox = new L.popup({ autoClose: false, closeOnClick: false }).setContent(receiver.description);
 
     receiver.marker.bindPopup(receiver.infobox);
+
+    receiverCanvas.addMarker(receiver.marker);
   } else {
     receiver.marker.setLatLng(latlng);
   }
@@ -2929,10 +2935,8 @@ function updateReceivers(r) {
             i++;
         }
         else {
-            // close box, remove event handle, and remove marker
-            //e.infobox.close();
-            //e.infobox_handle.remove();
-            map.removeLayer(e.marker);
+            map.removeLayer(e.infobox);
+            receiverCanvas.removeMarker(e.marker);
 
             // remove from arrays
             receivers.splice(i,1);