d3 = function() {

var d3 = {

version: "3.2.8"

};

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

return +new Date();

};

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

try {

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

} catch (error) {

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

d3_element_prototype.setAttribute = function(name, value) {

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

};

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

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

};

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

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

};

}

d3.ascending = function(a, b) {

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

};

d3.descending = function(a, b) {

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

};

d3.min = function(array, f) {

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

if (arguments.length === 1) {

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

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

} else {

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

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

}

return a;

};

d3.max = function(array, f) {

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

if (arguments.length === 1) {

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

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

} else {

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

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

}

return a;

};

d3.extent = function(array, f) {

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

if (arguments.length === 1) {

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

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

if (a > b) a = b;

if (c < b) c = b;

}

} else {

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

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

if (a > b) a = b;

if (c < b) c = b;

}

}

return [ a, c ];

};

d3.sum = function(array, f) {

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

if (arguments.length === 1) {

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

} else {

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

}

return s;

};

function d3_number(x) {

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

}

d3.mean = function(array, f) {

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

if (arguments.length === 1) {

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

} else {

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

}

return j ? m : undefined;

};

d3.quantile = function(values, p) {

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

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

};

d3.median = function(array, f) {

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

array = array.filter(d3_number);

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

};

d3.bisector = function(f) {

return {

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

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

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

while (lo < hi) {

var mid = lo + hi >>> 1;

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

}

return lo;

},

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

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

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

while (lo < hi) {

var mid = lo + hi >>> 1;

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

}

return lo;

}

};

};

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

return d;

});

d3.bisectLeft = d3_bisector.left;

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

d3.shuffle = function(array) {

var m = array.length, t, i;

while (m) {

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

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

}

return array;

};

d3.permute = function(array, indexes) {

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

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

return permutes;

};

d3.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) {

return Array.prototype.concat.apply([], arrays);

};

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(Math.abs(step)), i = -1, j;

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

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

return range;

};

function d3_range_integerScale(x) {

var k = 1;

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

return k;

}

function d3_class(ctor, properties) {

try {

for (var key in properties) {

Object.defineProperty(ctor.prototype, key, {

value: properties[key],

enumerable: false

});

}

} catch (e) {

ctor.prototype = properties;

}

}

d3.map = function(object) {

var map = new d3_Map();

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

map.set(key, value);

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

return map;

};

function d3_Map() {}

d3_class(d3_Map, {

has: function(key) {

return d3_map_prefix + key in this;

},

get: function(key) {

return this[d3_map_prefix + key];

},

set: function(key, value) {

return this[d3_map_prefix + key] = value;

},

remove: function(key) {

key = d3_map_prefix + key;

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

},

keys: function() {

var keys = [];

this.forEach(function(key) {

keys.push(key);

});

return keys;

},

values: function() {

var values = [];

this.forEach(function(key, value) {

values.push(value);

});

return values;

},

entries: function() {

var entries = [];

this.forEach(function(key, value) {

entries.push({

key: key,

value: value

});

});

return entries;

},

forEach: function(f) {

for (var key in this) {

if (key.charCodeAt(0) === d3_map_prefixCode) {

f.call(this, key.substring(1), this[key]);

}

}

}

});

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

d3.nest = function() {

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

function map(mapType, array, depth) {

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

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

while (++i < n) {

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

values.push(object);

} else {

valuesByKey.set(keyValue, [ object ]);

}

}

if (mapType) {

object = mapType();

setter = function(keyValue, values) {

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

};

} else {

object = {};

setter = function(keyValue, values) {

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

};

}

valuesByKey.forEach(setter);

return object;

}

function entries(map, depth) {

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

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

map.forEach(function(key, keyMap) {

array.push({

key: key,

values: entries(keyMap, depth)

});

});

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

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

}) : array;

}

nest.map = function(array, mapType) {

return map(mapType, array, 0);

};

nest.entries = function(array) {

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

};

nest.key = function(d) {

keys.push(d);

return nest;

};

nest.sortKeys = function(order) {

sortKeys[keys.length - 1] = order;

return nest;

};

nest.sortValues = function(order) {

sortValues = order;

return nest;

};

nest.rollup = function(f) {

rollup = f;

return nest;

};

return nest;

};

d3.set = function(array) {

var set = new d3_Set();

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

return set;

};

function d3_Set() {}

d3_class(d3_Set, {

has: function(value) {

return d3_map_prefix + value in this;

},

add: function(value) {

this[d3_map_prefix + value] = true;

return value;

},

remove: function(value) {

value = d3_map_prefix + value;

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

},

values: function() {

var values = [];

this.forEach(function(value) {

values.push(value);

});

return values;

},

forEach: function(f) {

for (var value in this) {

if (value.charCodeAt(0) === d3_map_prefixCode) {

f.call(this, value.substring(1));

}

}

}

});

