The Tor Browser / file revision

 !function() {

   var d3 = {

     version: "3.4.2"

   };

   if (!Date.now) Date.now = function() {

     return +new Date();

   };

   var d3_arraySlice = [].slice, d3_array = function(list) {

     return d3_arraySlice.call(list);

   };

   var d3_document = document, d3_documentElement = d3_document.documentElement, d3_window = window;

   try {

     d3_array(d3_documentElement.childNodes)[0].nodeType;

   } catch (e) {

     d3_array = function(list) {

       var i = list.length, array = new Array(i);

       while (i--) array[i] = list[i];

       return array;

     };

   }

   try {

     d3_document.createElement("div").style.setProperty("opacity", 0, "");

   } catch (error) {

     var d3_element_prototype = d3_window.Element.prototype, d3_element_setAttribute = d3_element_prototype.setAttribute, d3_element_setAttributeNS = d3_element_prototype.setAttributeNS, d3_style_prototype = d3_window.CSSStyleDeclaration.prototype, d3_style_setProperty = d3_style_prototype.setProperty;

     d3_element_prototype.setAttribute = function(name, value) {

       d3_element_setAttribute.call(this, name, value + "");

     };

     d3_element_prototype.setAttributeNS = function(space, local, value) {

       d3_element_setAttributeNS.call(this, space, local, value + "");

     };

     d3_style_prototype.setProperty = function(name, value, priority) {

       d3_style_setProperty.call(this, name, value + "", priority);

     };

   }

   d3.ascending = function(a, b) {

     return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;

   };

   d3.descending = function(a, b) {

     return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;

   };

   d3.min = function(array, f) {

     var i = -1, n = array.length, a, b;

     if (arguments.length === 1) {

       while (++i < n && !((a = array[i]) != null && a <= a)) a = undefined;

       while (++i < n) if ((b = array[i]) != null && a > b) a = b;

     } else {

       while (++i < n && !((a = f.call(array, array[i], i)) != null && a <= a)) a = undefined;

       while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;

     }

     return a;

   };

   d3.max = function(array, f) {

     var i = -1, n = array.length, a, b;

     if (arguments.length === 1) {

       while (++i < n && !((a = array[i]) != null && a <= a)) a = undefined;

       while (++i < n) if ((b = array[i]) != null && b > a) a = b;

     } else {

       while (++i < n && !((a = f.call(array, array[i], i)) != null && a <= a)) a = undefined;

       while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;

     }

     return a;

   };

   d3.extent = function(array, f) {

     var i = -1, n = array.length, a, b, c;

     if (arguments.length === 1) {

       while (++i < n && !((a = c = array[i]) != null && a <= a)) a = c = undefined;

       while (++i < n) if ((b = array[i]) != null) {

         if (a > b) a = b;

         if (c < b) c = b;

       }

     } else {

       while (++i < n && !((a = c = f.call(array, array[i], i)) != null && a <= a)) a = undefined;

       while (++i < n) if ((b = f.call(array, array[i], i)) != null) {

         if (a > b) a = b;

         if (c < b) c = b;

       }

     }

     return [ a, c ];

   };

   d3.sum = function(array, f) {

     var s = 0, n = array.length, a, i = -1;

     if (arguments.length === 1) {

       while (++i < n) if (!isNaN(a = +array[i])) s += a;

     } else {

       while (++i < n) if (!isNaN(a = +f.call(array, array[i], i))) s += a;

     }

     return s;

   };

   function d3_number(x) {

     return x != null && !isNaN(x);

   }

   d3.mean = function(array, f) {

     var n = array.length, a, m = 0, i = -1, j = 0;

     if (arguments.length === 1) {

       while (++i < n) if (d3_number(a = array[i])) m += (a - m) / ++j;

     } else {

       while (++i < n) if (d3_number(a = f.call(array, array[i], i))) m += (a - m) / ++j;

     }

     return j ? m : undefined;

   };

   d3.quantile = function(values, p) {

     var H = (values.length - 1) * p + 1, h = Math.floor(H), v = +values[h - 1], e = H - h;

     return e ? v + e * (values[h] - v) : v;

   };

   d3.median = function(array, f) {

     if (arguments.length > 1) array = array.map(f);

     array = array.filter(d3_number);

     return array.length ? d3.quantile(array.sort(d3.ascending), .5) : undefined;

   };

   d3.bisector = function(f) {

     return {

       left: function(a, x, lo, hi) {

         if (arguments.length < 3) lo = 0;

         if (arguments.length < 4) hi = a.length;

         while (lo < hi) {

           var mid = lo + hi >>> 1;

           if (f.call(a, a[mid], mid) < x) lo = mid + 1; else hi = mid;

         }

         return lo;

       },

       right: function(a, x, lo, hi) {

         if (arguments.length < 3) lo = 0;

         if (arguments.length < 4) hi = a.length;

         while (lo < hi) {

           var mid = lo + hi >>> 1;

           if (x < f.call(a, a[mid], mid)) hi = mid; else lo = mid + 1;

         }

         return lo;

       }

     };

   };

   var d3_bisector = d3.bisector(function(d) {

     return d;

   });

   d3.bisectLeft = d3_bisector.left;

   d3.bisect = d3.bisectRight = d3_bisector.right;

   d3.shuffle = function(array) {

     var m = array.length, t, i;

     while (m) {

       i = Math.random() * m-- | 0;

       t = array[m], array[m] = array[i], array[i] = t;

     }

     return array;

   };

   d3.permute = function(array, indexes) {

     var i = indexes.length, permutes = new Array(i);

     while (i--) permutes[i] = array[indexes[i]];

     return permutes;

   };

   d3.pairs = function(array) {

     var i = 0, n = array.length - 1, p0, p1 = array[0], pairs = new Array(n < 0 ? 0 : n);

     while (i < n) pairs[i] = [ p0 = p1, p1 = array[++i] ];

     return pairs;

   };

   d3.zip = function() {

     if (!(n = arguments.length)) return [];

     for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m; ) {

       for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n; ) {

         zip[j] = arguments[j][i];

       }

     }

     return zips;

   };

   function d3_zipLength(d) {

     return d.length;

   }

   d3.transpose = function(matrix) {

     return d3.zip.apply(d3, matrix);

   };

   d3.keys = function(map) {

     var keys = [];

     for (var key in map) keys.push(key);

     return keys;

   };

   d3.values = function(map) {

     var values = [];

     for (var key in map) values.push(map[key]);

     return values;

   };

   d3.entries = function(map) {

     var entries = [];

     for (var key in map) entries.push({

       key: key,

       value: map[key]

     });

     return entries;

   };

   d3.merge = function(arrays) {

     var n = arrays.length, m, i = -1, j = 0, merged, array;

     while (++i < n) j += arrays[i].length;

     merged = new Array(j);

     while (--n >= 0) {

       array = arrays[n];

       m = array.length;

       while (--m >= 0) {

         merged[--j] = array[m];

       }

     }

     return merged;

   };

   var abs = Math.abs;

   d3.range = function(start, stop, step) {

     if (arguments.length < 3) {

       step = 1;

       if (arguments.length < 2) {

         stop = start;

         start = 0;

       }

     }

     if ((stop - start) / step === Infinity) throw new Error("infinite range");

     var range = [], k = d3_range_integerScale(abs(step)), i = -1, j;

     start *= k, stop *= k, step *= k;

     if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k); else while ((j = start + step * ++i) < stop) range.push(j / k);

     return range;

   };

   function d3_range_integerScale(x) {

     var k = 1;

     while (x * k % 1) k *= 10;

     return k;

   }

   function d3_class(ctor, properties) {

     try {

       for (var key in properties) {

         Object.defineProperty(ctor.prototype, key, {

           value: properties[key],

           enumerable: false

         });

       }

     } catch (e) {

       ctor.prototype = properties;

     }

   }

   d3.map = function(object) {

     var map = new d3_Map();

     if (object instanceof d3_Map) object.forEach(function(key, value) {

       map.set(key, value);

     }); else for (var key in object) map.set(key, object[key]);

     return map;

   };

   function d3_Map() {}

   d3_class(d3_Map, {

     has: d3_map_has,

     get: function(key) {

       return this[d3_map_prefix + key];

     },

     set: function(key, value) {

       return this[d3_map_prefix + key] = value;

     },

     remove: d3_map_remove,

     keys: d3_map_keys,

     values: function() {

       var values = [];

       this.forEach(function(key, value) {

         values.push(value);

       });

       return values;

     },

     entries: function() {

       var entries = [];

       this.forEach(function(key, value) {

         entries.push({

           key: key,

           value: value

         });

       });

       return entries;

     },

     size: d3_map_size,

     empty: d3_map_empty,

     forEach: function(f) {

       for (var key in this) if (key.charCodeAt(0) === d3_map_prefixCode) f.call(this, key.substring(1), this[key]);

     }

   });

   var d3_map_prefix = "\x00", d3_map_prefixCode = d3_map_prefix.charCodeAt(0);

   function d3_map_has(key) {

     return d3_map_prefix + key in this;

   }

   function d3_map_remove(key) {

     key = d3_map_prefix + key;

     return key in this && delete this[key];

   }

   function d3_map_keys() {

     var keys = [];

     this.forEach(function(key) {

       keys.push(key);

     });

     return keys;

   }

   function d3_map_size() {

     var size = 0;

     for (var key in this) if (key.charCodeAt(0) === d3_map_prefixCode) ++size;

     return size;

   }

   function d3_map_empty() {

     for (var key in this) if (key.charCodeAt(0) === d3_map_prefixCode) return false;

     return true;

   }

   d3.nest = function() {

     var nest = {}, keys = [], sortKeys = [], sortValues, rollup;

     function map(mapType, array, depth) {

       if (depth >= keys.length) return rollup ? rollup.call(nest, array) : sortValues ? array.sort(sortValues) : array;

       var i = -1, n = array.length, key = keys[depth++], keyValue, object, setter, valuesByKey = new d3_Map(), values;

       while (++i < n) {

         if (values = valuesByKey.get(keyValue = key(object = array[i]))) {

           values.push(object);

         } else {

           valuesByKey.set(keyValue, [ object ]);

         }

       }

       if (mapType) {

         object = mapType();

         setter = function(keyValue, values) {

           object.set(keyValue, map(mapType, values, depth));

         };

       } else {

         object = {};

         setter = function(keyValue, values) {

           object[keyValue] = map(mapType, values, depth);

         };

       }

       valuesByKey.forEach(setter);

       return object;

     }

     function entries(map, depth) {

       if (depth >= keys.length) return map;

       var array = [], sortKey = sortKeys[depth++];

       map.forEach(function(key, keyMap) {

         array.push({

           key: key,

           values: entries(keyMap, depth)

         });

       });

       return sortKey ? array.sort(function(a, b) {

         return sortKey(a.key, b.key);

       }) : array;

     }

     nest.map = function(array, mapType) {

       return map(mapType, array, 0);

     };

     nest.entries = function(array) {

       return entries(map(d3.map, array, 0), 0);

     };

     nest.key = function(d) {

       keys.push(d);

       return nest;

     };

     nest.sortKeys = function(order) {

       sortKeys[keys.length - 1] = order;

       return nest;

     };

     nest.sortValues = function(order) {

       sortValues = order;

       return nest;

     };

     nest.rollup = function(f) {

       rollup = f;

       return nest;

     };

     return nest;

   };

   d3.set = function(array) {

     var set = new d3_Set();

     if (array) for (var i = 0, n = array.length; i < n; ++i) set.add(array[i]);

     return set;

   };

   function d3_Set() {}

   d3_class(d3_Set, {

     has: d3_map_has,

     add: function(value) {

       this[d3_map_prefix + value] = true;

       return value;

     },

     remove: function(value) {

       value = d3_map_prefix + value;

       return value in this && delete this[value];

     },

     values: d3_map_keys,

     size: d3_map_size,

     empty: d3_map_empty,

     forEach: function(f) {

       for (var value in this) if (value.charCodeAt(0) === d3_map_prefixCode) f.call(this, value.substring(1));

     }

   });

   d3.behavior = {};

   d3.rebind = function(target, source) {

     var i = 1, n = arguments.length, method;

     while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]);

     return target;

   };

   function d3_rebind(target, source, method) {

     return function() {

       var value = method.apply(source, arguments);

       return value === source ? target : value;

     };

   }

   function d3_vendorSymbol(object, name) {

     if (name in object) return name;

     name = name.charAt(0).toUpperCase() + name.substring(1);

     for (var i = 0, n = d3_vendorPrefixes.length; i < n; ++i) {

       var prefixName = d3_vendorPrefixes[i] + name;

       if (prefixName in object) return prefixName;

     }

   }

   var d3_vendorPrefixes = [ "webkit", "ms", "moz", "Moz", "o", "O" ];

   function d3_noop() {}

   d3.dispatch = function() {

     var dispatch = new d3_dispatch(), i = -1, n = arguments.length;

     while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);

     return dispatch;

   };

   function d3_dispatch() {}

   d3_dispatch.prototype.on = function(type, listener) {

     var i = type.indexOf("."), name = "";

     if (i >= 0) {

       name = type.substring(i + 1);

       type = type.substring(0, i);

     }

     if (type) return arguments.length < 2 ? this[type].on(name) : this[type].on(name, listener);

     if (arguments.length === 2) {

       if (listener == null) for (type in this) {

         if (this.hasOwnProperty(type)) this[type].on(name, null);

       }

       return this;

     }

   };

   function d3_dispatch_event(dispatch) {

     var listeners = [], listenerByName = new d3_Map();

     function event() {

       var z = listeners, i = -1, n = z.length, l;

       while (++i < n) if (l = z[i].on) l.apply(this, arguments);

       return dispatch;

     }

     event.on = function(name, listener) {

       var l = listenerByName.get(name), i;

       if (arguments.length < 2) return l && l.on;

       if (l) {

         l.on = null;

         listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1));

         listenerByName.remove(name);

       }

       if (listener) listeners.push(listenerByName.set(name, {

         on: listener

       }));

       return dispatch;

     };

     return event;

   }

   d3.event = null;

   function d3_eventPreventDefault() {

     d3.event.preventDefault();

   }

   function d3_eventSource() {

     var e = d3.event, s;

     while (s = e.sourceEvent) e = s;

     return e;

   }

   function d3_eventDispatch(target) {

     var dispatch = new d3_dispatch(), i = 0, n = arguments.length;

     while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);

     dispatch.of = function(thiz, argumentz) {

       return function(e1) {

         try {

           var e0 = e1.sourceEvent = d3.event;

           e1.target = target;

           d3.event = e1;

           dispatch[e1.type].apply(thiz, argumentz);

         } finally {

           d3.event = e0;

         }

       };

     };

     return dispatch;

   }

   d3.requote = function(s) {

     return s.replace(d3_requote_re, "\\$&");

   };

   var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;

   var d3_subclass = {}.__proto__ ? function(object, prototype) {

     object.__proto__ = prototype;

   } : function(object, prototype) {

     for (var property in prototype) object[property] = prototype[property];

   };

   function d3_selection(groups) {

     d3_subclass(groups, d3_selectionPrototype);

     return groups;

   }

   var d3_select = function(s, n) {

     return n.querySelector(s);

   }, d3_selectAll = function(s, n) {

     return n.querySelectorAll(s);

   }, d3_selectMatcher = d3_documentElement[d3_vendorSymbol(d3_documentElement, "matchesSelector")], d3_selectMatches = function(n, s) {

     return d3_selectMatcher.call(n, s);

   };

   if (typeof Sizzle === "function") {

     d3_select = function(s, n) {

       return Sizzle(s, n)[0] || null;

     };

     d3_selectAll = function(s, n) {

       return Sizzle.uniqueSort(Sizzle(s, n));

     };

     d3_selectMatches = Sizzle.matchesSelector;

   }

   d3.selection = function() {

     return d3_selectionRoot;

   };

   var d3_selectionPrototype = d3.selection.prototype = [];

   d3_selectionPrototype.select = function(selector) {

     var subgroups = [], subgroup, subnode, group, node;

     selector = d3_selection_selector(selector);

     for (var j = -1, m = this.length; ++j < m; ) {

       subgroups.push(subgroup = []);

       subgroup.parentNode = (group = this[j]).parentNode;

       for (var i = -1, n = group.length; ++i < n; ) {

         if (node = group[i]) {

           subgroup.push(subnode = selector.call(node, node.__data__, i, j));

           if (subnode && "__data__" in node) subnode.__data__ = node.__data__;

         } else {

           subgroup.push(null);

         }

       }

     }

     return d3_selection(subgroups);

   };

   function d3_selection_selector(selector) {

     return typeof selector === "function" ? selector : function() {

       return d3_select(selector, this);

     };

   }

   d3_selectionPrototype.selectAll = function(selector) {

     var subgroups = [], subgroup, node;

     selector = d3_selection_selectorAll(selector);

     for (var j = -1, m = this.length; ++j < m; ) {

       for (var group = this[j], i = -1, n = group.length; ++i < n; ) {

         if (node = group[i]) {

           subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i, j)));

           subgroup.parentNode = node;

         }

       }

     }

     return d3_selection(subgroups);

   };

   function d3_selection_selectorAll(selector) {

     return typeof selector === "function" ? selector : function() {

       return d3_selectAll(selector, this);

     };

   }

   var d3_nsPrefix = {

     svg: "http://www.w3.org/2000/svg",

     xhtml: "http://www.w3.org/1999/xhtml",

     xlink: "http://www.w3.org/1999/xlink",

     xml: "http://www.w3.org/XML/1998/namespace",

     xmlns: "http://www.w3.org/2000/xmlns/"

   };

   d3.ns = {

     prefix: d3_nsPrefix,

     qualify: function(name) {

       var i = name.indexOf(":"), prefix = name;

       if (i >= 0) {

         prefix = name.substring(0, i);

         name = name.substring(i + 1);

       }

       return d3_nsPrefix.hasOwnProperty(prefix) ? {

         space: d3_nsPrefix[prefix],

         local: name

       } : name;

     }

   };

   d3_selectionPrototype.attr = function(name, value) {

     if (arguments.length < 2) {

       if (typeof name === "string") {

         var node = this.node();

         name = d3.ns.qualify(name);

         return name.local ? node.getAttributeNS(name.space, name.local) : node.getAttribute(name);

       }

       for (value in name) this.each(d3_selection_attr(value, name[value]));

       return this;

     }

     return this.each(d3_selection_attr(name, value));

   };

   function d3_selection_attr(name, value) {

     name = d3.ns.qualify(name);

     function attrNull() {

       this.removeAttribute(name);

     }

     function attrNullNS() {

       this.removeAttributeNS(name.space, name.local);

     }

     function attrConstant() {

       this.setAttribute(name, value);

     }

     function attrConstantNS() {

       this.setAttributeNS(name.space, name.local, value);

     }

     function attrFunction() {

       var x = value.apply(this, arguments);

       if (x == null) this.removeAttribute(name); else this.setAttribute(name, x);

     }

     function attrFunctionNS() {

       var x = value.apply(this, arguments);

       if (x == null) this.removeAttributeNS(name.space, name.local); else this.setAttributeNS(name.space, name.local, x);

     }

     return value == null ? name.local ? attrNullNS : attrNull : typeof value === "function" ? name.local ? attrFunctionNS : attrFunction : name.local ? attrConstantNS : attrConstant;

   }

   function d3_collapse(s) {

     return s.trim().replace(/\s+/g, " ");

   }

   d3_selectionPrototype.classed = function(name, value) {

     if (arguments.length < 2) {

       if (typeof name === "string") {

         var node = this.node(), n = (name = d3_selection_classes(name)).length, i = -1;

         if (value = node.classList) {

           while (++i < n) if (!value.contains(name[i])) return false;

         } else {

           value = node.getAttribute("class");

           while (++i < n) if (!d3_selection_classedRe(name[i]).test(value)) return false;

         }

         return true;

       }

       for (value in name) this.each(d3_selection_classed(value, name[value]));

       return this;

     }

     return this.each(d3_selection_classed(name, value));

   };

   function d3_selection_classedRe(name) {

     return new RegExp("(?:^|\\s+)" + d3.requote(name) + "(?:\\s+|$)", "g");

   }

   function d3_selection_classes(name) {

     return name.trim().split(/^|\s+/);

   }

   function d3_selection_classed(name, value) {

     name = d3_selection_classes(name).map(d3_selection_classedName);

     var n = name.length;

     function classedConstant() {

       var i = -1;

       while (++i < n) name[i](this, value);

     }

     function classedFunction() {

       var i = -1, x = value.apply(this, arguments);

       while (++i < n) name[i](this, x);

     }

     return typeof value === "function" ? classedFunction : classedConstant;

   }

   function d3_selection_classedName(name) {

     var re = d3_selection_classedRe(name);

     return function(node, value) {

       if (c = node.classList) return value ? c.add(name) : c.remove(name);

       var c = node.getAttribute("class") || "";

       if (value) {

         re.lastIndex = 0;

         if (!re.test(c)) node.setAttribute("class", d3_collapse(c + " " + name));

       } else {

         node.setAttribute("class", d3_collapse(c.replace(re, " ")));

       }

     };

   }

   d3_selectionPrototype.style = function(name, value, priority) {

     var n = arguments.length;

     if (n < 3) {

       if (typeof name !== "string") {

         if (n < 2) value = "";

         for (priority in name) this.each(d3_selection_style(priority, name[priority], value));

         return this;

       }

       if (n < 2) return d3_window.getComputedStyle(this.node(), null).getPropertyValue(name);

       priority = "";

     }

     return this.each(d3_selection_style(name, value, priority));

   };

   function d3_selection_style(name, value, priority) {

     function styleNull() {

       this.style.removeProperty(name);

     }

     function styleConstant() {

       this.style.setProperty(name, value, priority);

     }

     function styleFunction() {

       var x = value.apply(this, arguments);

       if (x == null) this.style.removeProperty(name); else this.style.setProperty(name, x, priority);

     }

     return value == null ? styleNull : typeof value === "function" ? styleFunction : styleConstant;

   }

   d3_selectionPrototype.property = function(name, value) {

     if (arguments.length < 2) {

       if (typeof name === "string") return this.node()[name];

       for (value in name) this.each(d3_selection_property(value, name[value]));

       return this;

     }

     return this.each(d3_selection_property(name, value));

   };

   function d3_selection_property(name, value) {

     function propertyNull() {

       delete this[name];

     }

     function propertyConstant() {

       this[name] = value;

     }

     function propertyFunction() {

       var x = value.apply(this, arguments);

       if (x == null) delete this[name]; else this[name] = x;

     }

     return value == null ? propertyNull : typeof value === "function" ? propertyFunction : propertyConstant;

   }

   d3_selectionPrototype.text = function(value) {

     return arguments.length ? this.each(typeof value === "function" ? function() {

       var v = value.apply(this, arguments);

       this.textContent = v == null ? "" : v;

     } : value == null ? function() {

       this.textContent = "";

     } : function() {

       this.textContent = value;

     }) : this.node().textContent;

   };

   d3_selectionPrototype.html = function(value) {

     return arguments.length ? this.each(typeof value === "function" ? function() {

       var v = value.apply(this, arguments);

       this.innerHTML = v == null ? "" : v;

     } : value == null ? function() {

       this.innerHTML = "";

     } : function() {

       this.innerHTML = value;

     }) : this.node().innerHTML;

   };

   d3_selectionPrototype.append = function(name) {

     name = d3_selection_creator(name);

     return this.select(function() {

       return this.appendChild(name.apply(this, arguments));

     });

   };

   function d3_selection_creator(name) {

     return typeof name === "function" ? name : (name = d3.ns.qualify(name)).local ? function() {

       return this.ownerDocument.createElementNS(name.space, name.local);

     } : function() {

       return this.ownerDocument.createElementNS(this.namespaceURI, name);

     };

   }

   d3_selectionPrototype.insert = function(name, before) {

     name = d3_selection_creator(name);

     before = d3_selection_selector(before);

     return this.select(function() {

       return this.insertBefore(name.apply(this, arguments), before.apply(this, arguments) || null);

     });

   };

   d3_selectionPrototype.remove = function() {

     return this.each(function() {

       var parent = this.parentNode;

       if (parent) parent.removeChild(this);

     });

   };

   d3_selectionPrototype.data = function(value, key) {

     var i = -1, n = this.length, group, node;

     if (!arguments.length) {

       value = new Array(n = (group = this[0]).length);

       while (++i < n) {

         if (node = group[i]) {

           value[i] = node.__data__;

         }

       }

       return value;

     }

     function bind(group, groupData) {

       var i, n = group.length, m = groupData.length, n0 = Math.min(n, m), updateNodes = new Array(m), enterNodes = new Array(m), exitNodes = new Array(n), node, nodeData;

       if (key) {

         var nodeByKeyValue = new d3_Map(), dataByKeyValue = new d3_Map(), keyValues = [], keyValue;

         for (i = -1; ++i < n; ) {

           keyValue = key.call(node = group[i], node.__data__, i);

           if (nodeByKeyValue.has(keyValue)) {

             exitNodes[i] = node;

           } else {

             nodeByKeyValue.set(keyValue, node);

           }

           keyValues.push(keyValue);

         }

         for (i = -1; ++i < m; ) {

           keyValue = key.call(groupData, nodeData = groupData[i], i);

           if (node = nodeByKeyValue.get(keyValue)) {

             updateNodes[i] = node;

             node.__data__ = nodeData;

           } else if (!dataByKeyValue.has(keyValue)) {

             enterNodes[i] = d3_selection_dataNode(nodeData);

           }

           dataByKeyValue.set(keyValue, nodeData);

           nodeByKeyValue.remove(keyValue);

         }

         for (i = -1; ++i < n; ) {

           if (nodeByKeyValue.has(keyValues[i])) {

             exitNodes[i] = group[i];

           }

         }

       } else {

         for (i = -1; ++i < n0; ) {

           node = group[i];

           nodeData = groupData[i];

           if (node) {

             node.__data__ = nodeData;

             updateNodes[i] = node;

           } else {

             enterNodes[i] = d3_selection_dataNode(nodeData);

           }

         }

         for (;i < m; ++i) {

           enterNodes[i] = d3_selection_dataNode(groupData[i]);

         }

         for (;i < n; ++i) {

           exitNodes[i] = group[i];

         }

       }

       enterNodes.update = updateNodes;

       enterNodes.parentNode = updateNodes.parentNode = exitNodes.parentNode = group.parentNode;

       enter.push(enterNodes);

       update.push(updateNodes);

       exit.push(exitNodes);

     }

     var enter = d3_selection_enter([]), update = d3_selection([]), exit = d3_selection([]);

     if (typeof value === "function") {

       while (++i < n) {

         bind(group = this[i], value.call(group, group.parentNode.__data__, i));

       }

     } else {

       while (++i < n) {

         bind(group = this[i], value);

       }

     }

     update.enter = function() {

       return enter;

     };

     update.exit = function() {

       return exit;

     };

     return update;

   };

   function d3_selection_dataNode(data) {

     return {

       __data__: data

     };

   }

   d3_selectionPrototype.datum = function(value) {

     return arguments.length ? this.property("__data__", value) : this.property("__data__");

   };

   d3_selectionPrototype.filter = function(filter) {

     var subgroups = [], subgroup, group, node;

     if (typeof filter !== "function") filter = d3_selection_filter(filter);

     for (var j = 0, m = this.length; j < m; j++) {

       subgroups.push(subgroup = []);

       subgroup.parentNode = (group = this[j]).parentNode;

       for (var i = 0, n = group.length; i < n; i++) {

         if ((node = group[i]) && filter.call(node, node.__data__, i, j)) {

           subgroup.push(node);

         }

       }

     }

     return d3_selection(subgroups);

   };

   function d3_selection_filter(selector) {

     return function() {

       return d3_selectMatches(this, selector);

     };

   }

   d3_selectionPrototype.order = function() {

     for (var j = -1, m = this.length; ++j < m; ) {

       for (var group = this[j], i = group.length - 1, next = group[i], node; --i >= 0; ) {

         if (node = group[i]) {

           if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);

           next = node;

         }

       }

     }

     return this;

   };

   d3_selectionPrototype.sort = function(comparator) {

     comparator = d3_selection_sortComparator.apply(this, arguments);

     for (var j = -1, m = this.length; ++j < m; ) this[j].sort(comparator);

     return this.order();

   };

   function d3_selection_sortComparator(comparator) {

     if (!arguments.length) comparator = d3.ascending;

     return function(a, b) {

       return a && b ? comparator(a.__data__, b.__data__) : !a - !b;

     };

   }

   d3_selectionPrototype.each = function(callback) {

     return d3_selection_each(this, function(node, i, j) {

       callback.call(node, node.__data__, i, j);

     });

   };

   function d3_selection_each(groups, callback) {

     for (var j = 0, m = groups.length; j < m; j++) {

       for (var group = groups[j], i = 0, n = group.length, node; i < n; i++) {

         if (node = group[i]) callback(node, i, j);

       }

     }

     return groups;

   }

   d3_selectionPrototype.call = function(callback) {

     var args = d3_array(arguments);

     callback.apply(args[0] = this, args);

     return this;

   };

   d3_selectionPrototype.empty = function() {

     return !this.node();

   };

   d3_selectionPrototype.node = function() {

     for (var j = 0, m = this.length; j < m; j++) {

       for (var group = this[j], i = 0, n = group.length; i < n; i++) {

         var node = group[i];

         if (node) return node;

       }

     }

     return null;

   };

   d3_selectionPrototype.size = function() {

     var n = 0;

     this.each(function() {

       ++n;

     });

     return n;

   };

   function d3_selection_enter(selection) {

     d3_subclass(selection, d3_selection_enterPrototype);

     return selection;

   }

   var d3_selection_enterPrototype = [];

   d3.selection.enter = d3_selection_enter;

   d3.selection.enter.prototype = d3_selection_enterPrototype;

   d3_selection_enterPrototype.append = d3_selectionPrototype.append;

   d3_selection_enterPrototype.empty = d3_selectionPrototype.empty;

   d3_selection_enterPrototype.node = d3_selectionPrototype.node;

   d3_selection_enterPrototype.call = d3_selectionPrototype.call;

   d3_selection_enterPrototype.size = d3_selectionPrototype.size;

   d3_selection_enterPrototype.select = function(selector) {

     var subgroups = [], subgroup, subnode, upgroup, group, node;

     for (var j = -1, m = this.length; ++j < m; ) {

       upgroup = (group = this[j]).update;

       subgroups.push(subgroup = []);

       subgroup.parentNode = group.parentNode;

       for (var i = -1, n = group.length; ++i < n; ) {

         if (node = group[i]) {

           subgroup.push(upgroup[i] = subnode = selector.call(group.parentNode, node.__data__, i, j));

           subnode.__data__ = node.__data__;

         } else {

           subgroup.push(null);

         }

       }

     }

     return d3_selection(subgroups);

   };

   d3_selection_enterPrototype.insert = function(name, before) {

     if (arguments.length < 2) before = d3_selection_enterInsertBefore(this);

     return d3_selectionPrototype.insert.call(this, name, before);

   };

   function d3_selection_enterInsertBefore(enter) {

     var i0, j0;

     return function(d, i, j) {

       var group = enter[j].update, n = group.length, node;

       if (j != j0) j0 = j, i0 = 0;

       if (i >= i0) i0 = i + 1;

       while (!(node = group[i0]) && ++i0 < n) ;

       return node;

     };

   }

   d3_selectionPrototype.transition = function() {

     var id = d3_transitionInheritId || ++d3_transitionId, subgroups = [], subgroup, node, transition = d3_transitionInherit || {

       time: Date.now(),

       ease: d3_ease_cubicInOut,

       delay: 0,

       duration: 250

     };

     for (var j = -1, m = this.length; ++j < m; ) {

       subgroups.push(subgroup = []);

       for (var group = this[j], i = -1, n = group.length; ++i < n; ) {

         if (node = group[i]) d3_transitionNode(node, i, id, transition);

         subgroup.push(node);

       }

     }

     return d3_transition(subgroups, id);

   };

   d3_selectionPrototype.interrupt = function() {

     return this.each(d3_selection_interrupt);

   };

   function d3_selection_interrupt() {

     var lock = this.__transition__;

     if (lock) ++lock.active;

   }

   d3.select = function(node) {

     var group = [ typeof node === "string" ? d3_select(node, d3_document) : node ];

     group.parentNode = d3_documentElement;

     return d3_selection([ group ]);

   };

   d3.selectAll = function(nodes) {

     var group = d3_array(typeof nodes === "string" ? d3_selectAll(nodes, d3_document) : nodes);

     group.parentNode = d3_documentElement;

     return d3_selection([ group ]);

   };

   var d3_selectionRoot = d3.select(d3_documentElement);

   d3_selectionPrototype.on = function(type, listener, capture) {

     var n = arguments.length;

     if (n < 3) {

       if (typeof type !== "string") {

         if (n < 2) listener = false;

         for (capture in type) this.each(d3_selection_on(capture, type[capture], listener));

         return this;

       }

       if (n < 2) return (n = this.node()["__on" + type]) && n._;

       capture = false;

     }

     return this.each(d3_selection_on(type, listener, capture));

   };

   function d3_selection_on(type, listener, capture) {

     var name = "__on" + type, i = type.indexOf("."), wrap = d3_selection_onListener;

     if (i > 0) type = type.substring(0, i);

     var filter = d3_selection_onFilters.get(type);

     if (filter) type = filter, wrap = d3_selection_onFilter;

     function onRemove() {

       var l = this[name];

       if (l) {

         this.removeEventListener(type, l, l.$);

         delete this[name];

       }

     }

     function onAdd() {

       var l = wrap(listener, d3_array(arguments));

       onRemove.call(this);

       this.addEventListener(type, this[name] = l, l.$ = capture);

       l._ = listener;

     }

     function removeAll() {

       var re = new RegExp("^__on([^.]+)" + d3.requote(type) + "$"), match;

       for (var name in this) {

         if (match = name.match(re)) {

           var l = this[name];

           this.removeEventListener(match[1], l, l.$);

           delete this[name];

         }

       }

     }

     return i ? listener ? onAdd : onRemove : listener ? d3_noop : removeAll;

   }

   var d3_selection_onFilters = d3.map({

     mouseenter: "mouseover",

     mouseleave: "mouseout"

   });

   d3_selection_onFilters.forEach(function(k) {

     if ("on" + k in d3_document) d3_selection_onFilters.remove(k);

   });

   function d3_selection_onListener(listener, argumentz) {

     return function(e) {

       var o = d3.event;

       d3.event = e;

       argumentz[0] = this.__data__;

       try {

         listener.apply(this, argumentz);

       } finally {

         d3.event = o;

       }

     };

   }

   function d3_selection_onFilter(listener, argumentz) {

     var l = d3_selection_onListener(listener, argumentz);

     return function(e) {

       var target = this, related = e.relatedTarget;

       if (!related || related !== target && !(related.compareDocumentPosition(target) & 8)) {

         l.call(target, e);

       }

     };

   }

   var d3_event_dragSelect = "onselectstart" in d3_document ? null : d3_vendorSymbol(d3_documentElement.style, "userSelect"), d3_event_dragId = 0;

   function d3_event_dragSuppress() {

     var name = ".dragsuppress-" + ++d3_event_dragId, click = "click" + name, w = d3.select(d3_window).on("touchmove" + name, d3_eventPreventDefault).on("dragstart" + name, d3_eventPreventDefault).on("selectstart" + name, d3_eventPreventDefault);

     if (d3_event_dragSelect) {

       var style = d3_documentElement.style, select = style[d3_event_dragSelect];

       style[d3_event_dragSelect] = "none";

     }

     return function(suppressClick) {

       w.on(name, null);

       if (d3_event_dragSelect) style[d3_event_dragSelect] = select;

       if (suppressClick) {

         function off() {

           w.on(click, null);

         }

         w.on(click, function() {

           d3_eventPreventDefault();

           off();

         }, true);

         setTimeout(off, 0);

       }

     };

   }

   d3.mouse = function(container) {

     return d3_mousePoint(container, d3_eventSource());

   };

   var d3_mouse_bug44083 = /WebKit/.test(d3_window.navigator.userAgent) ? -1 : 0;

   function d3_mousePoint(container, e) {

     if (e.changedTouches) e = e.changedTouches[0];

     var svg = container.ownerSVGElement || container;

     if (svg.createSVGPoint) {

       var point = svg.createSVGPoint();

       if (d3_mouse_bug44083 < 0 && (d3_window.scrollX || d3_window.scrollY)) {

         svg = d3.select("body").append("svg").style({

           position: "absolute",

           top: 0,

           left: 0,

           margin: 0,

           padding: 0,

           border: "none"

         }, "important");

         var ctm = svg[0][0].getScreenCTM();

         d3_mouse_bug44083 = !(ctm.f || ctm.e);

         svg.remove();

       }

       if (d3_mouse_bug44083) point.x = e.pageX, point.y = e.pageY; else point.x = e.clientX, 

       point.y = e.clientY;

       point = point.matrixTransform(container.getScreenCTM().inverse());

       return [ point.x, point.y ];

     }

     var rect = container.getBoundingClientRect();

     return [ e.clientX - rect.left - container.clientLeft, e.clientY - rect.top - container.clientTop ];

   }

   d3.touches = function(container, touches) {

     if (arguments.length < 2) touches = d3_eventSource().touches;

     return touches ? d3_array(touches).map(function(touch) {

       var point = d3_mousePoint(container, touch);

       point.identifier = touch.identifier;

       return point;

     }) : [];

   };

   d3.behavior.drag = function() {

     var event = d3_eventDispatch(drag, "drag", "dragstart", "dragend"), origin = null, mousedown = dragstart(d3_noop, d3.mouse, "mousemove", "mouseup"), touchstart = dragstart(touchid, touchposition, "touchmove", "touchend");

     function drag() {

       this.on("mousedown.drag", mousedown).on("touchstart.drag", touchstart);

     }

     function touchid() {

       return d3.event.changedTouches[0].identifier;

     }

     function touchposition(parent, id) {

       return d3.touches(parent).filter(function(p) {

         return p.identifier === id;

       })[0];

     }

     function dragstart(id, position, move, end) {

       return function() {

         var target = this, parent = target.parentNode, event_ = event.of(target, arguments), eventTarget = d3.event.target, eventId = id(), drag = eventId == null ? "drag" : "drag-" + eventId, origin_ = position(parent, eventId), dragged = 0, offset, w = d3.select(d3_window).on(move + "." + drag, moved).on(end + "." + drag, ended), dragRestore = d3_event_dragSuppress();

         if (origin) {

           offset = origin.apply(target, arguments);

           offset = [ offset.x - origin_[0], offset.y - origin_[1] ];

         } else {

           offset = [ 0, 0 ];

         }

         event_({

           type: "dragstart"

         });

         function moved() {

           var p = position(parent, eventId), dx = p[0] - origin_[0], dy = p[1] - origin_[1];

           dragged |= dx | dy;

           origin_ = p;

           event_({

             type: "drag",

             x: p[0] + offset[0],

             y: p[1] + offset[1],

             dx: dx,

             dy: dy

           });

         }

         function ended() {

           w.on(move + "." + drag, null).on(end + "." + drag, null);

           dragRestore(dragged && d3.event.target === eventTarget);

           event_({

             type: "dragend"

           });

         }

       };

     }

     drag.origin = function(x) {

       if (!arguments.length) return origin;

       origin = x;

       return drag;

     };

     return d3.rebind(drag, event, "on");

   };

   var π = Math.PI, τ = 2 * π, halfπ = π / 2, ε = 1e-6, ε2 = ε * ε, d3_radians = π / 180, d3_degrees = 180 / π;

   function d3_sgn(x) {

     return x > 0 ? 1 : x < 0 ? -1 : 0;

   }

   function d3_cross2d(a, b, c) {

     return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);

   }

   function d3_acos(x) {

     return x > 1 ? 0 : x < -1 ? π : Math.acos(x);

   }

   function d3_asin(x) {

     return x > 1 ? halfπ : x < -1 ? -halfπ : Math.asin(x);

   }

   function d3_sinh(x) {

     return ((x = Math.exp(x)) - 1 / x) / 2;

   }

   function d3_cosh(x) {

     return ((x = Math.exp(x)) + 1 / x) / 2;

   }

   function d3_tanh(x) {

     return ((x = Math.exp(2 * x)) - 1) / (x + 1);

   }

   function d3_haversin(x) {

     return (x = Math.sin(x / 2)) * x;

   }

   var ρ = Math.SQRT2, ρ2 = 2, ρ4 = 4;

   d3.interpolateZoom = function(p0, p1) {

     var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], ux1 = p1[0], uy1 = p1[1], w1 = p1[2];

     var dx = ux1 - ux0, dy = uy1 - uy0, d2 = dx * dx + dy * dy, d1 = Math.sqrt(d2), b0 = (w1 * w1 - w0 * w0 + ρ4 * d2) / (2 * w0 * ρ2 * d1), b1 = (w1 * w1 - w0 * w0 - ρ4 * d2) / (2 * w1 * ρ2 * d1), r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1), dr = r1 - r0, S = (dr || Math.log(w1 / w0)) / ρ;

     function interpolate(t) {

       var s = t * S;

       if (dr) {

         var coshr0 = d3_cosh(r0), u = w0 / (ρ2 * d1) * (coshr0 * d3_tanh(ρ * s + r0) - d3_sinh(r0));

         return [ ux0 + u * dx, uy0 + u * dy, w0 * coshr0 / d3_cosh(ρ * s + r0) ];

       }

       return [ ux0 + t * dx, uy0 + t * dy, w0 * Math.exp(ρ * s) ];

     }

     interpolate.duration = S * 1e3;

     return interpolate;

   };

   d3.behavior.zoom = function() {

     var view = {

       x: 0,

       y: 0,

       k: 1

     }, translate0, center, size = [ 960, 500 ], scaleExtent = d3_behavior_zoomInfinity, mousedown = "mousedown.zoom", mousemove = "mousemove.zoom", mouseup = "mouseup.zoom", mousewheelTimer, touchstart = "touchstart.zoom", touchtime, event = d3_eventDispatch(zoom, "zoomstart", "zoom", "zoomend"), x0, x1, y0, y1;

     function zoom(g) {

       g.on(mousedown, mousedowned).on(d3_behavior_zoomWheel + ".zoom", mousewheeled).on(mousemove, mousewheelreset).on("dblclick.zoom", dblclicked).on(touchstart, touchstarted);

     }

     zoom.event = function(g) {

       g.each(function() {

         var event_ = event.of(this, arguments), view1 = view;

         if (d3_transitionInheritId) {

           d3.select(this).transition().each("start.zoom", function() {

             view = this.__chart__ || {

               x: 0,

               y: 0,

               k: 1

             };

             zoomstarted(event_);

           }).tween("zoom:zoom", function() {

             var dx = size[0], dy = size[1], cx = dx / 2, cy = dy / 2, i = d3.interpolateZoom([ (cx - view.x) / view.k, (cy - view.y) / view.k, dx / view.k ], [ (cx - view1.x) / view1.k, (cy - view1.y) / view1.k, dx / view1.k ]);

             return function(t) {

               var l = i(t), k = dx / l[2];

               this.__chart__ = view = {

                 x: cx - l[0] * k,

                 y: cy - l[1] * k,

                 k: k

               };

               zoomed(event_);

             };

           }).each("end.zoom", function() {

             zoomended(event_);

           });

         } else {

           this.__chart__ = view;

           zoomstarted(event_);

           zoomed(event_);

           zoomended(event_);

         }

       });

     };

     zoom.translate = function(_) {

       if (!arguments.length) return [ view.x, view.y ];

       view = {

         x: +_[0],

         y: +_[1],

         k: view.k

       };

       rescale();

       return zoom;

     };

     zoom.scale = function(_) {

       if (!arguments.length) return view.k;

       view = {

         x: view.x,

         y: view.y,

         k: +_

       };

       rescale();

       return zoom;

     };

     zoom.scaleExtent = function(_) {

       if (!arguments.length) return scaleExtent;

       scaleExtent = _ == null ? d3_behavior_zoomInfinity : [ +_[0], +_[1] ];

       return zoom;

     };

     zoom.center = function(_) {

       if (!arguments.length) return center;

       center = _ && [ +_[0], +_[1] ];

       return zoom;

     };

     zoom.size = function(_) {

       if (!arguments.length) return size;

       size = _ && [ +_[0], +_[1] ];

       return zoom;

     };

     zoom.x = function(z) {

       if (!arguments.length) return x1;

       x1 = z;

       x0 = z.copy();

       view = {

         x: 0,

         y: 0,

         k: 1

       };

       return zoom;

     };

     zoom.y = function(z) {

       if (!arguments.length) return y1;

       y1 = z;

       y0 = z.copy();

       view = {

         x: 0,

         y: 0,

         k: 1

       };

       return zoom;

     };

     function location(p) {

       return [ (p[0] - view.x) / view.k, (p[1] - view.y) / view.k ];

     }

     function point(l) {

       return [ l[0] * view.k + view.x, l[1] * view.k + view.y ];

     }

     function scaleTo(s) {

       view.k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s));

     }

     function translateTo(p, l) {

       l = point(l);

       view.x += p[0] - l[0];

       view.y += p[1] - l[1];

     }

     function rescale() {

       if (x1) x1.domain(x0.range().map(function(x) {

         return (x - view.x) / view.k;

       }).map(x0.invert));

       if (y1) y1.domain(y0.range().map(function(y) {

         return (y - view.y) / view.k;

       }).map(y0.invert));

     }

     function zoomstarted(event) {

       event({

         type: "zoomstart"

       });

     }

     function zoomed(event) {

       rescale();

       event({

         type: "zoom",

         scale: view.k,

         translate: [ view.x, view.y ]

       });

     }

     function zoomended(event) {

       event({

         type: "zoomend"

       });

     }

     function mousedowned() {

       var target = this, event_ = event.of(target, arguments), eventTarget = d3.event.target, dragged = 0, w = d3.select(d3_window).on(mousemove, moved).on(mouseup, ended), l = location(d3.mouse(target)), dragRestore = d3_event_dragSuppress();

       d3_selection_interrupt.call(target);

       zoomstarted(event_);

       function moved() {

         dragged = 1;

         translateTo(d3.mouse(target), l);

         zoomed(event_);

       }

       function ended() {

         w.on(mousemove, d3_window === target ? mousewheelreset : null).on(mouseup, null);

         dragRestore(dragged && d3.event.target === eventTarget);

         zoomended(event_);

       }

     }

     function touchstarted() {

       var target = this, event_ = event.of(target, arguments), locations0 = {}, distance0 = 0, scale0, eventId = d3.event.changedTouches[0].identifier, touchmove = "touchmove.zoom-" + eventId, touchend = "touchend.zoom-" + eventId, w = d3.select(d3_window).on(touchmove, moved).on(touchend, ended), t = d3.select(target).on(mousedown, null).on(touchstart, started), dragRestore = d3_event_dragSuppress();

       d3_selection_interrupt.call(target);

       started();

       zoomstarted(event_);

       function relocate() {

         var touches = d3.touches(target);

         scale0 = view.k;

         touches.forEach(function(t) {

           if (t.identifier in locations0) locations0[t.identifier] = location(t);

         });

         return touches;

       }

       function started() {

         var changed = d3.event.changedTouches;

         for (var i = 0, n = changed.length; i < n; ++i) {

           locations0[changed[i].identifier] = null;

         }

         var touches = relocate(), now = Date.now();

         if (touches.length === 1) {

           if (now - touchtime < 500) {

             var p = touches[0], l = locations0[p.identifier];

             scaleTo(view.k * 2);

             translateTo(p, l);

             d3_eventPreventDefault();

             zoomed(event_);

           }

           touchtime = now;

         } else if (touches.length > 1) {

           var p = touches[0], q = touches[1], dx = p[0] - q[0], dy = p[1] - q[1];

           distance0 = dx * dx + dy * dy;

         }

       }

       function moved() {

         var touches = d3.touches(target), p0, l0, p1, l1;

         for (var i = 0, n = touches.length; i < n; ++i, l1 = null) {

           p1 = touches[i];

           if (l1 = locations0[p1.identifier]) {

             if (l0) break;

             p0 = p1, l0 = l1;

           }

         }

         if (l1) {

           var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1, scale1 = distance0 && Math.sqrt(distance1 / distance0);

           p0 = [ (p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2 ];

           l0 = [ (l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2 ];

           scaleTo(scale1 * scale0);

         }

         touchtime = null;

         translateTo(p0, l0);

         zoomed(event_);

       }

       function ended() {

         if (d3.event.touches.length) {

           var changed = d3.event.changedTouches;

           for (var i = 0, n = changed.length; i < n; ++i) {

             delete locations0[changed[i].identifier];

           }

           for (var identifier in locations0) {

             return void relocate();

           }

         }

         w.on(touchmove, null).on(touchend, null);

         t.on(mousedown, mousedowned).on(touchstart, touchstarted);

         dragRestore();

         zoomended(event_);

       }

     }

     function mousewheeled() {

       var event_ = event.of(this, arguments);

       if (mousewheelTimer) clearTimeout(mousewheelTimer); else d3_selection_interrupt.call(this), 

       zoomstarted(event_);

       mousewheelTimer = setTimeout(function() {

         mousewheelTimer = null;

         zoomended(event_);

       }, 50);

       d3_eventPreventDefault();

       var point = center || d3.mouse(this);

       if (!translate0) translate0 = location(point);

       scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * view.k);

       translateTo(point, translate0);

       zoomed(event_);

     }

     function mousewheelreset() {

       translate0 = null;

     }

     function dblclicked() {

       var event_ = event.of(this, arguments), p = d3.mouse(this), l = location(p), k = Math.log(view.k) / Math.LN2;

       zoomstarted(event_);

       scaleTo(Math.pow(2, d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1));

       translateTo(p, l);

       zoomed(event_);

       zoomended(event_);

     }

     return d3.rebind(zoom, event, "on");

   };

   var d3_behavior_zoomInfinity = [ 0, Infinity ];

   var d3_behavior_zoomDelta, d3_behavior_zoomWheel = "onwheel" in d3_document ? (d3_behavior_zoomDelta = function() {

     return -d3.event.deltaY * (d3.event.deltaMode ? 120 : 1);

   }, "wheel") : "onmousewheel" in d3_document ? (d3_behavior_zoomDelta = function() {

     return d3.event.wheelDelta;

   }, "mousewheel") : (d3_behavior_zoomDelta = function() {

     return -d3.event.detail;

   }, "MozMousePixelScroll");

   function d3_Color() {}

   d3_Color.prototype.toString = function() {

     return this.rgb() + "";

   };

   d3.hsl = function(h, s, l) {

     return arguments.length === 1 ? h instanceof d3_Hsl ? d3_hsl(h.h, h.s, h.l) : d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl) : d3_hsl(+h, +s, +l);

   };

   function d3_hsl(h, s, l) {

     return new d3_Hsl(h, s, l);

   }

   function d3_Hsl(h, s, l) {

     this.h = h;

     this.s = s;

     this.l = l;

   }

   var d3_hslPrototype = d3_Hsl.prototype = new d3_Color();

   d3_hslPrototype.brighter = function(k) {

     k = Math.pow(.7, arguments.length ? k : 1);

     return d3_hsl(this.h, this.s, this.l / k);

   };

   d3_hslPrototype.darker = function(k) {

     k = Math.pow(.7, arguments.length ? k : 1);

     return d3_hsl(this.h, this.s, k * this.l);

   };

   d3_hslPrototype.rgb = function() {

     return d3_hsl_rgb(this.h, this.s, this.l);

   };

   function d3_hsl_rgb(h, s, l) {

     var m1, m2;

     h = isNaN(h) ? 0 : (h %= 360) < 0 ? h + 360 : h;

     s = isNaN(s) ? 0 : s < 0 ? 0 : s > 1 ? 1 : s;

     l = l < 0 ? 0 : l > 1 ? 1 : l;

     m2 = l <= .5 ? l * (1 + s) : l + s - l * s;

     m1 = 2 * l - m2;

     function v(h) {

       if (h > 360) h -= 360; else if (h < 0) h += 360;

       if (h < 60) return m1 + (m2 - m1) * h / 60;

       if (h < 180) return m2;

       if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60;

       return m1;

     }

     function vv(h) {

       return Math.round(v(h) * 255);

     }

     return d3_rgb(vv(h + 120), vv(h), vv(h - 120));

   }

   d3.hcl = function(h, c, l) {

     return arguments.length === 1 ? h instanceof d3_Hcl ? d3_hcl(h.h, h.c, h.l) : h instanceof d3_Lab ? d3_lab_hcl(h.l, h.a, h.b) : d3_lab_hcl((h = d3_rgb_lab((h = d3.rgb(h)).r, h.g, h.b)).l, h.a, h.b) : d3_hcl(+h, +c, +l);

   };

   function d3_hcl(h, c, l) {

     return new d3_Hcl(h, c, l);

   }

   function d3_Hcl(h, c, l) {

     this.h = h;

     this.c = c;

     this.l = l;

   }

   var d3_hclPrototype = d3_Hcl.prototype = new d3_Color();

   d3_hclPrototype.brighter = function(k) {

     return d3_hcl(this.h, this.c, Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)));

   };

   d3_hclPrototype.darker = function(k) {

     return d3_hcl(this.h, this.c, Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)));

   };

   d3_hclPrototype.rgb = function() {

     return d3_hcl_lab(this.h, this.c, this.l).rgb();

   };

   function d3_hcl_lab(h, c, l) {

     if (isNaN(h)) h = 0;

     if (isNaN(c)) c = 0;

     return d3_lab(l, Math.cos(h *= d3_radians) * c, Math.sin(h) * c);

   }

   d3.lab = function(l, a, b) {

     return arguments.length === 1 ? l instanceof d3_Lab ? d3_lab(l.l, l.a, l.b) : l instanceof d3_Hcl ? d3_hcl_lab(l.l, l.c, l.h) : d3_rgb_lab((l = d3.rgb(l)).r, l.g, l.b) : d3_lab(+l, +a, +b);

   };

   function d3_lab(l, a, b) {

     return new d3_Lab(l, a, b);

   }

   function d3_Lab(l, a, b) {

     this.l = l;

     this.a = a;

     this.b = b;

   }

   var d3_lab_K = 18;

   var d3_lab_X = .95047, d3_lab_Y = 1, d3_lab_Z = 1.08883;

   var d3_labPrototype = d3_Lab.prototype = new d3_Color();

   d3_labPrototype.brighter = function(k) {

     return d3_lab(Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)), this.a, this.b);

   };

   d3_labPrototype.darker = function(k) {

     return d3_lab(Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)), this.a, this.b);

   };

   d3_labPrototype.rgb = function() {

     return d3_lab_rgb(this.l, this.a, this.b);

   };

   function d3_lab_rgb(l, a, b) {

     var y = (l + 16) / 116, x = y + a / 500, z = y - b / 200;

     x = d3_lab_xyz(x) * d3_lab_X;

     y = d3_lab_xyz(y) * d3_lab_Y;

     z = d3_lab_xyz(z) * d3_lab_Z;

     return d3_rgb(d3_xyz_rgb(3.2404542 * x - 1.5371385 * y - .4985314 * z), d3_xyz_rgb(-.969266 * x + 1.8760108 * y + .041556 * z), d3_xyz_rgb(.0556434 * x - .2040259 * y + 1.0572252 * z));

   }

   function d3_lab_hcl(l, a, b) {

     return l > 0 ? d3_hcl(Math.atan2(b, a) * d3_degrees, Math.sqrt(a * a + b * b), l) : d3_hcl(NaN, NaN, l);

   }

   function d3_lab_xyz(x) {

     return x > .206893034 ? x * x * x : (x - 4 / 29) / 7.787037;

   }

   function d3_xyz_lab(x) {

     return x > .008856 ? Math.pow(x, 1 / 3) : 7.787037 * x + 4 / 29;

   }

   function d3_xyz_rgb(r) {

     return Math.round(255 * (r <= .00304 ? 12.92 * r : 1.055 * Math.pow(r, 1 / 2.4) - .055));

   }

   d3.rgb = function(r, g, b) {

     return arguments.length === 1 ? r instanceof d3_Rgb ? d3_rgb(r.r, r.g, r.b) : d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb) : d3_rgb(~~r, ~~g, ~~b);

   };

   function d3_rgbNumber(value) {

     return d3_rgb(value >> 16, value >> 8 & 255, value & 255);

   }

   function d3_rgbString(value) {

     return d3_rgbNumber(value) + "";

   }

   function d3_rgb(r, g, b) {

     return new d3_Rgb(r, g, b);

   }

   function d3_Rgb(r, g, b) {

     this.r = r;

     this.g = g;

     this.b = b;

   }

   var d3_rgbPrototype = d3_Rgb.prototype = new d3_Color();

   d3_rgbPrototype.brighter = function(k) {

     k = Math.pow(.7, arguments.length ? k : 1);

     var r = this.r, g = this.g, b = this.b, i = 30;

     if (!r && !g && !b) return d3_rgb(i, i, i);

     if (r && r < i) r = i;

     if (g && g < i) g = i;

     if (b && b < i) b = i;

     return d3_rgb(Math.min(255, ~~(r / k)), Math.min(255, ~~(g / k)), Math.min(255, ~~(b / k)));

   };

   d3_rgbPrototype.darker = function(k) {

     k = Math.pow(.7, arguments.length ? k : 1);

     return d3_rgb(~~(k * this.r), ~~(k * this.g), ~~(k * this.b));

   };

   d3_rgbPrototype.hsl = function() {

     return d3_rgb_hsl(this.r, this.g, this.b);

   };

   d3_rgbPrototype.toString = function() {

     return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b);

   };

   function d3_rgb_hex(v) {

     return v < 16 ? "0" + Math.max(0, v).toString(16) : Math.min(255, v).toString(16);

   }

   function d3_rgb_parse(format, rgb, hsl) {

     var r = 0, g = 0, b = 0, m1, m2, name;

     m1 = /([a-z]+)\((.*)\)/i.exec(format);

     if (m1) {

       m2 = m1[2].split(",");

       switch (m1[1]) {

        case "hsl":

         {

           return hsl(parseFloat(m2[0]), parseFloat(m2[1]) / 100, parseFloat(m2[2]) / 100);

         }

        case "rgb":

         {

           return rgb(d3_rgb_parseNumber(m2[0]), d3_rgb_parseNumber(m2[1]), d3_rgb_parseNumber(m2[2]));

         }

       }

     }

     if (name = d3_rgb_names.get(format)) return rgb(name.r, name.g, name.b);

     if (format != null && format.charAt(0) === "#") {

       if (format.length === 4) {

         r = format.charAt(1);

         r += r;

         g = format.charAt(2);

         g += g;

         b = format.charAt(3);

         b += b;

       } else if (format.length === 7) {

         r = format.substring(1, 3);

         g = format.substring(3, 5);

         b = format.substring(5, 7);

       }

       r = parseInt(r, 16);

       g = parseInt(g, 16);

       b = parseInt(b, 16);

     }

     return rgb(r, g, b);

   }

   function d3_rgb_hsl(r, g, b) {

     var min = Math.min(r /= 255, g /= 255, b /= 255), max = Math.max(r, g, b), d = max - min, h, s, l = (max + min) / 2;

     if (d) {

       s = l < .5 ? d / (max + min) : d / (2 - max - min);

       if (r == max) h = (g - b) / d + (g < b ? 6 : 0); else if (g == max) h = (b - r) / d + 2; else h = (r - g) / d + 4;

       h *= 60;

     } else {

       h = NaN;

       s = l > 0 && l < 1 ? 0 : h;

     }

     return d3_hsl(h, s, l);

   }

   function d3_rgb_lab(r, g, b) {

     r = d3_rgb_xyz(r);

     g = d3_rgb_xyz(g);

     b = d3_rgb_xyz(b);

     var x = d3_xyz_lab((.4124564 * r + .3575761 * g + .1804375 * b) / d3_lab_X), y = d3_xyz_lab((.2126729 * r + .7151522 * g + .072175 * b) / d3_lab_Y), z = d3_xyz_lab((.0193339 * r + .119192 * g + .9503041 * b) / d3_lab_Z);

     return d3_lab(116 * y - 16, 500 * (x - y), 200 * (y - z));

   }

   function d3_rgb_xyz(r) {

     return (r /= 255) <= .04045 ? r / 12.92 : Math.pow((r + .055) / 1.055, 2.4);

   }

   function d3_rgb_parseNumber(c) {

     var f = parseFloat(c);

     return c.charAt(c.length - 1) === "%" ? Math.round(f * 2.55) : f;

   }

   var d3_rgb_names = d3.map({

     aliceblue: 15792383,

     antiquewhite: 16444375,

     aqua: 65535,

     aquamarine: 8388564,

     azure: 15794175,

     beige: 16119260,

     bisque: 16770244,

     black: 0,

     blanchedalmond: 16772045,

     blue: 255,

     blueviolet: 9055202,

     brown: 10824234,

     burlywood: 14596231,

     cadetblue: 6266528,

     chartreuse: 8388352,

     chocolate: 13789470,

     coral: 16744272,

     cornflowerblue: 6591981,

     cornsilk: 16775388,

     crimson: 14423100,

     cyan: 65535,

     darkblue: 139,

     darkcyan: 35723,

     darkgoldenrod: 12092939,

     darkgray: 11119017,

     darkgreen: 25600,

     darkgrey: 11119017,

     darkkhaki: 12433259,

     darkmagenta: 9109643,

     darkolivegreen: 5597999,

     darkorange: 16747520,

     darkorchid: 10040012,

     darkred: 9109504,

     darksalmon: 15308410,

     darkseagreen: 9419919,

     darkslateblue: 4734347,

     darkslategray: 3100495,

     darkslategrey: 3100495,

     darkturquoise: 52945,

     darkviolet: 9699539,

     deeppink: 16716947,

     deepskyblue: 49151,

     dimgray: 6908265,

     dimgrey: 6908265,

     dodgerblue: 2003199,

     firebrick: 11674146,

     floralwhite: 16775920,

     forestgreen: 2263842,

     fuchsia: 16711935,

     gainsboro: 14474460,

     ghostwhite: 16316671,

     gold: 16766720,

     goldenrod: 14329120,

     gray: 8421504,

     green: 32768,

     greenyellow: 11403055,

     grey: 8421504,

     honeydew: 15794160,

     hotpink: 16738740,

     indianred: 13458524,

     indigo: 4915330,

     ivory: 16777200,

     khaki: 15787660,

     lavender: 15132410,

     lavenderblush: 16773365,

     lawngreen: 8190976,

     lemonchiffon: 16775885,

     lightblue: 11393254,

     lightcoral: 15761536,

     lightcyan: 14745599,

     lightgoldenrodyellow: 16448210,

     lightgray: 13882323,

     lightgreen: 9498256,

     lightgrey: 13882323,

     lightpink: 16758465,

     lightsalmon: 16752762,

     lightseagreen: 2142890,

     lightskyblue: 8900346,

     lightslategray: 7833753,

     lightslategrey: 7833753,

     lightsteelblue: 11584734,

     lightyellow: 16777184,

     lime: 65280,

     limegreen: 3329330,

     linen: 16445670,

     magenta: 16711935,

     maroon: 8388608,

     mediumaquamarine: 6737322,

     mediumblue: 205,

     mediumorchid: 12211667,

     mediumpurple: 9662683,

     mediumseagreen: 3978097,

     mediumslateblue: 8087790,

     mediumspringgreen: 64154,

     mediumturquoise: 4772300,

     mediumvioletred: 13047173,

     midnightblue: 1644912,

     mintcream: 16121850,

     mistyrose: 16770273,

     moccasin: 16770229,

     navajowhite: 16768685,

     navy: 128,

     oldlace: 16643558,

     olive: 8421376,

     olivedrab: 7048739,

     orange: 16753920,

     orangered: 16729344,

     orchid: 14315734,

     palegoldenrod: 15657130,

     palegreen: 10025880,

     paleturquoise: 11529966,

     palevioletred: 14381203,

     papayawhip: 16773077,

     peachpuff: 16767673,

     peru: 13468991,

     pink: 16761035,

     plum: 14524637,

     powderblue: 11591910,

     purple: 8388736,

     red: 16711680,

     rosybrown: 12357519,

     royalblue: 4286945,

     saddlebrown: 9127187,

     salmon: 16416882,

     sandybrown: 16032864,

     seagreen: 3050327,

     seashell: 16774638,

     sienna: 10506797,

     silver: 12632256,

     skyblue: 8900331,

     slateblue: 6970061,

     slategray: 7372944,

     slategrey: 7372944,

     snow: 16775930,

     springgreen: 65407,

     steelblue: 4620980,

     tan: 13808780,

     teal: 32896,

     thistle: 14204888,

     tomato: 16737095,

     turquoise: 4251856,

     violet: 15631086,

     wheat: 16113331,

     white: 16777215,

     whitesmoke: 16119285,

     yellow: 16776960,

     yellowgreen: 10145074

   });

   d3_rgb_names.forEach(function(key, value) {

     d3_rgb_names.set(key, d3_rgbNumber(value));

   });

   function d3_functor(v) {

     return typeof v === "function" ? v : function() {

       return v;

     };

   }

   d3.functor = d3_functor;

   function d3_identity(d) {

     return d;

   }

   d3.xhr = d3_xhrType(d3_identity);

   function d3_xhrType(response) {

     return function(url, mimeType, callback) {

       if (arguments.length === 2 && typeof mimeType === "function") callback = mimeType, 

       mimeType = null;

       return d3_xhr(url, mimeType, response, callback);

     };

   }

   function d3_xhr(url, mimeType, response, callback) {

     var xhr = {}, dispatch = d3.dispatch("beforesend", "progress", "load", "error"), headers = {}, request = new XMLHttpRequest(), responseType = null;

     if (d3_window.XDomainRequest && !("withCredentials" in request) && /^(http(s)?:)?\/\//.test(url)) request = new XDomainRequest();

     "onload" in request ? request.onload = request.onerror = respond : request.onreadystatechange = function() {

       request.readyState > 3 && respond();

     };

     function respond() {

       var status = request.status, result;

       if (!status && request.responseText || status >= 200 && status < 300 || status === 304) {

         try {

           result = response.call(xhr, request);

         } catch (e) {

           dispatch.error.call(xhr, e);

           return;

         }

         dispatch.load.call(xhr, result);

       } else {

         dispatch.error.call(xhr, request);

       }

     }

     request.onprogress = function(event) {

       var o = d3.event;

       d3.event = event;

       try {

         dispatch.progress.call(xhr, request);

       } finally {

         d3.event = o;

       }

     };

     xhr.header = function(name, value) {

       name = (name + "").toLowerCase();

       if (arguments.length < 2) return headers[name];

       if (value == null) delete headers[name]; else headers[name] = value + "";

       return xhr;

     };

     xhr.mimeType = function(value) {

       if (!arguments.length) return mimeType;

       mimeType = value == null ? null : value + "";

       return xhr;

     };

     xhr.responseType = function(value) {

       if (!arguments.length) return responseType;

       responseType = value;

       return xhr;

     };

     xhr.response = function(value) {

       response = value;

       return xhr;

     };

     [ "get", "post" ].forEach(function(method) {

       xhr[method] = function() {

         return xhr.send.apply(xhr, [ method ].concat(d3_array(arguments)));

       };

     });

     xhr.send = function(method, data, callback) {

       if (arguments.length === 2 && typeof data === "function") callback = data, data = null;

       request.open(method, url, true);

       if (mimeType != null && !("accept" in headers)) headers["accept"] = mimeType + ",*/*";

       if (request.setRequestHeader) for (var name in headers) request.setRequestHeader(name, headers[name]);

       if (mimeType != null && request.overrideMimeType) request.overrideMimeType(mimeType);

       if (responseType != null) request.responseType = responseType;

       if (callback != null) xhr.on("error", callback).on("load", function(request) {

         callback(null, request);

       });

       dispatch.beforesend.call(xhr, request);

       request.send(data == null ? null : data);

       return xhr;

     };

     xhr.abort = function() {

       request.abort();

       return xhr;

     };

     d3.rebind(xhr, dispatch, "on");

     return callback == null ? xhr : xhr.get(d3_xhr_fixCallback(callback));

   }

   function d3_xhr_fixCallback(callback) {

     return callback.length === 1 ? function(error, request) {

       callback(error == null ? request : null);

     } : callback;

   }

   d3.dsv = function(delimiter, mimeType) {

     var reFormat = new RegExp('["' + delimiter + "\n]"), delimiterCode = delimiter.charCodeAt(0);

     function dsv(url, row, callback) {

       if (arguments.length < 3) callback = row, row = null;

       var xhr = d3_xhr(url, mimeType, row == null ? response : typedResponse(row), callback);

       xhr.row = function(_) {

         return arguments.length ? xhr.response((row = _) == null ? response : typedResponse(_)) : row;

       };

       return xhr;

     }

     function response(request) {

       return dsv.parse(request.responseText);

     }

     function typedResponse(f) {

       return function(request) {

         return dsv.parse(request.responseText, f);

       };

     }

     dsv.parse = function(text, f) {

       var o;

       return dsv.parseRows(text, function(row, i) {

         if (o) return o(row, i - 1);

         var a = new Function("d", "return {" + row.map(function(name, i) {

           return JSON.stringify(name) + ": d[" + i + "]";

         }).join(",") + "}");

         o = f ? function(row, i) {

           return f(a(row), i);

         } : a;

       });

     };

     dsv.parseRows = function(text, f) {

       var EOL = {}, EOF = {}, rows = [], N = text.length, I = 0, n = 0, t, eol;

       function token() {

         if (I >= N) return EOF;

         if (eol) return eol = false, EOL;

         var j = I;

         if (text.charCodeAt(j) === 34) {

           var i = j;

           while (i++ < N) {

             if (text.charCodeAt(i) === 34) {

               if (text.charCodeAt(i + 1) !== 34) break;

               ++i;

             }

           }

           I = i + 2;

           var c = text.charCodeAt(i + 1);

           if (c === 13) {

             eol = true;

             if (text.charCodeAt(i + 2) === 10) ++I;

           } else if (c === 10) {

             eol = true;

           }

           return text.substring(j + 1, i).replace(/""/g, '"');

         }

         while (I < N) {

           var c = text.charCodeAt(I++), k = 1;

           if (c === 10) eol = true; else if (c === 13) {

             eol = true;

             if (text.charCodeAt(I) === 10) ++I, ++k;

           } else if (c !== delimiterCode) continue;

           return text.substring(j, I - k);

         }

         return text.substring(j);

       }

       while ((t = token()) !== EOF) {

         var a = [];

         while (t !== EOL && t !== EOF) {

           a.push(t);

           t = token();

         }

         if (f && !(a = f(a, n++))) continue;

         rows.push(a);

       }

       return rows;

     };

     dsv.format = function(rows) {

       if (Array.isArray(rows[0])) return dsv.formatRows(rows);

       var fieldSet = new d3_Set(), fields = [];

       rows.forEach(function(row) {

         for (var field in row) {

           if (!fieldSet.has(field)) {

             fields.push(fieldSet.add(field));

           }

         }

       });

       return [ fields.map(formatValue).join(delimiter) ].concat(rows.map(function(row) {

         return fields.map(function(field) {

           return formatValue(row[field]);

         }).join(delimiter);

       })).join("\n");

     };

     dsv.formatRows = function(rows) {

       return rows.map(formatRow).join("\n");

     };

     function formatRow(row) {

       return row.map(formatValue).join(delimiter);

     }

     function formatValue(text) {

       return reFormat.test(text) ? '"' + text.replace(/\"/g, '""') + '"' : text;

     }

     return dsv;

   };

   d3.csv = d3.dsv(",", "text/csv");

   d3.tsv = d3.dsv("	", "text/tab-separated-values");

   var d3_timer_queueHead, d3_timer_queueTail, d3_timer_interval, d3_timer_timeout, d3_timer_active, d3_timer_frame = d3_window[d3_vendorSymbol(d3_window, "requestAnimationFrame")] || function(callback) {

     setTimeout(callback, 17);

   };

   d3.timer = function(callback, delay, then) {

     var n = arguments.length;

     if (n < 2) delay = 0;

     if (n < 3) then = Date.now();

     var time = then + delay, timer = {

       c: callback,

       t: time,

       f: false,

       n: null

     };

     if (d3_timer_queueTail) d3_timer_queueTail.n = timer; else d3_timer_queueHead = timer;

     d3_timer_queueTail = timer;

     if (!d3_timer_interval) {

       d3_timer_timeout = clearTimeout(d3_timer_timeout);

       d3_timer_interval = 1;

       d3_timer_frame(d3_timer_step);

     }

   };

   function d3_timer_step() {

     var now = d3_timer_mark(), delay = d3_timer_sweep() - now;

     if (delay > 24) {

       if (isFinite(delay)) {

         clearTimeout(d3_timer_timeout);

         d3_timer_timeout = setTimeout(d3_timer_step, delay);

       }

       d3_timer_interval = 0;

     } else {

       d3_timer_interval = 1;

       d3_timer_frame(d3_timer_step);

     }

   }

   d3.timer.flush = function() {

     d3_timer_mark();

     d3_timer_sweep();

   };

   function d3_timer_mark() {

     var now = Date.now();

     d3_timer_active = d3_timer_queueHead;

     while (d3_timer_active) {

       if (now >= d3_timer_active.t) d3_timer_active.f = d3_timer_active.c(now - d3_timer_active.t);

       d3_timer_active = d3_timer_active.n;

     }

     return now;

   }

   function d3_timer_sweep() {

     var t0, t1 = d3_timer_queueHead, time = Infinity;

     while (t1) {

       if (t1.f) {

         t1 = t0 ? t0.n = t1.n : d3_timer_queueHead = t1.n;

       } else {

         if (t1.t < time) time = t1.t;

         t1 = (t0 = t1).n;

       }

     }

     d3_timer_queueTail = t0;

     return time;

   }

   function d3_format_precision(x, p) {

     return p - (x ? Math.ceil(Math.log(x) / Math.LN10) : 1);

   }

   d3.round = function(x, n) {

     return n ? Math.round(x * (n = Math.pow(10, n))) / n : Math.round(x);

   };

   var d3_formatPrefixes = [ "y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y" ].map(d3_formatPrefix);

   d3.formatPrefix = function(value, precision) {

     var i = 0;

     if (value) {

       if (value < 0) value *= -1;

       if (precision) value = d3.round(value, d3_format_precision(value, precision));

       i = 1 + Math.floor(1e-12 + Math.log(value) / Math.LN10);

       i = Math.max(-24, Math.min(24, Math.floor((i <= 0 ? i + 1 : i - 1) / 3) * 3));

     }

     return d3_formatPrefixes[8 + i / 3];

   };

   function d3_formatPrefix(d, i) {

     var k = Math.pow(10, abs(8 - i) * 3);

     return {

       scale: i > 8 ? function(d) {

         return d / k;

       } : function(d) {

         return d * k;

       },

       symbol: d

     };

   }

   function d3_locale_numberFormat(locale) {

     var locale_decimal = locale.decimal, locale_thousands = locale.thousands, locale_grouping = locale.grouping, locale_currency = locale.currency, formatGroup = locale_grouping ? function(value) {

       var i = value.length, t = [], j = 0, g = locale_grouping[0];

       while (i > 0 && g > 0) {

         t.push(value.substring(i -= g, i + g));

         g = locale_grouping[j = (j + 1) % locale_grouping.length];

       }

       return t.reverse().join(locale_thousands);

     } : d3_identity;

     return function(specifier) {

       var match = d3_format_re.exec(specifier), fill = match[1] || " ", align = match[2] || ">", sign = match[3] || "", symbol = match[4] || "", zfill = match[5], width = +match[6], comma = match[7], precision = match[8], type = match[9], scale = 1, prefix = "", suffix = "", integer = false;

       if (precision) precision = +precision.substring(1);

       if (zfill || fill === "0" && align === "=") {

         zfill = fill = "0";

         align = "=";

         if (comma) width -= Math.floor((width - 1) / 4);

       }

       switch (type) {

        case "n":

         comma = true;

         type = "g";

         break;

        case "%":

         scale = 100;

         suffix = "%";

         type = "f";

         break;

        case "p":

         scale = 100;

         suffix = "%";

         type = "r";

         break;

        case "b":

        case "o":

        case "x":

        case "X":

         if (symbol === "#") prefix = "0" + type.toLowerCase();

        case "c":

        case "d":

         integer = true;

         precision = 0;

         break;

        case "s":

         scale = -1;

         type = "r";

         break;

       }

       if (symbol === "$") prefix = locale_currency[0], suffix = locale_currency[1];

       if (type == "r" && !precision) type = "g";

       if (precision != null) {

         if (type == "g") precision = Math.max(1, Math.min(21, precision)); else if (type == "e" || type == "f") precision = Math.max(0, Math.min(20, precision));

       }

       type = d3_format_types.get(type) || d3_format_typeDefault;

       var zcomma = zfill && comma;

       return function(value) {

         var fullSuffix = suffix;

         if (integer && value % 1) return "";

         var negative = value < 0 || value === 0 && 1 / value < 0 ? (value = -value, "-") : sign;

         if (scale < 0) {

           var unit = d3.formatPrefix(value, precision);

           value = unit.scale(value);

           fullSuffix = unit.symbol + suffix;

         } else {

           value *= scale;

         }

         value = type(value, precision);

         var i = value.lastIndexOf("."), before = i < 0 ? value : value.substring(0, i), after = i < 0 ? "" : locale_decimal + value.substring(i + 1);

         if (!zfill && comma) before = formatGroup(before);

         var length = prefix.length + before.length + after.length + (zcomma ? 0 : negative.length), padding = length < width ? new Array(length = width - length + 1).join(fill) : "";

         if (zcomma) before = formatGroup(padding + before);

         negative += prefix;

         value = before + after;

         return (align === "<" ? negative + value + padding : align === ">" ? padding + negative + value : align === "^" ? padding.substring(0, length >>= 1) + negative + value + padding.substring(length) : negative + (zcomma ? value : padding + value)) + fullSuffix;

       };

     };

   }

   var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?([$#])?(0)?(\d+)?(,)?(\.-?\d+)?([a-z%])?/i;

   var d3_format_types = d3.map({

     b: function(x) {

       return x.toString(2);

     },

     c: function(x) {

       return String.fromCharCode(x);

     },

     o: function(x) {

       return x.toString(8);

     },

     x: function(x) {

       return x.toString(16);

     },

     X: function(x) {

       return x.toString(16).toUpperCase();

     },

     g: function(x, p) {

       return x.toPrecision(p);

     },

     e: function(x, p) {

       return x.toExponential(p);

     },

     f: function(x, p) {

       return x.toFixed(p);

     },

     r: function(x, p) {

       return (x = d3.round(x, d3_format_precision(x, p))).toFixed(Math.max(0, Math.min(20, d3_format_precision(x * (1 + 1e-15), p))));

     }

   });

   function d3_format_typeDefault(x) {

     return x + "";

   }

   var d3_time = d3.time = {}, d3_date = Date;

   function d3_date_utc() {

     this._ = new Date(arguments.length > 1 ? Date.UTC.apply(this, arguments) : arguments[0]);

   }

   d3_date_utc.prototype = {

     getDate: function() {

       return this._.getUTCDate();

     },

     getDay: function() {

       return this._.getUTCDay();

     },

     getFullYear: function() {

       return this._.getUTCFullYear();

     },

     getHours: function() {

       return this._.getUTCHours();

     },

     getMilliseconds: function() {

       return this._.getUTCMilliseconds();

     },

     getMinutes: function() {

       return this._.getUTCMinutes();

     },

     getMonth: function() {

       return this._.getUTCMonth();

     },

     getSeconds: function() {

       return this._.getUTCSeconds();

     },

     getTime: function() {

       return this._.getTime();

     },

     getTimezoneOffset: function() {

       return 0;

     },

     valueOf: function() {

       return this._.valueOf();

     },

     setDate: function() {

       d3_time_prototype.setUTCDate.apply(this._, arguments);

     },

     setDay: function() {

       d3_time_prototype.setUTCDay.apply(this._, arguments);

     },

     setFullYear: function() {

       d3_time_prototype.setUTCFullYear.apply(this._, arguments);

     },

     setHours: function() {

       d3_time_prototype.setUTCHours.apply(this._, arguments);

     },

     setMilliseconds: function() {

       d3_time_prototype.setUTCMilliseconds.apply(this._, arguments);

     },

     setMinutes: function() {

       d3_time_prototype.setUTCMinutes.apply(this._, arguments);

     },

     setMonth: function() {

       d3_time_prototype.setUTCMonth.apply(this._, arguments);

     },

     setSeconds: function() {

       d3_time_prototype.setUTCSeconds.apply(this._, arguments);

     },

     setTime: function() {

       d3_time_prototype.setTime.apply(this._, arguments);

     }

   };

   var d3_time_prototype = Date.prototype;

   function d3_time_interval(local, step, number) {

     function round(date) {

       var d0 = local(date), d1 = offset(d0, 1);

       return date - d0 < d1 - date ? d0 : d1;

     }

     function ceil(date) {

       step(date = local(new d3_date(date - 1)), 1);

       return date;

     }

     function offset(date, k) {

       step(date = new d3_date(+date), k);

       return date;

     }

     function range(t0, t1, dt) {

       var time = ceil(t0), times = [];

       if (dt > 1) {

         while (time < t1) {

           if (!(number(time) % dt)) times.push(new Date(+time));

           step(time, 1);

         }

       } else {

         while (time < t1) times.push(new Date(+time)), step(time, 1);

       }

       return times;

     }

     function range_utc(t0, t1, dt) {

       try {

         d3_date = d3_date_utc;

         var utc = new d3_date_utc();

         utc._ = t0;

         return range(utc, t1, dt);

       } finally {

         d3_date = Date;

       }

     }

     local.floor = local;

     local.round = round;

     local.ceil = ceil;

     local.offset = offset;

     local.range = range;

     var utc = local.utc = d3_time_interval_utc(local);

     utc.floor = utc;

     utc.round = d3_time_interval_utc(round);

     utc.ceil = d3_time_interval_utc(ceil);

     utc.offset = d3_time_interval_utc(offset);

     utc.range = range_utc;

     return local;

   }

   function d3_time_interval_utc(method) {

     return function(date, k) {

       try {

         d3_date = d3_date_utc;

         var utc = new d3_date_utc();

         utc._ = date;

         return method(utc, k)._;

       } finally {

         d3_date = Date;

       }

     };

   }

   d3_time.year = d3_time_interval(function(date) {

     date = d3_time.day(date);

     date.setMonth(0, 1);

     return date;

   }, function(date, offset) {

     date.setFullYear(date.getFullYear() + offset);

   }, function(date) {

     return date.getFullYear();

   });

   d3_time.years = d3_time.year.range;

   d3_time.years.utc = d3_time.year.utc.range;

   d3_time.day = d3_time_interval(function(date) {

     var day = new d3_date(2e3, 0);

     day.setFullYear(date.getFullYear(), date.getMonth(), date.getDate());

     return day;

   }, function(date, offset) {

     date.setDate(date.getDate() + offset);

   }, function(date) {

     return date.getDate() - 1;

   });

   d3_time.days = d3_time.day.range;

   d3_time.days.utc = d3_time.day.utc.range;

   d3_time.dayOfYear = function(date) {

     var year = d3_time.year(date);

     return Math.floor((date - year - (date.getTimezoneOffset() - year.getTimezoneOffset()) * 6e4) / 864e5);

   };

   [ "sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday" ].forEach(function(day, i) {

     i = 7 - i;

     var interval = d3_time[day] = d3_time_interval(function(date) {

       (date = d3_time.day(date)).setDate(date.getDate() - (date.getDay() + i) % 7);

       return date;

     }, function(date, offset) {

       date.setDate(date.getDate() + Math.floor(offset) * 7);

     }, function(date) {

       var day = d3_time.year(date).getDay();

       return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7) - (day !== i);

     });

     d3_time[day + "s"] = interval.range;

     d3_time[day + "s"].utc = interval.utc.range;

     d3_time[day + "OfYear"] = function(date) {

       var day = d3_time.year(date).getDay();

       return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7);

     };

   });

   d3_time.week = d3_time.sunday;

   d3_time.weeks = d3_time.sunday.range;

   d3_time.weeks.utc = d3_time.sunday.utc.range;

   d3_time.weekOfYear = d3_time.sundayOfYear;

   function d3_locale_timeFormat(locale) {

     var locale_dateTime = locale.dateTime, locale_date = locale.date, locale_time = locale.time, locale_periods = locale.periods, locale_days = locale.days, locale_shortDays = locale.shortDays, locale_months = locale.months, locale_shortMonths = locale.shortMonths;

     function d3_time_format(template) {

       var n = template.length;

       function format(date) {

         var string = [], i = -1, j = 0, c, p, f;

         while (++i < n) {

           if (template.charCodeAt(i) === 37) {

             string.push(template.substring(j, i));

             if ((p = d3_time_formatPads[c = template.charAt(++i)]) != null) c = template.charAt(++i);

             if (f = d3_time_formats[c]) c = f(date, p == null ? c === "e" ? " " : "0" : p);

             string.push(c);

             j = i + 1;

           }

         }

         string.push(template.substring(j, i));

         return string.join("");

       }

       format.parse = function(string) {

         var d = {

           y: 1900,

           m: 0,

           d: 1,

           H: 0,

           M: 0,

           S: 0,

           L: 0,

           Z: null

         }, i = d3_time_parse(d, template, string, 0);

         if (i != string.length) return null;

         if ("p" in d) d.H = d.H % 12 + d.p * 12;

         var localZ = d.Z != null && d3_date !== d3_date_utc, date = new (localZ ? d3_date_utc : d3_date)();

         if ("j" in d) date.setFullYear(d.y, 0, d.j); else if ("w" in d && ("W" in d || "U" in d)) {

           date.setFullYear(d.y, 0, 1);

           date.setFullYear(d.y, 0, "W" in d ? (d.w + 6) % 7 + d.W * 7 - (date.getDay() + 5) % 7 : d.w + d.U * 7 - (date.getDay() + 6) % 7);

         } else date.setFullYear(d.y, d.m, d.d);

         date.setHours(d.H + Math.floor(d.Z / 100), d.M + d.Z % 100, d.S, d.L);

         return localZ ? date._ : date;

       };

       format.toString = function() {

         return template;

       };

       return format;

     }

     function d3_time_parse(date, template, string, j) {

       var c, p, t, i = 0, n = template.length, m = string.length;

       while (i < n) {

         if (j >= m) return -1;

         c = template.charCodeAt(i++);

         if (c === 37) {

           t = template.charAt(i++);

           p = d3_time_parsers[t in d3_time_formatPads ? template.charAt(i++) : t];

           if (!p || (j = p(date, string, j)) < 0) return -1;

         } else if (c != string.charCodeAt(j++)) {

           return -1;

         }

       }

       return j;

     }

     d3_time_format.utc = function(template) {

       var local = d3_time_format(template);

       function format(date) {

         try {

           d3_date = d3_date_utc;

           var utc = new d3_date();

           utc._ = date;

           return local(utc);

         } finally {

           d3_date = Date;

         }

       }

       format.parse = function(string) {

         try {

           d3_date = d3_date_utc;

           var date = local.parse(string);

           return date && date._;

         } finally {

           d3_date = Date;

         }

       };

       format.toString = local.toString;

       return format;

     };

     d3_time_format.multi = d3_time_format.utc.multi = d3_time_formatMulti;

     var d3_time_periodLookup = d3.map(), d3_time_dayRe = d3_time_formatRe(locale_days), d3_time_dayLookup = d3_time_formatLookup(locale_days), d3_time_dayAbbrevRe = d3_time_formatRe(locale_shortDays), d3_time_dayAbbrevLookup = d3_time_formatLookup(locale_shortDays), d3_time_monthRe = d3_time_formatRe(locale_months), d3_time_monthLookup = d3_time_formatLookup(locale_months), d3_time_monthAbbrevRe = d3_time_formatRe(locale_shortMonths), d3_time_monthAbbrevLookup = d3_time_formatLookup(locale_shortMonths);

     locale_periods.forEach(function(p, i) {

       d3_time_periodLookup.set(p.toLowerCase(), i);

     });

     var d3_time_formats = {

       a: function(d) {

         return locale_shortDays[d.getDay()];

       },

       A: function(d) {

         return locale_days[d.getDay()];

       },

       b: function(d) {

         return locale_shortMonths[d.getMonth()];

       },

       B: function(d) {

         return locale_months[d.getMonth()];

       },

       c: d3_time_format(locale_dateTime),

       d: function(d, p) {

         return d3_time_formatPad(d.getDate(), p, 2);

       },

       e: function(d, p) {

         return d3_time_formatPad(d.getDate(), p, 2);

       },

       H: function(d, p) {

         return d3_time_formatPad(d.getHours(), p, 2);

       },

       I: function(d, p) {

         return d3_time_formatPad(d.getHours() % 12 || 12, p, 2);

       },

       j: function(d, p) {

         return d3_time_formatPad(1 + d3_time.dayOfYear(d), p, 3);

       },

       L: function(d, p) {

         return d3_time_formatPad(d.getMilliseconds(), p, 3);

       },

       m: function(d, p) {

         return d3_time_formatPad(d.getMonth() + 1, p, 2);

       },

       M: function(d, p) {

         return d3_time_formatPad(d.getMinutes(), p, 2);

       },

       p: function(d) {

         return locale_periods[+(d.getHours() >= 12)];

       },

       S: function(d, p) {

         return d3_time_formatPad(d.getSeconds(), p, 2);

       },

       U: function(d, p) {

         return d3_time_formatPad(d3_time.sundayOfYear(d), p, 2);

       },

       w: function(d) {

         return d.getDay();

       },

       W: function(d, p) {

         return d3_time_formatPad(d3_time.mondayOfYear(d), p, 2);

       },

       x: d3_time_format(locale_date),

       X: d3_time_format(locale_time),

       y: function(d, p) {

         return d3_time_formatPad(d.getFullYear() % 100, p, 2);

       },

       Y: function(d, p) {

         return d3_time_formatPad(d.getFullYear() % 1e4, p, 4);

       },

       Z: d3_time_zone,

       "%": function() {

         return "%";

       }

     };

     var d3_time_parsers = {

       a: d3_time_parseWeekdayAbbrev,

       A: d3_time_parseWeekday,

       b: d3_time_parseMonthAbbrev,

       B: d3_time_parseMonth,

       c: d3_time_parseLocaleFull,

       d: d3_time_parseDay,

       e: d3_time_parseDay,

       H: d3_time_parseHour24,

       I: d3_time_parseHour24,

       j: d3_time_parseDayOfYear,

       L: d3_time_parseMilliseconds,

       m: d3_time_parseMonthNumber,

       M: d3_time_parseMinutes,

       p: d3_time_parseAmPm,

       S: d3_time_parseSeconds,

       U: d3_time_parseWeekNumberSunday,

       w: d3_time_parseWeekdayNumber,

       W: d3_time_parseWeekNumberMonday,

       x: d3_time_parseLocaleDate,

       X: d3_time_parseLocaleTime,

       y: d3_time_parseYear,

       Y: d3_time_parseFullYear,

       Z: d3_time_parseZone,

       "%": d3_time_parseLiteralPercent

     };

     function d3_time_parseWeekdayAbbrev(date, string, i) {

       d3_time_dayAbbrevRe.lastIndex = 0;

       var n = d3_time_dayAbbrevRe.exec(string.substring(i));

       return n ? (date.w = d3_time_dayAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;

     }

     function d3_time_parseWeekday(date, string, i) {

       d3_time_dayRe.lastIndex = 0;

       var n = d3_time_dayRe.exec(string.substring(i));

       return n ? (date.w = d3_time_dayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;

     }

     function d3_time_parseMonthAbbrev(date, string, i) {

       d3_time_monthAbbrevRe.lastIndex = 0;

       var n = d3_time_monthAbbrevRe.exec(string.substring(i));

       return n ? (date.m = d3_time_monthAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;

     }

     function d3_time_parseMonth(date, string, i) {

       d3_time_monthRe.lastIndex = 0;

       var n = d3_time_monthRe.exec(string.substring(i));

       return n ? (date.m = d3_time_monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;

     }

     function d3_time_parseLocaleFull(date, string, i) {

       return d3_time_parse(date, d3_time_formats.c.toString(), string, i);

     }

     function d3_time_parseLocaleDate(date, string, i) {

       return d3_time_parse(date, d3_time_formats.x.toString(), string, i);

     }

     function d3_time_parseLocaleTime(date, string, i) {

       return d3_time_parse(date, d3_time_formats.X.toString(), string, i);

     }

     function d3_time_parseAmPm(date, string, i) {

       var n = d3_time_periodLookup.get(string.substring(i, i += 2).toLowerCase());

       return n == null ? -1 : (date.p = n, i);

     }

     return d3_time_format;

   }

   var d3_time_formatPads = {

     "-": "",

     _: " ",

     "0": "0"

   }, d3_time_numberRe = /^\s*\d+/, d3_time_percentRe = /^%/;

   function d3_time_formatPad(value, fill, width) {

     var sign = value < 0 ? "-" : "", string = (sign ? -value : value) + "", length = string.length;

     return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);

   }

   function d3_time_formatRe(names) {