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

return +new Date;

};

try {

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

} catch (error) {

var d3_style_prototype = CSSStyleDeclaration.prototype,

d3_style_setProperty = d3_style_prototype.setProperty;

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

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

};

}

d3 = {version: "2.7.1"}; // semver

var d3_array = d3_arraySlice; // conversion for NodeLists

function d3_arrayCopy(pseudoarray) {

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

while (++i < n) array.push(pseudoarray[i]);

return array;

}

function d3_arraySlice(pseudoarray) {

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

}

try {

d3_array(document.documentElement.childNodes)[0].nodeType;

} catch(e) {

d3_array = d3_arrayCopy;

}

var d3_arraySubclass = [].__proto__?

// Until ECMAScript supports array subclassing, prototype injection works well.

function(array, prototype) {

array.__proto__ = prototype;

}:

// And if your browser doesn't support __proto__, we'll use direct extension.

function(array, prototype) {

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

};

function d3_this() {

return this;

}

d3.functor = function(v) {

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

};

// Copies a variable number of methods from source to target.

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;

};

// Method is assumed to be a standard D3 getter-setter:

// If passed with no arguments, gets the value.

// If passed with arguments, sets the value and returns the target.

function d3_rebind(target, source, method) {

return function() {

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

return arguments.length ? target : value;

};

}

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.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.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.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.random = {

normal: function(mean, deviation) {

if (arguments.length < 2) deviation = 1;

if (arguments.length < 1) mean = 0;

return function() {

var x, y, r;

do {

x = Math.random() * 2 - 1;

y = Math.random() * 2 - 1;

r = x * x + y * y;

} while (!r || r > 1);

return mean + deviation * x * Math.sqrt(-2 * Math.log(r) / r);

};

}

};

function d3_number(x) {

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

}

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;

};

// R-7 per <http://en.wikipedia.org/wiki/Quantile>

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.transpose = function(matrix) {

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

};

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;

}

// Locate the insertion point for x in a to maintain sorted order. The

// arguments lo and hi may be used to specify a subset of the array which should

// be considered; by default the entire array is used. If x is already present

// in a, the insertion point will be before (to the left of) any existing

// entries. The return value is suitable for use as the first argument to

// `array.splice` assuming that a is already sorted.

//

// The returned insertion point i partitions the array a into two halves so that

// all v < x for v in a[lo:i] for the left side and all v >= x for v in a[i:hi]

// for the right side.

d3.bisectLeft = 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 (a[mid] < x) lo = mid + 1;

else hi = mid;

}

return lo;

};

// Similar to bisectLeft, but returns an insertion point which comes after (to

// the right of) any existing entries of x in a.

//

// The returned insertion point i partitions the array into two halves so that

// all v <= x for v in a[lo:i] for the left side and all v > x for v in a[i:hi]

// for the right side.

d3.bisect =

d3.bisectRight = 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 < a[mid]) hi = mid;

else lo = mid + 1;

}

return lo;

};

d3.first = function(array, f) {

var i = 0,

n = array.length,

a = array[0],

b;

if (arguments.length === 1) f = d3.ascending;

while (++i < n) {

if (f.call(array, a, b = array[i]) > 0) {

a = b;

}

}

return a;

};

d3.last = function(array, f) {

var i = 0,

n = array.length,

a = array[0],

b;

if (arguments.length === 1) f = d3.ascending;

while (++i < n) {

if (f.call(array, a, b = array[i]) <= 0) {

a = b;

}

}

return a;

};

d3.nest = function() {

var nest = {},

keys = [],

sortKeys = [],

sortValues,

rollup;

function map(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,

o = {};

while (++i < n) {

if ((keyValue = key(object = array[i])) in o) {

o[keyValue].push(object);

} else {

o[keyValue] = [object];

}

}

for (keyValue in o) {

o[keyValue] = map(o[keyValue], depth);

}

return o;

}

function entries(map, depth) {

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

var a = [],

sortKey = sortKeys[depth++],

key;

for (key in map) {

a.push({key: key, values: entries(map[key], depth)});

}

if (sortKey) a.sort(function(a, b) {

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

});

return a;

}

nest.map = function(array) {

return map(array, 0);

};

nest.entries = function(array) {

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

};

nest.key = function(d) {

keys.push(d);

return nest;

};

// Specifies the order for the most-recently specified key.

// Note: only applies to entries. Map keys are unordered!

nest.sortKeys = function(order) {

sortKeys[keys.length - 1] = order;

return nest;

};

// Specifies the order for leaf values.

// Applies to both maps and entries array.

nest.sortValues = function(order) {

sortValues = order;

return nest;

};

nest.rollup = function(f) {

rollup = f;

return nest;

};

return nest;

};

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.permute = function(array, indexes) {

var permutes = [],

i = -1,

n = indexes.length;

while (++i < n) permutes[i] = array[indexes[i]];

return permutes;

};

