!function() {

var d3 = {

version: "3.5.3"

};

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

return +new Date();

};

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

return d3_arraySlice.call(list);

};

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

try {

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

} catch (e) {

d3_array = function(list) {

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

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

return array;

};

}

try {

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

} catch (error) {

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

d3_element_prototype.setAttribute = function(name, value) {

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

};

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

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

};

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

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

};

}

d3.ascending = d3_ascending;

function d3_ascending(a, b) {

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

}

d3.descending = function(a, b) {

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

};

d3.min = function(array, f) {

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

if (arguments.length === 1) {

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

a = b;

break;

}

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

} else {

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

a = b;

break;

}

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

}

return a;

};

d3.max = function(array, f) {

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

if (arguments.length === 1) {

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

a = b;

break;

}

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

} else {

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

a = b;

break;

}

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

}

return a;

};

d3.extent = function(array, f) {

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

if (arguments.length === 1) {

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

a = c = b;

break;

}

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

if (a > b) a = b;

if (c < b) c = b;

}

} else {

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

a = c = b;

break;

}

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

if (a > b) a = b;

if (c < b) c = b;

}

}

return [ a, c ];

};

function d3_number(x) {

return x === null ? NaN : +x;

}

function d3_numeric(x) {

return !isNaN(x);

}

d3.sum = function(array, f) {

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

if (arguments.length === 1) {

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

} else {

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

}

return s;

};

d3.mean = function(array, f) {

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

if (arguments.length === 1) {

while (++i < n) if (d3_numeric(a = d3_number(array[i]))) s += a; else --j;

} else {

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

}

if (j) return s / j;

};

d3.quantile = function(values, p) {

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

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

};

d3.median = function(array, f) {

var numbers = [], n = array.length, a, i = -1;

if (arguments.length === 1) {

while (++i < n) if (d3_numeric(a = d3_number(array[i]))) numbers.push(a);

} else {

while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) numbers.push(a);

}

if (numbers.length) return d3.quantile(numbers.sort(d3_ascending), .5);

};

d3.variance = function(array, f) {

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

if (arguments.length === 1) {

while (++i < n) {

if (d3_numeric(a = d3_number(array[i]))) {

d = a - m;

m += d / ++j;

s += d * (a - m);

}

}

} else {

while (++i < n) {

if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) {

d = a - m;

m += d / ++j;

s += d * (a - m);

}

}

}

if (j > 1) return s / (j - 1);

};

d3.deviation = function() {

var v = d3.variance.apply(this, arguments);

return v ? Math.sqrt(v) : v;

};

function d3_bisector(compare) {

return {

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

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

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

while (lo < hi) {

var mid = lo + hi >>> 1;

if (compare(a[mid], x) < 0) lo = mid + 1; else hi = mid;

}

return lo;

},

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

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

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

while (lo < hi) {

var mid = lo + hi >>> 1;

if (compare(a[mid], x) > 0) hi = mid; else lo = mid + 1;

}

return lo;

}

};

}

var d3_bisect = d3_bisector(d3_ascending);

d3.bisectLeft = d3_bisect.left;

d3.bisect = d3.bisectRight = d3_bisect.right;

d3.bisector = function(f) {

return d3_bisector(f.length === 1 ? function(d, x) {

return d3_ascending(f(d), x);

} : f);

};

d3.shuffle = function(array, i0, i1) {

if ((m = arguments.length) < 3) {

i1 = array.length;

if (m < 2) i0 = 0;

}

var m = i1 - i0, t, i;

while (m) {

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

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

}

return array;

};

d3.permute = function(array, indexes) {

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

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

return permutes;

};

d3.pairs = function(array) {

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

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

return pairs;

};

d3.zip = function() {

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

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

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

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

}

}

return zips;

};

function d3_zipLength(d) {

return d.length;

}

d3.transpose = function(matrix) {

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

};

d3.keys = function(map) {

var keys = [];

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

return keys;

};

d3.values = function(map) {

var values = [];

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

return values;

};

d3.entries = function(map) {

var entries = [];

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

key: key,

value: map[key]

});

return entries;

};

d3.merge = function(arrays) {

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

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

merged = new Array(j);

while (--n >= 0) {

array = arrays[n];

m = array.length;

while (--m >= 0) {

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

}

}

return merged;

};

var abs = Math.abs;

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

if (arguments.length < 3) {

step = 1;

if (arguments.length < 2) {

stop = start;

start = 0;

}

}

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

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

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

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

return range;

};

function d3_range_integerScale(x) {

var k = 1;

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

return k;

}

