https://steamspy.com/assets/plugins/nvd3/lib/d3.v3.js

1d3 = function() {
2  var d3 = {
3    version: "3.1.5"
4  };
5  if (!Date.now) Date.now = function() {
6    return +new Date();
7  };
8  var d3_document = document, d3_window = window;
9  try {
10    d3_document.createElement("div").style.setProperty("opacity", 0, "");
11  } catch (error) {
12    var d3_style_prototype = d3_window.CSSStyleDeclaration.prototype, d3_style_setProperty = d3_style_prototype.setProperty;
13    d3_style_prototype.setProperty = function(name, value, priority) {
14      d3_style_setProperty.call(this, name, value + "", priority);
15    };
16  }
17  d3.ascending = function(a, b) {
18    return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
19  };
20  d3.descending = function(a, b) {
21    return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
22  };
23  d3.min = function(array, f) {
24    var i = -1, n = array.length, a, b;
25    if (arguments.length === 1) {
26      while (++i < n && ((a = array[i]) == null || a != a)) a = undefined;
27      while (++i < n) if ((b = array[i]) != null && a > b) a = b;
28    } else {
29      while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined;
30      while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;
31    }
32    return a;
33  };
34  d3.max = function(array, f) {
35    var i = -1, n = array.length, a, b;
36    if (arguments.length === 1) {
37      while (++i < n && ((a = array[i]) == null || a != a)) a = undefined;
38      while (++i < n) if ((b = array[i]) != null && b > a) a = b;
39    } else {
40      while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined;
41      while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;
42    }
43    return a;
44  };
45  d3.extent = function(array, f) {
46    var i = -1, n = array.length, a, b, c;
47    if (arguments.length === 1) {
48      while (++i < n && ((a = c = array[i]) == null || a != a)) a = c = undefined;
49      while (++i < n) if ((b = array[i]) != null) {
50        if (a > b) a = b;
51        if (c < b) c = b;
52      }
53    } else {
54      while (++i < n && ((a = c = f.call(array, array[i], i)) == null || a != a)) a = undefined;
55      while (++i < n) if ((b = f.call(array, array[i], i)) != null) {
56        if (a > b) a = b;
57        if (c < b) c = b;
58      }
59    }
60    return [ a, c ];
61  };
62  d3.sum = function(array, f) {
63    var s = 0, n = array.length, a, i = -1;
64    if (arguments.length === 1) {
65      while (++i < n) if (!isNaN(a = +array[i])) s += a;
66    } else {
67      while (++i < n) if (!isNaN(a = +f.call(array, array[i], i))) s += a;
68    }
69    return s;
70  };
71  function d3_number(x) {
72    return x != null && !isNaN(x);
73  }
74  d3.mean = function(array, f) {
75    var n = array.length, a, m = 0, i = -1, j = 0;
76    if (arguments.length === 1) {
77      while (++i < n) if (d3_number(a = array[i])) m += (a - m) / ++j;
78    } else {
79      while (++i < n) if (d3_number(a = f.call(array, array[i], i))) m += (a - m) / ++j;
80    }
81    return j ? m : undefined;
82  };
83  d3.quantile = function(values, p) {
84    var H = (values.length - 1) * p + 1, h = Math.floor(H), v = +values[h - 1], e = H - h;
85    return e ? v + e * (values[h] - v) : v;
86  };
87  d3.median = function(array, f) {
88    if (arguments.length > 1) array = array.map(f);
89    array = array.filter(d3_number);
90    return array.length ? d3.quantile(array.sort(d3.ascending), .5) : undefined;
91  };
92  d3.bisector = function(f) {
93    return {
94      left: function(a, x, lo, hi) {
95        if (arguments.length < 3) lo = 0;
96        if (arguments.length < 4) hi = a.length;
97        while (lo < hi) {
98          var mid = lo + hi >>> 1;
99          if (f.call(a, a[mid], mid) < x) lo = mid + 1; else hi = mid;
100        }
101        return lo;
102      },
103      right: function(a, x, lo, hi) {
104        if (arguments.length < 3) lo = 0;
105        if (arguments.length < 4) hi = a.length;
106        while (lo < hi) {
107          var mid = lo + hi >>> 1;
108          if (x < f.call(a, a[mid], mid)) hi = mid; else lo = mid + 1;
109        }
110        return lo;
111      }
112    };
113  };
114  var d3_bisector = d3.bisector(function(d) {
115    return d;
116  });
117  d3.bisectLeft = d3_bisector.left;
118  d3.bisect = d3.bisectRight = d3_bisector.right;
119  d3.shuffle = function(array) {
120    var m = array.length, t, i;
121    while (m) {
122      i = Math.random() * m-- | 0;
123      t = array[m], array[m] = array[i], array[i] = t;
124    }
125    return array;
126  };
127  d3.permute = function(array, indexes) {
128    var permutes = [], i = -1, n = indexes.length;
129    while (++i < n) permutes[i] = array[indexes[i]];
130    return permutes;
131  };

132  d3.zip = function() {
133    if (!(n = arguments.length)) return [];
134    for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m; ) {
135      for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n; ) {
136        zip[j] = arguments[j][i];
137      }
138    }
139    return zips;
140  };
141  function d3_zipLength(d) {
142    return d.length;
143  }
144  d3.transpose = function(matrix) {
145    return d3.zip.apply(d3, matrix);
146  };
147  d3.keys = function(map) {
148    var keys = [];
149    for (var key in map) keys.push(key);
150    return keys;
151  };
152  d3.values = function(map) {
153    var values = [];
154    for (var key in map) values.push(map[key]);
155    return values;
156  };
157  d3.entries = function(map) {
158    var entries = [];
159    for (var key in map) entries.push({
160      key: key,
161      value: map[key]
162    });
163    return entries;
164  };
165  d3.merge = function(arrays) {
166    return Array.prototype.concat.apply([], arrays);
167  };
168  d3.range = function(start, stop, step) {
169    if (arguments.length < 3) {
170      step = 1;
171      if (arguments.length < 2) {
172        stop = start;
173        start = 0;
174      }
175    }
176    if ((stop - start) / step === Infinity) throw new Error("infinite range");
177    var range = [], k = d3_range_integerScale(Math.abs(step)), i = -1, j;
178    start *= k, stop *= k, step *= k;
179    if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k); else while ((j = start + step * ++i) < stop) range.push(j / k);
180    return range;
181  };
182  function d3_range_integerScale(x) {
183    var k = 1;
184    while (x * k % 1) k *= 10;
185    return k;
186  }
187  function d3_class(ctor, properties) {
188    try {
189      for (var key in properties) {
190        Object.defineProperty(ctor.prototype, key, {
191          value: properties[key],
192          enumerable: false
193        });
194      }
195    } catch (e) {
196      ctor.prototype = properties;
197    }
198  }
199  d3.map = function(object) {
200    var map = new d3_Map();
201    for (var key in object) map.set(key, object[key]);
202    return map;
203  };
204  function d3_Map() {}
205  d3_class(d3_Map, {
206    has: function(key) {
207      return d3_map_prefix + key in this;
208    },
209    get: function(key) {
210      return this[d3_map_prefix + key];
211    },
212    set: function(key, value) {
213      return this[d3_map_prefix + key] = value;
214    },
215    remove: function(key) {
216      key = d3_map_prefix + key;
217      return key in this && delete this[key];
218    },
219    keys: function() {
220      var keys = [];
221      this.forEach(function(key) {
222        keys.push(key);
223      });
224      return keys;
225    },
226    values: function() {
227      var values = [];
228      this.forEach(function(key, value) {
229        values.push(value);
230      });
231      return values;
232    },
233    entries: function() {
234      var entries = [];
235      this.forEach(function(key, value) {
236        entries.push({
237          key: key,
238          value: value
239        });
240      });
241      return entries;
242    },
243    forEach: function(f) {
244      for (var key in this) {
245        if (key.charCodeAt(0) === d3_map_prefixCode) {
246          f.call(this, key.substring(1), this[key]);
247        }
248      }
249    }
250  });
251  var d3_map_prefix = "\0", d3_map_prefixCode = d3_map_prefix.charCodeAt(0);
252  d3.nest = function() {
253    var nest = {}, keys = [], sortKeys = [], sortValues, rollup;
254    function map(mapType, array, depth) {
255      if (depth >= keys.length) return rollup ? rollup.call(nest, array) : sortValues ? array.sort(sortValues) : array;
256      var i = -1, n = array.length, key = keys[depth++], keyValue, object, setter, valuesByKey = new d3_Map(), values;
257      while (++i < n) {
258        if (values = valuesByKey.get(keyValue = key(object = array[i]))) {
259          values.push(object);
260        } else {
261          valuesByKey.set(keyValue, [ object ]);
262        }
263      }
264      if (mapType) {
265        object = mapType();
266        setter = function(keyValue, values) {
267          object.set(keyValue, map(mapType, values, depth));
268        };
269      } else {
270        object = {};
271        setter = function(keyValue, values) {
272          object[keyValue] = map(mapType, values, depth);
273        };
274      }
275      valuesByKey.forEach(setter);
276      return object;
277    }
278    function entries(map, depth) {
279      if (depth >= keys.length) return map;
280      var array = [], sortKey = sortKeys[depth++];

281      map.forEach(function(key, keyMap) {
282        array.push({
283          key: key,
284          values: entries(keyMap, depth)
285        });
286      });
287      return sortKey ? array.sort(function(a, b) {
288        return sortKey(a.key, b.key);
289      }) : array;
290    }
291    nest.map = function(array, mapType) {
292      return map(mapType, array, 0);
293    };
294    nest.entries = function(array) {
295      return entries(map(d3.map, array, 0), 0);
296    };
297    nest.key = function(d) {
298      keys.push(d);
299      return nest;
300    };
301    nest.sortKeys = function(order) {
302      sortKeys[keys.length - 1] = order;
303      return nest;
304    };
305    nest.sortValues = function(order) {
306      sortValues = order;
307      return nest;
308    };
309    nest.rollup = function(f) {
310      rollup = f;
311      return nest;
312    };
313    return nest;
314  };
315  d3.set = function(array) {
316    var set = new d3_Set();
317    if (array) for (var i = 0; i < array.length; i++) set.add(array[i]);
318    return set;
319  };
320  function d3_Set() {}
321  d3_class(d3_Set, {
322    has: function(value) {
323      return d3_map_prefix + value in this;
324    },
325    add: function(value) {
326      this[d3_map_prefix + value] = true;
327      return value;
328    },
329    remove: function(value) {
330      value = d3_map_prefix + value;
331      return value in this && delete this[value];
332    },
333    values: function() {
334      var values = [];
335      this.forEach(function(value) {
336        values.push(value);
337      });
338      return values;
339    },
340    forEach: function(f) {
341      for (var value in this) {
342        if (value.charCodeAt(0) === d3_map_prefixCode) {
343          f.call(this, value.substring(1));
344        }
345      }
346    }
347  });
348  d3.behavior = {};
349  d3.rebind = function(target, source) {
350    var i = 1, n = arguments.length, method;
351    while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]);
352    return target;
353  };
354  function d3_rebind(target, source, method) {
355    return function() {
356      var value = method.apply(source, arguments);
357      return value === source ? target : value;
358    };
359  }
360  d3.dispatch = function() {
361    var dispatch = new d3_dispatch(), i = -1, n = arguments.length;
362    while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
363    return dispatch;
364  };
365  function d3_dispatch() {}
366  d3_dispatch.prototype.on = function(type, listener) {
367    var i = type.indexOf("."), name = "";
368    if (i >= 0) {
369      name = type.substring(i + 1);
370      type = type.substring(0, i);
371    }
372    if (type) return arguments.length < 2 ? this[type].on(name) : this[type].on(name, listener);
373    if (arguments.length === 2) {
374      if (listener == null) for (type in this) {
375        if (this.hasOwnProperty(type)) this[type].on(name, null);
376      }
377      return this;
378    }
379  };
380  function d3_dispatch_event(dispatch) {
381    var listeners = [], listenerByName = new d3_Map();
382    function event() {
383      var z = listeners, i = -1, n = z.length, l;
384      while (++i < n) if (l = z[i].on) l.apply(this, arguments);
385      return dispatch;
386    }
387    event.on = function(name, listener) {
388      var l = listenerByName.get(name), i;
389      if (arguments.length < 2) return l && l.on;
390      if (l) {
391        l.on = null;
392        listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1));
393        listenerByName.remove(name);
394      }
395      if (listener) listeners.push(listenerByName.set(name, {
396        on: listener
397      }));
398      return dispatch;
399    };
400    return event;
401  }
402  d3.event = null;
403  function d3_eventCancel() {
404    d3.event.stopPropagation();
405    d3.event.preventDefault();
406  }
407  function d3_eventSource() {
408    var e = d3.event, s;
409    while (s = e.sourceEvent) e = s;
410    return e;
411  }
412  function d3_eventSuppress(target, type) {
413    function off() {
414      target.on(type, null);
415    }
416    target.on(type, function() {
417      d3_eventCancel();
418      off();
419    }, true);
420    setTimeout(off, 0);
421  }
422  function d3_eventDispatch(target) {
423    var dispatch = new d3_dispatch(), i = 0, n = arguments.length;
424    while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
425    dispatch.of = function(thiz, argumentz) {
426      return function(e1) {
427        try {
428          var e0 = e1.sourceEvent = d3.event;
429          e1.target = target;
430          d3.event = e1;
431          dispatch[e1.type].apply(thiz, argumentz);
432        } finally {
433          d3.event = e0;
434        }
435      };
436    };

437    return dispatch;
438  }
439  d3.mouse = function(container) {
440    return d3_mousePoint(container, d3_eventSource());
441  };
442  var d3_mouse_bug44083 = /WebKit/.test(d3_window.navigator.userAgent) ? -1 : 0;
443  function d3_mousePoint(container, e) {
444    var svg = container.ownerSVGElement || container;
445    if (svg.createSVGPoint) {
446      var point = svg.createSVGPoint();
447      if (d3_mouse_bug44083 < 0 && (d3_window.scrollX || d3_window.scrollY)) {
448        svg = d3.select(d3_document.body).append("svg").style("position", "absolute").style("top", 0).style("left", 0);
449        var ctm = svg[0][0].getScreenCTM();
450        d3_mouse_bug44083 = !(ctm.f || ctm.e);
451        svg.remove();
452      }
453      if (d3_mouse_bug44083) {
454        point.x = e.pageX;
455        point.y = e.pageY;
456      } else {
457        point.x = e.clientX;
458        point.y = e.clientY;
459      }
460      point = point.matrixTransform(container.getScreenCTM().inverse());
461      return [ point.x, point.y ];
462    }
463    var rect = container.getBoundingClientRect();
464    return [ e.clientX - rect.left - container.clientLeft, e.clientY - rect.top - container.clientTop ];
465  }
466  var d3_array = d3_arraySlice;
467  function d3_arrayCopy(pseudoarray) {
468    var i = -1, n = pseudoarray.length, array = [];
469    while (++i < n) array.push(pseudoarray[i]);
470    return array;
471  }
472  function d3_arraySlice(pseudoarray) {
473    return Array.prototype.slice.call(pseudoarray);
474  }
475  try {
476    d3_array(d3_document.documentElement.childNodes)[0].nodeType;
477  } catch (e) {
478    d3_array = d3_arrayCopy;
479  }
480  var d3_arraySubclass = [].__proto__ ? function(array, prototype) {
481    array.__proto__ = prototype;
482  } : function(array, prototype) {
483    for (var property in prototype) array[property] = prototype[property];
484  };
485  d3.touches = function(container, touches) {
486    if (arguments.length < 2) touches = d3_eventSource().touches;
487    return touches ? d3_array(touches).map(function(touch) {
488      var point = d3_mousePoint(container, touch);
489      point.identifier = touch.identifier;
490      return point;
491    }) : [];
492  };
493  d3.behavior.drag = function() {
494    var event = d3_eventDispatch(drag, "drag", "dragstart", "dragend"), origin = null;
495    function drag() {
496      this.on("mousedown.drag", mousedown).on("touchstart.drag", mousedown);
497    }
498    function mousedown() {
499      var target = this, event_ = event.of(target, arguments), eventTarget = d3.event.target, touchId = d3.event.touches ? d3.event.changedTouches[0].identifier : null, offset, origin_ = point(), moved = 0;
500      var w = d3.select(d3_window).on(touchId != null ? "touchmove.drag-" + touchId : "mousemove.drag", dragmove).on(touchId != null ? "touchend.drag-" + touchId : "mouseup.drag", dragend, true);
501      if (origin) {
502        offset = origin.apply(target, arguments);
503        offset = [ offset.x - origin_[0], offset.y - origin_[1] ];
504      } else {
505        offset = [ 0, 0 ];
506      }
507      if (touchId == null) d3_eventCancel();
508      event_({
509        type: "dragstart"
510      });
511      function point() {
512        var p = target.parentNode;
513        return touchId != null ? d3.touches(p).filter(function(p) {
514          return p.identifier === touchId;
515        })[0] : d3.mouse(p);
516      }
517      function dragmove() {
518        if (!target.parentNode) return dragend();
519        var p = point(), dx = p[0] - origin_[0], dy = p[1] - origin_[1];
520        moved |= dx | dy;
521        origin_ = p;
522        d3_eventCancel();
523        event_({
524          type: "drag",
525          x: p[0] + offset[0],
526          y: p[1] + offset[1],
527          dx: dx,
528          dy: dy
529        });
530      }
531      function dragend() {
532        event_({
533          type: "dragend"
534        });
535        if (moved) {
536          d3_eventCancel();
537          if (d3.event.target === eventTarget) d3_eventSuppress(w, "click");
538        }
539        w.on(touchId != null ? "touchmove.drag-" + touchId : "mousemove.drag", null).on(touchId != null ? "touchend.drag-" + touchId : "mouseup.drag", null);
540      }
541    }
542    drag.origin = function(x) {
543      if (!arguments.length) return origin;
544      origin = x;
545      return drag;
546    };
547    return d3.rebind(drag, event, "on");
548  };
549  function d3_selection(groups) {
550    d3_arraySubclass(groups, d3_selectionPrototype);
551    return groups;
552  }
553  var d3_select = function(s, n) {
554    return n.querySelector(s);
555  }, d3_selectAll = function(s, n) {
556    return n.querySelectorAll(s);
557  }, d3_selectRoot = d3_document.documentElement, d3_selectMatcher = d3_selectRoot.matchesSelector || d3_selectRoot.webkitMatchesSelector || d3_selectRoot.mozMatchesSelector || d3_selectRoot.msMat