d3.behavior = {};

d3.rebind = function(target, source) {

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

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

return target;

};

function d3_rebind(target, source, method) {

return function() {

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

return value === source ? target : value;

};

}

function d3_vendorSymbol(object, name) {

if (name in object) return name;

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

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

var prefixName = d3_vendorPrefixes[i] + name;

if (prefixName in object) return prefixName;

}

}

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

var d3_array = d3_arraySlice;

function d3_arrayCopy(pseudoarray) {

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

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

return array;

}

function d3_arraySlice(pseudoarray) {

return Array.prototype.slice.call(pseudoarray);

}

try {

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

} catch (e) {

d3_array = d3_arrayCopy;

}

function d3_noop() {}

d3.dispatch = function() {

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

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

return dispatch;

};

function d3_dispatch() {}

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

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

if (i >= 0) {

name = type.substring(i + 1);

type = type.substring(0, i);

}

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

if (arguments.length === 2) {

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

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

}

return this;

}

};

function d3_dispatch_event(dispatch) {

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

function event() {

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

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

return dispatch;

}

event.on = function(name, listener) {

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

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

if (l) {

l.on = null;

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

listenerByName.remove(name);

}

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

on: listener

}));

return dispatch;

};

return event;

}

d3.event = null;

function d3_eventPreventDefault() {

d3.event.preventDefault();

}

function d3_eventSource() {

var e = d3.event, s;

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

return e;

}

function d3_eventDispatch(target) {

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

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

dispatch.of = function(thiz, argumentz) {

return function(e1) {

try {

var e0 = e1.sourceEvent = d3.event;

e1.target = target;

d3.event = e1;

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

} finally {

d3.event = e0;

}

};

};

return dispatch;

}

d3.requote = function(s) {

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

};

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

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

object.__proto__ = prototype;

} : function(object, prototype) {

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

};

function d3_selection(groups) {

d3_subclass(groups, d3_selectionPrototype);

return groups;

}

var d3_select = function(s, n) {

return n.querySelector(s);

}, d3_selectAll = function(s, n) {

return n.querySelectorAll(s);

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

return d3_selectMatcher.call(n, s);

};

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

d3_select = function(s, n) {

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

};

d3_selectAll = function(s, n) {

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

};

d3_selectMatches = Sizzle.matchesSelector;

}

d3.selection = function() {

return d3_selectionRoot;

};

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

d3_selectionPrototype.select = function(selector) {

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

selector = d3_selection_selector(selector);

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

subgroups.push(subgroup = []);

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

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

if (node = group[i]) {

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

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

} else {

subgroup.push(null);

}

}

}

return d3_selection(subgroups);

};

function d3_selection_selector(selector) {

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

return d3_select(selector, this);

};

}

d3_selectionPrototype.selectAll = function(selector) {

var subgroups = [], subgroup, node;

selector = d3_selection_selectorAll(selector);

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

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

if (node = group[i]) {

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

subgroup.parentNode = node;

}

}

}

return d3_selection(subgroups);

};

function d3_selection_selectorAll(selector) {

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

return d3_selectAll(selector, this);

};

}

var d3_nsPrefix = {

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

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

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

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

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

};

d3.ns = {

prefix: d3_nsPrefix,

qualify: function(name) {

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

if (i >= 0) {

prefix = name.substring(0, i);

name = name.substring(i + 1);

}

return d3_nsPrefix.hasOwnProperty(prefix) ? {

space: d3_nsPrefix[prefix],

local: name

} : name;

}

};

d3_selectionPrototype.attr = function(name, value) {

if (arguments.length < 2) {

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

var node = this.node();

name = d3.ns.qualify(name);

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

}

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

return this;

}

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

};

function d3_selection_attr(name, value) {

name = d3.ns.qualify(name);

function attrNull() {

this.removeAttribute(name);

}

function attrNullNS() {

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

}

function attrConstant() {

this.setAttribute(name, value);

}

function attrConstantNS() {

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

}

function attrFunction() {

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

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

}

function attrFunctionNS() {

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

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

}

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

}

function d3_collapse(s) {

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

}

d3_selectionPrototype.classed = function(name, value) {

if (arguments.length < 2) {

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

var node = this.node(), n = (name = name.trim().split(/^|\s+/g)).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_classed(name, value) {

name = name.trim().split(/\s+/).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 d3_document.createElementNS(name.space, name.local);

} : function() {

return d3_document.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));

});

};

d3_selectionPrototype.remove = function() {

return this.each(function() {

var parent = this.parentNode;

if (parent) parent.removeChild(this);

});

};

