(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;