d3.merge = function(arrays) {

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

};

d3.split = function(array, f) {

var arrays = [],

values = [],

value,

i = -1,

n = array.length;

if (arguments.length < 2) f = d3_splitter;

while (++i < n) {

if (f.call(values, value = array[i], i)) {

values = [];

} else {

if (!values.length) arrays.push(values);

values.push(value);

}

}

return arrays;

};

function d3_splitter(d) {

return d == null;

}

function d3_collapse(s) {

return s.replace(/(^\s+)|(\s+$)/g, "").replace(/\s+/g, " ");

}

/**

* @param {number} start

* @param {number=} stop

* @param {number=} step

*/

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 = [],

i = -1,

j;

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

else while ((j = start + step * ++i) < stop) range.push(j);

return range;

};

d3.requote = function(s) {

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

};

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

d3.round = function(x, n) {

return n

? Math.round(x * Math.pow(10, n)) * Math.pow(10, -n)

: Math.round(x);

};

d3.xhr = function(url, mime, callback) {

var req = new XMLHttpRequest;

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

else if (mime && req.overrideMimeType) req.overrideMimeType(mime);

req.open("GET", url, true);

if (mime) req.setRequestHeader("Accept", mime);

req.onreadystatechange = function() {

if (req.readyState === 4) callback(req.status < 300 ? req : null);

};

req.send(null);

};

d3.text = function(url, mime, callback) {

function ready(req) {

callback(req && req.responseText);

}

if (arguments.length < 3) {

callback = mime;

mime = null;

}

d3.xhr(url, mime, ready);

};

d3.json = function(url, callback) {

d3.text(url, "application/json", function(text) {

callback(text ? JSON.parse(text) : null);

});

};

d3.html = function(url, callback) {

d3.text(url, "text/html", function(text) {

if (text != null) { // Treat empty string as valid HTML.

var range = document.createRange();

range.selectNode(document.body);

text = range.createContextualFragment(text);

}

callback(text);

});

};

d3.xml = function(url, mime, callback) {

function ready(req) {

callback(req && req.responseXML);

}

if (arguments.length < 3) {

callback = mime;

mime = null;

}

d3.xhr(url, mime, ready);

};

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(":");

return i < 0 ? (name in d3_nsPrefix

? {space: d3_nsPrefix[name], local: name} : name)

: {space: d3_nsPrefix[name.substring(0, i)], local: name.substring(i + 1)};

}

};

d3.dispatch = function() {

var dispatch = new d3_dispatch(),

i = -1,

n = arguments.length;

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

return dispatch;

};

function d3_dispatch() {}

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

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

name = "";

// Extract optional namespace, e.g., "click.foo"

if (i > 0) {

name = type.substring(i + 1);

type = type.substring(0, i);

}

return arguments.length < 2

? this[type].on(name)

: (this[type].on(name, listener), this);

};

function d3_dispatch_event() {

var listeners = [],

listenerByName = {};

function dispatch() {

var z = listeners, // defensive reference

i = -1,

n = z.length,

l;

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

}

dispatch.on = function(name, listener) {

var l, i;

// return the current listener, if any

if (arguments.length < 2) return (l = listenerByName[name]) && l.on;

// remove the old listener, if any (with copy-on-write)

if (l = listenerByName[name]) {

l.on = null;

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

delete listenerByName[name];

}

// add the new listener, if any

if (listener) {

listeners.push(listenerByName[name] = {on: listener});

}

return dispatch;

};

return dispatch;

};

// TODO align