d3_selectionPrototype.data = function(value, key) {

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

if (!arguments.length) {

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

while (++i < n) {

if (node = group[i]) {

value[i] = node.__data__;

}

}

return value;

}

function bind(group, groupData) {

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

if (key) {

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

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

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

if (nodeByKeyValue.has(keyValue)) {

exitNodes[i] = node;

} else {

nodeByKeyValue.set(keyValue, node);

}

keyValues.push(keyValue);

}

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

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

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

updateNodes[i] = node;

node.__data__ = nodeData;

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

enterNodes[i] = d3_selection_dataNode(nodeData);

}

dataByKeyValue.set(keyValue, nodeData);

nodeByKeyValue.remove(keyValue);

}

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

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

exitNodes[i] = group[i];

}

}

} else {

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

node = group[i];

nodeData = groupData[i];

if (node) {

node.__data__ = nodeData;

updateNodes[i] = node;

} else {

enterNodes[i] = d3_selection_dataNode(nodeData);

}

}

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

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

}

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

exitNodes[i] = group[i];

}

}

enterNodes.update = updateNodes;

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

enter.push(enterNodes);

update.push(updateNodes);

exit.push(exitNodes);

}

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

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

while (++i < n) {

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

}

} else {

while (++i < n) {

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

}

}

update.enter = function() {

return enter;

};

update.exit = function() {

return exit;

};

return update;

};

function d3_selection_dataNode(data) {

return {

__data__: data

};

}

d3_selectionPrototype.datum = function(value) {

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

};

d3_selectionPrototype.filter = function(filter) {

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

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

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

subgroups.push(subgroup = []);

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

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

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

subgroup.push(node);

}

}

}

return d3_selection(subgroups);

};

function d3_selection_filter(selector) {

return function() {

return d3_selectMatches(this, selector);

};

}

d3_selectionPrototype.order = function() {

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

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

if (node = group[i]) {

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

next = node;

}

}

}

return this;

};

d3_selectionPrototype.sort = function(comparator) {

comparator = d3_selection_sortComparator.apply(this, arguments);

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

return this.order();

};

function d3_selection_sortComparator(comparator) {

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

return function(a, b) {

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

};

}

d3_selectionPrototype.each = function(callback) {

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

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

});

};

function d3_selection_each(groups, callback) {

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

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

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

}

}

return groups;

}

d3_selectionPrototype.call = function(callback) {

var args = d3_array(arguments);

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

return this;

};

d3_selectionPrototype.empty = function() {

return !this.node();

};

d3_selectionPrototype.node = function() {

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

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

var node = group[i];

if (node) return node;

}

}

return null;

};

d3_selectionPrototype.size = function() {

var n = 0;

this.each(function() {

++n;

});

return n;

};

function d3_selection_enter(selection) {

d3_subclass(selection, d3_selection_enterPrototype);

return selection;

}

var d3_selection_enterPrototype = [];

d3.selection.enter = d3_selection_enter;

d3.selection.enter.prototype = d3_selection_enterPrototype;

d3_selection_enterPrototype.append = d3_selectionPrototype.append;

d3_selection_enterPrototype.empty = d3_selectionPrototype.empty;

d3_selection_enterPrototype.node = d3_selectionPrototype.node;

d3_selection_enterPrototype.call = d3_selectionPrototype.call;

d3_selection_enterPrototype.size = d3_selectionPrototype.size;

d3_selection_enterPrototype.select = function(selector) {

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

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

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

subgroups.push(subgroup = []);

subgroup.parentNode = group.parentNode;

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

if (node = group[i]) {

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

subnode.__data__ = node.__data__;

} else {

subgroup.push(null);

}

}

}

return d3_selection(subgroups);

};

d3_selection_enterPrototype.insert = function(name, before) {

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

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

};

function d3_selection_enterInsertBefore(enter) {

var i0, j0;

return function(d, i, j) {

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

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

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

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

return node;

};

}

d3_selectionPrototype.transition = function() {

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

time: Date.now(),

ease: d3_ease_cubicInOut,

delay: 0,

duration: 250

};

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

subgroups.push(subgroup = []);

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

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

subgroup.push(node);

}

}

return d3_transition(subgroups, id);

};

d3.select = function(node) {

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

group.parentNode = d3_documentElement;

return d3_selection([ group ]);

};

d3.selectAll = function(nodes) {

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

group.parentNode = d3_documentElement;

return d3_selection([ group ]);

};

var d3_selectionRoot = d3.select(d3_documentElement);

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

var n = arguments.length;

if (n < 3) {

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

if (n < 2) listener = false;

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

return this;

}

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

capture = false;

}

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

};

function d3_selection_on(type, listener, capture) {

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

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

var filter = d3_selection_onFilters.get(type);

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

function onRemove() {

var l = this[name];

if (l) {

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

delete this[name];

}

}

function onAdd() {

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

onRemove.call(this);

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

l._ = listener;

}