function d3_class(ctor, properties) {

for (var key in properties) {

Object.defineProperty(ctor.prototype, key, {

value: properties[key],

enumerable: false

});

}

}

d3.map = function(object, f) {

var map = new d3_Map();

if (object instanceof d3_Map) {

object.forEach(function(key, value) {

map.set(key, value);

});

} else if (Array.isArray(object)) {

var i = -1, n = object.length, o;

if (arguments.length === 1) while (++i < n) map.set(i, object[i]); else while (++i < n) map.set(f.call(object, o = object[i], i), o);

} else {

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

}

return map;

};

function d3_Map() {

this._ = Object.create(null);

}

var d3_map_proto = "__proto__", d3_map_zero = "\x00";

d3_class(d3_Map, {

has: d3_map_has,

get: function(key) {

return this._[d3_map_escape(key)];

},

set: function(key, value) {

return this._[d3_map_escape(key)] = value;

},

remove: d3_map_remove,

keys: d3_map_keys,

values: function() {

var values = [];

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

return values;

},

entries: function() {

var entries = [];

for (var key in this._) entries.push({

key: d3_map_unescape(key),

value: this._[key]

});

return entries;

},

size: d3_map_size,

empty: d3_map_empty,

forEach: function(f) {

for (var key in this._) f.call(this, d3_map_unescape(key), this._[key]);

}

});

function d3_map_escape(key) {

return (key += "") === d3_map_proto || key[0] === d3_map_zero ? d3_map_zero + key : key;

}

function d3_map_unescape(key) {

return (key += "")[0] === d3_map_zero ? key.slice(1) : key;

}

function d3_map_has(key) {

return d3_map_escape(key) in this._;

}

function d3_map_remove(key) {

return (key = d3_map_escape(key)) in this._ && delete this._[key];

}

function d3_map_keys() {

var keys = [];

for (var key in this._) keys.push(d3_map_unescape(key));

return keys;

}

function d3_map_size() {

var size = 0;

for (var key in this._) ++size;

return size;

}

function d3_map_empty() {

for (var key in this._) return false;

return true;

}

d3.nest = function() {

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

function map(mapType, array, depth) {

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

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

while (++i < n) {

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

values.push(object);

} else {

valuesByKey.set(keyValue, [ object ]);

}

}

if (mapType) {

object = mapType();

setter = function(keyValue, values) {

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

};

} else {

object = {};

setter = function(keyValue, values) {

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

};

}

valuesByKey.forEach(setter);

return object;

}

function entries(map, depth) {

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

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

map.forEach(function(key, keyMap) {

array.push({

key: key,

values: entries(keyMap, depth)

});

});

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

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

}) : array;

}

nest.map = function(array, mapType) {

return map(mapType, array, 0);

};

nest.entries = function(array) {

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

};

nest.key = function(d) {

keys.push(d);

return nest;

};

nest.sortKeys = function(order) {

sortKeys[keys.length - 1] = order;

return nest;

};

nest.sortValues = function(order) {

sortValues = order;

return nest;

};

nest.rollup = function(f) {

rollup = f;

return nest;

};

return nest;

};

d3.set = function(array) {

var set = new d3_Set();

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

return set;

};

function d3_Set() {

this._ = Object.create(null);

}

d3_class(d3_Set, {

has: d3_map_has,

add: function(key) {

this._[d3_map_escape(key += "")] = true;

return key;

},

remove: d3_map_remove,

values: d3_map_keys,

size: d3_map_size,

empty: d3_map_empty,

forEach: function(f) {

for (var key in this._) f.call(this, d3_map_unescape(key));

}

});

d3.behavior = {};

d3.rebind = function(target, source) {

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

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

return target;

};

function d3_rebind(target, source, method) {

return function() {

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

return value === source ? target : value;

};

}

function d3_vendorSymbol(object, name) {

if (name in object) return name;

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

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

var prefixName = d3_vendorPrefixes[i] + name;

if (prefixName in object) return prefixName;

}

}

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

function d3_noop() {}

d3.dispatch = function() {

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

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

return dispatch;

};

function d3_dispatch() {}

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

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

if (i >= 0) {

name = type.slice(i + 1);

type = type.slice(0, i);

}

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

if (arguments.length === 2) {

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

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

}

return this;

}

};

function d3_dispatch_event(dispatch) {

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

function event() {

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

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

return dispatch;

}

event.on = function(name, listener) {

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

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

if (l) {

l.on = null;

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

listenerByName.remove(name);

}

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

on: listener

}));

return dispatch;

};