d3.format = function(specifier) {

var match = d3_format_re.exec(specifier),

fill = match[1] || " ",

sign = match[3] || "",

zfill = match[5],

width = +match[6],

comma = match[7],

precision = match[8],

type = match[9],

scale = 1,

suffix = "",

integer = false;

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

if (zfill) {

fill = "0"; // TODO align = "=";

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

}

switch (type) {

case "n": comma = true; type = "g"; break;

case "%": scale = 100; suffix = "%"; type = "f"; break;

case "p": scale = 100; suffix = "%"; type = "r"; break;

case "d": integer = true; precision = 0; break;

case "s": scale = -1; type = "r"; break;

}

// If no precision is specified for r, fallback to general notation.

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

type = d3_format_types[type] || d3_format_typeDefault;

return function(value) {

// Return the empty string for floats formatted as ints.

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

// Convert negative to positive, and record the sign prefix.

var negative = (value < 0) && (value = -value) ? "\u2212" : sign;

// Apply the scale, computing it from the value's exponent for si format.

if (scale < 0) {

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

value *= prefix.scale;

suffix = prefix.symbol;

} else {

value *= scale;

}

// Convert to the desired precision.

value = type(value, precision);

// If the fill character is 0, the sign and group is applied after the fill.

if (zfill) {

var length = value.length + negative.length;

if (length < width) value = new Array(width - length + 1).join(fill) + value;

if (comma) value = d3_format_group(value);

value = negative + value;

}

// Otherwise (e.g., space-filling), the sign and group is applied before.

else {

if (comma) value = d3_format_group(value);

value = negative + value;

var length = value.length;

if (length < width) value = new Array(width - length + 1).join(fill) + value;

}

return value + suffix;

};

};

// [[fill]align][sign][#][0][width][,][.precision][type]