557chesSelector || d3_selectRoot.oMatchesSelector, d3_selectMatches = function(n, s) {
558    return d3_selectMatcher.call(n, s);
559  };
560  if (typeof Sizzle === "function") {
561    d3_select = function(s, n) {
562      return Sizzle(s, n)[0] || null;
563    };
564    d3_selectAll = function(s, n) {
565      return Sizzle.uniqueSort(Sizzle(s, n));
566    };
567    d3_selectMatches = Sizzle.matchesSelector;
568  }
569  var d3_selectionPrototype = [];
570  d3.selection = function() {
571    return d3_selectionRoot;
572  };
573  d3.selection.prototype = d3_selectionPrototype;
574  d3_selectionPrototype.select = function(selector) {
575    var subgroups = [], subgroup, subnode, group, node;
576    if (typeof selector !== "function") selector = d3_selection_selector(selector);
577    for (var j = -1, m = this.length; ++j < m; ) {
578      subgroups.push(subgroup = []);
579      subgroup.parentNode = (group = this[j]).parentNode;
580      for (var i = -1, n = group.length; ++i < n; ) {
581        if (node = group[i]) {
582          subgroup.push(subnode = selector.call(node, node.__data__, i));
583          if (subnode && "__data__" in node) subnode.__data__ = node.__data__;
584        } else {
585          subgroup.push(null);
586        }
587      }
588    }
589    return d3_selection(subgroups);
590  };
591  function d3_selection_selector(selector) {
592    return function() {
593      return d3_select(selector, this);
594    };
595  }
596  d3_selectionPrototype.selectAll = function(selector) {
597    var subgroups = [], subgroup, node;
598    if (typeof selector !== "function") selector = d3_selection_selectorAll(selector);
599    for (var j = -1, m = this.length; ++j < m; ) {
600      for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
601        if (node = group[i]) {
602          subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i)));
603          subgroup.parentNode = node;
604        }
605      }
606    }
607    return d3_selection(subgroups);
608  };
609  function d3_selection_selectorAll(selector) {
610    return function() {
611      return d3_selectAll(selector, this);
612    };
613  }
614  var d3_nsPrefix = {
615    svg: "http://www.w3.org/2000/svg",
616    xhtml: "http://www.w3.org/1999/xhtml",
617    xlink: "http://www.w3.org/1999/xlink",
618    xml: "http://www.w3.org/XML/1998/namespace",
619    xmlns: "http://www.w3.org/2000/xmlns/"
620  };
621  d3.ns = {
622    prefix: d3_nsPrefix,
623    qualify: function(name) {
624      var i = name.indexOf(":"), prefix = name;
625      if (i >= 0) {
626        prefix = name.substring(0, i);
627        name = name.substring(i + 1);
628      }
629      return d3_nsPrefix.hasOwnProperty(prefix) ? {
630        space: d3_nsPrefix[prefix],
631        local: name
632      } : name;
633    }
634  };
635  d3_selectionPrototype.attr = function(name, value) {
636    if (arguments.length < 2) {
637      if (typeof name === "string") {
638        var node = this.node();
639        name = d3.ns.qualify(name);
640        return name.local ? node.getAttributeNS(name.space, name.local) : node.getAttribute(name);
641      }
642      for (value in name) this.each(d3_selection_attr(value, name[value]));
643      return this;
644    }
645    return this.each(d3_selection_attr(name, value));
646  };
647  function d3_selection_attr(name, value) {
648    name = d3.ns.qualify(name);
649    function attrNull() {
650      this.removeAttribute(name);
651    }
652    function attrNullNS() {
653      this.removeAttributeNS(name.space, name.local);
654    }
655    function attrConstant() {
656      this.setAttribute(name, value);
657    }
658    function attrConstantNS() {
659      this.setAttributeNS(name.space, name.local, value);
660    }
661    function attrFunction() {
662      var x = value.apply(this, arguments);
663      if (x == null) this.removeAttribute(name); else this.setAttribute(name, x);
664    }
665    function attrFunctionNS() {
666      var x = value.apply(this, arguments);
667      if (x == null) this.removeAttributeNS(name.space, name.local); else this.setAttributeNS(name.space, name.local, x);
668    }
669    return value == null ? name.local ? attrNullNS : attrNull : typeof value === "function" ? name.local ? attrFunctionNS : attrFunction : name.local ? attrConstantNS : attrConstant;
670  }
671  function d3_collapse(s) {
672    return s.trim().replace(/\s+/g, " ");
673  }
674  d3.requote = function(s) {
675    return s.replace(d3_requote_re, "\\$&");
676  };
677  var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;
678  d3_selectionPrototype.classed = function(name, value) {
679    if (arguments.length < 2) {
680      if (typeof name === "string") {
681        var node = this.node(), n = (name = name.trim().split(/^|\s+/g)).length, i = -1;
682        if (value = node.classList) {
683          while (++i < n) if (!value.contains(name[i])) return false;

684        } else {
685          value = node.getAttribute("class");
686          while (++i < n) if (!d3_selection_classedRe(name[i]).test(value)) return false;
687        }
688        return true;
689      }
690      for (value in name) this.each(d3_selection_classed(value, name[value]));
691      return this;
692    }
693    return this.each(d3_selection_classed(name, value));
694  };
695  function d3_selection_classedRe(name) {
696    return new RegExp("(?:^|\\s+)" + d3.requote(name) + "(?:\\s+|$)", "g");
697  }
698  function d3_selection_classed(name, value) {
699    name = name.trim().split(/\s+/).map(d3_selection_classedName);
700    var n = name.length;
701    function classedConstant() {
702      var i = -1;
703      while (++i < n) name[i](this, value);
704    }
705    function classedFunction() {
706      var i = -1, x = value.apply(this, arguments);
707      while (++i < n) name[i](this, x);
708    }
709    return typeof value === "function" ? classedFunction : classedConstant;
710  }
711  function d3_selection_classedName(name) {
712    var re = d3_selection_classedRe(name);
713    return function(node, value) {
714      if (c = node.classList) return value ? c.add(name) : c.remove(name);
715      var c = node.getAttribute("class") || "";
716      if (value) {
717        re.lastIndex = 0;
718        if (!re.test(c)) node.setAttribute("class", d3_collapse(c + " " + name));
719      } else {
720        node.setAttribute("class", d3_collapse(c.replace(re, " ")));
721      }
722    };
723  }
724  d3_selectionPrototype.style = function(name, value, priority) {
725    var n = arguments.length;
726    if (n < 3) {
727      if (typeof name !== "string") {
728        if (n < 2) value = "";
729        for (priority in name) this.each(d3_selection_style(priority, name[priority], value));
730        return this;
731      }
732      if (n < 2) return d3_window.getComputedStyle(this.node(), null).getPropertyValue(name);
733      priority = "";
734    }
735    return this.each(d3_selection_style(name, value, priority));
736  };
737  function d3_selection_style(name, value, priority) {
738    function styleNull() {
739      this.style.removeProperty(name);
740    }
741    function styleConstant() {
742      this.style.setProperty(name, value, priority);
743    }
744    function styleFunction() {
745      var x = value.apply(this, arguments);
746      if (x == null) this.style.removeProperty(name); else this.style.setProperty(name, x, priority);
747    }
748    return value == null ? styleNull : typeof value === "function" ? styleFunction : styleConstant;
749  }
750  d3_selectionPrototype.property = function(name, value) {
751    if (arguments.length < 2) {
752      if (typeof name === "string") return this.node()[name];
753      for (value in name) this.each(d3_selection_property(value, name[value]));
754      return this;
755    }
756    return this.each(d3_selection_property(name, value));
757  };
758  function d3_selection_property(name, value) {
759    function propertyNull() {
760      delete this[name];
761    }
762    function propertyConstant() {
763      this[name] = value;
764    }
765    function propertyFunction() {
766      var x = value.apply(this, arguments);
767      if (x == null) delete this[name]; else this[name] = x;
768    }
769    return value == null ? propertyNull : typeof value === "function" ? propertyFunction : propertyConstant;
770  }
771  d3_selectionPrototype.text = function(value) {
772    return arguments.length ? this.each(typeof value === "function" ? function() {
773      var v = value.apply(this, arguments);
774      this.textContent = v == null ? "" : v;
775    } : value == null ? function() {
776      this.textContent = "";
777    } : function() {
778      this.textContent = value;
779    }) : this.node().textContent;
780  };
781  d3_selectionPrototype.html = function(value) {
782    return arguments.length ? this.each(typeof value === "function" ? function() {
783      var v = value.apply(this, arguments);
784      this.innerHTML = v == null ? "" : v;
785    } : value == null ? function() {
786      this.innerHTML = "";
787    } : function() {
788      this.innerHTML = value;
789    }) : this.node().innerHTML;
790  };
791  d3_selectionPrototype.append = function(name) {
792    name = d3.ns.qualify(name);
793    function append() {
794      return this.appendChild(d3_document.createElementNS(this.namespaceURI, name));
795    }
796    function appendNS() {
797      return this.appendChild(d3_document.createElementNS(name.space, name.local));
798    }
799    return this.select(name.local ? appendNS : append);
800  };
801  d3_selectionPrototype.insert = function(name, before) {
802    name = d3.ns.qualify(name);
803    if (typeof before !== "function") before = d3_selection_selector(before);
804    function insert(d, i) {
805      return this.insertBefore(d3_document.createElementNS(this.namespaceURI, name), before.call(this, d, i));
806    }
807    function insertNS(d, i) {
808      return this.insertBefore(d3_document.createElementNS(name.space, name.local), before.call(this, d, i));
809    }
810    return this.select(name.local ? insertNS : insert);
811  };
812  d3_selectionPrototype.remove = function() {
813    return this.each(function() {
814      var parent = this.parentNode;
815      if (parent) parent.removeChild(this);
816    });
817  };
818  d3_selectionPrototype.data = function(value, key) {
819    var i = -1, n = this.length, group, node;
820    if (!arguments.length) {
821      value = new Array(n = (group = this[0]).length);
822      while (++i < n) {
823        if (node = group[i]) {
824          value[i] = node.__data__;
825        }
826      }
827      return value;
828    }
829    function bind(group, groupData) {
830      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;
831      if (key) {
832        var nodeByKeyValue = new d3_Map(), dataByKeyValue = new d3_Map(), keyValues = [], keyValue;
833        for (i = -1; ++i < n; ) {
834          keyValue = key.call(node = group[i], node.__data__, i);
835          if (nodeByKeyValue.has(keyValue)) {
836            exitNodes[i] = node;
837          } else {
838            nodeByKeyValue.set(keyValue, node);
839          }
840          keyValues.push(keyValue);
841        }
842        for (i = -1; ++i < m; ) {
843          keyValue = key.call(groupData, nodeData = groupData[i], i);
844          if (node = nodeByKeyValue.get(keyValue)) {
845            updateNodes[i] = node;
846            node.__data__ = nodeData;
847          } else if (!dataByKeyValue.has(keyValue)) {
848            enterNodes[i] = d3_selection_dataNode(nodeData);
849          }
850          dataByKeyValue.set(keyValue, nodeData);
851          nodeByKeyValue.remove(keyValue);
852        }
853        for (i = -1; ++i < n; ) {
854          if (nodeByKeyValue.has(keyValues[i])) {
855            exitNodes[i] = group[i];
856          }
857        }
858      } else {
859        for (i = -1; ++i < n0; ) {
860          node = group[i];
861          nodeData = groupData[i];
862          if (node) {
863            node.__data__ = nodeData;
864            updateNodes[i] = node;
865          } else {
866            enterNodes[i] = d3_selection_dataNode(nodeData);
867          }
868        }
869        for (;i < m; ++i) {
870          enterNodes[i] = d3_selection_dataNode(groupData[i]);
871        }
872        for (;i < n; ++i) {
873          exitNodes[i] = group[i];
874        }
875      }
876      enterNodes.update = updateNodes;
877      enterNodes.parentNode = updateNodes.parentNode = exitNodes.parentNode = group.parentNode;
878      enter.push(enterNodes);
879      update.push(updateNodes);
880      exit.push(exitNodes);
881    }
882    var enter = d3_selection_enter([]), update = d3_selection([]), exit = d3_selection([]);
883    if (typeof value === "function") {
884      while (++i < n) {
885        bind(group = this[i], value.call(group, group.parentNode.__data__, i));
886      }
887    } else {
888      while (++i < n) {
889        bind(group = this[i], value);
890      }
891    }
892    update.enter = function() {
893      return enter;
894    };
895    update.exit = function() {
896      return exit;
897    };
898    return update;
899  };
900  function d3_selection_dataNode(data) {
901    return {
902      __data__: data
903    };
904  }
905  d3_selectionPrototype.datum = function(value) {
906    return arguments.length ? this.property("__data__", value) : this.property("__data__");
907  };
908  d3_selectionPrototype.filter = function(filter) {
909    var subgroups = [], subgroup, group, node;
910    if (typeof filter !== "function") filter = d3_selection_filter(filter);
911    for (var j = 0, m = this.length; j < m; j++) {
912      subgroups.push(subgroup = []);
913      subgroup.parentNode = (group = this[j]).parentNode;
914      for (var i = 0, n = group.length; i < n; i++) {
915        if ((node = group[i]) && filter.call(node, node.__data__, i)) {
916          subgroup.push(node);
917        }
918      }
919    }
920    return d3_selection(subgroups);
921  };
922  function d3_selection_filter(selector) {
923    return function() {
924      return d3_selectMatches(this, selector);
925    };
926  }
927  d3_selectionPrototype.order = function() {
928    for (var j = -1, m = this.length; ++j < m; ) {
929      for (var group = this[j], i = group.length - 1, next = group[i], node; --i >= 0; ) {
930        if (node = group[i]) {
931          if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);
932          next = node;
933        }
934      }
935    }
936    return this;
937  };
938  d3_selectionPrototype.sort = function(comparator) {
939    comparator = d3_selection_sortComparator.apply(this, arguments);
940    for (var j = -1, m = this.length; ++j < m; ) this[j].sort(comparator);
941    return this.order();
942  };
943  function d3_selection_sortComparator(comparator) {
944    if (!arguments.length) comparator = d3.ascending;
945    return function(a, b) {
946      return !a - !b || comparator(a.__data__, b.__data__);
947    };
948  }
949  function d3_noop() {}
950  d3_selectionPrototype.on = function(type, listener, capture) {
951    var n = arguments.length;
952    if (n < 3) {
953      if (typeof type !== "string") {
954        if (n < 2) listener = false;

955        for (capture in type) this.each(d3_selection_on(capture, type[capture], listener));
956        return this;
957      }
958      if (n < 2) return (n = this.node()["__on" + type]) && n._;
959      capture = false;
960    }
961    return this.each(d3_selection_on(type, listener, capture));
962  };
963  function d3_selection_on(type, listener, capture) {
964    var name = "__on" + type, i = type.indexOf("."), wrap = d3_selection_onListener;
965    if (i > 0) type = type.substring(0, i);
966    var filter = d3_selection_onFilters.get(type);
967    if (filter) type = filter, wrap = d3_selection_onFilter;
968    function onRemove() {
969      var l = this[name];
970      if (l) {
971        this.removeEventListener(type, l, l.$);
972        delete this[name];
973      }
974    }
975    function onAdd() {
976      var l = wrap(listener, d3_array(arguments));
977      onRemove.call(this);
978      this.addEventListener(type, this[name] = l, l.$ = capture);
979      l._ = listener;
980    }
981    function removeAll() {
982      var re = new RegExp("^__on([^.]+)" + d3.requote(type) + "$"), match;
983      for (var name in this) {
984        if (match = name.match(re)) {
985          var l = this[name];
986          this.removeEventListener(match[1], l, l.$);
987          delete this[name];
988        }
989      }
990    }
991    return i ? listener ? onAdd : onRemove : listener ? d3_noop : removeAll;
992  }
993  var d3_selection_onFilters = d3.map({
994    mouseenter: "mouseover",
995    mouseleave: "mouseout"
996  });
997  d3_selection_onFilters.forEach(function(k) {
998    if ("on" + k in d3_document) d3_selection_onFilters.remove(k);
999  });
1000  function d3_selection_onListener(listener, argumentz) {
1001    return function(e) {
1002      var o = d3.event;
1003      d3.event = e;
1004      argumentz[0] = this.__data__;
1005      try {
1006        listener.apply(this, argumentz);
1007      } finally {
1008        d3.event = o;
1009      }
1010    };
1011  }
1012  function d3_selection_onFilter(listener, argumentz) {
1013    var l = d3_selection_onListener(listener, argumentz);
1014    return function(e) {
1015      var target = this, related = e.relatedTarget;
1016      if (!related || related !== target && !(related.compareDocumentPosition(target) & 8)) {
1017        l.call(target, e);
1018      }
1019    };
1020  }
1021  d3_selectionPrototype.each = function(callback) {
1022    return d3_selection_each(this, function(node, i, j) {
1023      callback.call(node, node.__data__, i, j);
1024    });
1025  };
1026  function d3_selection_each(groups, callback) {
1027    for (var j = 0, m = groups.length; j < m; j++) {
1028      for (var group = groups[j], i = 0, n = group.length, node; i < n; i++) {
1029        if (node = group[i]) callback(node, i, j);
1030      }
1031    }
1032    return groups;
1033  }
1034  d3_selectionPrototype.call = function(callback) {
1035    var args = d3_array(arguments);
1036    callback.apply(args[0] = this, args);
1037    return this;
1038  };
1039  d3_selectionPrototype.empty = function() {
1040    return !this.node();
1041  };
1042  d3_selectionPrototype.node = function() {
1043    for (var j = 0, m = this.length; j < m; j++) {
1044      for (var group = this[j], i = 0, n = group.length; i < n; i++) {
1045        var node = group[i];
1046        if (node) return node;
1047      }
1048    }
1049    return null;
1050  };
1051  function d3_selection_enter(selection) {
1052    d3_arraySubclass(selection, d3_selection_enterPrototype);
1053    return selection;
1054  }
1055  var d3_selection_enterPrototype = [];
1056  d3.selection.enter = d3_selection_enter;
1057  d3.selection.enter.prototype = d3_selection_enterPrototype;
1058  d3_selection_enterPrototype.append = d3_selectionPrototype.append;
1059  d3_selection_enterPrototype.insert = d3_selectionPrototype.insert;
1060  d3_selection_enterPrototype.empty = d3_selectionPrototype.empty;
1061  d3_selection_enterPrototype.node = d3_selectionPrototype.node;
1062  d3_selection_enterPrototype.select = function(selector) {
1063    var subgroups = [], subgroup, subnode, upgroup, group, node;
1064    for (var j = -1, m = this.length; ++j < m; ) {
1065      upgroup = (group = this[j]).update;
1066      subgroups.push(subgroup = []);
1067      subgroup.parentNode = group.parentNode;
1068      for (var i = -1, n = group.length; ++i < n; ) {
1069        if (node = group[i]) {
1070          subgroup.push(upgroup[i] = subnode = selector.call(group.parentNode, node.__data__, i));
1071          subnode.__data__ = node.__data__;
1072        } else {
1073          subgroup.push(null);
1074        }
1075      }
1076    }
1077    return d3_selection(subgroups);
1078  };
1079  d3_selectionPrototype.transition = function() {
1080    var id = d3_transitionInheritId || ++d3_transitionId, subgroups = [], subgroup, node, transition = Object.create(d3_transitionInherit);
1081    transition.time = Date.now();
1082    for (var j = -1, m = this.length; ++j < m; ) {
1083      subgroups.push(subgroup = []);
1084      for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
1085        if (node = group[i]) d3_transitionNode(node, i, id, transition);
1086        subgroup.push(node);
1087      }
1088    }
1089    return d3_transition(subgroups, id);
1090  };
1091  var d3_selectionRoot = d3_selection([ [ d3_document ] ]);
1092  d3_selectionRoot[0].parentNode = d3_selectRoot;
1093  d3.select = function(selector) {
1094    return typeof selector === "string" ? d3_selectionRoot.select(selector) : d3_selection([ [ selector ] ]);
1095  };
1096  d3.selectAll = function(selector) {
1097    return typeof selector === "string" ? d3_selectionRoot.selectAll(selector) : d3_selection([ d3_array(selector) ]);
1098  };
1099  d3.behavior.zoom = function() {
1100    var translate = [ 0, 0 ], translate0, scale = 1, scale0, scaleExtent = d3_behavior_zoomInfinity, event = d3_eventDispatch(zoom, "zoom"), x0, x1, y0, y1, touchtime;
1101    function zoom() {
1102      this.on("mousedown.zoom", mousedown).on("mousemove.zoom", mousemove).on(d3_behavior_zoomWheel + ".zoom", mousewheel).on("dblclick.zoom", dblclick).on("touchstart.zoom", touchstart).on("touchmove.zoom", touchmove).on("touchend.zoom", touchstart);
1103    }
1104    zoom.translate = function(x) {
1105      if (!arguments.length) return translate;
1106      translate = x.map(Number);
1107      rescale();
1108      return zoom;
1109    };
1110    zoom.scale = function(x) {
1111      if (!arguments.length) return scale;
1112      scale = +x;
1113      rescale();
1114      return zoom;
1115    };
1116    zoom.scaleExtent = function(x) {
1117      if (!arguments.length) return scaleExtent;
1118      scaleExtent = x == null ? d3_behavior_zoomInfinity : x.map(Number);
1119      return zoom;
1120    };
1121    zoom.x = function(z) {
1122      if (!arguments.length) return x1;
1123      x1 = z;
1124      x0 = z.copy();
1125      translate = [ 0, 0 ];
1126      scale = 1;
1127      return zoom;
1128    };
1129    zoom.y = function(z) {
1130      if (!arguments.length) return y1;
1131      y1 = z;
1132      y0 = z.copy();
1133      translate = [ 0, 0 ];
1134      scale = 1;
1135      return zoom;
1136    };
1137    function location(p) {
1138      return [ (p[0] - translate[0]) / scale, (p[1] - translate[1]) / scale ];
1139    }
1140    function point(l) {
1141      return [ l[0] * scale + translate[0], l[1] * scale + translate[1] ];
1142    }
1143    function scaleTo(s) {
1144      scale = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s));
1145    }
1146    function translateTo(p, l) {
1147      l = point(l);
1148      translate[0] += p[0] - l[0];
1149      translate[1] += p[1] - l[1];
1150    }
1151    function rescale() {
1152      if (x1) x1.domain(x0.range().map(function(x) {
1153        return (x - translate[0]) / scale;
1154      }).map(x0.invert));
1155      if (y1) y1.domain(y0.range().map(function(y) {
1156        return (y - translate[1]) / scale;
1157      }).map(y0.invert));
1158    }
1159    function dispatch(event) {
1160      rescale();
1161      d3.event.preventDefault();
1162      event({
1163        type: "zoom",
1164        scale: scale,
1165        translate: translate
1166      });
1167    }
1168    function mousedown() {
1169      var target = this, event_ = event.of(target, arguments), eventTarget = d3.event.target, moved = 0, w = d3.select(d3_window).on("mousemove.zoom", mousemove).on("mouseup.zoom", mouseup), l = location(d3.mouse(target));
1170      d3_window.focus();
1171      d3_eventCancel();
1172      function mousemove() {
1173        moved = 1;
1174        translateTo(d3.mouse(target), l);
1175        dispatch(event_);
1176      }
1177      function mouseup() {
1178        if (moved) d3_eventCancel();
1179        w.on("mousemove.zoom", null).on("mouseup.zoom", null);
1180        if (moved && d3.event.target === eventTarget) d3_eventSuppress(w, "click.zoom");
1181      }
1182    }
1183    function mousewheel() {

1184      if (!translate0) translate0 = location(d3.mouse(this));
1185      scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * scale);
1186      translateTo(d3.mouse(this), translate0);
1187      dispatch(event.of(this, arguments));
1188    }
1189    function mousemove() {
1190      translate0 = null;
1191    }
1192    function dblclick() {
1193      var p = d3.mouse(this), l = location(p), k = Math.log(scale) / Math.LN2;
1194      scaleTo(Math.pow(2, d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1));
1195      translateTo(p, l);
1196      dispatch(event.of(this, arguments));
1197    }
1198    function touchstart() {
1199      var touches = d3.touches(this), now = Date.now();
1200      scale0 = scale;
1201      translate0 = {};
1202      touches.forEach(function(t) {
1203        translate0[t.identifier] = location(t);
1204      });
1205      d3_eventCancel();
1206      if (touches.length === 1) {
1207        if (now - touchtime < 500) {
1208          var p = touches[0], l = location(touches[0]);
1209          scaleTo(scale * 2);
1210          translateTo(p, l);
1211          dispatch(event.of(this, arguments));
1212        }
1213        touchtime = now;
1214      }
1215    }
1216    function touchmove() {
1217      var touches = d3.touches(this), p0 = touches[0], l0 = translate0[p0.identifier];
1218      if (p1 = touches[1]) {
1219        var p1, l1 = translate0[p1.identifier];
1220        p0 = [ (p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2 ];
1221        l0 = [ (l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2 ];
1222        scaleTo(d3.event.scale * scale0);
1223      }
1224      translateTo(p0, l0);
1225      touchtime = null;
1226      dispatch(event.of(this, arguments));
1227    }
1228    return d3.rebind(zoom, event, "on");
1229  };
1230  var d3_behavior_zoomInfinity = [ 0, Infinity ];
1231  var d3_behavior_zoomDelta, d3_behavior_zoomWheel = "onwheel" in d3_document ? (d3_behavior_zoomDelta = function() {
1232    return -d3.event.deltaY * (d3.event.deltaMode ? 120 : 1);
1233  }, "wheel") : "onmousewheel" in d3_document ? (d3_behavior_zoomDelta = function() {
1234    return d3.event.wheelDelta;
1235  }, "mousewheel") : (d3_behavior_zoomDelta = function() {
1236    return -d3.event.detail;
1237  }, "MozMousePixelScroll");
1238  function d3_Color() {}
1239  d3_Color.prototype.toString = function() {
1240    return this.rgb() + "";
1241  };
1242  d3.hsl = function(h, s, l) {
1243    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);
1244  };
1245  function d3_hsl(h, s, l) {
1246    return new d3_Hsl(h, s, l);
1247  }
1248  function d3_Hsl(h, s, l) {
1249    this.h = h;
1250    this.s = s;
1251    this.l = l;
1252  }
1253  var d3_hslPrototype = d3_Hsl.prototype = new d3_Color();
1254  d3_hslPrototype.brighter = function(k) {
1255    k = Math.pow(.7, arguments.length ? k : 1);
1256    return d3_hsl(this.h, this.s, this.l / k);
1257  };
1258  d3_hslPrototype.darker = function(k) {
1259    k = Math.pow(.7, arguments.length ? k : 1);
1260    return d3_hsl(this.h, this.s, k * this.l);
1261  };
1262  d3_hslPrototype.rgb = function() {
1263    return d3_hsl_rgb(this.h, this.s, this.l);
1264  };
1265  function d3_hsl_rgb(h, s, l) {
1266    var m1, m2;
1267    h = h % 360;
1268    if (h < 0) h += 360;
1269    s = s < 0 ? 0 : s > 1 ? 1 : s;
1270    l = l < 0 ? 0 : l > 1 ? 1 : l;
1271    m2 = l <= .5 ? l * (1 + s) : l + s - l * s;
1272    m1 = 2 * l - m2;
1273    function v(h) {
1274      if (h > 360) h -= 360; else if (h < 0) h += 360;
1275      if (h < 60) return m1 + (m2 - m1) * h / 60;
1276      if (h < 180) return m2;
1277      if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60;
1278      return m1;
1279    }
1280    function vv(h) {
1281      return Math.round(v(h) * 255);
1282    }
1283    return d3_rgb(vv(h + 120), vv(h), vv(h - 120));
1284  }
1285  var π = Math.PI, ε = 1e-6, d3_radians = π / 180, d3_degrees = 180 / π;
1286  function d3_sgn(x) {
1287    return x > 0 ? 1 : x < 0 ? -1 : 0;
1288  }
1289  function d3_acos(x) {
1290    return Math.acos(Math.max(-1, Math.min(1, x)));
1291  }
1292  function d3_asin(x) {
1293    return x > 1 ? π / 2 : x < -1 ? -π / 2 : Math.asin(x);
1294  }
1295  function d3_sinh(x) {
1296    return (Math.exp(x) - Math.exp(-x)) / 2;
1297  }
1298  function d3_cosh(x) {
1299    return (Math.exp(x) + Math.exp(-x)) / 2;
1300  }
1301  function d3_haversin(x) {
1302    return (x = Math.sin(x / 2)) * x;
1303  }
1304  d3.hcl = function(h, c, l) {
1305    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);
1306  };
1307  function d3_hcl(h, c, l) {
1308    return new d3_Hcl(h, c, l);
1309  }
1310  function d3_Hcl(h, c, l) {
1311    this.h = h;
1312    this.c = c;
1313    this.l = l;
1314  }
1315  var d3_hclPrototype = d3_Hcl.prototype = new d3_Color();
1316  d3_hclPrototype.brighter = function(k) {
1317    return d3_hcl(this.h, this.c, Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)));
1318  };
1319  d3_hclPrototype.darker = function(k) {
1320    return d3_hcl(this.h, this.c, Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)));
1321  };
1322  d3_hclPrototype.rgb = function() {
1323    return d3_hcl_lab(this.h, this.c, this.l).rgb();
1324  };
1325  function d3_hcl_lab(h, c, l) {
1326    return d3_lab(l, Math.cos(h *= d3_radians) * c, Math.sin(h) * c);
1327  }
1328  d3.lab = function(l, a, b) {
1329    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);
1330  };
1331  function d3_lab(l, a, b) {
1332    return new d3_Lab(l, a, b);
1333  }
1334  function d3_Lab(l, a, b) {
1335    this.l = l;
1336    this.a = a;
1337    this.b = b;
1338  }
1339  var d3_lab_K = 18;
1340  var d3_lab_X = .95047, d3_lab_Y = 1, d3_lab_Z = 1.08883;
1341  var d3_labPrototype = d3_Lab.prototype = new d3_Color();
1342  d3_labPrototype.brighter = function(k) {
1343    return d3_lab(Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)), this.a, this.b);
1344  };
1345  d3_labPrototype.darker = function(k) {
1346    return d3_lab(Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)), this.a, this.b);
1347  };
1348  d3_labPrototype.rgb = function() {
1349    return d3_lab_rgb(this.l, this.a, this.b);
1350  };
1351  function d3_lab_rgb(l, a, b) {
1352    var y = (l + 16) / 116, x = y + a / 500, z = y - b / 200;
1353    x = d3_lab_xyz(x) * d3_lab_X;
1354    y = d3_lab_xyz(y) * d3_lab_Y;
1355    z = d3_lab_xyz(z) * d3_lab_Z;
1356    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));
1357  }
1358  function d3_lab_hcl(l, a, b) {
1359    return d3_hcl(Math.atan2(b, a) * d3_degrees, Math.sqrt(a * a + b * b), l);
1360  }
1361  function d3_lab_xyz(x) {
1362    return x > .206893034 ? x * x * x : (x - 4 / 29) / 7.787037;
1363  }
1364  function d3_xyz_lab(x) {
1365    return x > .008856 ? Math.pow(x, 1 / 3) : 7.787037 * x + 4 / 29;
1366  }
1367  function d3_xyz_rgb(r) {
1368    return Math.round(255 * (r <= .00304 ? 12.92 * r : 1.055 * Math.pow(r, 1 / 2.4) - .055));
1369  }
1370  d3.rgb = function(r, g, b) {
1371    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);
1372  };
1373  function d3_rgb(r, g, b) {
1374    return new d3_Rgb(r, g, b);
1375  }
1376  function d3_Rgb(r, g, b) {
1377    this.r = r;
1378    this.g = g;
1379    this.b = b;
1380  }
1381  var d3_rgbPrototype = d3_Rgb.prototype = new d3_Color();
1382  d3_rgbPrototype.brighter = function(k) {
1383    k = Math.pow(.7, arguments.length ? k : 1);
1384    var r = this.r, g = this.g, b = this.b, i = 30;
1385    if (!r && !g && !b) return d3_rgb(i, i, i);
1386    if (r && r < i) r = i;
1387    if (g && g < i) g = i;
1388    if (b && b < i) b = i;
1389    return d3_rgb(Math.min(255, Math.floor(r / k)), Math.min(255, Math.floor(g / k)), Math.min(255, Math.floor(b / k)));
1390  };
1391  d3_rgbPrototype.darker = function(k) {
1392    k = Math.pow(.7, arguments.length ? k : 1);
1393    return d3_rgb(Math.floor(k * this.r), Math.floor(k * this.g), Math.floor(k * this.b));
1394  };
1395  d3_rgbPrototype.hsl = function() {
1396    return d3_rgb_hsl(this.r, this.g, this.b);
1397  };
1398  d3_rgbPrototype.toString = function() {
1399    return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b);
1400  };
1401  function d3_rgb_hex(v) {
1402    return v < 16 ? "0" + Math.max(0, v).toString(16) : Math.min(255, v).toString(16);
1403  }
1404  function d3_rgb_parse(format, rgb, hsl) {
1405    var r = 0, g = 0, b = 0, m1, m2, name;
1406    m1 = /([a-z]+)\((.*)\)/i.exec(format);
1407    if (m1) {
1408      m2 = m1[2].split(",");
1409      switch (m1[1]) {
1410       case "hsl":
1411        {
1412          return hsl(parseFloat(m2[0]), parseFloat(m2[1]) / 100, parseFloat(m2[2]) / 100);
1413        }
1414
1415       case "rgb":
1416        {
1417          return rgb(d3_rgb_parseNumber(m2[0]), d3_rgb_parseNumber(m2[1]), d3_rgb_parseNumber(m2[2]));
1418        }
1419      }
1420    }
1421    if (name = d3_rgb_names.get(format)) return rgb(name.r, name.g, name.b);
1422    if (format != null && format.charAt(0) === "#") {
1423      if (format.length === 4) {
1424        r = format.charAt(1);
1425        r += r;
1426        g = format.charAt(2);
1427        g += g;
1428        b = format.charAt(3);
1429        b += b;
1430      } else if (format.length === 7) {
1431        r = format.substring(1, 3);
1432        g = format.substring(3, 5);
1433        b = format.substring(5, 7);
1434      }
1435      r = parseInt(r, 16);
1436      g = parseInt(g, 16);
1437      b = parseInt(b, 16);
1438    }
1439    return rgb(r, g, b);
1440  }
1441  function d3_rgb_hsl(r, g, b) {
1442    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;
1443    if (d) {
1444      s = l < .5 ? d / (max + min) : d / (2 - max - min);
1445      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;
1446      h *= 60;
1447    } else {
1448      s = h = 0;
1449    }
1450    return d3_hsl(h, s, l);
1451  }
1452  function d3_rgb_lab(r, g, b) {
1453    r = d3_rgb_xyz(r);
1454    g = d3_rgb_xyz(g);
1455    b = d3_rgb_xyz(b);
1456    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);
1457    return d3_lab(116 * y - 16, 500 * (x - y), 200 * (y - z));
1458  }
1459  function d3_rgb_xyz(r) {

1460    return (r /= 255) <= .04045 ? r / 12.92 : Math.pow((r + .055) / 1.055, 2.4);
1461  }
1462  function d3_rgb_parseNumber(c) {
1463    var f = parseFloat(c);
1464    return c.charAt(c.length - 1) === "%" ? Math.round(f * 2.55) : f;
1465  }
1466  var d3_rgb_names = d3.map({
1467    aliceblue: "#f0f8ff",
1468    antiquewhite: "#faebd7",
1469    aqua: "#00ffff",
1470    aquamarine: "#7fffd4",
1471    azure: "#f0ffff",
1472    beige: "#f5f5dc",
1473    bisque: "#ffe4c4",
1474    black: "#000000",
1475    blanchedalmond: "#ffebcd",
1476    blue: "#0000ff",
1477    blueviolet: "#8a2be2",
1478    brown: "#a52a2a",
1479    burlywood: "#deb887",
1480    cadetblue: "#5f9ea0",
1481    chartreuse: "#7fff00",
1482    chocolate: "#d2691e",
1483    coral: "#ff7f50",
1484    cornflowerblue: "#6495ed",
1485    cornsilk: "#fff8dc",
1486    crimson: "#dc143c",
1487    cyan: "#00ffff",
1488    darkblue: "#00008b",
1489    darkcyan: "#008b8b",
1490    darkgoldenrod: "#b8860b",
1491    darkgray: "#a9a9a9",
1492    darkgreen: "#006400",
1493    darkgrey: "#a9a9a9",
1494    darkkhaki: "#bdb76b",
1495    darkmagenta: "#8b008b",
1496    darkolivegreen: "#556b2f",
1497    darkorange: "#ff8c00",
1498    darkorchid: "#9932cc",
1499    darkred: "#8b0000",
1500    darksalmon: "#e9967a",
1501    darkseagreen: "#8fbc8f",
1502    darkslateblue: "#483d8b",
1503    darkslategray: "#2f4f4f",
1504    darkslategrey: "#2f4f4f",
1505    darkturquoise: "#00ced1",
1506    darkviolet: "#9400d3",
1507    deeppink: "#ff1493",
1508    deepskyblue: "#00bfff",
1509    dimgray: "#696969",
1510    dimgrey: "#696969",
1511    dodgerblue: "#1e90ff",
1512    firebrick: "#b22222",
1513    floralwhite: "#fffaf0",
1514    forestgreen: "#228b22",
1515    fuchsia: "#ff00ff",
1516    gainsboro: "#dcdcdc",
1517    ghostwhite: "#f8f8ff",
1518    gold: "#ffd700",
1519    goldenrod: "#daa520",
1520    gray: "#808080",
1521    green: "#008000",
1522    greenyellow: "#adff2f",
1523    grey: "#808080",
1524    honeydew: "#f0fff0",
1525    hotpink: "#ff69b4",
1526    indianred: "#cd5c5c",
1527    indigo: "#4b0082",
1528    ivory: "#fffff0",
1529    khaki: "#f0e68c",
1530    lavender: "#e6e6fa",
1531    lavenderblush: "#fff0f5",
1532    lawngreen: "#7cfc00",
1533    lemonchiffon: "#fffacd",
1534    lightblue: "#add8e6",
1535    lightcoral: "#f08080",
1536    lightcyan: "#e0ffff",
1537    lightgoldenrodyellow: "#fafad2",
1538    lightgray: "#d3d3d3",
1539    lightgreen: "#90ee90",
1540    lightgrey: "#d3d3d3",
1541    lightpink: "#ffb6c1",
1542    lightsalmon: "#ffa07a",
1543    lightseagreen: "#20b2aa",
1544    lightskyblue: "#87cefa",
1545    lightslategray: "#778899",
1546    lightslategrey: "#778899",
1547    lightsteelblue: "#b0c4de",
1548    lightyellow: "#ffffe0",
1549    lime: "#00ff00",
1550    limegreen: "#32cd32",
1551    linen: "#faf0e6",
1552    magenta: "#ff00ff",
1553    maroon: "#800000",
1554    mediumaquamarine: "#66cdaa",
1555    mediumblue: "#0000cd",
1556    mediumorchid: "#ba55d3",
1557    mediumpurple: "#9370db",
1558    mediumseagreen: "#3cb371",
1559    mediumslateblue: "#7b68ee",
1560    mediumspringgreen: "#00fa9a",
1561    mediumturquoise: "#48d1cc",
1562    mediumvioletred: "#c71585",
1563    midnightblue: "#191970",
1564    mintcream: "#f5fffa",
1565    mistyrose: "#ffe4e1",
1566    moccasin: "#ffe4b5",
1567    navajowhite: "#ffdead",
1568    navy: "#000080",
1569    oldlace: "#fdf5e6",
1570    olive: "#808000",
1571    olivedrab: "#6b8e23",
1572    orange: "#ffa500",
1573    orangered: "#ff4500",
1574    orchid: "#da70d6",
1575    palegoldenrod: "#eee8aa",
1576    palegreen: "#98fb98",
1577    paleturquoise: "#afeeee",
1578    palevioletred: "#db7093",
1579    papayawhip: "#ffefd5",
1580    peachpuff: "#ffdab9",
1581    peru: "#cd853f",
1582    pink: "#ffc0cb",
1583    plum: "#dda0dd",
1584    powderblue: "#b0e0e6",
1585    purple: "#800080",
1586    red: "#ff0000",
1587    rosybrown: "#bc8f8f",
1588    royalblue: "#4169e1",
1589    saddlebrown: "#8b4513",
1590    salmon: "#fa8072",
1591    sandybrown: "#f4a460",
1592    seagreen: "#2e8b57",
1593    seashell: "#fff5ee",
1594    sienna: "#a0522d",
1595    silver: "#c0c0c0",
1596    skyblue: "#87ceeb",
1597    slateblue: "#6a5acd",
1598    slategray: "#708090",
1599    slategrey: "#708090",
1600    snow: "#fffafa",
1601    springgreen: "#00ff7f",
1602    steelblue: "#4682b4",
1603    tan: "#d2b48c",
1604    teal: "#008080",
1605    thistle: "#d8bfd8",
1606    tomato: "#ff6347",
1607    turquoise: "#40e0d0",
1608    violet: "#ee82ee",
1609    wheat: "#f5deb3",
1610    white: "#ffffff",
1611    whitesmoke: "#f5f5f5",
1612    yellow: "#ffff00",
1613    yellowgreen: "#9acd32"
1614  });
1615  d3_rgb_names.forEach(function(key, value) {
1616    d3_rgb_names.set(key, d3_rgb_parse(value, d3_rgb, d3_hsl_rgb));
1617  });
1618  function d3_functor(v) {
1619    return typeof v === "function" ? v : function() {
1620      return v;
1621    };
1622  }
1623  d3.functor = d3_functor;
1624  function d3_identity(d) {
1625    return d;
1626  }
1627  d3.xhr = function(url, mimeType, callback) {
1628    var xhr = {}, dispatch = d3.dispatch("progress", "load", "error"), headers = {}, response = d3_identity, request = new (d3_window.XDomainRequest && /^(http(s)?:)?\/\//.test(url) ? XDomainRequest : XMLHttpRequest)();
1629    "onload" in request ? request.onload = request.onerror = respond : request.onreadystatechange = function() {
1630      request.readyState > 3 && respond();
1631    };
1632    function respond() {
1633      var s = request.status;
1634      !s && request.responseText || s >= 200 && s < 300 || s === 304 ? dispatch.load.call(xhr, response.call(xhr, request)) : dispatch.error.call(xhr, request);
1635    }
1636    request.onprogress = function(event) {
1637      var o = d3.event;
1638      d3.event = event;

1639      try {
1640        dispatch.progress.call(xhr, request);
1641      } finally {
1642        d3.event = o;
1643      }
1644    };
1645    xhr.header = function(name, value) {
1646      name = (name + "").toLowerCase();
1647      if (arguments.length < 2) return headers[name];
1648      if (value == null) delete headers[name]; else headers[name] = value + "";
1649      return xhr;
1650    };
1651    xhr.mimeType = function(value) {
1652      if (!arguments.length) return mimeType;
1653      mimeType = value == null ? null : value + "";
1654      return xhr;
1655    };
1656    xhr.response = function(value) {
1657      response = value;
1658      return xhr;
1659    };
1660    [ "get", "post" ].forEach(function(method) {
1661      xhr[method] = function() {
1662        return xhr.send.apply(xhr, [ method ].concat(d3_array(arguments)));
1663      };
1664    });
1665    xhr.send = function(method, data, callback) {
1666      if (arguments.length === 2 && typeof data === "function") callback = data, data = null;
1667      request.open(method, url, true);
1668      if (mimeType != null && !("accept" in headers)) headers["accept"] = mimeType + ",*/*";
1669      if (request.setRequestHeader) for (var name in headers) request.setRequestHeader(name, headers[name]);
1670      if (mimeType != null && request.overrideMimeType) request.overrideMimeType(mimeType);
1671      if (callback != null) xhr.on("error", callback).on("load", function(request) {
1672        callback(null, request);
1673      });
1674      request.send(data == null ? null : data);
1675      return xhr;
1676    };
1677    xhr.abort = function() {
1678      request.abort();
1679      return xhr;
1680    };
1681    d3.rebind(xhr, dispatch, "on");
1682    if (arguments.length === 2 && typeof mimeType === "function") callback = mimeType, 
1683    mimeType = null;
1684    return callback == null ? xhr : xhr.get(d3_xhr_fixCallback(callback));
1685  };
1686  function d3_xhr_fixCallback(callback) {
1687    return callback.length === 1 ? function(error, request) {
1688      callback(error == null ? request : null);
1689    } : callback;
1690  }
1691  function d3_dsv(delimiter, mimeType) {
1692    var reFormat = new RegExp('["' + delimiter + "\n]"), delimiterCode = delimiter.charCodeAt(0);
1693    function dsv(url, row, callback) {
1694      if (arguments.length < 3) callback = row, row = null;
1695      var xhr = d3.xhr(url, mimeType, callback);
1696      xhr.row = function(_) {
1697        return arguments.length ? xhr.response((row = _) == null ? response : typedResponse(_)) : row;
1698      };
1699      return xhr.row(row);
1700    }
1701    function response(request) {
1702      return dsv.parse(request.responseText);
1703    }
1704    function typedResponse(f) {
1705      return function(request) {
1706        return dsv.parse(request.responseText, f);
1707      };
1708    }
1709    dsv.parse = function(text, f) {
1710      var o;
1711      return dsv.parseRows(text, function(row, i) {
1712        if (o) return o(row, i - 1);
1713        var a = new Function("d", "return {" + row.map(function(name, i) {
1714          return JSON.stringify(name) + ": d[" + i + "]";
1715        }).join(",") + "}");
1716        o = f ? function(row, i) {
1717          return f(a(row), i);
1718        } : a;
1719      });
1720    };
1721    dsv.parseRows = function(text, f) {
1722      var EOL = {}, EOF = {}, rows = [], N = text.length, I = 0, n = 0, t, eol;
1723      function token() {
1724        if (I >= N) return EOF;
1725        if (eol) return eol = false, EOL;
1726        var j = I;
1727        if (text.charCodeAt(j) === 34) {
1728          var i = j;
1729          while (i++ < N) {
1730            if (text.charCodeAt(i) === 34) {
1731              if (text.charCodeAt(i + 1) !== 34) break;
1732              ++i;
1733            }
1734          }
1735          I = i + 2;
1736          var c = text.charCodeAt(i + 1);
1737          if (c === 13) {
1738            eol = true;
1739            if (text.charCodeAt(i + 2) === 10) ++I;
1740          } else if (c === 10) {
1741            eol = true;
1742          }
1743          return text.substring(j + 1, i).replace(/""/g, '"');
1744        }
1745        while (I < N) {
1746          var c = text.charCodeAt(I++), k = 1;
1747          if (c === 10) eol = true; else if (c === 13) {
1748            eol = true;
1749            if (text.charCodeAt(I) === 10) ++I, ++k;
1750          } else if (c !== delimiterCode) continue;
1751          return text.substring(j, I - k);
1752        }
1753        return text.substring(j);
1754      }
1755      while ((t = token()) !== EOF) {
1756        var a = [];
1757        while (t !== EOL && t !== EOF) {
1758          a.push(t);
1759          t = token();
1760        }
1761        if (f && !(a = f(a, n++))) continue;
1762        rows.push(a);
1763      }
1764      return rows;
1765    };
1766    dsv.format = function(rows) {
1767      if (Array.isArray(rows[0])) return dsv.formatRows(rows);
1768      var fieldSet = new d3_Set(), fields = [];
1769      rows.forEach(function(row) {
1770        for (var field in row) {
1771          if (!fieldSet.has(field)) {
1772            fields.push(fieldSet.add(field));
1773          }
1774        }
1775      });
1776      return [ fields.map(formatValue).join(delimiter) ].concat(rows.map(function(row) {
1777        return fields.map(function(field) {
1778          return formatValue(row[field]);
1779        }).join(delimiter);
1780      })).join("\n");
1781    };
1782    dsv.formatRows = function(rows) {
1783      return rows.map(formatRow).join("\n");
1784    };
1785    function formatRow(row) {
1786      return row.map(formatValue).join(delimiter);
1787    }
1788    function formatValue(text) {
1789      return reFormat.test(text) ? '"' + text.replace(/\"/g, '""') + '"' : text;
1790    }
1791    return dsv;
1792  }
1793  d3.csv = d3_dsv(",", "text/csv");
1794  d3.tsv = d3_dsv("	", "text/tab-separated-values");
1795  var d3_timer_id = 0, d3_timer_byId = {}, d3_timer_queue = null, d3_timer_interval, d3_timer_timeout;
1796  d3.timer = function(callback, delay, then) {
1797    if (arguments.length < 3) {
1798      if (arguments.length < 2) delay = 0; else if (!isFinite(delay)) return;
1799      then = Date.now();
1800    }
1801    var timer = d3_timer_byId[callback.id];
1802    if (timer && timer.callback === callback) {
1803      timer.then = then;
1804      timer.delay = delay;
1805    } else d3_timer_byId[callback.id = ++d3_timer_id] = d3_timer_queue = {
1806      callback: callback,
1807      then: then,
1808      delay: delay,
1809      next: d3_timer_queue
1810    };
1811    if (!d3_timer_interval) {
1812      d3_timer_timeout = clearTimeout(d3_timer_timeout);
1813      d3_timer_interval = 1;
1814      d3_timer_frame(d3_timer_step);
1815    }
1816  };
1817  function d3_timer_step() {
1818    var elapsed, now = Date.now(), t1 = d3_timer_queue;
1819    while (t1) {

1820      elapsed = now - t1.then;
1821      if (elapsed >= t1.delay) t1.flush = t1.callback(elapsed);
1822      t1 = t1.next;
1823    }
1824    var delay = d3_timer_flush() - now;
1825    if (delay > 24) {
1826      if (isFinite(delay)) {
1827        clearTimeout(d3_timer_timeout);
1828        d3_timer_timeout = setTimeout(d3_timer_step, delay);
1829      }
1830      d3_timer_interval = 0;
1831    } else {
1832      d3_timer_interval = 1;
1833      d3_timer_frame(d3_timer_step);
1834    }
1835  }
1836  d3.timer.flush = function() {
1837    var elapsed, now = Date.now(), t1 = d3_timer_queue;
1838    while (t1) {
1839      elapsed = now - t1.then;
1840      if (!t1.delay) t1.flush = t1.callback(elapsed);
1841      t1 = t1.next;
1842    }
1843    d3_timer_flush();
1844  };
1845  function d3_timer_flush() {
1846    var t0 = null, t1 = d3_timer_queue, then = Infinity;
1847    while (t1) {
1848      if (t1.flush) {
1849        delete d3_timer_byId[t1.callback.id];
1850        t1 = t0 ? t0.next = t1.next : d3_timer_queue = t1.next;
1851      } else {
1852        then = Math.min(then, t1.then + t1.delay);
1853        t1 = (t0 = t1).next;
1854      }
1855    }
1856    return then;
1857  }
1858  var d3_timer_frame = d3_window.requestAnimationFrame || d3_window.webkitRequestAnimationFrame || d3_window.mozRequestAnimationFrame || d3_window.oRequestAnimationFrame || d3_window.msRequestAnimationFrame || function(callback) {
1859    setTimeout(callback, 17);
1860  };
1861  var d3_format_decimalPoint = ".", d3_format_thousandsSeparator = ",", d3_format_grouping = [ 3, 3 ];
1862  var d3_formatPrefixes = [ "y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y" ].map(d3_formatPrefix);
1863  d3.formatPrefix = function(value, precision) {
1864    var i = 0;
1865    if (value) {
1866      if (value < 0) value *= -1;
1867      if (precision) value = d3.round(value, d3_format_precision(value, precision));
1868      i = 1 + Math.floor(1e-12 + Math.log(value) / Math.LN10);
1869      i = Math.max(-24, Math.min(24, Math.floor((i <= 0 ? i + 1 : i - 1) / 3) * 3));
1870    }
1871    return d3_formatPrefixes[8 + i / 3];
1872  };
1873  function d3_formatPrefix(d, i) {
1874    var k = Math.pow(10, Math.abs(8 - i) * 3);
1875    return {
1876      scale: i > 8 ? function(d) {
1877        return d / k;
1878      } : function(d) {
1879        return d * k;
1880      },
1881      symbol: d
1882    };
1883  }
1884  d3.round = function(x, n) {
1885    return n ? Math.round(x * (n = Math.pow(10, n))) / n : Math.round(x);
1886  };
1887  d3.format = function(specifier) {
1888    var match = d3_format_re.exec(specifier), fill = match[1] || " ", align = match[2] || ">", sign = match[3] || "", basePrefix = match[4] || "", zfill = match[5], width = +match[6], comma = match[7], precision = match[8], type = match[9], scale = 1, suffix = "", integer = false;
1889    if (precision) precision = +precision.substring(1);
1890    if (zfill || fill === "0" && align === "=") {
1891      zfill = fill = "0";
1892      align = "=";
1893      if (comma) width -= Math.floor((width - 1) / 4);
1894    }
1895    switch (type) {
1896     case "n":
1897      comma = true;
1898      type = "g";
1899      break;
1900
1901     case "%":
1902      scale = 100;
1903      suffix = "%";
1904      type = "f";
1905      break;
1906
1907     case "p":
1908      scale = 100;
1909      suffix = "%";
1910      type = "r";
1911      break;
1912
1913     case "b":
1914     case "o":
1915     case "x":
1916     case "X":
1917      if (basePrefix) basePrefix = "0" + type.toLowerCase();
1918
1919     case "c":
1920     case "d":
1921      integer = true;
1922      precision = 0;
1923      break;
1924
1925     case "s":
1926      scale = -1;
1927      type = "r";
1928      break;
1929    }
1930    if (basePrefix === "#") basePrefix = "";
1931    if (type == "r" && !precision) type = "g";
1932    if (precision != null) {
1933      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));
1934    }
1935    type = d3_format_types.get(type) || d3_format_typeDefault;
1936    var zcomma = zfill && comma;
1937    return function(value) {
1938      if (integer && value % 1) return "";
1939      var negative = value < 0 || value === 0 && 1 / value < 0 ? (value = -value, "-") : sign;
1940      if (scale < 0) {
1941        var prefix = d3.formatPrefix(value, precision);
1942        value = prefix.scale(value);
1943        suffix = prefix.symbol;
1944      } else {
1945        value *= scale;
1946      }
1947      value = type(value, precision);
1948      if (!zfill && comma) value = d3_format_group(value);
1949      var length = basePrefix.length + value.length + (zcomma ? 0 : negative.length), padding = length < width ? new Array(length = width - length + 1).join(fill) : "";
1950      if (zcomma) value = d3_format_group(padding + value);
1951      if (d3_format_decimalPoint) value.replace(".", d3_format_decimalPoint);
1952      negative += basePrefix;
1953      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)) + suffix;
1954    };
1955  };
1956  var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?(#)?(0)?(\d+)?(,)?(\.-?\d+)?([a-z%])?/i;
1957  var d3_format_types = d3.map({
1958    b: function(x) {
1959      return x.toString(2);
1960    },
1961    c: function(x) {
1962      return String.fromCharCode(x);
1963    },
1964    o: function(x) {
1965      return x.toString(8);
1966    },
1967    x: function(x) {
1968      return x.toString(16);
1969    },
1970    X: function(x) {
1971      return x.toString(16).toUpperCase();
1972    },
1973    g: function(x, p) {
1974      return x.toPrecision(p);
1975    },
1976    e: function(x, p) {
1977      return x.toExponential(p);
1978    },
1979    f: function(x, p) {
1980      return x.toFixed(p);
1981    },
1982    r: function(x, p) {
1983      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))));
1984    }
1985  });
1986  function d3_format_precision(x, p) {
1987    return p - (x ? Math.ceil(Math.log(x) / Math.LN10) : 1);
1988  }
1989  function d3_format_typeDefault(x) {
1990    return x + "";
1991  }
1992  var d3_format_group = d3_identity;
1993  if (d3_format_grouping) {
1994    var d3_format_groupingLength = d3_format_grouping.length;
1995    d3_format_group = function(value) {
1996      var i = value.lastIndexOf("."), f = i >= 0 ? "." + value.substring(i + 1) : (i = value.length, 
1997      ""), t = [], j = 0, g = d3_format_grouping[0];
1998      while (i > 0 && g > 0) {
1999        t.push(value.substring(i -= g, i + g));
2000        g = d3_format_grouping[j = (j + 1) % d3_format_groupingLength];
2001      }
2002      return t.reverse().join(d3_format_thousandsSeparator || "") + f;
2003    };
2004  }
2005  d3.geo = {};
2006  d3.geo.stream = function(object, listener) {
2007    if (object && d3_geo_streamObjectType.hasOwnProperty(object.type)) {
2008      d3_geo_streamObjectType[object.type](object, listener);
2009    } else {
2010      d3_geo_streamGeometry(object, listener);
2011    }
2012  };
2013  function d3_geo_streamGeometry(geometry, listener) {
2014    if (geometry && d3_geo_streamGeometryType.hasOwnProperty(geometry.type)) {
2015      d3_geo_streamGeometryType[geometry.type](geometry, listener);
2016    }
2017  }
2018  var d3_geo_streamObjectType = {
2019    Feature: function(feature, listener) {
2020      d3_geo_streamGeometry(feature.geometry, listener);
2021    },
2022    FeatureCollection: function(object, listener) {
2023      var features = object.features, i = -1, n = features.length;
2024      while (++i < n) d3_geo_streamGeometry(features[i].geometry, listener);
2025    }
2026  };
2027  var d3_geo_streamGeometryType = {
2028    Sphere: function(object, listener) {
2029      listener.sphere();
2030    },
2031    Point: function(object, listener) {
2032      var coordinate = object.coordinates;
2033      listener.point(coordinate[0], coordinate[1]);
2034    },
2035    MultiPoint: function(object, listener) {

2036      var coordinates = object.coordinates, i = -1, n = coordinates.length, coordinate;
2037      while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1]);
2038    },
2039    LineString: function(object, listener) {
2040      d3_geo_streamLine(object.coordinates, listener, 0);
2041    },
2042    MultiLineString: function(object, listener) {
2043      var coordinates = object.coordinates, i = -1, n = coordinates.length;
2044      while (++i < n) d3_geo_streamLine(coordinates[i], listener, 0);
2045    },
2046    Polygon: function(object, listener) {
2047      d3_geo_streamPolygon(object.coordinates, listener);
2048    },
2049    MultiPolygon: function(object, listener) {
2050      var coordinates = object.coordinates, i = -1, n = coordinates.length;
2051      while (++i < n) d3_geo_streamPolygon(coordinates[i], listener);
2052    },
2053    GeometryCollection: function(object, listener) {
2054      var geometries = object.geometries, i = -1, n = geometries.length;
2055      while (++i < n) d3_geo_streamGeometry(geometries[i], listener);
2056    }
2057  };
2058  function d3_geo_streamLine(coordinates, listener, closed) {
2059    var i = -1, n = coordinates.length - closed, coordinate;
2060    listener.lineStart();
2061    while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1]);
2062    listener.lineEnd();
2063  }
2064  function d3_geo_streamPolygon(coordinates, listener) {
2065    var i = -1, n = coordinates.length;
2066    listener.polygonStart();
2067    while (++i < n) d3_geo_streamLine(coordinates[i], listener, 1);
2068    listener.polygonEnd();
2069  }
2070  d3.geo.area = function(object) {
2071    d3_geo_areaSum = 0;
2072    d3.geo.stream(object, d3_geo_area);
2073    return d3_geo_areaSum;
2074  };
2075  var d3_geo_areaSum, d3_geo_areaRingU, d3_geo_areaRingV;
2076  var d3_geo_area = {
2077    sphere: function() {
2078      d3_geo_areaSum += 4 * π;
2079    },
2080    point: d3_noop,
2081    lineStart: d3_noop,
2082    lineEnd: d3_noop,
2083    polygonStart: function() {
2084      d3_geo_areaRingU = 1, d3_geo_areaRingV = 0;
2085      d3_geo_area.lineStart = d3_geo_areaRingStart;
2086    },
2087    polygonEnd: function() {
2088      var area = 2 * Math.atan2(d3_geo_areaRingV, d3_geo_areaRingU);
2089      d3_geo_areaSum += area < 0 ? 4 * π + area : area;
2090      d3_geo_area.lineStart = d3_geo_area.lineEnd = d3_geo_area.point = d3_noop;
2091    }
2092  };
2093  function d3_geo_areaRingStart() {
2094    var λ00, φ00, λ0, cosφ0, sinφ0;
2095    d3_geo_area.point = function(λ, φ) {
2096      d3_geo_area.point = nextPoint;
2097      λ0 = (λ00 = λ) * d3_radians, cosφ0 = Math.cos(φ = (φ00 = φ) * d3_radians / 2 + π / 4), 
2098      sinφ0 = Math.sin(φ);
2099    };
2100    function nextPoint(λ, φ) {
2101      λ *= d3_radians;
2102      φ = φ * d3_radians / 2 + π / 4;
2103      var dλ = λ - λ0, cosφ = Math.cos(φ), sinφ = Math.sin(φ), k = sinφ0 * sinφ, u0 = d3_geo_areaRingU, v0 = d3_geo_areaRingV, u = cosφ0 * cosφ + k * Math.cos(dλ), v = k * Math.sin(dλ);
2104      d3_geo_areaRingU = u0 * u - v0 * v;
2105      d3_geo_areaRingV = v0 * u + u0 * v;
2106      λ0 = λ, cosφ0 = cosφ, sinφ0 = sinφ;
2107    }
2108    d3_geo_area.lineEnd = function() {
2109      nextPoint(λ00, φ00);
2110    };
2111  }
2112  d3.geo.bounds = d3_geo_bounds(d3_identity);
2113  function d3_geo_bounds(projectStream) {
2114    var x0, y0, x1, y1;
2115    var bound = {
2116      point: boundPoint,
2117      lineStart: d3_noop,
2118      lineEnd: d3_noop,
2119      polygonStart: function() {
2120        bound.lineEnd = boundPolygonLineEnd;
2121      },
2122      polygonEnd: function() {
2123        bound.point = boundPoint;
2124      }
2125    };
2126    function boundPoint(x, y) {
2127      if (x < x0) x0 = x;
2128      if (x > x1) x1 = x;
2129      if (y < y0) y0 = y;
2130      if (y > y1) y1 = y;
2131    }
2132    function boundPolygonLineEnd() {
2133      bound.point = bound.lineEnd = d3_noop;
2134    }
2135    return function(feature) {
2136      y1 = x1 = -(x0 = y0 = Infinity);
2137      d3.geo.stream(feature, projectStream(bound));
2138      return [ [ x0, y0 ], [ x1, y1 ] ];
2139    };
2140  }
2141  d3.geo.centroid = function(object) {
2142    d3_geo_centroidDimension = d3_geo_centroidW = d3_geo_centroidX = d3_geo_centroidY = d3_geo_centroidZ = 0;
2143    d3.geo.stream(object, d3_geo_centroid);
2144    var m;
2145    if (d3_geo_centroidW && Math.abs(m = Math.sqrt(d3_geo_centroidX * d3_geo_centroidX + d3_geo_centroidY * d3_geo_centroidY + d3_geo_centroidZ * d3_geo_centroidZ)) > ε) {
2146      return [ Math.atan2(d3_geo_centroidY, d3_geo_centroidX) * d3_degrees, Math.asin(Math.max(-1, Math.min(1, d3_geo_centroidZ / m))) * d3_degrees ];
2147    }
2148  };
2149  var d3_geo_centroidDimension, d3_geo_centroidW, d3_geo_centroidX, d3_geo_centroidY, d3_geo_centroidZ;
2150  var d3_geo_centroid = {
2151    sphere: function() {
2152      if (d3_geo_centroidDimension < 2) {
2153        d3_geo_centroidDimension = 2;
2154        d3_geo_centroidW = d3_geo_centroidX = d3_geo_centroidY = d3_geo_centroidZ = 0;
2155      }
2156    },
2157    point: d3_geo_centroidPoint,
2158    lineStart: d3_geo_centroidLineStart,
2159    lineEnd: d3_geo_centroidLineEnd,
2160    polygonStart: function() {
2161      if (d3_geo_centroidDimension < 2) {
2162        d3_geo_centroidDimension = 2;
2163        d3_geo_centroidW = d3_geo_centroidX = d3_geo_centroidY = d3_geo_centroidZ = 0;
2164      }
2165      d3_geo_centroid.lineStart = d3_geo_centroidRingStart;
2166    },
2167    polygonEnd: function() {
2168      d3_geo_centroid.lineStart = d3_geo_centroidLineStart;
2169    }
2170  };
2171  function d3_geo_centroidPoint(λ, φ) {
2172    if (d3_geo_centroidDimension) return;
2173    ++d3_geo_centroidW;
2174    λ *= d3_radians;
2175    var cosφ = Math.cos(φ *= d3_radians);
2176    d3_geo_centroidX += (cosφ * Math.cos(λ) - d3_geo_centroidX) / d3_geo_centroidW;
2177    d3_geo_centroidY += (cosφ * Math.sin(λ) - d3_geo_centroidY) / d3_geo_centroidW;
2178    d3_geo_centroidZ += (Math.sin(φ) - d3_geo_centroidZ) / d3_geo_centroidW;
2179  }
2180  function d3_geo_centroidRingStart() {
2181    var λ00, φ00;
2182    d3_geo_centroidDimension = 1;
2183    d3_geo_centroidLineStart();
2184    d3_geo_centroidDimension = 2;
2185    var linePoint = d3_geo_centroid.point;
2186    d3_geo_centroid.point = function(λ, φ) {
2187      linePoint(λ00 = λ, φ00 = φ);
2188    };
2189    d3_geo_centroid.lineEnd = function() {
2190      d3_geo_centroid.point(λ00, φ00);
2191      d3_geo_centroidLineEnd();
2192      d3_geo_centroid.lineEnd = d3_geo_centroidLineEnd;
2193    };
2194  }
2195  function d3_geo_centroidLineStart() {
2196    var x0, y0, z0;
2197    if (d3_geo_centroidDimension > 1) return;
2198    if (d3_geo_centroidDimension < 1) {
2199      d3_geo_centroidDimension = 1;
2200      d3_geo_centroidW = d3_geo_centroidX = d3_geo_centroidY = d3_geo_centroidZ = 0;
2201    }
2202    d3_geo_centroid.point = function(λ, φ) {
2203      λ *= d3_radians;
2204      var cosφ = Math.cos(φ *= d3_radians);
2205      x0 = cosφ * Math.cos(λ);
2206      y0 = cosφ * Math.sin(λ);
2207      z0 = Math.sin(φ);
2208      d3_geo_centroid.point = nextPoint;
2209    };
2210    function nextPoint(λ, φ) {
2211      λ *= d3_radians;
2212      var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), w = Math.atan2(Math.sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);
2213      d3_geo_centroidW += w;
2214      d3_geo_centroidX += w * (x0 + (x0 = x));
2215      d3_geo_centroidY += w * (y0 + (y0 = y));
2216      d3_geo_centroidZ += w * (z0 + (z0 = z));
2217    }
2218  }
2219  function d3_geo_centroidLineEnd() {
2220    d3_geo_centroid.point = d3_geo_centroidPoint;
2221  }
2222  function d3_geo_cartesian(spherical) {
2223    var λ = spherical[0], φ = spherical[1], cosφ = Math.cos(φ);
2224    return [ cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ) ];
2225  }
2226  function d3_geo_cartesianDot(a, b) {
2227    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
2228  }
2229  function d3_geo_cartesianCross(a, b) {
2230    return [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0] ];
2231  }
2232  function d3_geo_cartesianAdd(a, b) {
2233    a[0] += b[0];
2234    a[1] += b[1];
2235    a[2] += b[2];
2236  }
2237  function d3_geo_cartesianScale(vector, k) {
2238    return [ vector[0] * k, vector[1] * k, vector[2] * k ];
2239  }
2240  function d3_geo_cartesianNormalize(d) {
2241    var l = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
2242    d[0] /= l;
2243    d[1] /= l;
2244    d[2] /= l;
2245  }
2246  function d3_true() {
2247    return true;
2248  }
2249  function d3_geo_spherical(cartesian) {
2250    return [ Math.atan2(cartesian[1], cartesian[0]), Math.asin(Math.max(-1, Math.min(1, cartesian[2]))) ];
2251  }
2252  function d3_geo_sphericalEqual(a, b) {
2253    return Math.abs(a[0] - b[0]) < ε && Math.abs(a[1] - b[1]) < ε;
2254  }
2255  function d3_geo_clipPolygon(segments, compare, inside, interpolate, listener) {
2256    var subject = [], clip = [];

2257    segments.forEach(function(segment) {
2258      if ((n = segment.length - 1) <= 0) return;
2259      var n, p0 = segment[0], p1 = segment[n];
2260      if (d3_geo_sphericalEqual(p0, p1)) {
2261        listener.lineStart();
2262        for (var i = 0; i < n; ++i) listener.point((p0 = segment[i])[0], p0[1]);
2263        listener.lineEnd();
2264        return;
2265      }
2266      var a = {
2267        point: p0,
2268        points: segment,
2269        other: null,
2270        visited: false,
2271        entry: true,
2272        subject: true
2273      }, b = {
2274        point: p0,
2275        points: [ p0 ],
2276        other: a,
2277        visited: false,
2278        entry: false,
2279        subject: false
2280      };
2281      a.other = b;
2282      subject.push(a);
2283      clip.push(b);
2284      a = {
2285        point: p1,
2286        points: [ p1 ],
2287        other: null,
2288        visited: false,
2289        entry: false,
2290        subject: true
2291      };
2292      b = {
2293        point: p1,
2294        points: [ p1 ],
2295        other: a,
2296        visited: false,
2297        entry: true,
2298        subject: false
2299      };
2300      a.other = b;
2301      subject.push(a);
2302      clip.push(b);
2303    });
2304    clip.sort(compare);
2305    d3_geo_clipPolygonLinkCircular(subject);
2306    d3_geo_clipPolygonLinkCircular(clip);
2307    if (!subject.length) return;
2308    if (inside) for (var i = 1, e = !inside(clip[0].point), n = clip.length; i < n; ++i) {
2309      clip[i].entry = e = !e;
2310    }
2311    var start = subject[0], current, points, point;
2312    while (1) {
2313      current = start;
2314      while (current.visited) if ((current = current.next) === start) return;
2315      points = current.points;
2316      listener.lineStart();
2317      do {
2318        current.visited = current.other.visited = true;
2319        if (current.entry) {
2320          if (current.subject) {
2321            for (var i = 0; i < points.length; i++) listener.point((point = points[i])[0], point[1]);
2322          } else {
2323            interpolate(current.point, current.next.point, 1, listener);
2324          }
2325          current = current.next;
2326        } else {
2327          if (current.subject) {
2328            points = current.prev.points;
2329            for (var i = points.length; --i >= 0; ) listener.point((point = points[i])[0], point[1]);
2330          } else {
2331            interpolate(current.point, current.prev.point, -1, listener);
2332          }
2333          current = current.prev;
2334        }
2335        current = current.other;
2336        points = current.points;
2337      } while (!current.visited);
2338      listener.lineEnd();
2339    }
2340  }
2341  function d3_geo_clipPolygonLinkCircular(array) {
2342    if (!(n = array.length)) return;
2343    var n, i = 0, a = array[0], b;
2344    while (++i < n) {
2345      a.next = b = array[i];
2346      b.prev = a;
2347      a = b;
2348    }
2349    a.next = b = array[0];
2350    b.prev = a;
2351  }
2352  function d3_geo_clip(pointVisible, clipLine, interpolate) {
2353    return function(listener) {
2354      var line = clipLine(listener);
2355      var clip = {
2356        point: point,
2357        lineStart: lineStart,
2358        lineEnd: lineEnd,
2359        polygonStart: function() {
2360          clip.point = pointRing;
2361          clip.lineStart = ringStart;
2362          clip.lineEnd = ringEnd;
2363          invisible = false;
2364          invisibleArea = visibleArea = 0;
2365          segments = [];
2366          listener.polygonStart();
2367        },
2368        polygonEnd: function() {
2369          clip.point = point;
2370          clip.lineStart = lineStart;
2371          clip.lineEnd = lineEnd;
2372          segments = d3.merge(segments);
2373          if (segments.length) {
2374            d3_geo_clipPolygon(segments, d3_geo_clipSort, null, interpolate, listener);
2375          } else if (visibleArea < -ε || invisible && invisibleArea < -ε) {
2376            listener.lineStart();
2377            interpolate(null, null, 1, listener);
2378            listener.lineEnd();
2379          }
2380          listener.polygonEnd();
2381          segments = null;
2382        },
2383        sphere: function() {
2384          listener.polygonStart();
2385          listener.lineStart();
2386          interpolate(null, null, 1, listener);
2387          listener.lineEnd();
2388          listener.polygonEnd();
2389        }
2390      };
2391      function point(λ, φ) {
2392        if (pointVisible(λ, φ)) listener.point(λ, φ);
2393      }
2394      function pointLine(λ, φ) {
2395        line.point(λ, φ);
2396      }
2397      function lineStart() {
2398        clip.point = pointLine;
2399        line.lineStart();
2400      }
2401      function lineEnd() {
2402        clip.point = point;
2403        line.lineEnd();
2404      }
2405      var segments, visibleArea, invisibleArea, invisible;
2406      var buffer = d3_geo_clipBufferListener(), ringListener = clipLine(buffer), ring;
2407      function pointRing(λ, φ) {
2408        ringListener.point(λ, φ);
2409        ring.push([ λ, φ ]);
2410      }
2411      function ringStart() {
2412        ringListener.lineStart();
2413        ring = [];
2414      }
2415      function ringEnd() {
2416        pointRing(ring[0][0], ring[0][1]);
2417        ringListener.lineEnd();
2418        var clean = ringListener.clean(), ringSegments = buffer.buffer(), segment, n = ringSegments.length;
2419        if (!n) {
2420          invisible = true;
2421          invisibleArea += d3_geo_clipAreaRing(ring, -1);
2422          ring = null;
2423          return;
2424        }
2425        ring = null;
2426        if (clean & 1) {
2427          segment = ringSegments[0];
2428          visibleArea += d3_geo_clipAreaRing(segment, 1);
2429          var n = segment.length - 1, i = -1, point;
2430          listener.lineStart();
2431          while (++i < n) listener.point((point = segment[i])[0], point[1]);
2432          listener.lineEnd();
2433          return;
2434        }
2435        if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
2436        segments.push(ringSegments.filter(d3_geo_clipSegmentLength1));
2437      }
2438      return clip;
2439    };
2440  }
2441  function d3_geo_clipSegmentLength1(segment) {
2442    return segment.length > 1;
2443  }
2444  function d3_geo_clipBufferListener() {
2445    var lines = [], line;
2446    return {
2447      lineStart: function() {
2448        lines.push(line = []);
2449      },
2450      point: function(λ, φ) {
2451        line.push([ λ, φ ]);
2452      },
2453      lineEnd: d3_noop,
2454      buffer: function() {
2455        var buffer = lines;
2456        lines = [];
2457        line = null;
2458        return buffer;
2459      },
2460      rejoin: function() {
2461        if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));
2462      }
2463    };
2464  }
2465  function d3_geo_clipAreaRing(ring, invisible) {
2466    if (!(n = ring.length)) return 0;
2467    var n, i = 0, area = 0, p = ring[0], λ = p[0], φ = p[1], cosφ = Math.cos(φ), x0 = Math.atan2(invisible * Math.sin(λ) * cosφ, Math.sin(φ)), y0 = 1 - invisible * Math.cos(λ) * cosφ, x1 = x0, x, y;
2468    while (++i < n) {
2469      p = ring[i];
2470      cosφ = Math.cos(φ = p[1]);
2471      x = Math.atan2(invisible * Math.sin(λ = p[0]) * cosφ, Math.sin(φ));
2472      y = 1 - invisible * Math.cos(λ) * cosφ;
2473      if (Math.abs(y0 - 2) < ε && Math.abs(y - 2) < ε) continue;
2474      if (Math.abs(y) < ε || Math.abs(y0) < ε) {} else if (Math.abs(Math.abs(x - x0) - π) < ε) {
2475        if (y + y0 > 2) area += 4 * (x - x0);
2476      } else if (Math.abs(y0 - 2) < ε) area += 4 * (x - x1); else area += ((3 * π + x - x0) % (2 * π) - π) * (y0 + y);
2477      x1 = x0, x0 = x, y0 = y;
2478    }
2479    return area;
2480  }
2481  function d3_geo_clipSort(a, b) {
2482    return ((a = a.point)[0] < 0 ? a[1] - π / 2 - ε : π / 2 - a[1]) - ((b = b.point)[0] < 0 ? b[1] - π / 2 - ε : π / 2 - b[1]);
2483  }
2484  var d3_geo_clipAntimeridian = d3_geo_clip(d3_true, d3_geo_clipAntimeridianLine, d3_geo_clipAntimeridianInterpolate);
2485  function d3_geo_clipAntimeridianLine(listener) {
2486    var λ0 = NaN, φ0 = NaN, sλ0 = NaN, clean;
2487    return {
2488      lineStart: function() {
2489        listener.lineStart();
2490        clean = 1;
2491      },
2492      point: function(λ1, φ1) {
2493        var sλ1 = λ1 > 0 ? π : -π, dλ = Math.abs(λ1 - λ0);
2494        if (Math.abs(dλ - π) < ε) {
2495          listener.point(λ0, φ0 = (φ0 + φ1) / 2 > 0 ? π / 2 : -π / 2);
2496          listener.point(sλ0, φ0);
2497          listener.lineEnd();
2498          listener.lineStart();
2499          listener.point(sλ1, φ0);
2500          listener.point(λ1, φ0);
2501          clean = 0;
2502        } else if (sλ0 !== sλ1 && dλ >= π) {
2503          if (Math.abs(λ0 - sλ0) < ε) λ0 -= sλ0 * ε;
2504          if (Math.abs(λ1 - sλ1) < ε) λ1 -= sλ1 * ε;
2505          φ0 = d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1);
2506          listener.point(sλ0, φ0);
2507          listener.lineEnd();
2508          listener.lineStart();
2509          listener.point(sλ1, φ0);
2510          clean = 0;
2511        }
2512        listener.point(λ0 = λ1, φ0 = φ1);
2513        sλ0 = sλ1;
2514      },
2515      lineEnd: function() {
2516        listener.lineEnd();
2517        λ0 = φ0 = NaN;
2518      },
2519      clean: function() {
2520        return 2 - clean;
2521      }
2522    };
2523  }
2524  function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) {
2525    var cosφ0, cosφ1, sinλ0_λ1 = Math.sin(λ0 - λ1);
2526    return Math.abs(sinλ0_λ1) > ε ? Math.atan((Math.sin(φ0) * (cosφ1 = Math.cos(φ1)) * Math.sin(λ1) - Math.sin(φ1) * (cosφ0 = Math.cos(φ0)) * Math.sin(λ0)) / (cosφ0 * cosφ1 * sinλ0_λ1)) : (φ0 + φ1) / 2;
2527  }
2528  function d3_geo_clipAntimeridianInterpolate(from, to, direction, listener) {
2529    var φ;
2530    if (from == null) {
2531      φ = direction * π / 2;
2532      listener.point(-π, φ);
2533      listener.point(0, φ);
2534      listener.point(π, φ);
2535      listener.point(π, 0);
2536      listener.point(π, -φ);
2537      listener.point(0, -φ);
2538      listener.point(-π, -φ);
2539      listener.point(-π, 0);
2540      listener.point(-π, φ);
2541    } else if (Math.abs(from[0] - to[0]) > ε) {
2542      var s = (from[0] < to[0] ? 1 : -1) * π;
2543      φ = direction * s / 2;
2544      listener.point(-s, φ);
2545      listener.point(0, φ);
2546      listener.point(s, φ);
2547    } else {
2548      listener.point(to[0], to[1]);
2549    }
2550  }
2551  function d3_geo_clipCircle(radius) {

2552    var cr = Math.cos(radius), smallRadius = cr > 0, notHemisphere = Math.abs(cr) > ε, interpolate = d3_geo_circleInterpolate(radius, 6 * d3_radians);
2553    return d3_geo_clip(visible, clipLine, interpolate);
2554    function visible(λ, φ) {
2555      return Math.cos(λ) * Math.cos(φ) > cr;
2556    }
2557    function clipLine(listener) {
2558      var point0, c0, v0, v00, clean;
2559      return {
2560        lineStart: function() {
2561          v00 = v0 = false;
2562          clean = 1;
2563        },
2564        point: function(λ, φ) {
2565          var point1 = [ λ, φ ], point2, v = visible(λ, φ), c = smallRadius ? v ? 0 : code(λ, φ) : v ? code(λ + (λ < 0 ? π : -π), φ) : 0;
2566          if (!point0 && (v00 = v0 = v)) listener.lineStart();
2567          if (v !== v0) {
2568            point2 = intersect(point0, point1);
2569            if (d3_geo_sphericalEqual(point0, point2) || d3_geo_sphericalEqual(point1, point2)) {
2570              point1[0] += ε;
2571              point1[1] += ε;
2572              v = visible(point1[0], point1[1]);
2573            }
2574          }
2575          if (v !== v0) {
2576            clean = 0;
2577            if (v) {
2578              listener.lineStart();
2579              point2 = intersect(point1, point0);
2580              listener.point(point2[0], point2[1]);
2581            } else {
2582              point2 = intersect(point0, point1);
2583              listener.point(point2[0], point2[1]);
2584              listener.lineEnd();
2585            }
2586            point0 = point2;
2587          } else if (notHemisphere && point0 && smallRadius ^ v) {
2588            var t;
2589            if (!(c & c0) && (t = intersect(point1, point0, true))) {
2590              clean = 0;
2591              if (smallRadius) {
2592                listener.lineStart();
2593                listener.point(t[0][0], t[0][1]);
2594                listener.point(t[1][0], t[1][1]);
2595                listener.lineEnd();
2596              } else {
2597                listener.point(t[1][0], t[1][1]);
2598                listener.lineEnd();
2599                listener.lineStart();
2600                listener.point(t[0][0], t[0][1]);
2601              }
2602            }
2603          }
2604          if (v && (!point0 || !d3_geo_sphericalEqual(point0, point1))) {
2605            listener.point(point1[0], point1[1]);
2606          }
2607          point0 = point1, v0 = v, c0 = c;
2608        },
2609        lineEnd: function() {
2610          if (v0) listener.lineEnd();
2611          point0 = null;
2612        },
2613        clean: function() {
2614          return clean | (v00 && v0) << 1;
2615        }
2616      };
2617    }
2618    function intersect(a, b, two) {
2619      var pa = d3_geo_cartesian(a), pb = d3_geo_cartesian(b);
2620      var n1 = [ 1, 0, 0 ], n2 = d3_geo_cartesianCross(pa, pb), n2n2 = d3_geo_cartesianDot(n2, n2), n1n2 = n2[0], determinant = n2n2 - n1n2 * n1n2;
2621      if (!determinant) return !two && a;
2622      var c1 = cr * n2n2 / determinant, c2 = -cr * n1n2 / determinant, n1xn2 = d3_geo_cartesianCross(n1, n2), A = d3_geo_cartesianScale(n1, c1), B = d3_geo_cartesianScale(n2, c2);
2623      d3_geo_cartesianAdd(A, B);
2624      var u = n1xn2, w = d3_geo_cartesianDot(A, u), uu = d3_geo_cartesianDot(u, u), t2 = w * w - uu * (d3_geo_cartesianDot(A, A) - 1);
2625      if (t2 < 0) return;
2626      var t = Math.sqrt(t2), q = d3_geo_cartesianScale(u, (-w - t) / uu);
2627      d3_geo_cartesianAdd(q, A);
2628      q = d3_geo_spherical(q);
2629      if (!two) return q;
2630      var λ0 = a[0], λ1 = b[0], φ0 = a[1], φ1 = b[1], z;
2631      if (λ1 < λ0) z = λ0, λ0 = λ1, λ1 = z;
2632      var δλ = λ1 - λ0, polar = Math.abs(δλ - π) < ε, meridian = polar || δλ < ε;
2633      if (!polar && φ1 < φ0) z = φ0, φ0 = φ1, φ1 = z;
2634      if (meridian ? polar ? φ0 + φ1 > 0 ^ q[1] < (Math.abs(q[0] - λ0) < ε ? φ0 : φ1) : φ0 <= q[1] && q[1] <= φ1 : δλ > π ^ (λ0 <= q[0] && q[0] <= λ1)) {
2635        var q1 = d3_geo_cartesianScale(u, (-w + t) / uu);
2636        d3_geo_cartesianAdd(q1, A);
2637        return [ q, d3_geo_spherical(q1) ];
2638      }
2639    }
2640    function code(λ, φ) {
2641      var r = smallRadius ? radius : π - radius, code = 0;
2642      if (λ < -r) code |= 1; else if (λ > r) code |= 2;
2643      if (φ < -r) code |= 4; else if (φ > r) code |= 8;
2644      return code;
2645    }
2646  }
2647  var d3_geo_clipViewMAX = 1e9;
2648  function d3_geo_clipView(x0, y0, x1, y1) {
2649    return function(listener) {
2650      var listener_ = listener, bufferListener = d3_geo_clipBufferListener(), segments, polygon, ring;
2651      var clip = {
2652        point: point,
2653        lineStart: lineStart,
2654        lineEnd: lineEnd,
2655        polygonStart: function() {
2656          listener = bufferListener;
2657          segments = [];
2658          polygon = [];
2659        },
2660        polygonEnd: function() {
2661          listener = listener_;
2662          if ((segments = d3.merge(segments)).length) {
2663            listener.polygonStart();
2664            d3_geo_clipPolygon(segments, compare, inside, interpolate, listener);
2665            listener.polygonEnd();
2666          } else if (insidePolygon([ x0, y0 ])) {
2667            listener.polygonStart(), listener.lineStart();
2668            interpolate(null, null, 1, listener);
2669            listener.lineEnd(), listener.polygonEnd();
2670          }
2671          segments = polygon = ring = null;
2672        }
2673      };
2674      function inside(point) {
2675        var a = corner(point, -1), i = insidePolygon([ a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0 ]);
2676        return i;
2677      }
2678      function insidePolygon(p) {
2679        var wn = 0, n = polygon.length, y = p[1];
2680        for (var i = 0; i < n; ++i) {
2681          for (var j = 1, v = polygon[i], m = v.length, a = v[0]; j < m; ++j) {
2682            b = v[j];
2683            if (a[1] <= y) {
2684              if (b[1] > y && isLeft(a, b, p) > 0) ++wn;
2685            } else {
2686              if (b[1] <= y && isLeft(a, b, p) < 0) --wn;
2687            }
2688            a = b;
2689          }
2690        }
2691        return wn !== 0;
2692      }
2693      function isLeft(a, b, c) {
2694        return (b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1]);
2695      }
2696      function interpolate(from, to, direction, listener) {
2697        var a = 0, a1 = 0;
2698        if (from == null || (a = corner(from, direction)) !== (a1 = corner(to, direction)) || comparePoints(from, to) < 0 ^ direction > 0) {
2699          do {
2700            listener.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0);
2701          } while ((a = (a + direction + 4) % 4) !== a1);
2702        } else {
2703          listener.point(to[0], to[1]);
2704        }
2705      }
2706      function visible(x, y) {
2707        return x0 <= x && x <= x1 && y0 <= y && y <= y1;
2708      }
2709      function point(x, y) {
2710        if (visible(x, y)) listener.point(x, y);
2711      }
2712      var x__, y__, v__, x_, y_, v_, first;
2713      function lineStart() {
2714        clip.point = linePoint;
2715        if (polygon) polygon.push(ring = []);
2716        first = true;
2717        v_ = false;