return event;

}

d3.event = null;

function d3_eventPreventDefault() {

d3.event.preventDefault();

}

function d3_eventSource() {

var e = d3.event, s;

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

return e;

}

function d3_eventDispatch(target) {

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

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

dispatch.of = function(thiz, argumentz) {

return function(e1) {

try {

var e0 = e1.sourceEvent = d3.event;

e1.target = target;

d3.event = e1;

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

} finally {

d3.event = e0;

}

};

};

return dispatch;

}

d3.requote = function(s) {

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

};

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

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

object.__proto__ = prototype;

} : function(object, prototype) {

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

};

function d3_selection(groups) {

d3_subclass(groups, d3_selectionPrototype);

return groups;

}

var d3_select = function(s, n) {

return n.querySelector(s);

}, d3_selectAll = function(s, n) {

return n.querySelectorAll(s);

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

return d3_selectMatcher.call(n, s);

};

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

d3_select = function(s, n) {

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

};

d3_selectAll = Sizzle;

d3_selectMatches = Sizzle.matchesSelector;

}

d3.selection = function() {

return d3_selectionRoot;

};

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

d3_selectionPrototype.select = function(selector) {

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

selector = d3_selection_selector(selector);

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

subgroups.push(subgroup = []);

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

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

if (node = group[i]) {

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

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

} else {

subgroup.push(null);

}

}

}

return d3_selection(subgroups);

};

function d3_selection_selector(selector) {

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

return d3_select(selector, this);

};

}

d3_selectionPrototype.selectAll = function(selector) {

var subgroups = [], subgroup, node;

selector = d3_selection_selectorAll(selector);

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

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

if (node = group[i]) {

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

subgroup.parentNode = node;

}

}

}

return d3_selection(subgroups);

};

function d3_selection_selectorAll(selector) {

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

return d3_selectAll(selector, this);

};

}

var d3_nsPrefix = {

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

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

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

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

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

};

d3.ns = {

prefix: d3_nsPrefix,

qualify: function(name) {

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

if (i >= 0) {

prefix = name.slice(0, i);

name = name.slice(i + 1);

}

return d3_nsPrefix.hasOwnProperty(prefix) ? {

space: d3_nsPrefix[prefix],

local: name

} : name;

}

};

d3_selectionPrototype.attr = function(name, value) {

if (arguments.length < 2) {

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

var node = this.node();

name = d3.ns.qualify(name);

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

}

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

return this;

}

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

};

function d3_selection_attr(name, value) {

name = d3.ns.qualify(name);

function attrNull() {

this.removeAttribute(name);

}

function attrNullNS() {

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

}

function attrConstant() {

this.setAttribute(name, value);

}

function attrConstantNS() {

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

}

function attrFunction() {

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

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

}

function attrFunctionNS() {

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

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

}

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

}

function d3_collapse(s) {

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

}

d3_selectionPrototype.classed = function(name, value) {

if (arguments.length < 2) {

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

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

if (value = node.classList) {

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

} else {

value = node.getAttribute("class");

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

}

return true;

}

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

return this;

}

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

};

function d3_selection_classedRe(name) {

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

}

function d3_selection_classes(name) {

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

}

function d3_selection_classed(name, value) {

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

var n = name.length;

function classedConstant() {

var i = -1;

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

}

function classedFunction() {

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

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

}

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

}

function d3_selection_classedName(name) {

var re = d3_selection_classedRe(name);

return function(node, value) {

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

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

if (value) {

re.lastIndex = 0;

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

} else {

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

}

};

}

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

var n = arguments.length;

if (n < 3) {

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

if (n < 2) value = "";

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

return this;

}

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

priority = "";

}

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

};

function d3_selection_style(name, value, priority) {

function styleNull() {

this.style.removeProperty(name);

}

function styleConstant() {

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

}

function styleFunction() {

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

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

}

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

}

d3_selectionPrototype.property = function(name, value) {

if (arguments.length < 2) {

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

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

return this;

}

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

};

function d3_selection_property(name, value) {

function propertyNull() {

delete this[name];

}

function propertyConstant() {

this[name] = value;

}

function propertyFunction() {

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

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

}

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

}

d3_selectionPrototype.text = function(value) {

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

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

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

} : value == null ? function() {

this.textContent = "";

} : function() {

this.textContent = value;

}) : this.node().textContent;

};

d3_selectionPrototype.html = function(value) {

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

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

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

} : value == null ? function() {

this.innerHTML = "";

} : function() {

this.innerHTML = value;

}) : this.node().innerHTML;

};