var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?(#)?(0)?([0-9]+)?(,)?(\.[0-9]+)?([a-zA-Z%])?/;

var d3_format_types = {

g: function(x, p) { return x.toPrecision(p); },

e: function(x, p) { return x.toExponential(p); },

f: function(x, p) { return x.toFixed(p); },

r: function(x, p) { return d3.round(x, p = d3_format_precision(x, p)).toFixed(Math.max(0, Math.min(20, p))); }

};

function d3_format_precision(x, p) {

return p - (x ? 1 + Math.floor(Math.log(x + Math.pow(10, 1 + Math.floor(Math.log(x) / Math.LN10) - p)) / Math.LN10) : 1);

}

function d3_format_typeDefault(x) {

return x + "";

}

// Apply comma grouping for thousands.

function d3_format_group(value) {

var i = value.lastIndexOf("."),

f = i >= 0 ? value.substring(i) : (i = value.length, ""),

t = [];

while (i > 0) t.push(value.substring(i -= 3, i + 3));

return t.reverse().join(",") + f;

}

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

d3.formatPrefix = function(value, precision) {

var i = 0;

if (value) {

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

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

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

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

}

return d3_formatPrefixes[8 + i / 3];

};

function d3_formatPrefix(d, i) {

return {

scale: Math.pow(10, (8 - i) * 3),

symbol: d

};

}

/*

* TERMS OF USE - EASING EQUATIONS

*

* Open source under the BSD License.

*

* Copyright 2001 Robert Penner

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are met:

*

* - Redistributions of source code must retain the above copyright notice, this

* list of conditions and the following disclaimer.

*

* - Redistributions in binary form must reproduce the above copyright notice,

* this list of conditions and the following disclaimer in the documentation

* and/or other materials provided with the distribution.

*

* - Neither the name of the author nor the names of contributors may be used to

* endorse or promote products derived from this software without specific

* prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

* POSSIBILITY OF SUCH DAMAGE.

*/

var d3_ease_quad = d3_ease_poly(2),

d3_ease_cubic = d3_ease_poly(3);

var d3_ease = {

linear: function() { return d3_ease_linear; },

poly: d3_ease_poly,

quad: function() { return d3_ease_quad; },

cubic: function() { return d3_ease_cubic; },

sin: function() { return d3_ease_sin; },

exp: function() { return d3_ease_exp; },

circle: function() { return d3_ease_circle; },

elastic: d3_ease_elastic,

back: d3_ease_back,

bounce: function() { return d3_ease_bounce; }

};

var d3_ease_mode = {

"in": function(f) { return f; },

"out": d3_ease_reverse,

"in-out": d3_ease_reflect,

"out-in": function(f) { return d3_ease_reflect(d3_ease_reverse(f)); }

};

d3.ease = function(name) {

var i = name.indexOf("-"),

t = i >= 0 ? name.substring(0, i) : name,

m = i >= 0 ? name.substring(i + 1) : "in";

return d3_ease_clamp(d3_ease_mode[m](d3_ease[t].apply(null, Array.prototype.slice.call(arguments, 1))));

};

function d3_ease_clamp(f) {

return function(t) {

return t <= 0 ? 0 : t >= 1 ? 1 : f(t);

};

}

function d3_ease_reverse(f) {

return function(t) {

return 1 - f(1 - t);

};

}

function d3_ease_reflect(f) {

return function(t) {

return .5 * (t < .5 ? f(2 * t) : (2 - f(2 - 2 * t)));

};

}

function d3_ease_linear(t) {

return t;

}

function d3_ease_poly(e) {

return function(t) {

return Math.pow(t, e);

}

}

function d3_ease_sin(t) {

return 1 - Math.cos(t * Math.PI / 2);

}

function d3_ease_exp(t) {

return Math.pow(2, 10 * (t - 1));

}

function d3_ease_circle(t) {

return 1 - Math.sqrt(1 - t * t);

}

function d3_ease_elastic(a, p) {

var s;

if (arguments.length < 2) p = 0.45;

if (arguments.length < 1) { a = 1; s = p / 4; }

else s = p / (2 * Math.PI) * Math.asin(1 / a);

return function(t) {

return 1 + a * Math.pow(2, 10 * -t) * Math.sin((t - s) * 2 * Math.PI / p);

};

}

function d3_ease_back(s) {

if (!s) s = 1.70158;

return function(t) {

return t * t * ((s + 1) * t - s);

};

}

function d3_ease_bounce(t) {

return t < 1 / 2.75 ? 7.5625 * t * t

: t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75

: t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375

: 7.5625 * (t -= 2.625 / 2.75) * t + .984375;

}

d3.event = null;

function d3_eventCancel() {

d3.event.stopPropagation();

d3.event.preventDefault();

}

d3.interpolate = function(a, b) {

var i = d3.interpolators.length, f;

while (--i >= 0 && !(f = d3.interpolators[i](a, b)));

return f;

};

d3.interpolateNumber = function(a, b) {

b -= a;

return function(t) { return a + b * t; };

};

d3.interpolateRound = function(a, b) {

b -= a;

return function(t) { return Math.round(a + b * t); };

};

d3.interpolateString = function(a, b) {

var m, // current match

i, // current index

j, // current index (for coallescing)

s0 = 0, // start index of current string prefix

s1 = 0, // end index of current string prefix

s = [], // string constants and placeholders

q = [], // number interpolators

n, // q.length

o;

// Reset our regular expression!

d3_interpolate_number.lastIndex = 0;

// Find all numbers in b.

for (i = 0; m = d3_interpolate_number.exec(b); ++i) {

if (m.index) s.push(b.substring(s0, s1 = m.index));

q.push({i: s.length, x: m[0]});

s.push(null);

s0 = d3_interpolate_number.lastIndex;

}

if (s0 < b.length) s.push(b.substring(s0));

// Find all numbers in a.

for (i = 0, n = q.length; (m = d3_interpolate_number.exec(a)) && i < n; ++i) {

o = q[i];

if (o.x == m[0]) { // The numbers match, so coallesce.

if (o.i) {

if (s[o.i + 1] == null) { // This match is followed by another number.

s[o.i - 1] += o.x;

s.splice(o.i, 1);

for (j = i + 1; j < n; ++j) q[j].i--;

} else { // This match is followed by a string, so coallesce twice.

s[o.i - 1] += o.x + s[o.i + 1];

s.splice(o.i, 2);

for (j = i + 1; j < n; ++j) q[j].i -= 2;

}

} else {

if (s[o.i + 1] == null) { // This match is followed by another number.

s[o.i] = o.x;

} else { // This match is followed by a string, so coallesce twice.

s[o.i] = o.x + s[o.i + 1];

s.splice(o.i + 1, 1);

for (j = i + 1; j < n; ++j) q[j].i--;

}

}

q.splice(i, 1);

n--;

i--;

} else {

o.x = d3.interpolateNumber(parseFloat(m[0]), parseFloat(o.x));

}

}

// Remove any numbers in b not found in a.

while (i < n) {

o = q.pop();

if (s[o.i + 1] == null) { // This match is followed by another number.

s[o.i] = o.x;

} else { // This match is followed by a string, so coallesce twice.

s[o.i] = o.x + s[o.i + 1];

s.splice(o.i + 1, 1);

}

n--;

}

// Special optimization for only a single match.

if (s.length === 1) {

return s[0] == null ? q[0].x : function() { return b; };

}

// Otherwise, interpolate each of the numbers and rejoin the string.

return function(t) {

for (i = 0; i < n; ++i) s[(o = q[i]).i] = o.x(t);

return s.join("");

};

};

d3.interpolateTransform = function(a, b) {

return d3.interpolateString(d3.transform(a) + "", d3.transform(b) + "");

};

d3.interpolateRgb = function(a, b) {

a = d3.rgb(a);

b = d3.rgb(b);

var ar = a.r,

ag = a.g,

ab = a.b,

br = b.r - ar,

bg = b.g - ag,

bb = b.b - ab;

return function(t) {

return "#"

+ d3_rgb_hex(Math.round(ar + br * t))

+ d3_rgb_hex(Math.round(ag + bg * t))

+ d3_rgb_hex(Math.round(ab + bb * t));

};

};

// interpolates HSL space, but outputs RGB string (for compatibility)

d3.interpolateHsl = function(a, b) {

a = d3.hsl(a);

b = d3.hsl(b);

var h0 = a.h,

s0 = a.s,

l0 = a.l,

h1 = b.h - h0,

s1 = b.s - s0,

l1 = b.l - l0;

return function(t) {

return d3_hsl_rgb(h0 + h1 * t, s0 + s1 * t, l0 + l1 * t).toString();

};

};

d3.interpolateArray = function(a, b) {

var x = [],

c = [],

na = a.length,

nb = b.length,

n0 = Math.min(a.length, b.length),

i;

for (i = 0; i < n0; ++i) x.push(d3.interpolate(a[i], b[i]));

for (; i < na; ++i) c[i] = a[i];

for (; i < nb; ++i) c[i] = b[i];

return function(t) {

for (i = 0; i < n0; ++i) c[i] = x[i](t);

return c;

};

};

d3.interpolateObject = function(a, b) {

var i = {},

c = {},

k;

for (k in a) {

if (k in b) {

i[k] = d3_interpolateByName(k)(a[k], b[k]);

} else {

c[k] = a[k];

}

}

for (k in b) {

if (!(k in a)) {

c[k] = b[k];

}

}

return function(t) {

for (k in i) c[k] = i[k](t);

return c;

};

}

var d3_interpolate_number = /[-+]?(?:\d*\.?\d+)(?:[eE][-+]?\d+)?/g;

function d3_interpolateByName(n) {

return n == "transform"

? d3.interpolateTransform

: d3.interpolate;

}

d3.interpolators = [

d3.interpolateObject,

function(a, b) { return (b instanceof Array) && d3.interpolateArray(a, b); },

function(a, b) { return (typeof a === "string" || typeof b === "string") && d3.interpolateString(a + "", b + ""); },

function(a, b) { return (typeof b === "string" ? b in d3_rgb_names || /^(#|rgb\(|hsl\()/.test(b) : b instanceof d3_Rgb || b instanceof d3_Hsl) && d3.interpolateRgb(a, b); },

function(a, b) { return !isNaN(a = +a) && !isNaN(b = +b) && d3.interpolateNumber(a, b); }

];

function d3_uninterpolateNumber(a, b) {

b = b - (a = +a) ? 1 / (b - a) : 0;

return function(x) { return (x - a) * b; };

}

function d3_uninterpolateClamp(a, b) {

b = b - (a = +a) ? 1 / (b - a) : 0;

return function(x) { return Math.max(0, Math.min(1, (x - a) * b)); };

}

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

return arguments.length === 1

? (r instanceof d3_Rgb ? d3_rgb(r.r, r.g, r.b)

: d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb))

: d3_rgb(~~r, ~~g, ~~b);

};