d3_selectionPrototype.append = function(name) {

name = d3_selection_creator(name);

return this.select(function() {

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

});

};

function d3_selection_creator(name) {

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

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

} : function() {

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

};

}

d3_selectionPrototype.insert = function(name, before) {

name = d3_selection_creator(name);

before = d3_selection_selector(before);

return this.select(function() {

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

});

};

d3_selectionPrototype.remove = function() {

return this.each(d3_selectionRemove);

};

function d3_selectionRemove() {

var parent = this.parentNode;

if (parent) parent.removeChild(this);

}

d3_selectionPrototype.data = function(value, key) {

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

if (!arguments.length) {

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

while (++i < n) {

if (node = group[i]) {

value[i] = node.__data__;

}

}

return value;

}

function bind(group, groupData) {

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

if (key) {

var nodeByKeyValue = new d3_Map(), keyValues = new Array(n), keyValue;

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

if (nodeByKeyValue.has(keyValue = key.call(node = group[i], node.__data__, i))) {

exitNodes[i] = node;

} else {

nodeByKeyValue.set(keyValue, node);

}

keyValues[i] = keyValue;

}

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

if (!(node = nodeByKeyValue.get(keyValue = key.call(groupData, nodeData = groupData[i], i)))) {

enterNodes[i] = d3_selection_dataNode(nodeData);

} else if (node !== true) {

updateNodes[i] = node;

node.__data__ = nodeData;

}

nodeByKeyValue.set(keyValue, true);

}

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

if (nodeByKeyValue.get(keyValues[i]) !== true) {

exitNodes[i] = group[i];

}

}

} else {

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

node = group[i];

nodeData = groupData[i];

if (node) {

node.__data__ = nodeData;

updateNodes[i] = node;

} else {

enterNodes[i] = d3_selection_dataNode(nodeData);

}

}

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

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

}

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

exitNodes[i] = group[i];

}

}

enterNodes.update = updateNodes;

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

enter.push(enterNodes);

update.push(updateNodes);

exit.push(exitNodes);

}

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

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

while (++i < n) {

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

}

} else {

while (++i < n) {

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

}

}

update.enter = function() {

return enter;

};

update.exit = function() {

return exit;

};

return update;

};

function d3_selection_dataNode(data) {

return {

__data__: data

};

}

d3_selectionPrototype.datum = function(value) {

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

};

d3_selectionPrototype.filter = function(filter) {

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

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

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

subgroups.push(subgroup = []);

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

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

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

subgroup.push(node);

}

}

}

return d3_selection(subgroups);

};

function d3_selection_filter(selector) {

return function() {

return d3_selectMatches(this, selector);

};

}

d3_selectionPrototype.order = function() {

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

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

if (node = group[i]) {

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

next = node;

}

}

}

return this;

};

d3_selectionPrototype.sort = function(comparator) {

comparator = d3_selection_sortComparator.apply(this, arguments);

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

return this.order();

};

function d3_selection_sortComparator(comparator) {

if (!arguments.length) comparator = d3_ascending;

return function(a, b) {

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

};

}

d3_selectionPrototype.each = function(callback) {

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

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

});

};

function d3_selection_each(groups, callback) {

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

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

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

}

}

return groups;

}

d3_selectionPrototype.call = function(callback) {

var args = d3_array(arguments);

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

return this;

};

d3_selectionPrototype.empty = function() {

return !this.node();

};

d3_selectionPrototype.node = function() {

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

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

var node = group[i];

if (node) return node;

}

}

return null;

};

d3_selectionPrototype.size = function() {

var n = 0;

d3_selection_each(this, function() {

++n;

});

return n;

};

function d3_selection_enter(selection) {

d3_subclass(selection, d3_selection_enterPrototype);

return selection;

}

var d3_selection_enterPrototype = [];

d3.selection.enter = d3_selection_enter;

d3.selection.enter.prototype = d3_selection_enterPrototype;

d3_selection_enterPrototype.append = d3_selectionPrototype.append;

d3_selection_enterPrototype.empty = d3_selectionPrototype.empty;

d3_selection_enterPrototype.node = d3_selectionPrototype.node;

d3_selection_enterPrototype.call = d3_selectionPrototype.call;

d3_selection_enterPrototype.size = d3_selectionPrototype.size;

d3_selection_enterPrototype.select = function(selector) {

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

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

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

subgroups.push(subgroup = []);

subgroup.parentNode = group.parentNode;

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

if (node = group[i]) {

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

subnode.__data__ = node.__data__;

} else {

subgroup.push(null);

}

}

}