/* /_ui/js/lib/prototype.js */
/*  Prototype JavaScript framework, version 1.6.1
 *  (c) 2005-2009 Sam Stephenson
 *
 *  Prototype is freely distributable under the terms of an MIT-style license.
 *  For details, see the Prototype web site: http://www.prototypejs.org/
 *
 *--------------------------------------------------------------------------*/

var Prototype = {
  Version: '1.6.1',

  Browser: (function(){
    var ua = navigator.userAgent;
    var isOpera = Object.prototype.toString.call(window.opera) == '[object Opera]';
    return {
      IE:             !!window.attachEvent && !isOpera,
      Opera:          isOpera,
      WebKit:         ua.indexOf('AppleWebKit/') > -1,
      Gecko:          ua.indexOf('Gecko') > -1 && ua.indexOf('KHTML') === -1,
      MobileSafari:   /Apple.*Mobile.*Safari/.test(ua)
    }
  })(),

  BrowserFeatures: {
    XPath: !!document.evaluate,
    SelectorsAPI: !!document.querySelector,
    ElementExtensions: (function() {
      var constructor = window.Element || window.HTMLElement;
      return !!(constructor && constructor.prototype);
    })(),
    SpecificElementExtensions: (function() {
      if (typeof window.HTMLDivElement !== 'undefined')
        return true;

      var div = document.createElement('div');
      var form = document.createElement('form');
      var isSupported = false;

      if (div['__proto__'] && (div['__proto__'] !== form['__proto__'])) {
        isSupported = true;
      }

      div = form = null;

      return isSupported;
    })()
  },

  ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
  JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,

  emptyFunction: function() { },
  K: function(x) { return x }
};

if (Prototype.Browser.MobileSafari)
  Prototype.BrowserFeatures.SpecificElementExtensions = false;


var Abstract = { };


var Try = {
  these: function() {
    var returnValue;

    for (var i = 0, length = arguments.length; i < length; i++) {
      var lambda = arguments[i];
      try {
        returnValue = lambda();
        break;
      } catch (e) { }
    }

    return returnValue;
  }
};

/* Based on Alex Arnell's inheritance implementation. */

var Class = (function() {
  function subclass() {};
  function create() {
    var parent = null, properties = $A(arguments);
    if (Object.isFunction(properties[0]))
      parent = properties.shift();

    function klass() {
      this.initialize.apply(this, arguments);
    }

    Object.extend(klass, Class.Methods);
    klass.superclass = parent;
    klass.subclasses = [];

    if (parent) {
      subclass.prototype = parent.prototype;
      klass.prototype = new subclass;
      parent.subclasses.push(klass);
    }

    for (var i = 0; i < properties.length; i++)
      klass.addMethods(properties[i]);

    if (!klass.prototype.initialize)
      klass.prototype.initialize = Prototype.emptyFunction;

    klass.prototype.constructor = klass;
    return klass;
  }

  function addMethods(source) {
    var ancestor   = this.superclass && this.superclass.prototype;
    var properties = Object.keys(source);

    if (!Object.keys({ toString: true }).length) {
      if (source.toString != Object.prototype.toString)
        properties.push("toString");
      if (source.valueOf != Object.prototype.valueOf)
        properties.push("valueOf");
    }

    for (var i = 0, length = properties.length; i < length; i++) {
      var property = properties[i], value = source[property];
      if (ancestor && Object.isFunction(value) &&
          value.argumentNames().first() == "$super") {
        var method = value;
        value = (function(m) {
          return function() { return ancestor[m].apply(this, arguments); };
        })(property).wrap(method);

        value.valueOf = method.valueOf.bind(method);
        value.toString = method.toString.bind(method);
      }
      this.prototype[property] = value;
    }

    return this;
  }

  return {
    create: create,
    Methods: {
      addMethods: addMethods
    }
  };
})();
(function() {

  var _toString = Object.prototype.toString;

  function extend(destination, source) {
    for (var property in source)
      destination[property] = source[property];
    return destination;
  }

  function inspect(object) {
    try {
      if (isUndefined(object)) return 'undefined';
      if (object === null) return 'null';
      return object.inspect ? object.inspect() : String(object);
    } catch (e) {
      if (e instanceof RangeError) return '...';
      throw e;
    }
  }

  function toJSON(object) {
    var type = typeof object;
    switch (type) {
      case 'undefined':
      case 'function':
      case 'unknown': return;
      case 'boolean': return object.toString();
    }

    if (object === null) return 'null';
    if (object.toJSON) return object.toJSON();
    if (isElement(object)) return;

    var results = [];
    for (var property in object) {
      var value = toJSON(object[property]);
      if (!isUndefined(value))
        results.push(property.toJSON() + ': ' + value);
    }

    return '{' + results.join(', ') + '}';
  }

  function toQueryString(object) {
    return $H(object).toQueryString();
  }

  function toHTML(object) {
    return object && object.toHTML ? object.toHTML() : String.interpret(object);
  }

  function keys(object) {
    var results = [];
    for (var property in object)
      results.push(property);
    return results;
  }

  function values(object) {
    var results = [];
    for (var property in object)
      results.push(object[property]);
    return results;
  }

  function clone(object) {
    return extend({ }, object);
  }

  function isElement(object) {
    return !!(object && object.nodeType == 1);
  }

  function isArray(object) {
    return _toString.call(object) == "[object Array]";
  }


  function isHash(object) {
    return object instanceof Hash;
  }

  function isFunction(object) {
    return typeof object === "function";
  }

  function isString(object) {
    return _toString.call(object) == "[object String]";
  }

  function isNumber(object) {
    return _toString.call(object) == "[object Number]";
  }

  function isUndefined(object) {
    return typeof object === "undefined";
  }

  extend(Object, {
    extend:        extend,
    inspect:       inspect,
    toJSON:        toJSON,
    toQueryString: toQueryString,
    toHTML:        toHTML,
    keys:          keys,
    values:        values,
    clone:         clone,
    isElement:     isElement,
    isArray:       isArray,
    isHash:        isHash,
    isFunction:    isFunction,
    isString:      isString,
    isNumber:      isNumber,
    isUndefined:   isUndefined
  });
})();
Object.extend(Function.prototype, (function() {
  var slice = Array.prototype.slice;

  function update(array, args) {
    var arrayLength = array.length, length = args.length;
    while (length--) array[arrayLength + length] = args[length];
    return array;
  }

  function merge(array, args) {
    array = slice.call(array, 0);
    return update(array, args);
  }

  function argumentNames() {
    var names = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1]
      .replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '')
      .replace(/\s+/g, '').split(',');
    return names.length == 1 && !names[0] ? [] : names;
  }

  function bind(context) {
    if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
    var __method = this, args = slice.call(arguments, 1);
    return function() {
      var a = merge(args, arguments);
      return __method.apply(context, a);
    }
  }

  function bindAsEventListener(context) {
    var __method = this, args = slice.call(arguments, 1);
    return function(event) {
      var a = update([event || window.event], args);
      return __method.apply(context, a);
    }
  }

  function curry() {
    if (!arguments.length) return this;
    var __method = this, args = slice.call(arguments, 0);
    return function() {
      var a = merge(args, arguments);
      return __method.apply(this, a);
    }
  }

  function delay(timeout) {
    var __method = this, args = slice.call(arguments, 1);
    timeout = timeout * 1000
    return window.setTimeout(function() {
      return __method.apply(__method, args);
    }, timeout);
  }

  function defer() {
    var args = update([0.01], arguments);
    return this.delay.apply(this, args);
  }

  function wrap(wrapper) {
    var __method = this;
    return function() {
      var a = update([__method.bind(this)], arguments);
      return wrapper.apply(this, a);
    }
  }

  function methodize() {
    if (this._methodized) return this._methodized;
    var __method = this;
    return this._methodized = function() {
      var a = update([this], arguments);
      return __method.apply(null, a);
    };
  }

  return {
    argumentNames:       argumentNames,
    bind:                bind,
    bindAsEventListener: bindAsEventListener,
    curry:               curry,
    delay:               delay,
    defer:               defer,
    wrap:                wrap,
    methodize:           methodize
  }
})());


Date.prototype.toJSON = function() {
  return '"' + this.getUTCFullYear() + '-' +
    (this.getUTCMonth() + 1).toPaddedString(2) + '-' +
    this.getUTCDate().toPaddedString(2) + 'T' +
    this.getUTCHours().toPaddedString(2) + ':' +
    this.getUTCMinutes().toPaddedString(2) + ':' +
    this.getUTCSeconds().toPaddedString(2) + 'Z"';
};


RegExp.prototype.match = RegExp.prototype.test;

RegExp.escape = function(str) {
  return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
};
var PeriodicalExecuter = Class.create({
  initialize: function(callback, frequency) {
    this.callback = callback;
    this.frequency = frequency;
    this.currentlyExecuting = false;

    this.registerCallback();
  },

  registerCallback: function() {
    this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
  },

  execute: function() {
    this.callback(this);
  },

  stop: function() {
    if (!this.timer) return;
    clearInterval(this.timer);
    this.timer = null;
  },

  onTimerEvent: function() {
    if (!this.currentlyExecuting) {
      try {
        this.currentlyExecuting = true;
        this.execute();
        this.currentlyExecuting = false;
      } catch(e) {
        this.currentlyExecuting = false;
        throw e;
      }
    }
  }
});
Object.extend(String, {
  interpret: function(value) {
    return value == null ? '' : String(value);
  },
  specialChar: {
    '\b': '\\b',
    '\t': '\\t',
    '\n': '\\n',
    '\f': '\\f',
    '\r': '\\r',
    '\\': '\\\\'
  }
});

Object.extend(String.prototype, (function() {

  function prepareReplacement(replacement) {
    if (Object.isFunction(replacement)) return replacement;
    var template = new Template(replacement);
    return function(match) { return template.evaluate(match) };
  }

  function gsub(pattern, replacement) {
    var result = '', source = this, match;
    replacement = prepareReplacement(replacement);

    if (Object.isString(pattern))
      pattern = RegExp.escape(pattern);

    if (!(pattern.length || pattern.source)) {
      replacement = replacement('');
      return replacement + source.split('').join(replacement) + replacement;
    }

    while (source.length > 0) {
      if (match = source.match(pattern)) {
        result += source.slice(0, match.index);
        result += String.interpret(replacement(match));
        source  = source.slice(match.index + match[0].length);
      } else {
        result += source, source = '';
      }
    }
    return result;
  }

  function sub(pattern, replacement, count) {
    replacement = prepareReplacement(replacement);
    count = Object.isUndefined(count) ? 1 : count;

    return this.gsub(pattern, function(match) {
      if (--count < 0) return match[0];
      return replacement(match);
    });
  }

  function scan(pattern, iterator) {
    this.gsub(pattern, iterator);
    return String(this);
  }

  function truncate(length, truncation) {
    length = length || 30;
    truncation = Object.isUndefined(truncation) ? '...' : truncation;
    return this.length > length ?
      this.slice(0, length - truncation.length) + truncation : String(this);
  }

  function strip() {
    return this.replace(/^\s+/, '').replace(/\s+$/, '');
  }

  function stripTags() {
    return this.replace(/<\w+(\s+("[^"]*"|'[^']*'|[^>])+)?>|<\/\w+>/gi, '');
  }

  function stripScripts() {
    return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
  }

  function extractScripts() {
    var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
    var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
    return (this.match(matchAll) || []).map(function(scriptTag) {
      return (scriptTag.match(matchOne) || ['', ''])[1];
    });
  }

  function evalScripts() {
    return this.extractScripts().map(function(script) { return eval(script) });
  }

  function escapeHTML() {
    return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
  }

  function unescapeHTML() {
    return this.stripTags().replace(/&lt;/g,'<').replace(/&gt;/g,'>').replace(/&amp;/g,'&');
  }


  function toQueryParams(separator) {
    var match = this.strip().match(/([^?#]*)(#.*)?$/);
    if (!match) return { };

    return match[1].split(separator || '&').inject({ }, function(hash, pair) {
      if ((pair = pair.split('='))[0]) {
        var key = decodeURIComponent(pair.shift());
        var value = pair.length > 1 ? pair.join('=') : pair[0];
        if (value != undefined) value = decodeURIComponent(value);

        if (key in hash) {
          if (!Object.isArray(hash[key])) hash[key] = [hash[key]];
          hash[key].push(value);
        }
        else hash[key] = value;
      }
      return hash;
    });
  }

  function toArray() {
    return this.split('');
  }

  function succ() {
    return this.slice(0, this.length - 1) +
      String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
  }

  function times(count) {
    return count < 1 ? '' : new Array(count + 1).join(this);
  }

  function camelize() {
    var parts = this.split('-'), len = parts.length;
    if (len == 1) return parts[0];

    var camelized = this.charAt(0) == '-'
      ? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
      : parts[0];

    for (var i = 1; i < len; i++)
      camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);

    return camelized;
  }

  function capitalize() {
    return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
  }

  function underscore() {
    return this.replace(/::/g, '/')
               .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
               .replace(/([a-z\d])([A-Z])/g, '$1_$2')
               .replace(/-/g, '_')
               .toLowerCase();
  }

  function dasherize() {
    return this.replace(/_/g, '-');
  }

  function inspect(useDoubleQuotes) {
    var escapedString = this.replace(/[\x00-\x1f\\]/g, function(character) {
      if (character in String.specialChar) {
        return String.specialChar[character];
      }
      return '\\u00' + character.charCodeAt().toPaddedString(2, 16);
    });
    if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
    return "'" + escapedString.replace(/'/g, '\\\'') + "'";
  }

  function toJSON() {
    return this.inspect(true);
  }

  function unfilterJSON(filter) {
    return this.replace(filter || Prototype.JSONFilter, '$1');
  }

  function isJSON() {
    var str = this;
    if (str.blank()) return false;
    str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
    return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);
  }

  function evalJSON(sanitize) {
    var json = this.unfilterJSON();
    try {
      if (!sanitize || json.isJSON()) return eval('(' + json + ')');
    } catch (e) { }
    throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
  }

  function include(pattern) {
    return this.indexOf(pattern) > -1;
  }

  function startsWith(pattern) {
    return this.indexOf(pattern) === 0;
  }

  function endsWith(pattern) {
    var d = this.length - pattern.length;
    return d >= 0 && this.lastIndexOf(pattern) === d;
  }

  function empty() {
    return this == '';
  }

  function blank() {
    return /^\s*$/.test(this);
  }

  function interpolate(object, pattern) {
    return new Template(this, pattern).evaluate(object);
  }

  return {
    gsub:           gsub,
    sub:            sub,
    scan:           scan,
    truncate:       truncate,
    strip:          String.prototype.trim ? String.prototype.trim : strip,
    stripTags:      stripTags,
    stripScripts:   stripScripts,
    extractScripts: extractScripts,
    evalScripts:    evalScripts,
    escapeHTML:     escapeHTML,
    unescapeHTML:   unescapeHTML,
    toQueryParams:  toQueryParams,
    parseQuery:     toQueryParams,
    toArray:        toArray,
    succ:           succ,
    times:          times,
    camelize:       camelize,
    capitalize:     capitalize,
    underscore:     underscore,
    dasherize:      dasherize,
    inspect:        inspect,
    toJSON:         toJSON,
    unfilterJSON:   unfilterJSON,
    isJSON:         isJSON,
    evalJSON:       evalJSON,
    include:        include,
    startsWith:     startsWith,
    endsWith:       endsWith,
    empty:          empty,
    blank:          blank,
    interpolate:    interpolate
  };
})());

var Template = Class.create({
  initialize: function(template, pattern) {
    this.template = template.toString();
    this.pattern = pattern || Template.Pattern;
  },

  evaluate: function(object) {
    if (object && Object.isFunction(object.toTemplateReplacements))
      object = object.toTemplateReplacements();

    return this.template.gsub(this.pattern, function(match) {
      if (object == null) return (match[1] + '');

      var before = match[1] || '';
      if (before == '\\') return match[2];

      var ctx = object, expr = match[3];
      var pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;
      match = pattern.exec(expr);
      if (match == null) return before;

      while (match != null) {
        var comp = match[1].startsWith('[') ? match[2].replace(/\\\\]/g, ']') : match[1];
        ctx = ctx[comp];
        if (null == ctx || '' == match[3]) break;
        expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);
        match = pattern.exec(expr);
      }

      return before + String.interpret(ctx);
    });
  }
});
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;

var $break = { };

var Enumerable = (function() {
  function each(iterator, context) {
    var index = 0;
    try {
      this._each(function(value) {
        iterator.call(context, value, index++);
      });
    } catch (e) {
      if (e != $break) throw e;
    }
    return this;
  }

  function eachSlice(number, iterator, context) {
    var index = -number, slices = [], array = this.toArray();
    if (number < 1) return array;
    while ((index += number) < array.length)
      slices.push(array.slice(index, index+number));
    return slices.collect(iterator, context);
  }

  function all(iterator, context) {
    iterator = iterator || Prototype.K;
    var result = true;
    this.each(function(value, index) {
      result = result && !!iterator.call(context, value, index);
      if (!result) throw $break;
    });
    return result;
  }

  function any(iterator, context) {
    iterator = iterator || Prototype.K;
    var result = false;
    this.each(function(value, index) {
      if (result = !!iterator.call(context, value, index))
        throw $break;
    });
    return result;
  }

  function collect(iterator, context) {
    iterator = iterator || Prototype.K;
    var results = [];
    this.each(function(value, index) {
      results.push(iterator.call(context, value, index));
    });
    return results;
  }

  function detect(iterator, context) {
    var result;
    this.each(function(value, index) {
      if (iterator.call(context, value, index)) {
        result = value;
        throw $break;
      }
    });
    return result;
  }

  function findAll(iterator, context) {
    var results = [];
    this.each(function(value, index) {
      if (iterator.call(context, value, index))
        results.push(value);
    });
    return results;
  }

  function grep(filter, iterator, context) {
    iterator = iterator || Prototype.K;
    var results = [];

    if (Object.isString(filter))
      filter = new RegExp(RegExp.escape(filter));

    this.each(function(value, index) {
      if (filter.match(value))
        results.push(iterator.call(context, value, index));
    });
    return results;
  }

  function include(object) {
    if (Object.isFunction(this.indexOf))
      if (this.indexOf(object) != -1) return true;

    var found = false;
    this.each(function(value) {
      if (value == object) {
        found = true;
        throw $break;
      }
    });
    return found;
  }

  function inGroupsOf(number, fillWith) {
    fillWith = Object.isUndefined(fillWith) ? null : fillWith;
    return this.eachSlice(number, function(slice) {
      while(slice.length < number) slice.push(fillWith);
      return slice;
    });
  }

  function inject(memo, iterator, context) {
    this.each(function(value, index) {
      memo = iterator.call(context, memo, value, index);
    });
    return memo;
  }

  function invoke(method) {
    var args = $A(arguments).slice(1);
    return this.map(function(value) {
      return value[method].apply(value, args);
    });
  }

  function max(iterator, context) {
    iterator = iterator || Prototype.K;
    var result;
    this.each(function(value, index) {
      value = iterator.call(context, value, index);
      if (result == null || value >= result)
        result = value;
    });
    return result;
  }

  function min(iterator, context) {
    iterator = iterator || Prototype.K;
    var result;
    this.each(function(value, index) {
      value = iterator.call(context, value, index);
      if (result == null || value < result)
        result = value;
    });
    return result;
  }

  function partition(iterator, context) {
    iterator = iterator || Prototype.K;
    var trues = [], falses = [];
    this.each(function(value, index) {
      (iterator.call(context, value, index) ?
        trues : falses).push(value);
    });
    return [trues, falses];
  }

  function pluck(property) {
    var results = [];
    this.each(function(value) {
      results.push(value[property]);
    });
    return results;
  }

  function reject(iterator, context) {
    var results = [];
    this.each(function(value, index) {
      if (!iterator.call(context, value, index))
        results.push(value);
    });
    return results;
  }

  function sortBy(iterator, context) {
    return this.map(function(value, index) {
      return {
        value: value,
        criteria: iterator.call(context, value, index)
      };
    }).sort(function(left, right) {
      var a = left.criteria, b = right.criteria;
      return a < b ? -1 : a > b ? 1 : 0;
    }).pluck('value');
  }

  function toArray() {
    return this.map();
  }

  function zip() {
    var iterator = Prototype.K, args = $A(arguments);
    if (Object.isFunction(args.last()))
      iterator = args.pop();

    var collections = [this].concat(args).map($A);
    return this.map(function(value, index) {
      return iterator(collections.pluck(index));
    });
  }

  function size() {
    return this.toArray().length;
  }

  function inspect() {
    return '#<Enumerable:' + this.toArray().inspect() + '>';
  }









  return {
    each:       each,
    eachSlice:  eachSlice,
    all:        all,
    every:      all,
    any:        any,
    some:       any,
    collect:    collect,
    map:        collect,
    detect:     detect,
    findAll:    findAll,
    select:     findAll,
    filter:     findAll,
    grep:       grep,
    include:    include,
    member:     include,
    inGroupsOf: inGroupsOf,
    inject:     inject,
    invoke:     invoke,
    max:        max,
    min:        min,
    partition:  partition,
    pluck:      pluck,
    reject:     reject,
    sortBy:     sortBy,
    toArray:    toArray,
    entries:    toArray,
    zip:        zip,
    size:       size,
    inspect:    inspect,
    find:       detect
  };
})();
function $A(iterable) {
  if (!iterable) return [];
  if ('toArray' in Object(iterable)) return iterable.toArray();
  var length = iterable.length || 0, results = new Array(length);
  while (length--) results[length] = iterable[length];
  return results;
}

function $w(string) {
  if (!Object.isString(string)) return [];
  string = string.strip();
  return string ? string.split(/\s+/) : [];
}

Array.from = $A;


(function() {
  var arrayProto = Array.prototype,
      slice = arrayProto.slice,
      _each = arrayProto.forEach; // use native browser JS 1.6 implementation if available

  function each(iterator) {
    for (var i = 0, length = this.length; i < length; i++)
      iterator(this[i]);
  }
  if (!_each) _each = each;

  function clear() {
    this.length = 0;
    return this;
  }

  function first() {
    return this[0];
  }

  function last() {
    return this[this.length - 1];
  }

  function compact() {
    return this.select(function(value) {
      return value != null;
    });
  }

  function flatten() {
    return this.inject([], function(array, value) {
      if (Object.isArray(value))
        return array.concat(value.flatten());
      array.push(value);
      return array;
    });
  }

  function without() {
    var values = slice.call(arguments, 0);
    return this.select(function(value) {
      return !values.include(value);
    });
  }

  function reverse(inline) {
    return (inline !== false ? this : this.toArray())._reverse();
  }

  function uniq(sorted) {
    return this.inject([], function(array, value, index) {
      if (0 == index || (sorted ? array.last() != value : !array.include(value)))
        array.push(value);
      return array;
    });
  }

  function intersect(array) {
    return this.uniq().findAll(function(item) {
      return array.detect(function(value) { return item === value });
    });
  }


  function clone() {
    return slice.call(this, 0);
  }

  function size() {
    return this.length;
  }

  function inspect() {
    return '[' + this.map(Object.inspect).join(', ') + ']';
  }

  function toJSON() {
    var results = [];
    this.each(function(object) {
      var value = Object.toJSON(object);
      if (!Object.isUndefined(value)) results.push(value);
    });
    return '[' + results.join(', ') + ']';
  }

  function indexOf(item, i) {
    i || (i = 0);
    var length = this.length;
    if (i < 0) i = length + i;
    for (; i < length; i++)
      if (this[i] === item) return i;
    return -1;
  }

  function lastIndexOf(item, i) {
    i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;
    var n = this.slice(0, i).reverse().indexOf(item);
    return (n < 0) ? n : i - n - 1;
  }

  function concat() {
    var array = slice.call(this, 0), item;
    for (var i = 0, length = arguments.length; i < length; i++) {
      item = arguments[i];
      if (Object.isArray(item) && !('callee' in item)) {
        for (var j = 0, arrayLength = item.length; j < arrayLength; j++)
          array.push(item[j]);
      } else {
        array.push(item);
      }
    }
    return array;
  }

  Object.extend(arrayProto, Enumerable);

  if (!arrayProto._reverse)
    arrayProto._reverse = arrayProto.reverse;

  Object.extend(arrayProto, {
    _each:     _each,
    clear:     clear,
    first:     first,
    last:      last,
    compact:   compact,
    flatten:   flatten,
    without:   without,
    reverse:   reverse,
    uniq:      uniq,
    intersect: intersect,
    clone:     clone,
    toArray:   clone,
    size:      size,
    inspect:   inspect,
    toJSON:    toJSON
  });

  var CONCAT_ARGUMENTS_BUGGY = (function() {
    return [].concat(arguments)[0][0] !== 1;
  })(1,2)

  if (CONCAT_ARGUMENTS_BUGGY) arrayProto.concat = concat;

  if (!arrayProto.indexOf) arrayProto.indexOf = indexOf;
  if (!arrayProto.lastIndexOf) arrayProto.lastIndexOf = lastIndexOf;
})();
function $H(object) {
  return new Hash(object);
};

var Hash = Class.create(Enumerable, (function() {
  function initialize(object) {
    this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
  }

  function _each(iterator) {
    for (var key in this._object) {
      var value = this._object[key], pair = [key, value];
      pair.key = key;
      pair.value = value;
      iterator(pair);
    }
  }

  function set(key, value) {
    return this._object[key] = value;
  }

  function get(key) {
    if (this._object[key] !== Object.prototype[key])
      return this._object[key];
  }

  function unset(key) {
    var value = this._object[key];
    delete this._object[key];
    return value;
  }

  function toObject() {
    return Object.clone(this._object);
  }

  function keys() {
    return this.pluck('key');
  }

  function values() {
    return this.pluck('value');
  }

  function index(value) {
    var match = this.detect(function(pair) {
      return pair.value === value;
    });
    return match && match.key;
  }

  function merge(object) {
    return this.clone().update(object);
  }

  function update(object) {
    return new Hash(object).inject(this, function(result, pair) {
      result.set(pair.key, pair.value);
      return result;
    });
  }

  function toQueryPair(key, value) {
    if (Object.isUndefined(value)) return key;
    return key + '=' + encodeURIComponent(String.interpret(value));
  }

  function toQueryString() {
    return this.inject([], function(results, pair) {
      var key = encodeURIComponent(pair.key), values = pair.value;

      if (values && typeof values == 'object') {
        if (Object.isArray(values))
          return results.concat(values.map(toQueryPair.curry(key)));
      } else results.push(toQueryPair(key, values));
      return results;
    }).join('&');
  }

  function inspect() {
    return '#<Hash:{' + this.map(function(pair) {
      return pair.map(Object.inspect).join(': ');
    }).join(', ') + '}>';
  }

  function toJSON() {
    return Object.toJSON(this.toObject());
  }

  function clone() {
    return new Hash(this);
  }

  return {
    initialize:             initialize,
    _each:                  _each,
    set:                    set,
    get:                    get,
    unset:                  unset,
    toObject:               toObject,
    toTemplateReplacements: toObject,
    keys:                   keys,
    values:                 values,
    index:                  index,
    merge:                  merge,
    update:                 update,
    toQueryString:          toQueryString,
    inspect:                inspect,
    toJSON:                 toJSON,
    clone:                  clone
  };
})());

Hash.from = $H;
Object.extend(Number.prototype, (function() {
  function toColorPart() {
    return this.toPaddedString(2, 16);
  }

  function succ() {
    return this + 1;
  }

  function times(iterator, context) {
    $R(0, this, true).each(iterator, context);
    return this;
  }

  function toPaddedString(length, radix) {
    var string = this.toString(radix || 10);
    return '0'.times(length - string.length) + string;
  }

  function toJSON() {
    return isFinite(this) ? this.toString() : 'null';
  }

  function abs() {
    return Math.abs(this);
  }

  function round() {
    return Math.round(this);
  }

  function ceil() {
    return Math.ceil(this);
  }

  function floor() {
    return Math.floor(this);
  }

  return {
    toColorPart:    toColorPart,
    succ:           succ,
    times:          times,
    toPaddedString: toPaddedString,
    toJSON:         toJSON,
    abs:            abs,
    round:          round,
    ceil:           ceil,
    floor:          floor
  };
})());

function $R(start, end, exclusive) {
  return new ObjectRange(start, end, exclusive);
}

var ObjectRange = Class.create(Enumerable, (function() {
  function initialize(start, end, exclusive) {
    this.start = start;
    this.end = end;
    this.exclusive = exclusive;
  }

  function _each(iterator) {
    var value = this.start;
    while (this.include(value)) {
      iterator(value);
      value = value.succ();
    }
  }

  function include(value) {
    if (value < this.start)
      return false;
    if (this.exclusive)
      return value < this.end;
    return value <= this.end;
  }

  return {
    initialize: initialize,
    _each:      _each,
    include:    include
  };
})());



var Ajax = {
  getTransport: function() {
    return Try.these(
      function() {return new XMLHttpRequest()},
      function() {return new ActiveXObject('Msxml2.XMLHTTP')},
      function() {return new ActiveXObject('Microsoft.XMLHTTP')}
    ) || false;
  },

  activeRequestCount: 0
};

Ajax.Responders = {
  responders: [],

  _each: function(iterator) {
    this.responders._each(iterator);
  },

  register: function(responder) {
    if (!this.include(responder))
      this.responders.push(responder);
  },

  unregister: function(responder) {
    this.responders = this.responders.without(responder);
  },

  dispatch: function(callback, request, transport, json) {
    this.each(function(responder) {
      if (Object.isFunction(responder[callback])) {
        try {
          responder[callback].apply(responder, [request, transport, json]);
        } catch (e) { }
      }
    });
  }
};

Object.extend(Ajax.Responders, Enumerable);

Ajax.Responders.register({
  onCreate:   function() { Ajax.activeRequestCount++ },
  onComplete: function() { Ajax.activeRequestCount-- }
});
Ajax.Base = Class.create({
  initialize: function(options) {
    this.options = {
      method:       'post',
      asynchronous: true,
      contentType:  'application/x-www-form-urlencoded',
      encoding:     'UTF-8',
      parameters:   '',
      evalJSON:     true,
      evalJS:       true
    };
    Object.extend(this.options, options || { });

    this.options.method = this.options.method.toLowerCase();

    if (Object.isString(this.options.parameters))
      this.options.parameters = this.options.parameters.toQueryParams();
    else if (Object.isHash(this.options.parameters))
      this.options.parameters = this.options.parameters.toObject();
  }
});
Ajax.Request = Class.create(Ajax.Base, {
  _complete: false,

  initialize: function($super, url, options) {
    $super(options);
    this.transport = Ajax.getTransport();
    this.request(url);
  },

  request: function(url) {
    this.url = url;
    this.method = this.options.method;
    var params = Object.clone(this.options.parameters);

    if (!['get', 'post'].include(this.method)) {
      params['_method'] = this.method;
      this.method = 'post';
    }

    this.parameters = params;

    if (params = Object.toQueryString(params)) {
      if (this.method == 'get')
        this.url += (this.url.include('?') ? '&' : '?') + params;
      else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
        params += '&_=';
    }

    try {
      var response = new Ajax.Response(this);
      if (this.options.onCreate) this.options.onCreate(response);
      Ajax.Responders.dispatch('onCreate', this, response);

      this.transport.open(this.method.toUpperCase(), this.url,
        this.options.asynchronous);

      if (this.options.asynchronous) this.respondToReadyState.bind(this).defer(1);

      this.transport.onreadystatechange = this.onStateChange.bind(this);
      this.setRequestHeaders();

      this.body = this.method == 'post' ? (this.options.postBody || params) : null;
      this.transport.send(this.body);

      /* Force Firefox to handle ready state 4 for synchronous requests */
      if (!this.options.asynchronous && this.transport.overrideMimeType)
        this.onStateChange();

    }
    catch (e) {
      this.dispatchException(e);
    }
  },

  onStateChange: function() {
    var readyState = this.transport.readyState;
    if (readyState > 1 && !((readyState == 4) && this._complete))
      this.respondToReadyState(this.transport.readyState);
  },

  setRequestHeaders: function() {
    var headers = {
      'X-Requested-With': 'XMLHttpRequest',
      'X-Prototype-Version': Prototype.Version,
      'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
    };

    if (this.method == 'post') {
      headers['Content-type'] = this.options.contentType +
        (this.options.encoding ? '; charset=' + this.options.encoding : '');

      /* Force "Connection: close" for older Mozilla browsers to work
       * around a bug where XMLHttpRequest sends an incorrect
       * Content-length header. See Mozilla Bugzilla #246651.
       */
      if (this.transport.overrideMimeType &&
          (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
            headers['Connection'] = 'close';
    }

    if (typeof this.options.requestHeaders == 'object') {
      var extras = this.options.requestHeaders;

      if (Object.isFunction(extras.push))
        for (var i = 0, length = extras.length; i < length; i += 2)
          headers[extras[i]] = extras[i+1];
      else
        $H(extras).each(function(pair) { headers[pair.key] = pair.value });
    }

    for (var name in headers)
      this.transport.setRequestHeader(name, headers[name]);
  },

  success: function() {
    var status = this.getStatus();
    return !status || (status >= 200 && status < 300);
  },

  getStatus: function() {
    try {
      return this.transport.status || 0;
    } catch (e) { return 0 }
  },

  respondToReadyState: function(readyState) {
    var state = Ajax.Request.Events[readyState], response = new Ajax.Response(this);

    if (state == 'Complete') {
      try {
        this._complete = true;
        (this.options['on' + response.status]
         || this.options['on' + (this.success() ? 'Success' : 'Failure')]
         || Prototype.emptyFunction)(response, response.headerJSON);
      } catch (e) {
        this.dispatchException(e);
      }

      var contentType = response.getHeader('Content-type');
      if (this.options.evalJS == 'force'
          || (this.options.evalJS && this.isSameOrigin() && contentType
          && contentType.match(/^\s*(text|application)\/(x-)?(java|ecma)script(;.*)?\s*$/i)))
        this.evalResponse();
    }

    try {
      (this.options['on' + state] || Prototype.emptyFunction)(response, response.headerJSON);
      Ajax.Responders.dispatch('on' + state, this, response, response.headerJSON);
    } catch (e) {
      this.dispatchException(e);
    }

    if (state == 'Complete') {
      this.transport.onreadystatechange = Prototype.emptyFunction;
    }
  },

  isSameOrigin: function() {
    var m = this.url.match(/^\s*https?:\/\/[^\/]*/);
    return !m || (m[0] == '#{protocol}//#{domain}#{port}'.interpolate({
      protocol: location.protocol,
      domain: document.domain,
      port: location.port ? ':' + location.port : ''
    }));
  },

  getHeader: function(name) {
    try {
      return this.transport.getResponseHeader(name) || null;
    } catch (e) { return null; }
  },

  evalResponse: function() {
    try {
      return eval((this.transport.responseText || '').unfilterJSON());
    } catch (e) {
      this.dispatchException(e);
    }
  },

  dispatchException: function(exception) {
    (this.options.onException || Prototype.emptyFunction)(this, exception);
    Ajax.Responders.dispatch('onException', this, exception);
  }
});

Ajax.Request.Events =
  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];








Ajax.Response = Class.create({
  initialize: function(request){
    this.request = request;
    var transport  = this.transport  = request.transport,
        readyState = this.readyState = transport.readyState;

    if((readyState > 2 && !Prototype.Browser.IE) || readyState == 4) {
      this.status       = this.getStatus();
      this.statusText   = this.getStatusText();
      this.responseText = String.interpret(transport.responseText);
      this.headerJSON   = this._getHeaderJSON();
    }

    if(readyState == 4) {
      var xml = transport.responseXML;
      this.responseXML  = Object.isUndefined(xml) ? null : xml;
      this.responseJSON = this._getResponseJSON();
    }
  },

  status:      0,

  statusText: '',

  getStatus: Ajax.Request.prototype.getStatus,

  getStatusText: function() {
    try {
      return this.transport.statusText || '';
    } catch (e) { return '' }
  },

  getHeader: Ajax.Request.prototype.getHeader,

  getAllHeaders: function() {
    try {
      return this.getAllResponseHeaders();
    } catch (e) { return null }
  },

  getResponseHeader: function(name) {
    return this.transport.getResponseHeader(name);
  },

  getAllResponseHeaders: function() {
    return this.transport.getAllResponseHeaders();
  },

  _getHeaderJSON: function() {
    var json = this.getHeader('X-JSON');
    if (!json) return null;
    json = decodeURIComponent(escape(json));
    try {
      return json.evalJSON(this.request.options.sanitizeJSON ||
        !this.request.isSameOrigin());
    } catch (e) {
      this.request.dispatchException(e);
    }
  },

  _getResponseJSON: function() {
    var options = this.request.options;
    if (!options.evalJSON || (options.evalJSON != 'force' &&
      !(this.getHeader('Content-type') || '').include('application/json')) ||
        this.responseText.blank())
          return null;
    try {
      return this.responseText.evalJSON(options.sanitizeJSON ||
        !this.request.isSameOrigin());
    } catch (e) {
      this.request.dispatchException(e);
    }
  }
});

Ajax.Updater = Class.create(Ajax.Request, {
  initialize: function($super, container, url, options) {
    this.container = {
      success: (container.success || container),
      failure: (container.failure || (container.success ? null : container))
    };

    options = Object.clone(options);
    var onComplete = options.onComplete;
    options.onComplete = (function(response, json) {
      this.updateContent(response.responseText);
      if (Object.isFunction(onComplete)) onComplete(response, json);
    }).bind(this);

    $super(url, options);
  },

  updateContent: function(responseText) {
    var receiver = this.container[this.success() ? 'success' : 'failure'],
        options = this.options;

    if (!options.evalScripts) responseText = responseText.stripScripts();

    if (receiver = $(receiver)) {
      if (options.insertion) {
        if (Object.isString(options.insertion)) {
          var insertion = { }; insertion[options.insertion] = responseText;
          receiver.insert(insertion);
        }
        else options.insertion(receiver, responseText);
      }
      else receiver.update(responseText);
    }
  }
});

Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
  initialize: function($super, container, url, options) {
    $super(options);
    this.onComplete = this.options.onComplete;

    this.frequency = (this.options.frequency || 2);
    this.decay = (this.options.decay || 1);

    this.updater = { };
    this.container = container;
    this.url = url;

    this.start();
  },

  start: function() {
    this.options.onComplete = this.updateComplete.bind(this);
    this.onTimerEvent();
  },

  stop: function() {
    this.updater.options.onComplete = undefined;
    clearTimeout(this.timer);
    (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
  },

  updateComplete: function(response) {
    if (this.options.decay) {
      this.decay = (response.responseText == this.lastText ?
        this.decay * this.options.decay : 1);

      this.lastText = response.responseText;
    }
    this.timer = this.onTimerEvent.bind(this).delay(this.decay * this.frequency);
  },

  onTimerEvent: function() {
    this.updater = new Ajax.Updater(this.container, this.url, this.options);
  }
});



function $(element) {
  if (arguments.length > 1) {
    for (var i = 0, elements = [], length = arguments.length; i < length; i++)
      elements.push($(arguments[i]));
    return elements;
  }
  if (Object.isString(element))
    element = document.getElementById(element);
  return Element.extend(element);
}

if (Prototype.BrowserFeatures.XPath) {
  document._getElementsByXPath = function(expression, parentElement) {
    var results = [];
    var query = document.evaluate(expression, $(parentElement) || document,
      null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
    for (var i = 0, length = query.snapshotLength; i < length; i++)
      results.push(Element.extend(query.snapshotItem(i)));
    return results;
  };
}

/*--------------------------------------------------------------------------*/

if (!window.Node) var Node = { };

if (!Node.ELEMENT_NODE) {
  Object.extend(Node, {
    ELEMENT_NODE: 1,
    ATTRIBUTE_NODE: 2,
    TEXT_NODE: 3,
    CDATA_SECTION_NODE: 4,
    ENTITY_REFERENCE_NODE: 5,
    ENTITY_NODE: 6,
    PROCESSING_INSTRUCTION_NODE: 7,
    COMMENT_NODE: 8,
    DOCUMENT_NODE: 9,
    DOCUMENT_TYPE_NODE: 10,
    DOCUMENT_FRAGMENT_NODE: 11,
    NOTATION_NODE: 12
  });
}


(function(global) {

  var SETATTRIBUTE_IGNORES_NAME = (function(){
    var elForm = document.createElement("form");
    var elInput = document.createElement("input");
    var root = document.documentElement;
    elInput.setAttribute("name", "test");
    elForm.appendChild(elInput);
    root.appendChild(elForm);
    var isBuggy = elForm.elements
      ? (typeof elForm.elements.test == "undefined")
      : null;
    root.removeChild(elForm);
    elForm = elInput = null;
    return isBuggy;
  })();

  var element = global.Element;
  global.Element = function(tagName, attributes) {
    attributes = attributes || { };
    tagName = tagName.toLowerCase();
    var cache = Element.cache;
    if (SETATTRIBUTE_IGNORES_NAME && attributes.name) {
      tagName = '<' + tagName + ' name="' + attributes.name + '">';
      delete attributes.name;
      return Element.writeAttribute(document.createElement(tagName), attributes);
    }
    if (!cache[tagName]) cache[tagName] = Element.extend(document.createElement(tagName));
    return Element.writeAttribute(cache[tagName].cloneNode(false), attributes);
  };
  Object.extend(global.Element, element || { });
  if (element) global.Element.prototype = element.prototype;
})(this);

Element.cache = { };
Element.idCounter = 1;

Element.Methods = {
  visible: function(element) {
    return $(element).style.display != 'none';
  },

  toggle: function(element) {
    element = $(element);
    Element[Element.visible(element) ? 'hide' : 'show'](element);
    return element;
  },


  hide: function(element) {
    element = $(element);
    element.style.display = 'none';
    return element;
  },

  show: function(element) {
    element = $(element);
    element.style.display = '';
    return element;
  },

  remove: function(element) {
    element = $(element);
    element.parentNode.removeChild(element);
    return element;
  },

  update: (function(){

    var SELECT_ELEMENT_INNERHTML_BUGGY = (function(){
      var el = document.createElement("select"),
          isBuggy = true;
      el.innerHTML = "<option value=\"test\">test</option>";
      if (el.options && el.options[0]) {
        isBuggy = el.options[0].nodeName.toUpperCase() !== "OPTION";
      }
      el = null;
      return isBuggy;
    })();

    var TABLE_ELEMENT_INNERHTML_BUGGY = (function(){
      try {
        var el = document.createElement("table");
        if (el && el.tBodies) {
          el.innerHTML = "<tbody><tr><td>test</td></tr></tbody>";
          var isBuggy = typeof el.tBodies[0] == "undefined";
          el = null;
          return isBuggy;
        }
      } catch (e) {
        return true;
      }
    })();

    var SCRIPT_ELEMENT_REJECTS_TEXTNODE_APPENDING = (function () {
      var s = document.createElement("script"),
          isBuggy = false;
      try {
        s.appendChild(document.createTextNode(""));
        isBuggy = !s.firstChild ||
          s.firstChild && s.firstChild.nodeType !== 3;
      } catch (e) {
        isBuggy = true;
      }
      s = null;
      return isBuggy;
    })();

    function update(element, content) {
      element = $(element);

      if (content && content.toElement)
        content = content.toElement();

      if (Object.isElement(content))
        return element.update().insert(content);

      content = Object.toHTML(content);

      var tagName = element.tagName.toUpperCase();

      if (tagName === 'SCRIPT' && SCRIPT_ELEMENT_REJECTS_TEXTNODE_APPENDING) {
        element.text = content;
        return element;
      }

      if (SELECT_ELEMENT_INNERHTML_BUGGY || TABLE_ELEMENT_INNERHTML_BUGGY) {
        if (tagName in Element._insertionTranslations.tags) {
          while (element.firstChild) {
            element.removeChild(element.firstChild);
          }
          Element._getContentFromAnonymousElement(tagName, content.stripScripts())
            .each(function(node) {
              element.appendChild(node)
            });
        }
        else {
          element.innerHTML = content.stripScripts();
        }
      }
      else {
        element.innerHTML = content.stripScripts();
      }

      content.evalScripts.bind(content).defer();
      return element;
    }

    return update;
  })(),

  replace: function(element, content) {
    element = $(element);
    if (content && content.toElement) content = content.toElement();
    else if (!Object.isElement(content)) {
      content = Object.toHTML(content);
      var range = element.ownerDocument.createRange();
      range.selectNode(element);
      content.evalScripts.bind(content).defer();
      content = range.createContextualFragment(content.stripScripts());
    }
    element.parentNode.replaceChild(content, element);
    return element;
  },

  insert: function(element, insertions) {
    element = $(element);

    if (Object.isString(insertions) || Object.isNumber(insertions) ||
        Object.isElement(insertions) || (insertions && (insertions.toElement || insertions.toHTML)))
          insertions = {bottom:insertions};

    var content, insert, tagName, childNodes;

    for (var position in insertions) {
      content  = insertions[position];
      position = position.toLowerCase();
      insert = Element._insertionTranslations[position];

      if (content && content.toElement) content = content.toElement();
      if (Object.isElement(content)) {
        insert(element, content);
        continue;
      }

      content = Object.toHTML(content);

      tagName = ((position == 'before' || position == 'after')
        ? element.parentNode : element).tagName.toUpperCase();

      childNodes = Element._getContentFromAnonymousElement(tagName, content.stripScripts());

      if (position == 'top' || position == 'after') childNodes.reverse();
      childNodes.each(insert.curry(element));

      content.evalScripts.bind(content).defer();
    }

    return element;
  },

  wrap: function(element, wrapper, attributes) {
    element = $(element);
    if (Object.isElement(wrapper))
      $(wrapper).writeAttribute(attributes || { });
    else if (Object.isString(wrapper)) wrapper = new Element(wrapper, attributes);
    else wrapper = new Element('div', wrapper);
    if (element.parentNode)
      element.parentNode.replaceChild(wrapper, element);
    wrapper.appendChild(element);
    return wrapper;
  },

  inspect: function(element) {
    element = $(element);
    var result = '<' + element.tagName.toLowerCase();
    $H({'id': 'id', 'className': 'class'}).each(function(pair) {
      var property = pair.first(), attribute = pair.last();
      var value = (element[property] || '').toString();
      if (value) result += ' ' + attribute + '=' + value.inspect(true);
    });
    return result + '>';
  },

  recursivelyCollect: function(element, property) {
    element = $(element);
    var elements = [];
    while (element = element[property])
      if (element.nodeType == 1)
        elements.push(Element.extend(element));
    return elements;
  },

  ancestors: function(element) {
    return Element.recursivelyCollect(element, 'parentNode');
  },

  descendants: function(element) {
    return Element.select(element, "*");
  },

  firstDescendant: function(element) {
    element = $(element).firstChild;
    while (element && element.nodeType != 1) element = element.nextSibling;
    return $(element);
  },

  immediateDescendants: function(element) {
    if (!(element = $(element).firstChild)) return [];
    while (element && element.nodeType != 1) element = element.nextSibling;
    if (element) return [element].concat($(element).nextSiblings());
    return [];
  },

  previousSiblings: function(element) {
    return Element.recursivelyCollect(element, 'previousSibling');
  },

  nextSiblings: function(element) {
    return Element.recursivelyCollect(element, 'nextSibling');
  },

  siblings: function(element) {
    element = $(element);
    return Element.previousSiblings(element).reverse()
      .concat(Element.nextSiblings(element));
  },

  match: function(element, selector) {
    if (Object.isString(selector))
      selector = new Selector(selector);
    return selector.match($(element));
  },

  up: function(element, expression, index) {
    element = $(element);
    if (arguments.length == 1) return $(element.parentNode);
    var ancestors = Element.ancestors(element);
    return Object.isNumber(expression) ? ancestors[expression] :
      Selector.findElement(ancestors, expression, index);
  },

  down: function(element, expression, index) {
    element = $(element);
    if (arguments.length == 1) return Element.firstDescendant(element);
    return Object.isNumber(expression) ? Element.descendants(element)[expression] :
      Element.select(element, expression)[index || 0];
  },

  previous: function(element, expression, index) {
    element = $(element);
    if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
    var previousSiblings = Element.previousSiblings(element);
    return Object.isNumber(expression) ? previousSiblings[expression] :
      Selector.findElement(previousSiblings, expression, index);
  },

  next: function(element, expression, index) {
    element = $(element);
    if (arguments.length == 1) return $(Selector.handlers.nextElementSibling(element));
    var nextSiblings = Element.nextSiblings(element);
    return Object.isNumber(expression) ? nextSiblings[expression] :
      Selector.findElement(nextSiblings, expression, index);
  },


  select: function(element) {
    var args = Array.prototype.slice.call(arguments, 1);
    return Selector.findChildElements(element, args);
  },

  adjacent: function(element) {
    var args = Array.prototype.slice.call(arguments, 1);
    return Selector.findChildElements(element.parentNode, args).without(element);
  },

  identify: function(element) {
    element = $(element);
    var id = Element.readAttribute(element, 'id');
    if (id) return id;
    do { id = 'anonymous_element_' + Element.idCounter++ } while ($(id));
    Element.writeAttribute(element, 'id', id);
    return id;
  },

  readAttribute: function(element, name) {
    element = $(element);
    if (Prototype.Browser.IE) {
      var t = Element._attributeTranslations.read;
      if (t.values[name]) return t.values[name](element, name);
      if (t.names[name]) name = t.names[name];
      if (name.include(':')) {
        return (!element.attributes || !element.attributes[name]) ? null :
         element.attributes[name].value;
      }
    }
    return element.getAttribute(name);
  },

  writeAttribute: function(element, name, value) {
    element = $(element);
    var attributes = { }, t = Element._attributeTranslations.write;

    if (typeof name == 'object') attributes = name;
    else attributes[name] = Object.isUndefined(value) ? true : value;

    for (var attr in attributes) {
      name = t.names[attr] || attr;
      value = attributes[attr];
      if (t.values[attr]) name = t.values[attr](element, value);
      if (value === false || value === null)
        element.removeAttribute(name);
      else if (value === true)
        element.setAttribute(name, name);
      else element.setAttribute(name, value);
    }
    return element;
  },

  getHeight: function(element) {
    return Element.getDimensions(element).height;
  },

  getWidth: function(element) {
    return Element.getDimensions(element).width;
  },

  classNames: function(element) {
    return new Element.ClassNames(element);
  },

  hasClassName: function(element, className) {
    if (!(element = $(element))) return;
    var elementClassName = element.className;
    return (elementClassName.length > 0 && (elementClassName == className ||
      new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
  },

  addClassName: function(element, className) {
    if (!(element = $(element))) return;
    if (!Element.hasClassName(element, className))
      element.className += (element.className ? ' ' : '') + className;
    return element;
  },

  removeClassName: function(element, className) {
    if (!(element = $(element))) return;
    element.className = element.className.replace(
      new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
    return element;
  },

  toggleClassName: function(element, className) {
    if (!(element = $(element))) return;
    return Element[Element.hasClassName(element, className) ?
      'removeClassName' : 'addClassName'](element, className);
  },

  cleanWhitespace: function(element) {
    element = $(element);
    var node = element.firstChild;
    while (node) {
      var nextNode = node.nextSibling;
      if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
        element.removeChild(node);
      node = nextNode;
    }
    return element;
  },

  empty: function(element) {
    return $(element).innerHTML.blank();
  },

  descendantOf: function(element, ancestor) {
    element = $(element), ancestor = $(ancestor);

    if (element.compareDocumentPosition)
      return (element.compareDocumentPosition(ancestor) & 8) === 8;

    if (ancestor.contains)
      return ancestor.contains(element) && ancestor !== element;

    while (element = element.parentNode)
      if (element == ancestor) return true;

    return false;
  },

  scrollTo: function(element) {
    element = $(element);
    var pos = Element.cumulativeOffset(element);
    window.scrollTo(pos[0], pos[1]);
    return element;
  },

  getStyle: function(element, style) {
    element = $(element);
    style = style == 'float' ? 'cssFloat' : style.camelize();
    var value = element.style[style];
    if (!value || value == 'auto') {
      var css = document.defaultView.getComputedStyle(element, null);
      value = css ? css[style] : null;
    }
    if (style == 'opacity') return value ? parseFloat(value) : 1.0;
    return value == 'auto' ? null : value;
  },

  getOpacity: function(element) {
    return $(element).getStyle('opacity');
  },

  setStyle: function(element, styles) {
    element = $(element);
    var elementStyle = element.style, match;
    if (Object.isString(styles)) {
      element.style.cssText += ';' + styles;
      return styles.include('opacity') ?
        element.setOpacity(styles.match(/opacity:\s*(\d?\.?\d*)/)[1]) : element;
    }
    for (var property in styles)
      if (property == 'opacity') element.setOpacity(styles[property]);
      else
        elementStyle[(property == 'float' || property == 'cssFloat') ?
          (Object.isUndefined(elementStyle.styleFloat) ? 'cssFloat' : 'styleFloat') :
            property] = styles[property];

    return element;
  },

  setOpacity: function(element, value) {
    element = $(element);
    element.style.opacity = (value == 1 || value === '') ? '' :
      (value < 0.00001) ? 0 : value;
    return element;
  },

  getDimensions: function(element) {
    element = $(element);
    var display = Element.getStyle(element, 'display');
    if (display != 'none' && display != null) // Safari bug
      return {width: element.offsetWidth, height: element.offsetHeight};

    var els = element.style;
    var originalVisibility = els.visibility;
    var originalPosition = els.position;
    var originalDisplay = els.display;
    els.visibility = 'hidden';
    if (originalPosition != 'fixed') // Switching fixed to absolute causes issues in Safari
      els.position = 'absolute';
    els.display = 'block';
    var originalWidth = element.clientWidth;
    var originalHeight = element.clientHeight;
    els.display = originalDisplay;
    els.position = originalPosition;
    els.visibility = originalVisibility;
    return {width: originalWidth, height: originalHeight};
  },

  makePositioned: function(element) {
    element = $(element);
    var pos = Element.getStyle(element, 'position');
    if (pos == 'static' || !pos) {
      element._madePositioned = true;
      element.style.position = 'relative';
      if (Prototype.Browser.Opera) {
        element.style.top = 0;
        element.style.left = 0;
      }
    }
    return element;
  },

  undoPositioned: function(element) {
    element = $(element);
    if (element._madePositioned) {
      element._madePositioned = undefined;
      element.style.position =
        element.style.top =
        element.style.left =
        element.style.bottom =
        element.style.right = '';
    }
    return element;
  },

  makeClipping: function(element) {
    element = $(element);
    if (element._overflow) return element;
    element._overflow = Element.getStyle(element, 'overflow') || 'auto';
    if (element._overflow !== 'hidden')
      element.style.overflow = 'hidden';
    return element;
  },

  undoClipping: function(element) {
    element = $(element);
    if (!element._overflow) return element;
    element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
    element._overflow = null;
    return element;
  },

  cumulativeOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;
      element = element.offsetParent;
    } while (element);
    return Element._returnOffset(valueL, valueT);
  },

  positionedOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;
      element = element.offsetParent;
      if (element) {
        if (element.tagName.toUpperCase() == 'BODY') break;
        var p = Element.getStyle(element, 'position');
        if (p !== 'static') break;
      }
    } while (element);
    return Element._returnOffset(valueL, valueT);
  },

  absolutize: function(element) {
    element = $(element);
    if (Element.getStyle(element, 'position') == 'absolute') return element;

    var offsets = Element.positionedOffset(element);
    var top     = offsets[1];
    var left    = offsets[0];
    var width   = element.clientWidth;
    var height  = element.clientHeight;

    element._originalLeft   = left - parseFloat(element.style.left  || 0);
    element._originalTop    = top  - parseFloat(element.style.top || 0);
    element._originalWidth  = element.style.width;
    element._originalHeight = element.style.height;

    element.style.position = 'absolute';
    element.style.top    = top + 'px';
    element.style.left   = left + 'px';
    element.style.width  = width + 'px';
    element.style.height = height + 'px';
    return element;
  },

  relativize: function(element) {
    element = $(element);
    if (Element.getStyle(element, 'position') == 'relative') return element;

    element.style.position = 'relative';
    var top  = parseFloat(element.style.top  || 0) - (element._originalTop || 0);
    var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);

    element.style.top    = top + 'px';
    element.style.left   = left + 'px';
    element.style.height = element._originalHeight;
    element.style.width  = element._originalWidth;
    return element;
  },

  cumulativeScrollOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.scrollTop  || 0;
      valueL += element.scrollLeft || 0;
      element = element.parentNode;
    } while (element);
    return Element._returnOffset(valueL, valueT);
  },

  getOffsetParent: function(element) {
    if (element.offsetParent) return $(element.offsetParent);
    if (element == document.body) return $(element);

    while ((element = element.parentNode) && element != document.body)
      if (Element.getStyle(element, 'position') != 'static')
        return $(element);

    return $(document.body);
  },

  viewportOffset: function(forElement) {
    var valueT = 0, valueL = 0;

    var element = forElement;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;

      if (element.offsetParent == document.body &&
        Element.getStyle(element, 'position') == 'absolute') break;

    } while (element = element.offsetParent);

    element = forElement;
    do {
      if (!Prototype.Browser.Opera || (element.tagName && (element.tagName.toUpperCase() == 'BODY'))) {
        valueT -= element.scrollTop  || 0;
        valueL -= element.scrollLeft || 0;
      }
    } while (element = element.parentNode);

    return Element._returnOffset(valueL, valueT);
  },

  clonePosition: function(element, source) {
    var options = Object.extend({
      setLeft:    true,
      setTop:     true,
      setWidth:   true,
      setHeight:  true,
      offsetTop:  0,
      offsetLeft: 0
    }, arguments[2] || { });

    source = $(source);
    var p = Element.viewportOffset(source);

    element = $(element);
    var delta = [0, 0];
    var parent = null;
    if (Element.getStyle(element, 'position') == 'absolute') {
      parent = Element.getOffsetParent(element);
      delta = Element.viewportOffset(parent);
    }

    if (parent == document.body) {
      delta[0] -= document.body.offsetLeft;
      delta[1] -= document.body.offsetTop;
    }

    if (options.setLeft)   element.style.left  = (p[0] - delta[0] + options.offsetLeft) + 'px';
    if (options.setTop)    element.style.top   = (p[1] - delta[1] + options.offsetTop) + 'px';
    if (options.setWidth)  element.style.width = source.offsetWidth + 'px';
    if (options.setHeight) element.style.height = source.offsetHeight + 'px';
    return element;
  }
};

Object.extend(Element.Methods, {
  getElementsBySelector: Element.Methods.select,

  childElements: Element.Methods.immediateDescendants
});

Element._attributeTranslations = {
  write: {
    names: {
      className: 'class',
      htmlFor:   'for'
    },
    values: { }
  }
};

if (Prototype.Browser.Opera) {
  Element.Methods.getStyle = Element.Methods.getStyle.wrap(
    function(proceed, element, style) {
      switch (style) {
        case 'left': case 'top': case 'right': case 'bottom':
          if (proceed(element, 'position') === 'static') return null;
        case 'height': case 'width':
          if (!Element.visible(element)) return null;

          var dim = parseInt(proceed(element, style), 10);

          if (dim !== element['offset' + style.capitalize()])
            return dim + 'px';

          var properties;
          if (style === 'height') {
            properties = ['border-top-width', 'padding-top',
             'padding-bottom', 'border-bottom-width'];
          }
          else {
            properties = ['border-left-width', 'padding-left',
             'padding-right', 'border-right-width'];
          }
          return properties.inject(dim, function(memo, property) {
            var val = proceed(element, property);
            return val === null ? memo : memo - parseInt(val, 10);
          }) + 'px';
        default: return proceed(element, style);
      }
    }
  );

  Element.Methods.readAttribute = Element.Methods.readAttribute.wrap(
    function(proceed, element, attribute) {
      if (attribute === 'title') return element.title;
      return proceed(element, attribute);
    }
  );
}

else if (Prototype.Browser.IE) {
  Element.Methods.getOffsetParent = Element.Methods.getOffsetParent.wrap(
    function(proceed, element) {
      element = $(element);
      try { element.offsetParent }
      catch(e) { return $(document.body) }
      var position = element.getStyle('position');
      if (position !== 'static') return proceed(element);
      element.setStyle({ position: 'relative' });
      var value = proceed(element);
      element.setStyle({ position: position });
      return value;
    }
  );

  $w('positionedOffset viewportOffset').each(function(method) {
    Element.Methods[method] = Element.Methods[method].wrap(
      function(proceed, element) {
        element = $(element);
        try { element.offsetParent }
        catch(e) { return Element._returnOffset(0,0) }
        var position = element.getStyle('position');
        if (position !== 'static') return proceed(element);
        var offsetParent = element.getOffsetParent();
        if (offsetParent && offsetParent.getStyle('position') === 'fixed')
          offsetParent.setStyle({ zoom: 1 });
        element.setStyle({ position: 'relative' });
        var value = proceed(element);
        element.setStyle({ position: position });
        return value;
      }
    );
  });

  Element.Methods.cumulativeOffset = Element.Methods.cumulativeOffset.wrap(
    function(proceed, element) {
      try { element.offsetParent }
      catch(e) { return Element._returnOffset(0,0) }
      return proceed(element);
    }
  );

  Element.Methods.getStyle = function(element, style) {
    element = $(element);
    style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' : style.camelize();
    var value = element.style[style];
    if (!value && element.currentStyle) value = element.currentStyle[style];

    if (style == 'opacity') {
      if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
        if (value[1]) return parseFloat(value[1]) / 100;
      return 1.0;
    }

    if (value == 'auto') {
      if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
        return element['offset' + style.capitalize()] + 'px';
      return null;
    }
    return value;
  };

  Element.Methods.setOpacity = function(element, value) {
    function stripAlpha(filter){
      return filter.replace(/alpha\([^\)]*\)/gi,'');
    }
    element = $(element);
    var currentStyle = element.currentStyle;
    if ((currentStyle && !currentStyle.hasLayout) ||
      (!currentStyle && element.style.zoom == 'normal'))
        element.style.zoom = 1;

    var filter = element.getStyle('filter'), style = element.style;
    if (value == 1 || value === '') {
      (filter = stripAlpha(filter)) ?
        style.filter = filter : style.removeAttribute('filter');
      return element;
    } else if (value < 0.00001) value = 0;
    style.filter = stripAlpha(filter) +
      'alpha(opacity=' + (value * 100) + ')';
    return element;
  };

  Element._attributeTranslations = (function(){

    var classProp = 'className';
    var forProp = 'for';

    var el = document.createElement('div');

    el.setAttribute(classProp, 'x');

    if (el.className !== 'x') {
      el.setAttribute('class', 'x');
      if (el.className === 'x') {
        classProp = 'class';
      }
    }
    el = null;

    el = document.createElement('label');
    el.setAttribute(forProp, 'x');
    if (el.htmlFor !== 'x') {
      el.setAttribute('htmlFor', 'x');
      if (el.htmlFor === 'x') {
        forProp = 'htmlFor';
      }
    }
    el = null;

    return {
      read: {
        names: {
          'class':      classProp,
          'className':  classProp,
          'for':        forProp,
          'htmlFor':    forProp
        },
        values: {
          _getAttr: function(element, attribute) {
            return element.getAttribute(attribute);
          },
          _getAttr2: function(element, attribute) {
            return element.getAttribute(attribute, 2);
          },
          _getAttrNode: function(element, attribute) {
            var node = element.getAttributeNode(attribute);
            return node ? node.value : "";
          },
          _getEv: (function(){

            var el = document.createElement('div');
            el.onclick = Prototype.emptyFunction;
            var value = el.getAttribute('onclick');
            var f;

            if (String(value).indexOf('{') > -1) {
              f = function(element, attribute) {
                attribute = element.getAttribute(attribute);
                if (!attribute) return null;
                attribute = attribute.toString();
                attribute = attribute.split('{')[1];
                attribute = attribute.split('}')[0];
                return attribute.strip();
              };
            }
            else if (value === '') {
              f = function(element, attribute) {
                attribute = element.getAttribute(attribute);
                if (!attribute) return null;
                return attribute.strip();
              };
            }
            el = null;
            return f;
          })(),
          _flag: function(element, attribute) {
            return $(element).hasAttribute(attribute) ? attribute : null;
          },
          style: function(element) {
            return element.style.cssText.toLowerCase();
          },
          title: function(element) {
            return element.title;
          }
        }
      }
    }
  })();

  Element._attributeTranslations.write = {
    names: Object.extend({
      cellpadding: 'cellPadding',
      cellspacing: 'cellSpacing'
    }, Element._attributeTranslations.read.names),
    values: {
      checked: function(element, value) {
        element.checked = !!value;
      },

      style: function(element, value) {
        element.style.cssText = value ? value : '';
      }
    }
  };

  Element._attributeTranslations.has = {};

  $w('colSpan rowSpan vAlign dateTime accessKey tabIndex ' +
      'encType maxLength readOnly longDesc frameBorder').each(function(attr) {
    Element._attributeTranslations.write.names[attr.toLowerCase()] = attr;
    Element._attributeTranslations.has[attr.toLowerCase()] = attr;
  });

  (function(v) {
    Object.extend(v, {
      href:        v._getAttr2,
      src:         v._getAttr2,
      type:        v._getAttr,
      action:      v._getAttrNode,
      disabled:    v._flag,
      checked:     v._flag,
      readonly:    v._flag,
      multiple:    v._flag,
      onload:      v._getEv,
      onunload:    v._getEv,
      onclick:     v._getEv,
      ondblclick:  v._getEv,
      onmousedown: v._getEv,
      onmouseup:   v._getEv,
      onmouseover: v._getEv,
      onmousemove: v._getEv,
      onmouseout:  v._getEv,
      onfocus:     v._getEv,
      onblur:      v._getEv,
      onkeypress:  v._getEv,
      onkeydown:   v._getEv,
      onkeyup:     v._getEv,
      onsubmit:    v._getEv,
      onreset:     v._getEv,
      onselect:    v._getEv,
      onchange:    v._getEv
    });
  })(Element._attributeTranslations.read.values);

  if (Prototype.BrowserFeatures.ElementExtensions) {
    (function() {
      function _descendants(element) {
        var nodes = element.getElementsByTagName('*'), results = [];
        for (var i = 0, node; node = nodes[i]; i++)
          if (node.tagName !== "!") // Filter out comment nodes.
            results.push(node);
        return results;
      }

      Element.Methods.down = function(element, expression, index) {
        element = $(element);
        if (arguments.length == 1) return element.firstDescendant();
        return Object.isNumber(expression) ? _descendants(element)[expression] :
          Element.select(element, expression)[index || 0];
      }
    })();
  }

}

else if (Prototype.Browser.Gecko && /rv:1\.8\.0/.test(navigator.userAgent)) {
  Element.Methods.setOpacity = function(element, value) {
    element = $(element);
    element.style.opacity = (value == 1) ? 0.999999 :
      (value === '') ? '' : (value < 0.00001) ? 0 : value;
    return element;
  };
}

else if (Prototype.Browser.WebKit) {
  Element.Methods.setOpacity = function(element, value) {
    element = $(element);
    element.style.opacity = (value == 1 || value === '') ? '' :
      (value < 0.00001) ? 0 : value;

    if (value == 1)
      if(element.tagName.toUpperCase() == 'IMG' && element.width) {
        element.width++; element.width--;
      } else try {
        var n = document.createTextNode(' ');
        element.appendChild(n);
        element.removeChild(n);
      } catch (e) { }

    return element;
  };

  Element.Methods.cumulativeOffset = function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;
      if (element.offsetParent == document.body)
        if (Element.getStyle(element, 'position') == 'absolute') break;

      element = element.offsetParent;
    } while (element);

    return Element._returnOffset(valueL, valueT);
  };
}

if ('outerHTML' in document.documentElement) {
  Element.Methods.replace = function(element, content) {
    element = $(element);

    if (content && content.toElement) content = content.toElement();
    if (Object.isElement(content)) {
      element.parentNode.replaceChild(content, element);
      return element;
    }

    content = Object.toHTML(content);
    var parent = element.parentNode, tagName = parent.tagName.toUpperCase();

    if (Element._insertionTranslations.tags[tagName]) {
      var nextSibling = element.next();
      var fragments = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
      parent.removeChild(element);
      if (nextSibling)
        fragments.each(function(node) { parent.insertBefore(node, nextSibling) });
      else
        fragments.each(function(node) { parent.appendChild(node) });
    }
    else element.outerHTML = content.stripScripts();

    content.evalScripts.bind(content).defer();
    return element;
  };
}

Element._returnOffset = function(l, t) {
  var result = [l, t];
  result.left = l;
  result.top = t;
  return result;
};

Element._getContentFromAnonymousElement = function(tagName, html) {
  var div = new Element('div'), t = Element._insertionTranslations.tags[tagName];
  if (t) {
    div.innerHTML = t[0] + html + t[1];
    t[2].times(function() { div = div.firstChild });
  } else div.innerHTML = html;
  return $A(div.childNodes);
};

Element._insertionTranslations = {
  before: function(element, node) {
    element.parentNode.insertBefore(node, element);
  },
  top: function(element, node) {
    element.insertBefore(node, element.firstChild);
  },
  bottom: function(element, node) {
    element.appendChild(node);
  },
  after: function(element, node) {
    element.parentNode.insertBefore(node, element.nextSibling);
  },
  tags: {
    TABLE:  ['<table>',                '</table>',                   1],
    TBODY:  ['<table><tbody>',         '</tbody></table>',           2],
    TR:     ['<table><tbody><tr>',     '</tr></tbody></table>',      3],
    TD:     ['<table><tbody><tr><td>', '</td></tr></tbody></table>', 4],
    SELECT: ['<select>',               '</select>',                  1]
  }
};

(function() {
  var tags = Element._insertionTranslations.tags;
  Object.extend(tags, {
    THEAD: tags.TBODY,
    TFOOT: tags.TBODY,
    TH:    tags.TD
  });
})();

Element.Methods.Simulated = {
  hasAttribute: function(element, attribute) {
    attribute = Element._attributeTranslations.has[attribute] || attribute;
    var node = $(element).getAttributeNode(attribute);
    return !!(node && node.specified);
  }
};

Element.Methods.ByTag = { };

Object.extend(Element, Element.Methods);

(function(div) {

  if (!Prototype.BrowserFeatures.ElementExtensions && div['__proto__']) {
    window.HTMLElement = { };
    window.HTMLElement.prototype = div['__proto__'];
    Prototype.BrowserFeatures.ElementExtensions = true;
  }

  div = null;

})(document.createElement('div'))

Element.extend = (function() {

  function checkDeficiency(tagName) {
    if (typeof window.Element != 'undefined') {
      var proto = window.Element.prototype;
      if (proto) {
        var id = '_' + (Math.random()+'').slice(2);
        var el = document.createElement(tagName);
        proto[id] = 'x';
        var isBuggy = (el[id] !== 'x');
        delete proto[id];
        el = null;
        return isBuggy;
      }
    }
    return false;
  }

  function extendElementWith(element, methods) {
    for (var property in methods) {
      var value = methods[property];
      if (Object.isFunction(value) && !(property in element))
        element[property] = value.methodize();
    }
  }

  var HTMLOBJECTELEMENT_PROTOTYPE_BUGGY = checkDeficiency('object');

  if (Prototype.BrowserFeatures.SpecificElementExtensions) {
    if (HTMLOBJECTELEMENT_PROTOTYPE_BUGGY) {
      return function(element) {
        if (element && typeof element._extendedByPrototype == 'undefined') {
          var t = element.tagName;
          if (t && (/^(?:object|applet|embed)$/i.test(t))) {
            extendElementWith(element, Element.Methods);
            extendElementWith(element, Element.Methods.Simulated);
            extendElementWith(element, Element.Methods.ByTag[t.toUpperCase()]);
          }
        }
        return element;
      }
    }
    return Prototype.K;
  }

  var Methods = { }, ByTag = Element.Methods.ByTag;

  var extend = Object.extend(function(element) {
    if (!element || typeof element._extendedByPrototype != 'undefined' ||
        element.nodeType != 1 || element == window) return element;

    var methods = Object.clone(Methods),
        tagName = element.tagName.toUpperCase();

    if (ByTag[tagName]) Object.extend(methods, ByTag[tagName]);

    extendElementWith(element, methods);

    element._extendedByPrototype = Prototype.emptyFunction;
    return element;

  }, {
    refresh: function() {
      if (!Prototype.BrowserFeatures.ElementExtensions) {
        Object.extend(Methods, Element.Methods);
        Object.extend(Methods, Element.Methods.Simulated);
      }
    }
  });

  extend.refresh();
  return extend;
})();

Element.hasAttribute = function(element, attribute) {
  if (element.hasAttribute) return element.hasAttribute(attribute);
  return Element.Methods.Simulated.hasAttribute(element, attribute);
};

Element.addMethods = function(methods) {
  var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;

  if (!methods) {
    Object.extend(Form, Form.Methods);
    Object.extend(Form.Element, Form.Element.Methods);
    Object.extend(Element.Methods.ByTag, {
      "FORM":     Object.clone(Form.Methods),
      "INPUT":    Object.clone(Form.Element.Methods),
      "SELECT":   Object.clone(Form.Element.Methods),
      "TEXTAREA": Object.clone(Form.Element.Methods)
    });
  }

  if (arguments.length == 2) {
    var tagName = methods;
    methods = arguments[1];
  }

  if (!tagName) Object.extend(Element.Methods, methods || { });
  else {
    if (Object.isArray(tagName)) tagName.each(extend);
    else extend(tagName);
  }

  function extend(tagName) {
    tagName = tagName.toUpperCase();
    if (!Element.Methods.ByTag[tagName])
      Element.Methods.ByTag[tagName] = { };
    Object.extend(Element.Methods.ByTag[tagName], methods);
  }

  function copy(methods, destination, onlyIfAbsent) {
    onlyIfAbsent = onlyIfAbsent || false;
    for (var property in methods) {
      var value = methods[property];
      if (!Object.isFunction(value)) continue;
      if (!onlyIfAbsent || !(property in destination))
        destination[property] = value.methodize();
    }
  }

  function findDOMClass(tagName) {
    var klass;
    var trans = {
      "OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
      "FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
      "DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
      "H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
      "INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
      "TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
      "TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
      "TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
      "FrameSet", "IFRAME": "IFrame"
    };
    if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
    if (window[klass]) return window[klass];
    klass = 'HTML' + tagName + 'Element';
    if (window[klass]) return window[klass];
    klass = 'HTML' + tagName.capitalize() + 'Element';
    if (window[klass]) return window[klass];

    var element = document.createElement(tagName);
    var proto = element['__proto__'] || element.constructor.prototype;
    element = null;
    return proto;
  }

  var elementPrototype = window.HTMLElement ? HTMLElement.prototype :
   Element.prototype;

  if (F.ElementExtensions) {
    copy(Element.Methods, elementPrototype);
    copy(Element.Methods.Simulated, elementPrototype, true);
  }

  if (F.SpecificElementExtensions) {
    for (var tag in Element.Methods.ByTag) {
      var klass = findDOMClass(tag);
      if (Object.isUndefined(klass)) continue;
      copy(T[tag], klass.prototype);
    }
  }

  Object.extend(Element, Element.Methods);
  delete Element.ByTag;

  if (Element.extend.refresh) Element.extend.refresh();
  Element.cache = { };
};


document.viewport = {

  getDimensions: function() {
    return { width: this.getWidth(), height: this.getHeight() };
  },

  getScrollOffsets: function() {
    return Element._returnOffset(
      window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft,
      window.pageYOffset || document.documentElement.scrollTop  || document.body.scrollTop);
  }
};

(function(viewport) {
  var B = Prototype.Browser, doc = document, element, property = {};

  function getRootElement() {
    if (B.WebKit && !doc.evaluate)
      return document;

    if (B.Opera && window.parseFloat(window.opera.version()) < 9.5)
      return document.body;

    return document.documentElement;
  }

  function define(D) {
    if (!element) element = getRootElement();

    property[D] = 'client' + D;

    viewport['get' + D] = function() { return element[property[D]] };
    return viewport['get' + D]();
  }

  viewport.getWidth  = define.curry('Width');

  viewport.getHeight = define.curry('Height');
})(document.viewport);


Element.Storage = {
  UID: 1
};

Element.addMethods({
  getStorage: function(element) {
    if (!(element = $(element))) return;

    var uid;
    if (element === window) {
      uid = 0;
    } else {
      if (typeof element._prototypeUID === "undefined")
        element._prototypeUID = [Element.Storage.UID++];
      uid = element._prototypeUID[0];
    }

    if (!Element.Storage[uid])
      Element.Storage[uid] = $H();

    return Element.Storage[uid];
  },

  store: function(element, key, value) {
    if (!(element = $(element))) return;

    if (arguments.length === 2) {
      Element.getStorage(element).update(key);
    } else {
      Element.getStorage(element).set(key, value);
    }

    return element;
  },

  retrieve: function(element, key, defaultValue) {
    if (!(element = $(element))) return;
    var hash = Element.getStorage(element), value = hash.get(key);

    if (Object.isUndefined(value)) {
      hash.set(key, defaultValue);
      value = defaultValue;
    }

    return value;
  },

  clone: function(element, deep) {
    if (!(element = $(element))) return;
    var clone = element.cloneNode(deep);
    clone._prototypeUID = void 0;
    if (deep) {
      var descendants = Element.select(clone, '*'),
          i = descendants.length;
      while (i--) {
        descendants[i]._prototypeUID = void 0;
      }
    }
    return Element.extend(clone);
  }
});
/* Portions of the Selector class are derived from Jack Slocum's DomQuery,
 * part of YUI-Ext version 0.40, distributed under the terms of an MIT-style
 * license.  Please see http://www.yui-ext.com/ for more information. */

var Selector = Class.create({
  initialize: function(expression) {
    this.expression = expression.strip();

    if (this.shouldUseSelectorsAPI()) {
      this.mode = 'selectorsAPI';
    } else if (this.shouldUseXPath()) {
      this.mode = 'xpath';
      this.compileXPathMatcher();
    } else {
      this.mode = "normal";
      this.compileMatcher();
    }

  },

  shouldUseXPath: (function() {

    var IS_DESCENDANT_SELECTOR_BUGGY = (function(){
      var isBuggy = false;
      if (document.evaluate && window.XPathResult) {
        var el = document.createElement('div');
        el.innerHTML = '<ul><li></li></ul><div><ul><li></li></ul></div>';

        var xpath = ".//*[local-name()='ul' or local-name()='UL']" +
          "//*[local-name()='li' or local-name()='LI']";

        var result = document.evaluate(xpath, el, null,
          XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);

        isBuggy = (result.snapshotLength !== 2);
        el = null;
      }
      return isBuggy;
    })();

    return function() {
      if (!Prototype.BrowserFeatures.XPath) return false;

      var e = this.expression;

      if (Prototype.Browser.WebKit &&
       (e.include("-of-type") || e.include(":empty")))
        return false;

      if ((/(\[[\w-]*?:|:checked)/).test(e))
        return false;

      if (IS_DESCENDANT_SELECTOR_BUGGY) return false;

      return true;
    }

  })(),

  shouldUseSelectorsAPI: function() {
    if (!Prototype.BrowserFeatures.SelectorsAPI) return false;

    if (Selector.CASE_INSENSITIVE_CLASS_NAMES) return false;

    if (!Selector._div) Selector._div = new Element('div');

    try {
      Selector._div.querySelector(this.expression);
    } catch(e) {
      return false;
    }

    return true;
  },

  compileMatcher: function() {
    var e = this.expression, ps = Selector.patterns, h = Selector.handlers,
        c = Selector.criteria, le, p, m, len = ps.length, name;

    if (Selector._cache[e]) {
      this.matcher = Selector._cache[e];
      return;
    }

    this.matcher = ["this.matcher = function(root) {",
                    "var r = root, h = Selector.handlers, c = false, n;"];

    while (e && le != e && (/\S/).test(e)) {
      le = e;
      for (var i = 0; i<len; i++) {
        p = ps[i].re;
        name = ps[i].name;
        if (m = e.match(p)) {
          this.matcher.push(Object.isFunction(c[name]) ? c[name](m) :
            new Template(c[name]).evaluate(m));
          e = e.replace(m[0], '');
          break;
        }
      }
    }

    this.matcher.push("return h.unique(n);\n}");
    eval(this.matcher.join('\n'));
    Selector._cache[this.expression] = this.matcher;
  },

  compileXPathMatcher: function() {
    var e = this.expression, ps = Selector.patterns,
        x = Selector.xpath, le, m, len = ps.length, name;

    if (Selector._cache[e]) {
      this.xpath = Selector._cache[e]; return;
    }

    this.matcher = ['.//*'];
    while (e && le != e && (/\S/).test(e)) {
      le = e;
      for (var i = 0; i<len; i++) {
        name = ps[i].name;
        if (m = e.match(ps[i].re)) {
          this.matcher.push(Object.isFunction(x[name]) ? x[name](m) :
            new Template(x[name]).evaluate(m));
          e = e.replace(m[0], '');
          break;
        }
      }
    }

    this.xpath = this.matcher.join('');
    Selector._cache[this.expression] = this.xpath;
  },

  findElements: function(root) {
    root = root || document;
    var e = this.expression, results;

    switch (this.mode) {
      case 'selectorsAPI':
        if (root !== document) {
          var oldId = root.id, id = $(root).identify();
          id = id.replace(/([\.:])/g, "\\$1");
          e = "#" + id + " " + e;
        }

        results = $A(root.querySelectorAll(e)).map(Element.extend);
        root.id = oldId;

        return results;
      case 'xpath':
        return document._getElementsByXPath(this.xpath, root);
      default:
       return this.matcher(root);
    }
  },

  match: function(element) {
    this.tokens = [];

    var e = this.expression, ps = Selector.patterns, as = Selector.assertions;
    var le, p, m, len = ps.length, name;

    while (e && le !== e && (/\S/).test(e)) {
      le = e;
      for (var i = 0; i<len; i++) {
        p = ps[i].re;
        name = ps[i].name;
        if (m = e.match(p)) {
          if (as[name]) {
            this.tokens.push([name, Object.clone(m)]);
            e = e.replace(m[0], '');
          } else {
            return this.findElements(document).include(element);
          }
        }
      }
    }

    var match = true, name, matches;
    for (var i = 0, token; token = this.tokens[i]; i++) {
      name = token[0], matches = token[1];
      if (!Selector.assertions[name](element, matches)) {
        match = false; break;
      }
    }

    return match;
  },

  toString: function() {
    return this.expression;
  },

  inspect: function() {
    return "#<Selector:" + this.expression.inspect() + ">";
  }
});

if (Prototype.BrowserFeatures.SelectorsAPI &&
 document.compatMode === 'BackCompat') {
  Selector.CASE_INSENSITIVE_CLASS_NAMES = (function(){
    var div = document.createElement('div'),
     span = document.createElement('span');

    div.id = "prototype_test_id";
    span.className = 'Test';
    div.appendChild(span);
    var isIgnored = (div.querySelector('#prototype_test_id .test') !== null);
    div = span = null;
    return isIgnored;
  })();
}

Object.extend(Selector, {
  _cache: { },

  xpath: {
    descendant:   "//*",
    child:        "/*",
    adjacent:     "/following-sibling::*[1]",
    laterSibling: '/following-sibling::*',
    tagName:      function(m) {
      if (m[1] == '*') return '';
      return "[local-name()='" + m[1].toLowerCase() +
             "' or local-name()='" + m[1].toUpperCase() + "']";
    },
    className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
    id:           "[@id='#{1}']",
    attrPresence: function(m) {
      m[1] = m[1].toLowerCase();
      return new Template("[@#{1}]").evaluate(m);
    },
    attr: function(m) {
      m[1] = m[1].toLowerCase();
      m[3] = m[5] || m[6];
      return new Template(Selector.xpath.operators[m[2]]).evaluate(m);
    },
    pseudo: function(m) {
      var h = Selector.xpath.pseudos[m[1]];
      if (!h) return '';
      if (Object.isFunction(h)) return h(m);
      return new Template(Selector.xpath.pseudos[m[1]]).evaluate(m);
    },
    operators: {
      '=':  "[@#{1}='#{3}']",
      '!=': "[@#{1}!='#{3}']",
      '^=': "[starts-with(@#{1}, '#{3}')]",
      '$=': "[substring(@#{1}, (string-length(@#{1}) - string-length('#{3}') + 1))='#{3}']",
      '*=': "[contains(@#{1}, '#{3}')]",
      '~=': "[contains(concat(' ', @#{1}, ' '), ' #{3} ')]",
      '|=': "[contains(concat('-', @#{1}, '-'), '-#{3}-')]"
    },
    pseudos: {
      'first-child': '[not(preceding-sibling::*)]',
      'last-child':  '[not(following-sibling::*)]',
      'only-child':  '[not(preceding-sibling::* or following-sibling::*)]',
      'empty':       "[count(*) = 0 and (count(text()) = 0)]",
      'checked':     "[@checked]",
      'disabled':    "[(@disabled) and (@type!='hidden')]",
      'enabled':     "[not(@disabled) and (@type!='hidden')]",
      'not': function(m) {
        var e = m[6], p = Selector.patterns,
            x = Selector.xpath, le, v, len = p.length, name;

        var exclusion = [];
        while (e && le != e && (/\S/).test(e)) {
          le = e;
          for (var i = 0; i<len; i++) {
            name = p[i].name
            if (m = e.match(p[i].re)) {
              v = Object.isFunction(x[name]) ? x[name](m) : new Template(x[name]).evaluate(m);
              exclusion.push("(" + v.substring(1, v.length - 1) + ")");
              e = e.replace(m[0], '');
              break;
            }
          }
        }
        return "[not(" + exclusion.join(" and ") + ")]";
      },
      'nth-child':      function(m) {
        return Selector.xpath.pseudos.nth("(count(./preceding-sibling::*) + 1) ", m);
      },
      'nth-last-child': function(m) {
        return Selector.xpath.pseudos.nth("(count(./following-sibling::*) + 1) ", m);
      },
      'nth-of-type':    function(m) {
        return Selector.xpath.pseudos.nth("position() ", m);
      },
      'nth-last-of-type': function(m) {
        return Selector.xpath.pseudos.nth("(last() + 1 - position()) ", m);
      },
      'first-of-type':  function(m) {
        m[6] = "1"; return Selector.xpath.pseudos['nth-of-type'](m);
      },
      'last-of-type':   function(m) {
        m[6] = "1"; return Selector.xpath.pseudos['nth-last-of-type'](m);
      },
      'only-of-type':   function(m) {
        var p = Selector.xpath.pseudos; return p['first-of-type'](m) + p['last-of-type'](m);
      },
      nth: function(fragment, m) {
        var mm, formula = m[6], predicate;
        if (formula == 'even') formula = '2n+0';
        if (formula == 'odd')  formula = '2n+1';
        if (mm = formula.match(/^(\d+)$/)) // digit only
          return '[' + fragment + "= " + mm[1] + ']';
        if (mm = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
          if (mm[1] == "-") mm[1] = -1;
          var a = mm[1] ? Number(mm[1]) : 1;
          var b = mm[2] ? Number(mm[2]) : 0;
          predicate = "[((#{fragment} - #{b}) mod #{a} = 0) and " +
          "((#{fragment} - #{b}) div #{a} >= 0)]";
          return new Template(predicate).evaluate({
            fragment: fragment, a: a, b: b });
        }
      }
    }
  },

  criteria: {
    tagName:      'n = h.tagName(n, r, "#{1}", c);      c = false;',
    className:    'n = h.className(n, r, "#{1}", c);    c = false;',
    id:           'n = h.id(n, r, "#{1}", c);           c = false;',
    attrPresence: 'n = h.attrPresence(n, r, "#{1}", c); c = false;',
    attr: function(m) {
      m[3] = (m[5] || m[6]);
      return new Template('n = h.attr(n, r, "#{1}", "#{3}", "#{2}", c); c = false;').evaluate(m);
    },
    pseudo: function(m) {
      if (m[6]) m[6] = m[6].replace(/"/g, '\\"');
      return new Template('n = h.pseudo(n, "#{1}", "#{6}", r, c); c = false;').evaluate(m);
    },
    descendant:   'c = "descendant";',
    child:        'c = "child";',
    adjacent:     'c = "adjacent";',
    laterSibling: 'c = "laterSibling";'
  },

  patterns: [
    { name: 'laterSibling', re: /^\s*~\s*/ },
    { name: 'child',        re: /^\s*>\s*/ },
    { name: 'adjacent',     re: /^\s*\+\s*/ },
    { name: 'descendant',   re: /^\s/ },

    { name: 'tagName',      re: /^\s*(\*|[\w\-]+)(\b|$)?/ },
    { name: 'id',           re: /^#([\w\-\*]+)(\b|$)/ },
    { name: 'className',    re: /^\.([\w\-\*]+)(\b|$)/ },
    { name: 'pseudo',       re: /^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|(?=\s|[:+~>]))/ },
    { name: 'attrPresence', re: /^\[((?:[\w-]+:)?[\w-]+)\]/ },
    { name: 'attr',         re: /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\4]*?)\4|([^'"][^\]]*?)))?\]/ }
  ],

  assertions: {
    tagName: function(element, matches) {
      return matches[1].toUpperCase() == element.tagName.toUpperCase();
    },

    className: function(element, matches) {
      return Element.hasClassName(element, matches[1]);
    },

    id: function(element, matches) {
      return element.id === matches[1];
    },

    attrPresence: function(element, matches) {
      return Element.hasAttribute(element, matches[1]);
    },

    attr: function(element, matches) {
      var nodeValue = Element.readAttribute(element, matches[1]);
      return nodeValue && Selector.operators[matches[2]](nodeValue, matches[5] || matches[6]);
    }
  },

  handlers: {
    concat: function(a, b) {
      for (var i = 0, node; node = b[i]; i++)
        a.push(node);
      return a;
    },

    mark: function(nodes) {
      var _true = Prototype.emptyFunction;
      for (var i = 0, node; node = nodes[i]; i++)
        node._countedByPrototype = _true;
      return nodes;
    },

    unmark: (function(){

      var PROPERTIES_ATTRIBUTES_MAP = (function(){
        var el = document.createElement('div'),
            isBuggy = false,
            propName = '_countedByPrototype',
            value = 'x'
        el[propName] = value;
        isBuggy = (el.getAttribute(propName) === value);
        el = null;
        return isBuggy;
      })();

      return PROPERTIES_ATTRIBUTES_MAP ?
        function(nodes) {
          for (var i = 0, node; node = nodes[i]; i++)
            node.removeAttribute('_countedByPrototype');
          return nodes;
        } :
        function(nodes) {
          for (var i = 0, node; node = nodes[i]; i++)
            node._countedByPrototype = void 0;
          return nodes;
        }
    })(),

    index: function(parentNode, reverse, ofType) {
      parentNode._countedByPrototype = Prototype.emptyFunction;
      if (reverse) {
        for (var nodes = parentNode.childNodes, i = nodes.length - 1, j = 1; i >= 0; i--) {
          var node = nodes[i];
          if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
        }
      } else {
        for (var i = 0, j = 1, nodes = parentNode.childNodes; node = nodes[i]; i++)
          if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
      }
    },

    unique: function(nodes) {
      if (nodes.length == 0) return nodes;
      var results = [], n;
      for (var i = 0, l = nodes.length; i < l; i++)
        if (typeof (n = nodes[i])._countedByPrototype == 'undefined') {
          n._countedByPrototype = Prototype.emptyFunction;
          results.push(Element.extend(n));
        }
      return Selector.handlers.unmark(results);
    },

    descendant: function(nodes) {
      var h = Selector.handlers;
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        h.concat(results, node.getElementsByTagName('*'));
      return results;
    },

    child: function(nodes) {
      var h = Selector.handlers;
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        for (var j = 0, child; child = node.childNodes[j]; j++)
          if (child.nodeType == 1 && child.tagName != '!') results.push(child);
      }
      return results;
    },

    adjacent: function(nodes) {
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        var next = this.nextElementSibling(node);
        if (next) results.push(next);
      }
      return results;
    },

    laterSibling: function(nodes) {
      var h = Selector.handlers;
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        h.concat(results, Element.nextSiblings(node));
      return results;
    },

    nextElementSibling: function(node) {
      while (node = node.nextSibling)
        if (node.nodeType == 1) return node;
      return null;
    },

    previousElementSibling: function(node) {
      while (node = node.previousSibling)
        if (node.nodeType == 1) return node;
      return null;
    },

    tagName: function(nodes, root, tagName, combinator) {
      var uTagName = tagName.toUpperCase();
      var results = [], h = Selector.handlers;
      if (nodes) {
        if (combinator) {
          if (combinator == "descendant") {
            for (var i = 0, node; node = nodes[i]; i++)
              h.concat(results, node.getElementsByTagName(tagName));
            return results;
          } else nodes = this[combinator](nodes);
          if (tagName == "*") return nodes;
        }
        for (var i = 0, node; node = nodes[i]; i++)
          if (node.tagName.toUpperCase() === uTagName) results.push(node);
        return results;
      } else return root.getElementsByTagName(tagName);
    },

    id: function(nodes, root, id, combinator) {
      var targetNode = $(id), h = Selector.handlers;

      if (root == document) {
        if (!targetNode) return [];
        if (!nodes) return [targetNode];
      } else {
        if (!root.sourceIndex || root.sourceIndex < 1) {
          var nodes = root.getElementsByTagName('*');
          for (var j = 0, node; node = nodes[j]; j++) {
            if (node.id === id) return [node];
          }
        }
      }

      if (nodes) {
        if (combinator) {
          if (combinator == 'child') {
            for (var i = 0, node; node = nodes[i]; i++)
              if (targetNode.parentNode == node) return [targetNode];
          } else if (combinator == 'descendant') {
            for (var i = 0, node; node = nodes[i]; i++)
              if (Element.descendantOf(targetNode, node)) return [targetNode];
          } else if (combinator == 'adjacent') {
            for (var i = 0, node; node = nodes[i]; i++)
              if (Selector.handlers.previousElementSibling(targetNode) == node)
                return [targetNode];
          } else nodes = h[combinator](nodes);
        }
        for (var i = 0, node; node = nodes[i]; i++)
          if (node == targetNode) return [targetNode];
        return [];
      }
      return (targetNode && Element.descendantOf(targetNode, root)) ? [targetNode] : [];
    },

    className: function(nodes, root, className, combinator) {
      if (nodes && combinator) nodes = this[combinator](nodes);
      return Selector.handlers.byClassName(nodes, root, className);
    },

    byClassName: function(nodes, root, className) {
      if (!nodes) nodes = Selector.handlers.descendant([root]);
      var needle = ' ' + className + ' ';
      for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
        nodeClassName = node.className;
        if (nodeClassName.length == 0) continue;
        if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
          results.push(node);
      }
      return results;
    },

    attrPresence: function(nodes, root, attr, combinator) {
      if (!nodes) nodes = root.getElementsByTagName("*");
      if (nodes && combinator) nodes = this[combinator](nodes);
      var results = [];
      for (var i = 0, node; node = nodes[i]; i++)
        if (Element.hasAttribute(node, attr)) results.push(node);
      return results;
    },

    attr: function(nodes, root, attr, value, operator, combinator) {
      if (!nodes) nodes = root.getElementsByTagName("*");
      if (nodes && combinator) nodes = this[combinator](nodes);
      var handler = Selector.operators[operator], results = [];
      for (var i = 0, node; node = nodes[i]; i++) {
        var nodeValue = Element.readAttribute(node, attr);
        if (nodeValue === null) continue;
        if (handler(nodeValue, value)) results.push(node);
      }
      return results;
    },

    pseudo: function(nodes, name, value, root, combinator) {
      if (nodes && combinator) nodes = this[combinator](nodes);
      if (!nodes) nodes = root.getElementsByTagName("*");
      return Selector.pseudos[name](nodes, value, root);
    }
  },

  pseudos: {
    'first-child': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        if (Selector.handlers.previousElementSibling(node)) continue;
          results.push(node);
      }
      return results;
    },
    'last-child': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        if (Selector.handlers.nextElementSibling(node)) continue;
          results.push(node);
      }
      return results;
    },
    'only-child': function(nodes, value, root) {
      var h = Selector.handlers;
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (!h.previousElementSibling(node) && !h.nextElementSibling(node))
          results.push(node);
      return results;
    },
    'nth-child':        function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, formula, root);
    },
    'nth-last-child':   function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, formula, root, true);
    },
    'nth-of-type':      function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, formula, root, false, true);
    },
    'nth-last-of-type': function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, formula, root, true, true);
    },
    'first-of-type':    function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, "1", root, false, true);
    },
    'last-of-type':     function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, "1", root, true, true);
    },
    'only-of-type':     function(nodes, formula, root) {
      var p = Selector.pseudos;
      return p['last-of-type'](p['first-of-type'](nodes, formula, root), formula, root);
    },

    getIndices: function(a, b, total) {
      if (a == 0) return b > 0 ? [b] : [];
      return $R(1, total).inject([], function(memo, i) {
        if (0 == (i - b) % a && (i - b) / a >= 0) memo.push(i);
        return memo;
      });
    },

    nth: function(nodes, formula, root, reverse, ofType) {
      if (nodes.length == 0) return [];
      if (formula == 'even') formula = '2n+0';
      if (formula == 'odd')  formula = '2n+1';
      var h = Selector.handlers, results = [], indexed = [], m;
      h.mark(nodes);
      for (var i = 0, node; node = nodes[i]; i++) {
        if (!node.parentNode._countedByPrototype) {
          h.index(node.parentNode, reverse, ofType);
          indexed.push(node.parentNode);
        }
      }
      if (formula.match(/^\d+$/)) { // just a number
        formula = Number(formula);
        for (var i = 0, node; node = nodes[i]; i++)
          if (node.nodeIndex == formula) results.push(node);
      } else if (m = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
        if (m[1] == "-") m[1] = -1;
        var a = m[1] ? Number(m[1]) : 1;
        var b = m[2] ? Number(m[2]) : 0;
        var indices = Selector.pseudos.getIndices(a, b, nodes.length);
        for (var i = 0, node, l = indices.length; node = nodes[i]; i++) {
          for (var j = 0; j < l; j++)
            if (node.nodeIndex == indices[j]) results.push(node);
        }
      }
      h.unmark(nodes);
      h.unmark(indexed);
      return results;
    },

    'empty': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        if (node.tagName == '!' || node.firstChild) continue;
        results.push(node);
      }
      return results;
    },

    'not': function(nodes, selector, root) {
      var h = Selector.handlers, selectorType, m;
      var exclusions = new Selector(selector).findElements(root);
      h.mark(exclusions);
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (!node._countedByPrototype) results.push(node);
      h.unmark(exclusions);
      return results;
    },

    'enabled': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (!node.disabled && (!node.type || node.type !== 'hidden'))
          results.push(node);
      return results;
    },

    'disabled': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (node.disabled) results.push(node);
      return results;
    },

    'checked': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (node.checked) results.push(node);
      return results;
    }
  },

  operators: {
    '=':  function(nv, v) { return nv == v; },
    '!=': function(nv, v) { return nv != v; },
    '^=': function(nv, v) { return nv == v || nv && nv.startsWith(v); },
    '$=': function(nv, v) { return nv == v || nv && nv.endsWith(v); },
    '*=': function(nv, v) { return nv == v || nv && nv.include(v); },
    '~=': function(nv, v) { return (' ' + nv + ' ').include(' ' + v + ' '); },
    '|=': function(nv, v) { return ('-' + (nv || "").toUpperCase() +
     '-').include('-' + (v || "").toUpperCase() + '-'); }
  },

  split: function(expression) {
    var expressions = [];
    expression.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
      expressions.push(m[1].strip());
    });
    return expressions;
  },

  matchElements: function(elements, expression) {
    var matches = $$(expression), h = Selector.handlers;
    h.mark(matches);
    for (var i = 0, results = [], element; element = elements[i]; i++)
      if (element._countedByPrototype) results.push(element);
    h.unmark(matches);
    return results;
  },

  findElement: function(elements, expression, index) {
    if (Object.isNumber(expression)) {
      index = expression; expression = false;
    }
    return Selector.matchElements(elements, expression || '*')[index || 0];
  },

  findChildElements: function(element, expressions) {
    expressions = Selector.split(expressions.join(','));
    var results = [], h = Selector.handlers;
    for (var i = 0, l = expressions.length, selector; i < l; i++) {
      selector = new Selector(expressions[i].strip());
      h.concat(results, selector.findElements(element));
    }
    return (l > 1) ? h.unique(results) : results;
  }
});

if (Prototype.Browser.IE) {
  Object.extend(Selector.handlers, {
    concat: function(a, b) {
      for (var i = 0, node; node = b[i]; i++)
        if (node.tagName !== "!") a.push(node);
      return a;
    }
  });
}

function $$() {
  return Selector.findChildElements(document, $A(arguments));
}

var Form = {
  reset: function(form) {
    form = $(form);
    form.reset();
    return form;
  },

  serializeElements: function(elements, options) {
    if (typeof options != 'object') options = { hash: !!options };
    else if (Object.isUndefined(options.hash)) options.hash = true;
    var key, value, submitted = false, submit = options.submit;

    var data = elements.inject({ }, function(result, element) {
      if (!element.disabled && element.name) {
        key = element.name; value = $(element).getValue();
        if (value != null && element.type != 'file' && (element.type != 'submit' || (!submitted &&
            submit !== false && (!submit || key == submit) && (submitted = true)))) {
          if (key in result) {
            if (!Object.isArray(result[key])) result[key] = [result[key]];
            result[key].push(value);
          }
          else result[key] = value;
        }
      }
      return result;
    });

    return options.hash ? data : Object.toQueryString(data);
  }
};

Form.Methods = {
  serialize: function(form, options) {
    return Form.serializeElements(Form.getElements(form), options);
  },

  getElements: function(form) {
    var elements = $(form).getElementsByTagName('*'),
        element,
        arr = [ ],
        serializers = Form.Element.Serializers;
    for (var i = 0; element = elements[i]; i++) {
      arr.push(element);
    }
    return arr.inject([], function(elements, child) {
      if (serializers[child.tagName.toLowerCase()])
        elements.push(Element.extend(child));
      return elements;
    })
  },

  getInputs: function(form, typeName, name) {
    form = $(form);
    var inputs = form.getElementsByTagName('input');

    if (!typeName && !name) return $A(inputs).map(Element.extend);

    for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
      var input = inputs[i];
      if ((typeName && input.type != typeName) || (name && input.name != name))
        continue;
      matchingInputs.push(Element.extend(input));
    }

    return matchingInputs;
  },

  disable: function(form) {
    form = $(form);
    Form.getElements(form).invoke('disable');
    return form;
  },

  enable: function(form) {
    form = $(form);
    Form.getElements(form).invoke('enable');
    return form;
  },

  findFirstElement: function(form) {
    var elements = $(form).getElements().findAll(function(element) {
      return 'hidden' != element.type && !element.disabled;
    });
    var firstByIndex = elements.findAll(function(element) {
      return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
    }).sortBy(function(element) { return element.tabIndex }).first();

    return firstByIndex ? firstByIndex : elements.find(function(element) {
      return /^(?:input|select|textarea)$/i.test(element.tagName);
    });
  },

  focusFirstElement: function(form) {
    form = $(form);
    form.findFirstElement().activate();
    return form;
  },

  request: function(form, options) {
    form = $(form), options = Object.clone(options || { });

    var params = options.parameters, action = form.readAttribute('action') || '';
    if (action.blank()) action = window.location.href;
    options.parameters = form.serialize(true);

    if (params) {
      if (Object.isString(params)) params = params.toQueryParams();
      Object.extend(options.parameters, params);
    }

    if (form.hasAttribute('method') && !options.method)
      options.method = form.method;

    return new Ajax.Request(action, options);
  }
};

/*--------------------------------------------------------------------------*/


Form.Element = {
  focus: function(element) {
    $(element).focus();
    return element;
  },

  select: function(element) {
    $(element).select();
    return element;
  }
};

Form.Element.Methods = {

  serialize: function(element) {
    element = $(element);
    if (!element.disabled && element.name) {
      var value = element.getValue();
      if (value != undefined) {
        var pair = { };
        pair[element.name] = value;
        return Object.toQueryString(pair);
      }
    }
    return '';
  },

  getValue: function(element) {
    element = $(element);
    var method = element.tagName.toLowerCase();
    return Form.Element.Serializers[method](element);
  },

  setValue: function(element, value) {
    element = $(element);
    var method = element.tagName.toLowerCase();
    Form.Element.Serializers[method](element, value);
    return element;
  },

  clear: function(element) {
    $(element).value = '';
    return element;
  },

  present: function(element) {
    return $(element).value != '';
  },

  activate: function(element) {
    element = $(element);
    try {
      element.focus();
      if (element.select && (element.tagName.toLowerCase() != 'input' ||
          !(/^(?:button|reset|submit)$/i.test(element.type))))
        element.select();
    } catch (e) { }
    return element;
  },

  disable: function(element) {
    element = $(element);
    element.disabled = true;
    return element;
  },

  enable: function(element) {
    element = $(element);
    element.disabled = false;
    return element;
  }
};

/*--------------------------------------------------------------------------*/

var Field = Form.Element;

var $F = Form.Element.Methods.getValue;

/*--------------------------------------------------------------------------*/

Form.Element.Serializers = {
  input: function(element, value) {
    switch (element.type.toLowerCase()) {
      case 'checkbox':
      case 'radio':
        return Form.Element.Serializers.inputSelector(element, value);
      default:
        return Form.Element.Serializers.textarea(element, value);
    }
  },

  inputSelector: function(element, value) {
    if (Object.isUndefined(value)) return element.checked ? element.value : null;
    else element.checked = !!value;
  },

  textarea: function(element, value) {
    if (Object.isUndefined(value)) return element.value;
    else element.value = value;
  },

  select: function(element, value) {
    if (Object.isUndefined(value))
      return this[element.type == 'select-one' ?
        'selectOne' : 'selectMany'](element);
    else {
      var opt, currentValue, single = !Object.isArray(value);
      for (var i = 0, length = element.length; i < length; i++) {
        opt = element.options[i];
        currentValue = this.optionValue(opt);
        if (single) {
          if (currentValue == value) {
            opt.selected = true;
            return;
          }
        }
        else opt.selected = value.include(currentValue);
      }
    }
  },

  selectOne: function(element) {
    var index = element.selectedIndex;
    return index >= 0 ? this.optionValue(element.options[index]) : null;
  },

  selectMany: function(element) {
    var values, length = element.length;
    if (!length) return null;

    for (var i = 0, values = []; i < length; i++) {
      var opt = element.options[i];
      if (opt.selected) values.push(this.optionValue(opt));
    }
    return values;
  },

  optionValue: function(opt) {
    return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
  }
};

/*--------------------------------------------------------------------------*/


Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
  initialize: function($super, element, frequency, callback) {
    $super(callback, frequency);
    this.element   = $(element);
    this.lastValue = this.getValue();
  },

  execute: function() {
    var value = this.getValue();
    if (Object.isString(this.lastValue) && Object.isString(value) ?
        this.lastValue != value : String(this.lastValue) != String(value)) {
      this.callback(this.element, value);
      this.lastValue = value;
    }
  }
});

Form.Element.Observer = Class.create(Abstract.TimedObserver, {
  getValue: function() {
    return Form.Element.getValue(this.element);
  }
});

Form.Observer = Class.create(Abstract.TimedObserver, {
  getValue: function() {
    return Form.serialize(this.element);
  }
});

/*--------------------------------------------------------------------------*/

Abstract.EventObserver = Class.create({
  initialize: function(element, callback) {
    this.element  = $(element);
    this.callback = callback;

    this.lastValue = this.getValue();
    if (this.element.tagName.toLowerCase() == 'form')
      this.registerFormCallbacks();
    else
      this.registerCallback(this.element);
  },

  onElementEvent: function() {
    var value = this.getValue();
    if (this.lastValue != value) {
      this.callback(this.element, value);
      this.lastValue = value;
    }
  },

  registerFormCallbacks: function() {
    Form.getElements(this.element).each(this.registerCallback, this);
  },

  registerCallback: function(element) {
    if (element.type) {
      switch (element.type.toLowerCase()) {
        case 'checkbox':
        case 'radio':
          Event.observe(element, 'click', this.onElementEvent.bind(this));
          break;
        default:
          Event.observe(element, 'change', this.onElementEvent.bind(this));
          break;
      }
    }
  }
});

Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
  getValue: function() {
    return Form.Element.getValue(this.element);
  }
});

Form.EventObserver = Class.create(Abstract.EventObserver, {
  getValue: function() {
    return Form.serialize(this.element);
  }
});
(function() {

  var Event = {
    KEY_BACKSPACE: 8,
    KEY_TAB:       9,
    KEY_RETURN:   13,
    KEY_ESC:      27,
    KEY_LEFT:     37,
    KEY_UP:       38,
    KEY_RIGHT:    39,
    KEY_DOWN:     40,
    KEY_DELETE:   46,
    KEY_HOME:     36,
    KEY_END:      35,
    KEY_PAGEUP:   33,
    KEY_PAGEDOWN: 34,
    KEY_INSERT:   45,

    cache: {}
  };

  var docEl = document.documentElement;
  var MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED = 'onmouseenter' in docEl
    && 'onmouseleave' in docEl;

  var _isButton;
  if (Prototype.Browser.IE) {
    var buttonMap = { 0: 1, 1: 4, 2: 2 };
    _isButton = function(event, code) {
      return event.button === buttonMap[code];
    };
  } else if (Prototype.Browser.WebKit) {
    _isButton = function(event, code) {
      switch (code) {
        case 0: return event.which == 1 && !event.metaKey;
        case 1: return event.which == 1 && event.metaKey;
        default: return false;
      }
    };
  } else {
    _isButton = function(event, code) {
      return event.which ? (event.which === code + 1) : (event.button === code);
    };
  }

  function isLeftClick(event)   { return _isButton(event, 0) }

  function isMiddleClick(event) { return _isButton(event, 1) }

  function isRightClick(event)  { return _isButton(event, 2) }

  function element(event) {
    event = Event.extend(event);

    var node = event.target, type = event.type,
     currentTarget = event.currentTarget;

    if (currentTarget && currentTarget.tagName) {
      if (type === 'load' || type === 'error' ||
        (type === 'click' && currentTarget.tagName.toLowerCase() === 'input'
          && currentTarget.type === 'radio'))
            node = currentTarget;
    }

    if (node.nodeType == Node.TEXT_NODE)
      node = node.parentNode;

    return Element.extend(node);
  }

  function findElement(event, expression) {
    var element = Event.element(event);
    if (!expression) return element;
    var elements = [element].concat(element.ancestors());
    return Selector.findElement(elements, expression, 0);
  }

  function pointer(event) {
    return { x: pointerX(event), y: pointerY(event) };
  }

  function pointerX(event) {
    var docElement = document.documentElement,
     body = document.body || { scrollLeft: 0 };

    return event.pageX || (event.clientX +
      (docElement.scrollLeft || body.scrollLeft) -
      (docElement.clientLeft || 0));
  }

  function pointerY(event) {
    var docElement = document.documentElement,
     body = document.body || { scrollTop: 0 };

    return  event.pageY || (event.clientY +
       (docElement.scrollTop || body.scrollTop) -
       (docElement.clientTop || 0));
  }


  function stop(event) {
    Event.extend(event);
    event.preventDefault();
    event.stopPropagation();

    event.stopped = true;
  }

  Event.Methods = {
    isLeftClick: isLeftClick,
    isMiddleClick: isMiddleClick,
    isRightClick: isRightClick,

    element: element,
    findElement: findElement,

    pointer: pointer,
    pointerX: pointerX,
    pointerY: pointerY,

    stop: stop
  };


  var methods = Object.keys(Event.Methods).inject({ }, function(m, name) {
    m[name] = Event.Methods[name].methodize();
    return m;
  });

  if (Prototype.Browser.IE) {
    function _relatedTarget(event) {
      var element;
      switch (event.type) {
        case 'mouseover': element = event.fromElement; break;
        case 'mouseout':  element = event.toElement;   break;
        default: return null;
      }
      return Element.extend(element);
    }

    Object.extend(methods, {
      stopPropagation: function() { this.cancelBubble = true },
      preventDefault:  function() { this.returnValue = false },
      inspect: function() { return '[object Event]' }
    });

    Event.extend = function(event, element) {
      if (!event) return false;
      if (event._extendedByPrototype) return event;

      event._extendedByPrototype = Prototype.emptyFunction;
      var pointer = Event.pointer(event);

      Object.extend(event, {
        target: event.srcElement || element,
        relatedTarget: _relatedTarget(event),
        pageX:  pointer.x,
        pageY:  pointer.y
      });

      return Object.extend(event, methods);
    };
  } else {
    Event.prototype = window.Event.prototype || document.createEvent('HTMLEvents').__proto__;
    Object.extend(Event.prototype, methods);
    Event.extend = Prototype.K;
  }

  function _createResponder(element, eventName, handler) {
    var registry = Element.retrieve(element, 'prototype_event_registry');

    if (Object.isUndefined(registry)) {
      CACHE.push(element);
      registry = Element.retrieve(element, 'prototype_event_registry', $H());
    }

    var respondersForEvent = registry.get(eventName);
    if (Object.isUndefined(respondersForEvent)) {
      respondersForEvent = [];
      registry.set(eventName, respondersForEvent);
    }

    if (respondersForEvent.pluck('handler').include(handler)) return false;

    var responder;
    if (eventName.include(":")) {
      responder = function(event) {
        if (Object.isUndefined(event.eventName))
          return false;

        if (event.eventName !== eventName)
          return false;

        Event.extend(event, element);
        handler.call(element, event);
      };
    } else {
      if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED &&
       (eventName === "mouseenter" || eventName === "mouseleave")) {
        if (eventName === "mouseenter" || eventName === "mouseleave") {
          responder = function(event) {
            Event.extend(event, element);

            var parent = event.relatedTarget;
            while (parent && parent !== element) {
              try { parent = parent.parentNode; }
              catch(e) { parent = element; }
            }

            if (parent === element) return;

            handler.call(element, event);
          };
        }
      } else {
        responder = function(event) {
          Event.extend(event, element);
          handler.call(element, event);
        };
      }
    }

    responder.handler = handler;
    respondersForEvent.push(responder);
    return responder;
  }

  function _destroyCache() {
    for (var i = 0, length = CACHE.length; i < length; i++) {
      Event.stopObserving(CACHE[i]);
      CACHE[i] = null;
    }
  }

  var CACHE = [];

  if (Prototype.Browser.IE)
    window.attachEvent('onunload', _destroyCache);

  if (Prototype.Browser.WebKit)
    window.addEventListener('unload', Prototype.emptyFunction, false);


  var _getDOMEventName = Prototype.K;

  if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED) {
    _getDOMEventName = function(eventName) {
      var translations = { mouseenter: "mouseover", mouseleave: "mouseout" };
      return eventName in translations ? translations[eventName] : eventName;
    };
  }

  function observe(element, eventName, handler) {
    element = $(element);

    var responder = _createResponder(element, eventName, handler);

    if (!responder) return element;

    if (eventName.include(':')) {
      if (element.addEventListener)
        element.addEventListener("dataavailable", responder, false);
      else {
        element.attachEvent("ondataavailable", responder);
        element.attachEvent("onfilterchange", responder);
      }
    } else {
      var actualEventName = _getDOMEventName(eventName);

      if (element.addEventListener)
        element.addEventListener(actualEventName, responder, false);
      else
        element.attachEvent("on" + actualEventName, responder);
    }

    return element;
  }

  function stopObserving(element, eventName, handler) {
    element = $(element);

    var registry = Element.retrieve(element, 'prototype_event_registry');

    if (Object.isUndefined(registry)) return element;

    if (eventName && !handler) {
      var responders = registry.get(eventName);

      if (Object.isUndefined(responders)) return element;

      responders.each( function(r) {
        Element.stopObserving(element, eventName, r.handler);
      });
      return element;
    } else if (!eventName) {
      registry.each( function(pair) {
        var eventName = pair.key, responders = pair.value;

        responders.each( function(r) {
          Element.stopObserving(element, eventName, r.handler);
        });
      });
      return element;
    }

    var responders = registry.get(eventName);

    if (!responders) return;

    var responder = responders.find( function(r) { return r.handler === handler; });
    if (!responder) return element;

    var actualEventName = _getDOMEventName(eventName);

    if (eventName.include(':')) {
      if (element.removeEventListener)
        element.removeEventListener("dataavailable", responder, false);
      else {
        element.detachEvent("ondataavailable", responder);
        element.detachEvent("onfilterchange",  responder);
      }
    } else {
      if (element.removeEventListener)
        element.removeEventListener(actualEventName, responder, false);
      else
        element.detachEvent('on' + actualEventName, responder);
    }

    registry.set(eventName, responders.without(responder));

    return element;
  }

  function fire(element, eventName, memo, bubble) {
    element = $(element);

    if (Object.isUndefined(bubble))
      bubble = true;

    if (element == document && document.createEvent && !element.dispatchEvent)
      element = document.documentElement;

    var event;
    if (document.createEvent) {
      event = document.createEvent('HTMLEvents');
      event.initEvent('dataavailable', true, true);
    } else {
      event = document.createEventObject();
      event.eventType = bubble ? 'ondataavailable' : 'onfilterchange';
    }

    event.eventName = eventName;
    event.memo = memo || { };

    if (document.createEvent)
      element.dispatchEvent(event);
    else
      element.fireEvent(event.eventType, event);

    return Event.extend(event);
  }


  Object.extend(Event, Event.Methods);

  Object.extend(Event, {
    fire:          fire,
    observe:       observe,
    stopObserving: stopObserving
  });

  Element.addMethods({
    fire:          fire,

    observe:       observe,

    stopObserving: stopObserving
  });

  Object.extend(document, {
    fire:          fire.methodize(),

    observe:       observe.methodize(),

    stopObserving: stopObserving.methodize(),

    loaded:        false
  });

  if (window.Event) Object.extend(window.Event, Event);
  else window.Event = Event;
})();

(function() {
  /* Support for the DOMContentLoaded event is based on work by Dan Webb,
     Matthias Miller, Dean Edwards, John Resig, and Diego Perini. */

  var timer;

  function fireContentLoadedEvent() {
    if (document.loaded) return;
    if (timer) window.clearTimeout(timer);
    document.loaded = true;
    document.fire('dom:loaded');
  }

  function checkReadyState() {
    if (document.readyState === 'complete') {
      document.stopObserving('readystatechange', checkReadyState);
      fireContentLoadedEvent();
    }
  }

  function pollDoScroll() {
    try { document.documentElement.doScroll('left'); }
    catch(e) {
      timer = pollDoScroll.defer();
      return;
    }
    fireContentLoadedEvent();
  }

  if (document.addEventListener) {
    document.addEventListener('DOMContentLoaded', fireContentLoadedEvent, false);
  } else {
    document.observe('readystatechange', checkReadyState);
    if (window == top)
      timer = pollDoScroll.defer();
  }

  Event.observe(window, 'load', fireContentLoadedEvent);
})();

Element.addMethods();

/*------------------------------- DEPRECATED -------------------------------*/

Hash.toQueryString = Object.toQueryString;

var Toggle = { display: Element.toggle };

Element.Methods.childOf = Element.Methods.descendantOf;

var Insertion = {
  Before: function(element, content) {
    return Element.insert(element, {before:content});
  },

  Top: function(element, content) {
    return Element.insert(element, {top:content});
  },

  Bottom: function(element, content) {
    return Element.insert(element, {bottom:content});
  },

  After: function(element, content) {
    return Element.insert(element, {after:content});
  }
};

var $continue = new Error('"throw $continue" is deprecated, use "return" instead');

var Position = {
  includeScrollOffsets: false,

  prepare: function() {
    this.deltaX =  window.pageXOffset
                || document.documentElement.scrollLeft
                || document.body.scrollLeft
                || 0;
    this.deltaY =  window.pageYOffset
                || document.documentElement.scrollTop
                || document.body.scrollTop
                || 0;
  },

  within: function(element, x, y) {
    if (this.includeScrollOffsets)
      return this.withinIncludingScrolloffsets(element, x, y);
    this.xcomp = x;
    this.ycomp = y;
    this.offset = Element.cumulativeOffset(element);

    return (y >= this.offset[1] &&
            y <  this.offset[1] + element.offsetHeight &&
            x >= this.offset[0] &&
            x <  this.offset[0] + element.offsetWidth);
  },

  withinIncludingScrolloffsets: function(element, x, y) {
    var offsetcache = Element.cumulativeScrollOffset(element);

    this.xcomp = x + offsetcache[0] - this.deltaX;
    this.ycomp = y + offsetcache[1] - this.deltaY;
    this.offset = Element.cumulativeOffset(element);

    return (this.ycomp >= this.offset[1] &&
            this.ycomp <  this.offset[1] + element.offsetHeight &&
            this.xcomp >= this.offset[0] &&
            this.xcomp <  this.offset[0] + element.offsetWidth);
  },

  overlap: function(mode, element) {
    if (!mode) return 0;
    if (mode == 'vertical')
      return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
        element.offsetHeight;
    if (mode == 'horizontal')
      return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
        element.offsetWidth;
  },


  cumulativeOffset: Element.Methods.cumulativeOffset,

  positionedOffset: Element.Methods.positionedOffset,

  absolutize: function(element) {
    Position.prepare();
    return Element.absolutize(element);
  },

  relativize: function(element) {
    Position.prepare();
    return Element.relativize(element);
  },

  realOffset: Element.Methods.cumulativeScrollOffset,

  offsetParent: Element.Methods.getOffsetParent,

  page: Element.Methods.viewportOffset,

  clone: function(source, target, options) {
    options = options || { };
    return Element.clonePosition(target, source, options);
  }
};

/*--------------------------------------------------------------------------*/

if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
  function iter(name) {
    return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
  }

  instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
  function(element, className) {
    className = className.toString().strip();
    var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
    return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
  } : function(element, className) {
    className = className.toString().strip();
    var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
    if (!classNames && !className) return elements;

    var nodes = $(element).getElementsByTagName('*');
    className = ' ' + className + ' ';

    for (var i = 0, child, cn; child = nodes[i]; i++) {
      if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
          (classNames && classNames.all(function(name) {
            return !name.toString().blank() && cn.include(' ' + name + ' ');
          }))))
        elements.push(Element.extend(child));
    }
    return elements;
  };

  return function(className, parentElement) {
    return $(parentElement || document.body).getElementsByClassName(className);
  };
}(Element.Methods);

/*--------------------------------------------------------------------------*/

Element.ClassNames = Class.create();
Element.ClassNames.prototype = {
  initialize: function(element) {
    this.element = $(element);
  },

  _each: function(iterator) {
    this.element.className.split(/\s+/).select(function(name) {
      return name.length > 0;
    })._each(iterator);
  },

  set: function(className) {
    this.element.className = className;
  },

  add: function(classNameToAdd) {
    if (this.include(classNameToAdd)) return;
    this.set($A(this).concat(classNameToAdd).join(' '));
  },

  remove: function(classNameToRemove) {
    if (!this.include(classNameToRemove)) return;
    this.set($A(this).without(classNameToRemove).join(' '));
  },

  toString: function() {
    return $A(this).join(' ');
  }
};

Object.extend(Element.ClassNames.prototype, Enumerable);

/*--------------------------------------------------------------------------*/

/* /_ui/js/lib/effects.js */
// script.aculo.us effects.js v1.8.3, Thu Oct 08 11:23:33 +0200 2009

// Copyright (c) 2005-2009 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// Contributors:
//  Justin Palmer (http://encytemedia.com/)
//  Mark Pilgrim (http://diveintomark.org/)
//  Martin Bialasinki
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

// converts rgb() and #xxx to #xxxxxx format,
// returns self (or first argument) if not convertable
String.prototype.parseColor = function() {
  var color = '#';
  if (this.slice(0,4) == 'rgb(') {
    var cols = this.slice(4,this.length-1).split(',');
    var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3);
  } else {
    if (this.slice(0,1) == '#') {
      if (this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase();
      if (this.length==7) color = this.toLowerCase();
    }
  }
  return (color.length==7 ? color : (arguments[0] || this));
};

/*--------------------------------------------------------------------------*/

Element.collectTextNodes = function(element) {
  return $A($(element).childNodes).collect( function(node) {
    return (node.nodeType==3 ? node.nodeValue :
      (node.hasChildNodes() ? Element.collectTextNodes(node) : ''));
  }).flatten().join('');
};

Element.collectTextNodesIgnoreClass = function(element, className) {
  return $A($(element).childNodes).collect( function(node) {
    return (node.nodeType==3 ? node.nodeValue :
      ((node.hasChildNodes() && !Element.hasClassName(node,className)) ?
        Element.collectTextNodesIgnoreClass(node, className) : ''));
  }).flatten().join('');
};

Element.setContentZoom = function(element, percent) {
  element = $(element);
  element.setStyle({fontSize: (percent/100) + 'em'});
  if (Prototype.Browser.WebKit) window.scrollBy(0,0);
  return element;
};

Element.getInlineOpacity = function(element){
  return $(element).style.opacity || '';
};

Element.forceRerendering = function(element) {
  try {
    element = $(element);
    var n = document.createTextNode(' ');
    element.appendChild(n);
    element.removeChild(n);
  } catch(e) { }
};

/*--------------------------------------------------------------------------*/

var Effect = {
  _elementDoesNotExistError: {
    name: 'ElementDoesNotExistError',
    message: 'The specified DOM element does not exist, but is required for this effect to operate'
  },
  Transitions: {
    linear: Prototype.K,
    sinoidal: function(pos) {
      return (-Math.cos(pos*Math.PI)/2) + .5;
    },
    reverse: function(pos) {
      return 1-pos;
    },
    flicker: function(pos) {
      var pos = ((-Math.cos(pos*Math.PI)/4) + .75) + Math.random()/4;
      return pos > 1 ? 1 : pos;
    },
    wobble: function(pos) {
      return (-Math.cos(pos*Math.PI*(9*pos))/2) + .5;
    },
    pulse: function(pos, pulses) {
      return (-Math.cos((pos*((pulses||5)-.5)*2)*Math.PI)/2) + .5;
    },
    spring: function(pos) {
      return 1 - (Math.cos(pos * 4.5 * Math.PI) * Math.exp(-pos * 6));
    },
    none: function(pos) {
      return 0;
    },
    full: function(pos) {
      return 1;
    }
  },
  DefaultOptions: {
    duration:   1.0,   // seconds
    fps:        100,   // 100= assume 66fps max.
    sync:       false, // true for combining
    from:       0.0,
    to:         1.0,
    delay:      0.0,
    queue:      'parallel'
  },
  tagifyText: function(element) {
    var tagifyStyle = 'position:relative';
    if (Prototype.Browser.IE) tagifyStyle += ';zoom:1';

    element = $(element);
    $A(element.childNodes).each( function(child) {
      if (child.nodeType==3) {
        child.nodeValue.toArray().each( function(character) {
          element.insertBefore(
            new Element('span', {style: tagifyStyle}).update(
              character == ' ' ? String.fromCharCode(160) : character),
              child);
        });
        Element.remove(child);
      }
    });
  },
  multiple: function(element, effect) {
    var elements;
    if (((typeof element == 'object') ||
        Object.isFunction(element)) &&
       (element.length))
      elements = element;
    else
      elements = $(element).childNodes;

    var options = Object.extend({
      speed: 0.1,
      delay: 0.0
    }, arguments[2] || { });
    var masterDelay = options.delay;

    $A(elements).each( function(element, index) {
      new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));
    });
  },
  PAIRS: {
    'slide':  ['SlideDown','SlideUp'],
    'blind':  ['BlindDown','BlindUp'],
    'appear': ['Appear','Fade']
  },
  toggle: function(element, effect, options) {
    element = $(element);
    effect  = (effect || 'appear').toLowerCase();
    
    return Effect[ Effect.PAIRS[ effect ][ element.visible() ? 1 : 0 ] ](element, Object.extend({
      queue: { position:'end', scope:(element.id || 'global'), limit: 1 }
    }, options || {}));
  }
};

Effect.DefaultOptions.transition = Effect.Transitions.sinoidal;

/* ------------- core effects ------------- */

Effect.ScopedQueue = Class.create(Enumerable, {
  initialize: function() {
    this.effects  = [];
    this.interval = null;
  },
  _each: function(iterator) {
    this.effects._each(iterator);
  },
  add: function(effect) {
    var timestamp = new Date().getTime();

    var position = Object.isString(effect.options.queue) ?
      effect.options.queue : effect.options.queue.position;

    switch(position) {
      case 'front':
        // move unstarted effects after this effect
        this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
            e.startOn  += effect.finishOn;
            e.finishOn += effect.finishOn;
          });
        break;
      case 'with-last':
        timestamp = this.effects.pluck('startOn').max() || timestamp;
        break;
      case 'end':
        // start effect after last queued effect has finished
        timestamp = this.effects.pluck('finishOn').max() || timestamp;
        break;
    }

    effect.startOn  += timestamp;
    effect.finishOn += timestamp;

    if (!effect.options.queue.limit || (this.effects.length < effect.options.queue.limit))
      this.effects.push(effect);

    if (!this.interval)
      this.interval = setInterval(this.loop.bind(this), 15);
  },
  remove: function(effect) {
    this.effects = this.effects.reject(function(e) { return e==effect });
    if (this.effects.length == 0) {
      clearInterval(this.interval);
      this.interval = null;
    }
  },
  loop: function() {
    var timePos = new Date().getTime();
    for(var i=0, len=this.effects.length;i<len;i++)
      this.effects[i] && this.effects[i].loop(timePos);
  }
});

Effect.Queues = {
  instances: $H(),
  get: function(queueName) {
    if (!Object.isString(queueName)) return queueName;

    return this.instances.get(queueName) ||
      this.instances.set(queueName, new Effect.ScopedQueue());
  }
};
Effect.Queue = Effect.Queues.get('global');

Effect.Base = Class.create({
  position: null,
  start: function(options) {
    if (options && options.transition === false) options.transition = Effect.Transitions.linear;
    this.options      = Object.extend(Object.extend({ },Effect.DefaultOptions), options || { });
    this.currentFrame = 0;
    this.state        = 'idle';
    this.startOn      = this.options.delay*1000;
    this.finishOn     = this.startOn+(this.options.duration*1000);
    this.fromToDelta  = this.options.to-this.options.from;
    this.totalTime    = this.finishOn-this.startOn;
    this.totalFrames  = this.options.fps*this.options.duration;

    this.render = (function() {
      function dispatch(effect, eventName) {
        if (effect.options[eventName + 'Internal'])
          effect.options[eventName + 'Internal'](effect);
        if (effect.options[eventName])
          effect.options[eventName](effect);
      }

      return function(pos) {
        if (this.state === "idle") {
          this.state = "running";
          dispatch(this, 'beforeSetup');
          if (this.setup) this.setup();
          dispatch(this, 'afterSetup');
        }
        if (this.state === "running") {
          pos = (this.options.transition(pos) * this.fromToDelta) + this.options.from;
          this.position = pos;
          dispatch(this, 'beforeUpdate');
          if (this.update) this.update(pos);
          dispatch(this, 'afterUpdate');
        }
      };
    })();

    this.event('beforeStart');
    if (!this.options.sync)
      Effect.Queues.get(Object.isString(this.options.queue) ?
        'global' : this.options.queue.scope).add(this);
  },
  loop: function(timePos) {
    if (timePos >= this.startOn) {
      if (timePos >= this.finishOn) {
        this.render(1.0);
        this.cancel();
        this.event('beforeFinish');
        if (this.finish) this.finish();
        this.event('afterFinish');
        return;
      }
      var pos   = (timePos - this.startOn) / this.totalTime,
          frame = (pos * this.totalFrames).round();
      if (frame > this.currentFrame) {
        this.render(pos);
        this.currentFrame = frame;
      }
    }
  },
  cancel: function() {
    if (!this.options.sync)
      Effect.Queues.get(Object.isString(this.options.queue) ?
        'global' : this.options.queue.scope).remove(this);
    this.state = 'finished';
  },
  event: function(eventName) {
    if (this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
    if (this.options[eventName]) this.options[eventName](this);
  },
  inspect: function() {
    var data = $H();
    for(property in this)
      if (!Object.isFunction(this[property])) data.set(property, this[property]);
    return '#<Effect:' + data.inspect() + ',options:' + $H(this.options).inspect() + '>';
  }
});

Effect.Parallel = Class.create(Effect.Base, {
  initialize: function(effects) {
    this.effects = effects || [];
    this.start(arguments[1]);
  },
  update: function(position) {
    this.effects.invoke('render', position);
  },
  finish: function(position) {
    this.effects.each( function(effect) {
      effect.render(1.0);
      effect.cancel();
      effect.event('beforeFinish');
      if (effect.finish) effect.finish(position);
      effect.event('afterFinish');
    });
  }
});

Effect.Tween = Class.create(Effect.Base, {
  initialize: function(object, from, to) {
    object = Object.isString(object) ? $(object) : object;
    var args = $A(arguments), method = args.last(),
      options = args.length == 5 ? args[3] : null;
    this.method = Object.isFunction(method) ? method.bind(object) :
      Object.isFunction(object[method]) ? object[method].bind(object) :
      function(value) { object[method] = value };
    this.start(Object.extend({ from: from, to: to }, options || { }));
  },
  update: function(position) {
    this.method(position);
  }
});

Effect.Event = Class.create(Effect.Base, {
  initialize: function() {
    this.start(Object.extend({ duration: 0 }, arguments[0] || { }));
  },
  update: Prototype.emptyFunction
});

Effect.Opacity = Class.create(Effect.Base, {
  initialize: function(element) {
    this.element = $(element);
    if (!this.element) throw(Effect._elementDoesNotExistError);
    // make this work on IE on elements without 'layout'
    if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
      this.element.setStyle({zoom: 1});
    var options = Object.extend({
      from: this.element.getOpacity() || 0.0,
      to:   1.0
    }, arguments[1] || { });
    this.start(options);
  },
  update: function(position) {
    this.element.setOpacity(position);
  }
});

Effect.Move = Class.create(Effect.Base, {
  initialize: function(element) {
    this.element = $(element);
    if (!this.element) throw(Effect._elementDoesNotExistError);
    var options = Object.extend({
      x:    0,
      y:    0,
      mode: 'relative'
    }, arguments[1] || { });
    this.start(options);
  },
  setup: function() {
    this.element.makePositioned();
    this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
    this.originalTop  = parseFloat(this.element.getStyle('top')  || '0');
    if (this.options.mode == 'absolute') {
      this.options.x = this.options.x - this.originalLeft;
      this.options.y = this.options.y - this.originalTop;
    }
  },
  update: function(position) {
    this.element.setStyle({
      left: (this.options.x  * position + this.originalLeft).round() + 'px',
      top:  (this.options.y  * position + this.originalTop).round()  + 'px'
    });
  }
});

// for backwards compatibility
Effect.MoveBy = function(element, toTop, toLeft) {
  return new Effect.Move(element,
    Object.extend({ x: toLeft, y: toTop }, arguments[3] || { }));
};

Effect.Scale = Class.create(Effect.Base, {
  initialize: function(element, percent) {
    this.element = $(element);
    if (!this.element) throw(Effect._elementDoesNotExistError);
    var options = Object.extend({
      scaleX: true,
      scaleY: true,
      scaleContent: true,
      scaleFromCenter: false,
      scaleMode: 'box',        // 'box' or 'contents' or { } with provided values
      scaleFrom: 100.0,
      scaleTo:   percent
    }, arguments[2] || { });
    this.start(options);
  },
  setup: function() {
    this.restoreAfterFinish = this.options.restoreAfterFinish || false;
    this.elementPositioning = this.element.getStyle('position');

    this.originalStyle = { };
    ['top','left','width','height','fontSize'].each( function(k) {
      this.originalStyle[k] = this.element.style[k];
    }.bind(this));

    this.originalTop  = this.element.offsetTop;
    this.originalLeft = this.element.offsetLeft;

    var fontSize = this.element.getStyle('font-size') || '100%';
    ['em','px','%','pt'].each( function(fontSizeType) {
      if (fontSize.indexOf(fontSizeType)>0) {
        this.fontSize     = parseFloat(fontSize);
        this.fontSizeType = fontSizeType;
      }
    }.bind(this));

    this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;

    this.dims = null;
    if (this.options.scaleMode=='box')
      this.dims = [this.element.offsetHeight, this.element.offsetWidth];
    if (/^content/.test(this.options.scaleMode))
      this.dims = [this.element.scrollHeight, this.element.scrollWidth];
    if (!this.dims)
      this.dims = [this.options.scaleMode.originalHeight,
                   this.options.scaleMode.originalWidth];
  },
  update: function(position) {
    var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
    if (this.options.scaleContent && this.fontSize)
      this.element.setStyle({fontSize: this.fontSize * currentScale + this.fontSizeType });
    this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
  },
  finish: function(position) {
    if (this.restoreAfterFinish) this.element.setStyle(this.originalStyle);
  },
  setDimensions: function(height, width) {
    var d = { };
    if (this.options.scaleX) d.width = width.round() + 'px';
    if (this.options.scaleY) d.height = height.round() + 'px';
    if (this.options.scaleFromCenter) {
      var topd  = (height - this.dims[0])/2;
      var leftd = (width  - this.dims[1])/2;
      if (this.elementPositioning == 'absolute') {
        if (this.options.scaleY) d.top = this.originalTop-topd + 'px';
        if (this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
      } else {
        if (this.options.scaleY) d.top = -topd + 'px';
        if (this.options.scaleX) d.left = -leftd + 'px';
      }
    }
    this.element.setStyle(d);
  }
});

Effect.Highlight = Class.create(Effect.Base, {
  initialize: function(element) {
    this.element = $(element);
    if (!this.element) throw(Effect._elementDoesNotExistError);
    var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] || { });
    this.start(options);
  },
  setup: function() {
    // Prevent executing on elements not in the layout flow
    if (this.element.getStyle('display')=='none') { this.cancel(); return; }
    // Disable background image during the effect
    this.oldStyle = { };
    if (!this.options.keepBackgroundImage) {
      this.oldStyle.backgroundImage = this.element.getStyle('background-image');
      this.element.setStyle({backgroundImage: 'none'});
    }
    if (!this.options.endcolor)
      this.options.endcolor = this.element.getStyle('background-color').parseColor('#ffffff');
    if (!this.options.restorecolor)
      this.options.restorecolor = this.element.getStyle('background-color');
    // init color calculations
    this._base  = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16) }.bind(this));
    this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i] }.bind(this));
  },
  update: function(position) {
    this.element.setStyle({backgroundColor: $R(0,2).inject('#',function(m,v,i){
      return m+((this._base[i]+(this._delta[i]*position)).round().toColorPart()); }.bind(this)) });
  },
  finish: function() {
    this.element.setStyle(Object.extend(this.oldStyle, {
      backgroundColor: this.options.restorecolor
    }));
  }
});

Effect.ScrollTo = function(element) {
  var options = arguments[1] || { },
  scrollOffsets = document.viewport.getScrollOffsets(),
  elementOffsets = $(element).cumulativeOffset();

  if (options.offset) elementOffsets[1] += options.offset;

  return new Effect.Tween(null,
    scrollOffsets.top,
    elementOffsets[1],
    options,
    function(p){ scrollTo(scrollOffsets.left, p.round()); }
  );
};

/* ------------- combination effects ------------- */

Effect.Fade = function(element) {
  element = $(element);
  var oldOpacity = element.getInlineOpacity();
  var options = Object.extend({
    from: element.getOpacity() || 1.0,
    to:   0.0,
    afterFinishInternal: function(effect) {
      if (effect.options.to!=0) return;
      effect.element.hide().setStyle({opacity: oldOpacity});
    }
  }, arguments[1] || { });
  return new Effect.Opacity(element,options);
};

Effect.Appear = function(element) {
  element = $(element);
  var options = Object.extend({
  from: (element.getStyle('display') == 'none' ? 0.0 : element.getOpacity() || 0.0),
  to:   1.0,
  // force Safari to render floated elements properly
  afterFinishInternal: function(effect) {
    effect.element.forceRerendering();
  },
  beforeSetup: function(effect) {
    effect.element.setOpacity(effect.options.from).show();
  }}, arguments[1] || { });
  return new Effect.Opacity(element,options);
};

Effect.Puff = function(element) {
  element = $(element);
  var oldStyle = {
    opacity: element.getInlineOpacity(),
    position: element.getStyle('position'),
    top:  element.style.top,
    left: element.style.left,
    width: element.style.width,
    height: element.style.height
  };
  return new Effect.Parallel(
   [ new Effect.Scale(element, 200,
      { sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }),
     new Effect.Opacity(element, { sync: true, to: 0.0 } ) ],
     Object.extend({ duration: 1.0,
      beforeSetupInternal: function(effect) {
        Position.absolutize(effect.effects[0].element);
      },
      afterFinishInternal: function(effect) {
         effect.effects[0].element.hide().setStyle(oldStyle); }
     }, arguments[1] || { })
   );
};

Effect.BlindUp = function(element) {
  element = $(element);
  element.makeClipping();
  return new Effect.Scale(element, 0,
    Object.extend({ scaleContent: false,
      scaleX: false,
      restoreAfterFinish: true,
      afterFinishInternal: function(effect) {
        effect.element.hide().undoClipping();
      }
    }, arguments[1] || { })
  );
};

Effect.BlindDown = function(element) {
  element = $(element);
  var elementDimensions = element.getDimensions();
  return new Effect.Scale(element, 100, Object.extend({
    scaleContent: false,
    scaleX: false,
    scaleFrom: 0,
    scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
    restoreAfterFinish: true,
    afterSetup: function(effect) {
      effect.element.makeClipping().setStyle({height: '0px'}).show();
    },
    afterFinishInternal: function(effect) {
      effect.element.undoClipping();
    }
  }, arguments[1] || { }));
};

Effect.SwitchOff = function(element) {
  element = $(element);
  var oldOpacity = element.getInlineOpacity();
  return new Effect.Appear(element, Object.extend({
    duration: 0.4,
    from: 0,
    transition: Effect.Transitions.flicker,
    afterFinishInternal: function(effect) {
      new Effect.Scale(effect.element, 1, {
        duration: 0.3, scaleFromCenter: true,
        scaleX: false, scaleContent: false, restoreAfterFinish: true,
        beforeSetup: function(effect) {
          effect.element.makePositioned().makeClipping();
        },
        afterFinishInternal: function(effect) {
          effect.element.hide().undoClipping().undoPositioned().setStyle({opacity: oldOpacity});
        }
      });
    }
  }, arguments[1] || { }));
};

Effect.DropOut = function(element) {
  element = $(element);
  var oldStyle = {
    top: element.getStyle('top'),
    left: element.getStyle('left'),
    opacity: element.getInlineOpacity() };
  return new Effect.Parallel(
    [ new Effect.Move(element, {x: 0, y: 100, sync: true }),
      new Effect.Opacity(element, { sync: true, to: 0.0 }) ],
    Object.extend(
      { duration: 0.5,
        beforeSetup: function(effect) {
          effect.effects[0].element.makePositioned();
        },
        afterFinishInternal: function(effect) {
          effect.effects[0].element.hide().undoPositioned().setStyle(oldStyle);
        }
      }, arguments[1] || { }));
};

Effect.Shake = function(element) {
  element = $(element);
  var options = Object.extend({
    distance: 20,
    duration: 0.5
  }, arguments[1] || {});
  var distance = parseFloat(options.distance);
  var split = parseFloat(options.duration) / 10.0;
  var oldStyle = {
    top: element.getStyle('top'),
    left: element.getStyle('left') };
    return new Effect.Move(element,
      { x:  distance, y: 0, duration: split, afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x: -distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x:  distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x: -distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x:  distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x: -distance, y: 0, duration: split, afterFinishInternal: function(effect) {
        effect.element.undoPositioned().setStyle(oldStyle);
  }}); }}); }}); }}); }}); }});
};

Effect.SlideDown = function(element) {
  element = $(element).cleanWhitespace();
  // SlideDown need to have the content of the element wrapped in a container element with fixed height!
  var oldInnerBottom = element.down().getStyle('bottom');
  var elementDimensions = element.getDimensions();
  return new Effect.Scale(element, 100, Object.extend({
    scaleContent: false,
    scaleX: false,
    scaleFrom: window.opera ? 0 : 1,
    scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
    restoreAfterFinish: true,
    afterSetup: function(effect) {
      effect.element.makePositioned();
      effect.element.down().makePositioned();
      if (window.opera) effect.element.setStyle({top: ''});
      effect.element.makeClipping().setStyle({height: '0px'}).show();
    },
    afterUpdateInternal: function(effect) {
      effect.element.down().setStyle({bottom:
        (effect.dims[0] - effect.element.clientHeight) + 'px' });
    },
    afterFinishInternal: function(effect) {
      effect.element.undoClipping().undoPositioned();
      effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom}); }
    }, arguments[1] || { })
  );
};

Effect.SlideUp = function(element) {
  element = $(element).cleanWhitespace();
  var oldInnerBottom = element.down().getStyle('bottom');
  var elementDimensions = element.getDimensions();
  return new Effect.Scale(element, window.opera ? 0 : 1,
   Object.extend({ scaleContent: false,
    scaleX: false,
    scaleMode: 'box',
    scaleFrom: 100,
    scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
    restoreAfterFinish: true,
    afterSetup: function(effect) {
      effect.element.makePositioned();
      effect.element.down().makePositioned();
      if (window.opera) effect.element.setStyle({top: ''});
      effect.element.makeClipping().show();
    },
    afterUpdateInternal: function(effect) {
      effect.element.down().setStyle({bottom:
        (effect.dims[0] - effect.element.clientHeight) + 'px' });
    },
    afterFinishInternal: function(effect) {
      effect.element.hide().undoClipping().undoPositioned();
      effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom});
    }
   }, arguments[1] || { })
  );
};

// Bug in opera makes the TD containing this element expand for a instance after finish
Effect.Squish = function(element) {
  return new Effect.Scale(element, window.opera ? 1 : 0, {
    restoreAfterFinish: true,
    beforeSetup: function(effect) {
      effect.element.makeClipping();
    },
    afterFinishInternal: function(effect) {
      effect.element.hide().undoClipping();
    }
  });
};

Effect.Grow = function(element) {
  element = $(element);
  var options = Object.extend({
    direction: 'center',
    moveTransition: Effect.Transitions.sinoidal,
    scaleTransition: Effect.Transitions.sinoidal,
    opacityTransition: Effect.Transitions.full
  }, arguments[1] || { });
  var oldStyle = {
    top: element.style.top,
    left: element.style.left,
    height: element.style.height,
    width: element.style.width,
    opacity: element.getInlineOpacity() };

  var dims = element.getDimensions();
  var initialMoveX, initialMoveY;
  var moveX, moveY;

  switch (options.direction) {
    case 'top-left':
      initialMoveX = initialMoveY = moveX = moveY = 0;
      break;
    case 'top-right':
      initialMoveX = dims.width;
      initialMoveY = moveY = 0;
      moveX = -dims.width;
      break;
    case 'bottom-left':
      initialMoveX = moveX = 0;
      initialMoveY = dims.height;
      moveY = -dims.height;
      break;
    case 'bottom-right':
      initialMoveX = dims.width;
      initialMoveY = dims.height;
      moveX = -dims.width;
      moveY = -dims.height;
      break;
    case 'center':
      initialMoveX = dims.width / 2;
      initialMoveY = dims.height / 2;
      moveX = -dims.width / 2;
      moveY = -dims.height / 2;
      break;
  }

  return new Effect.Move(element, {
    x: initialMoveX,
    y: initialMoveY,
    duration: 0.01,
    beforeSetup: function(effect) {
      effect.element.hide().makeClipping().makePositioned();
    },
    afterFinishInternal: function(effect) {
      new Effect.Parallel(
        [ new Effect.Opacity(effect.element, { sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition }),
          new Effect.Move(effect.element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition }),
          new Effect.Scale(effect.element, 100, {
            scaleMode: { originalHeight: dims.height, originalWidth: dims.width },
            sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})
        ], Object.extend({
             beforeSetup: function(effect) {
               effect.effects[0].element.setStyle({height: '0px'}).show();
             },
             afterFinishInternal: function(effect) {
               effect.effects[0].element.undoClipping().undoPositioned().setStyle(oldStyle);
             }
           }, options)
      );
    }
  });
};

Effect.Shrink = function(element) {
  element = $(element);
  var options = Object.extend({
    direction: 'center',
    moveTransition: Effect.Transitions.sinoidal,
    scaleTransition: Effect.Transitions.sinoidal,
    opacityTransition: Effect.Transitions.none
  }, arguments[1] || { });
  var oldStyle = {
    top: element.style.top,
    left: element.style.left,
    height: element.style.height,
    width: element.style.width,
    opacity: element.getInlineOpacity() };

  var dims = element.getDimensions();
  var moveX, moveY;

  switch (options.direction) {
    case 'top-left':
      moveX = moveY = 0;
      break;
    case 'top-right':
      moveX = dims.width;
      moveY = 0;
      break;
    case 'bottom-left':
      moveX = 0;
      moveY = dims.height;
      break;
    case 'bottom-right':
      moveX = dims.width;
      moveY = dims.height;
      break;
    case 'center':
      moveX = dims.width / 2;
      moveY = dims.height / 2;
      break;
  }

  return new Effect.Parallel(
    [ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition }),
      new Effect.Scale(element, window.opera ? 1 : 0, { sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),
      new Effect.Move(element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition })
    ], Object.extend({
         beforeStartInternal: function(effect) {
           effect.effects[0].element.makePositioned().makeClipping();
         },
         afterFinishInternal: function(effect) {
           effect.effects[0].element.hide().undoClipping().undoPositioned().setStyle(oldStyle); }
       }, options)
  );
};

Effect.Pulsate = function(element) {
  element = $(element);
  var options    = arguments[1] || { },
    oldOpacity = element.getInlineOpacity(),
    transition = options.transition || Effect.Transitions.linear,
    reverser   = function(pos){
      return 1 - transition((-Math.cos((pos*(options.pulses||5)*2)*Math.PI)/2) + .5);
    };

  return new Effect.Opacity(element,
    Object.extend(Object.extend({  duration: 2.0, from: 0,
      afterFinishInternal: function(effect) { effect.element.setStyle({opacity: oldOpacity}); }
    }, options), {transition: reverser}));
};

Effect.Fold = function(element) {
  element = $(element);
  var oldStyle = {
    top: element.style.top,
    left: element.style.left,
    width: element.style.width,
    height: element.style.height };
  element.makeClipping();
  return new Effect.Scale(element, 5, Object.extend({
    scaleContent: false,
    scaleX: false,
    afterFinishInternal: function(effect) {
    new Effect.Scale(element, 1, {
      scaleContent: false,
      scaleY: false,
      afterFinishInternal: function(effect) {
        effect.element.hide().undoClipping().setStyle(oldStyle);
      } });
  }}, arguments[1] || { }));
};

Effect.Morph = Class.create(Effect.Base, {
  initialize: function(element) {
    this.element = $(element);
    if (!this.element) throw(Effect._elementDoesNotExistError);
    var options = Object.extend({
      style: { }
    }, arguments[1] || { });

    if (!Object.isString(options.style)) this.style = $H(options.style);
    else {
      if (options.style.include(':'))
        this.style = options.style.parseStyle();
      else {
        this.element.addClassName(options.style);
        this.style = $H(this.element.getStyles());
        this.element.removeClassName(options.style);
        var css = this.element.getStyles();
        this.style = this.style.reject(function(style) {
          return style.value == css[style.key];
        });
        options.afterFinishInternal = function(effect) {
          effect.element.addClassName(effect.options.style);
          effect.transforms.each(function(transform) {
            effect.element.style[transform.style] = '';
          });
        };
      }
    }
    this.start(options);
  },

  setup: function(){
    function parseColor(color){
      if (!color || ['rgba(0, 0, 0, 0)','transparent'].include(color)) color = '#ffffff';
      color = color.parseColor();
      return $R(0,2).map(function(i){
        return parseInt( color.slice(i*2+1,i*2+3), 16 );
      });
    }
    this.transforms = this.style.map(function(pair){
      var property = pair[0], value = pair[1], unit = null;

      if (value.parseColor('#zzzzzz') != '#zzzzzz') {
        value = value.parseColor();
        unit  = 'color';
      } else if (property == 'opacity') {
        value = parseFloat(value);
        if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
          this.element.setStyle({zoom: 1});
      } else if (Element.CSS_LENGTH.test(value)) {
          var components = value.match(/^([\+\-]?[0-9\.]+)(.*)$/);
          value = parseFloat(components[1]);
          unit = (components.length == 3) ? components[2] : null;
      }

      var originalValue = this.element.getStyle(property);
      return {
        style: property.camelize(),
        originalValue: unit=='color' ? parseColor(originalValue) : parseFloat(originalValue || 0),
        targetValue: unit=='color' ? parseColor(value) : value,
        unit: unit
      };
    }.bind(this)).reject(function(transform){
      return (
        (transform.originalValue == transform.targetValue) ||
        (
          transform.unit != 'color' &&
          (isNaN(transform.originalValue) || isNaN(transform.targetValue))
        )
      );
    });
  },
  update: function(position) {
    var style = { }, transform, i = this.transforms.length;
    while(i--)
      style[(transform = this.transforms[i]).style] =
        transform.unit=='color' ? '#'+
          (Math.round(transform.originalValue[0]+
            (transform.targetValue[0]-transform.originalValue[0])*position)).toColorPart() +
          (Math.round(transform.originalValue[1]+
            (transform.targetValue[1]-transform.originalValue[1])*position)).toColorPart() +
          (Math.round(transform.originalValue[2]+
            (transform.targetValue[2]-transform.originalValue[2])*position)).toColorPart() :
        (transform.originalValue +
          (transform.targetValue - transform.originalValue) * position).toFixed(3) +
            (transform.unit === null ? '' : transform.unit);
    this.element.setStyle(style, true);
  }
});

Effect.Transform = Class.create({
  initialize: function(tracks){
    this.tracks  = [];
    this.options = arguments[1] || { };
    this.addTracks(tracks);
  },
  addTracks: function(tracks){
    tracks.each(function(track){
      track = $H(track);
      var data = track.values().first();
      this.tracks.push($H({
        ids:     track.keys().first(),
        effect:  Effect.Morph,
        options: { style: data }
      }));
    }.bind(this));
    return this;
  },
  play: function(){
    return new Effect.Parallel(
      this.tracks.map(function(track){
        var ids = track.get('ids'), effect = track.get('effect'), options = track.get('options');
        var elements = [$(ids) || $$(ids)].flatten();
        return elements.map(function(e){ return new effect(e, Object.extend({ sync:true }, options)) });
      }).flatten(),
      this.options
    );
  }
});

Element.CSS_PROPERTIES = $w(
  'backgroundColor backgroundPosition borderBottomColor borderBottomStyle ' +
  'borderBottomWidth borderLeftColor borderLeftStyle borderLeftWidth ' +
  'borderRightColor borderRightStyle borderRightWidth borderSpacing ' +
  'borderTopColor borderTopStyle borderTopWidth bottom clip color ' +
  'fontSize fontWeight height left letterSpacing lineHeight ' +
  'marginBottom marginLeft marginRight marginTop markerOffset maxHeight '+
  'maxWidth minHeight minWidth opacity outlineColor outlineOffset ' +
  'outlineWidth paddingBottom paddingLeft paddingRight paddingTop ' +
  'right textIndent top width wordSpacing zIndex');

Element.CSS_LENGTH = /^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;

String.__parseStyleElement = document.createElement('div');
String.prototype.parseStyle = function(){
  var style, styleRules = $H();
  if (Prototype.Browser.WebKit)
    style = new Element('div',{style:this}).style;
  else {
    String.__parseStyleElement.innerHTML = '<div style="' + this + '"></div>';
    style = String.__parseStyleElement.childNodes[0].style;
  }

  Element.CSS_PROPERTIES.each(function(property){
    if (style[property]) styleRules.set(property, style[property]);
  });

  if (Prototype.Browser.IE && this.include('opacity'))
    styleRules.set('opacity', this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1]);

  return styleRules;
};

if (document.defaultView && document.defaultView.getComputedStyle) {
  Element.getStyles = function(element) {
    var css = document.defaultView.getComputedStyle($(element), null);
    return Element.CSS_PROPERTIES.inject({ }, function(styles, property) {
      styles[property] = css[property];
      return styles;
    });
  };
} else {
  Element.getStyles = function(element) {
    element = $(element);
    var css = element.currentStyle, styles;
    styles = Element.CSS_PROPERTIES.inject({ }, function(results, property) {
      results[property] = css[property];
      return results;
    });
    if (!styles.opacity) styles.opacity = element.getOpacity();
    return styles;
  };
}

Effect.Methods = {
  morph: function(element, style) {
    element = $(element);
    new Effect.Morph(element, Object.extend({ style: style }, arguments[2] || { }));
    return element;
  },
  visualEffect: function(element, effect, options) {
    element = $(element);
    var s = effect.dasherize().camelize(), klass = s.charAt(0).toUpperCase() + s.substring(1);
    new Effect[klass](element, options);
    return element;
  },
  highlight: function(element, options) {
    element = $(element);
    new Effect.Highlight(element, options);
    return element;
  }
};

$w('fade appear grow shrink fold blindUp blindDown slideUp slideDown '+
  'pulsate shake puff squish switchOff dropOut').each(
  function(effect) {
    Effect.Methods[effect] = function(element, options){
      element = $(element);
      Effect[effect.charAt(0).toUpperCase() + effect.substring(1)](element, options);
      return element;
    };
  }
);

$w('getInlineOpacity forceRerendering setContentZoom collectTextNodes collectTextNodesIgnoreClass getStyles').each(
  function(f) { Effect.Methods[f] = Element[f]; }
);

Element.addMethods(Effect.Methods);
/* /_ui/js/lib/transitions.js */
/** 
 * Easing Equations for Script.aculo.us originally created by
 * Brian Crescimanno <http://briancrescimanno.com>.  
 * Expanded by Brett Lavalla.
 *
 * @author Brian Crescimanno <brian.crescimanno@gmail.com>
 * @author Brett Lavalla <blavalla@gmail.com>
 * @version 1.0
 * @revised February 10, 2009
 * @copyright 2009 Brett Lavalla, all rights reserved
 *
 * Released under terms of the BSD License
 * http://www.opensource.org/licenses/bsd-license.php
 *
 * The math for these equations was created by Robert Penner
 * http://www.robertpenner.com/profmx
 * 
**/
  
/****** Quadratic ******/

Effect.Transitions.easeInQuad = function(pos){
	return Math.pow(pos, 2);
}

Effect.Transitions.easeOutQuad = function(pos){
	return -(Math.pow((pos-1), 2) -1);
}

Effect.Transitions.easeInOutQuad = function(pos){
	if ((pos/=0.5) < 1) return 0.5*Math.pow(pos,2);
    return -0.5 * ((pos-=2)*pos - 2); 
}

/****** Cubic ******/

Effect.Transitions.easeInCubic = function(pos){
	return Math.pow(pos, 3);
}

Effect.Transitions.easeOutCubic = function(pos){
	return (Math.pow((pos-1), 3) +1);
}

Effect.Transitions.easeInOutCubic = function(pos){
	if ((pos/=0.5) < 1) return 0.5*Math.pow(pos,3);
    return 0.5 * (Math.pow((pos-2),3) + 2); 	
}

/****** Quartic ******/

Effect.Transitions.easeInQuart = function(pos){
	return Math.pow(pos, 4);
}

Effect.Transitions.easeOutQuart = function(pos){
	return -(Math.pow((pos-1), 4) -1)
}

Effect.Transitions.easeInOutQuart = function(pos){
	if ((pos/=0.5) < 1) return 0.5*Math.pow(pos,4);
    return -0.5 * ((pos-=2)*Math.pow(pos,3) - 2); 
}

/****** Quintic ******/

Effect.Transitions.easeInQuint = function(pos){
	return Math.pow(pos, 5);
}

Effect.Transitions.easeOutQuint = function(pos){
	return (Math.pow((pos-1), 5) +1);
}

Effect.Transitions.easeInOutQuint = function(pos){
	if ((pos/=0.5) < 1) return 0.5*Math.pow(pos,5);
    return 0.5 * (Math.pow((pos-2),5) + 2); 	
}

/****** Sinusoidal ******/

Effect.Transitions.easeInSine = function(pos){
	return -Math.cos(pos * (Math.PI/2)) + 1;
}

Effect.Transitions.easeOutSine = function(pos){
	return Math.sin(pos * (Math.PI/2));
}

Effect.Transitions.easeInOutSine = function(pos){
	return (-.5 * (Math.cos(Math.PI*pos) -1));
}

/****** Exponential ******/

Effect.Transitions.easeInExpo = function(pos){
	return (pos==0) ? 0 : Math.pow(2, 10 * (pos - 1));
}

Effect.Transitions.easeOutExpo = function(pos){
	return (pos==1) ? 1 : -Math.pow(2, -10 * pos) + 1;
}

Effect.Transitions.easeInOutExpo = function(pos){
	if(pos==0) return 0;
	if(pos==1) return 1;
	if((pos/=0.5) < 1) return 0.5 * Math.pow(2,10 * (pos-1));
	return 0.5 * (-Math.pow(2, -10 * --pos) + 2);	
}

/****** Circular ******/

Effect.Transitions.easeInCirc = function(pos){
	return -(Math.sqrt(1 - (pos*pos)) - 1);
}

Effect.Transitions.easeOutCirc = function(pos){
	return Math.sqrt(1 - Math.pow((pos-1), 2))
}

Effect.Transitions.easeInOutCirc = function(pos){
	if((pos/=0.5) < 1) return -0.5 * (Math.sqrt(1 - pos*pos) - 1);
	return 0.5 * (Math.sqrt(1 - (pos-=2)*pos) + 1);	
}

/****** Bounce ******/

Effect.Transitions.easeOutBounce = function(pos){
	if ((pos) < (1/2.75)) {
		return (7.5625*pos*pos);
	} else if (pos < (2/2.75)) {
		return (7.5625*(pos-=(1.5/2.75))*pos + .75);
	} else if (pos < (2.5/2.75)) {
		return (7.5625*(pos-=(2.25/2.75))*pos + .9375);
	} else {
		return (7.5625*(pos-=(2.625/2.75))*pos + .984375);
	}
}

Effect.Transitions.easeInBounce = function(pos){
	var value;
	for (var a = 0, b = 1; 1; a += b, b /= 2){
		if (pos >= (7 - 4 * a) / 11){
			value = - Math.pow((11 - 6 * a - 11 * pos) / 4, 2) + b * b;
			break;
		}
	}
	return value;
}

Effect.Transitions.easeInOutBounce = function(pos){
	if(pos<= 0.5){
		pos = 2* pos;
		var value;
		for (var a = 0, b = 1; 1; a += b, b /= 2){
			if (pos >= (7 - 4 * a) / 11){
				value = - Math.pow((11 - 6 * a - 11 * pos) / 4, 2) + b * b;
				break;
			}
		}
		return value/2;
	} else {
		pos = 2*(1-pos);
		var value;
		for (var a = 0, b = 1; 1; a += b, b /= 2){
			if (pos >= (7 - 4 * a) / 11){
				value = - Math.pow((11 - 6 * a - 11 * pos) / 4, 2) + b * b;
				break;
			}
		}
		return 1-(value)/2;
	}
}

/****** Back ******/

Effect.Transitions.easeInBack = function(pos){
	var s = 1.70158;	
	return (pos)*pos*((s+1)*pos - s);
}

Effect.Transitions.easeOutBack = function(pos){
	var s = 1.70158;	
	return (pos=pos-1)*pos*((s+1)*pos + s) + 1;
}

Effect.Transitions.easeInOutBack = function(pos){
	var s = 1.70158;	
	if((pos/=0.5) < 1) return 0.5*(pos*pos*(((s*=(1.525))+1)*pos -s));
	return 0.5*((pos-=2)*pos*(((s*=(1.525))+1)*pos +s) +2);
}

/****** Elastic ******/

Effect.Transitions.easeInElastic = function(pos){
	return Math.pow(2, 10 * --pos) * Math.cos(20 * pos * Math.PI * (1) / 3);
}

Effect.Transitions.easeOutElastic = function(pos){
	pos = 1 - pos;
	return 1-(Math.pow(2, 10 * --pos) * Math.cos(20 * pos * Math.PI * (1) / 3));
}

Effect.Transitions.easeInOutElastic = function(pos){	
	if(pos<= 0.5){
		pos = 2* pos;
		return (Math.pow(2, 10 * --pos) * Math.cos(20 * pos * Math.PI * (1) / 3))/2;
	} else {
		pos = 2*(1-pos);
		return 1-(Math.pow(2, 10 * --pos) * Math.cos(20 * pos * Math.PI * (1) / 3)/2);
	}
}


/* /_ui/js/lib/cufon.js */
/*!
 * Copyright (c) 2009 Simo Kinnunen.
 * Licensed under the MIT license.
 *
 * @version 1.09
 */

var Cufon = (function() {

	var api = function() {
		return api.replace.apply(null, arguments);
	};

	var DOM = api.DOM = {

		ready: (function() {

			var complete = false, readyStatus = { loaded: 1, complete: 1 };

			var queue = [], perform = function() {
				if (complete) return;
				complete = true;
				for (var fn; fn = queue.shift(); fn());
			};

			// Gecko, Opera, WebKit r26101+

			if (document.addEventListener) {
				document.addEventListener('DOMContentLoaded', perform, false);
				window.addEventListener('pageshow', perform, false); // For cached Gecko pages
			}

			// Old WebKit, Internet Explorer

			if (!window.opera && document.readyState) (function() {
				readyStatus[document.readyState] ? perform() : setTimeout(arguments.callee, 10);
			})();

			// Internet Explorer

			if (document.readyState && document.createStyleSheet) (function() {
				try {
					document.body.doScroll('left');
					perform();
				}
				catch (e) {
					setTimeout(arguments.callee, 1);
				}
			})();

			addEvent(window, 'load', perform); // Fallback

			return function(listener) {
				if (!arguments.length) perform();
				else complete ? listener() : queue.push(listener);
			};

		})(),

		root: function() {
			return document.documentElement || document.body;
		}

	};

	var CSS = api.CSS = {

		Size: function(value, base) {

			this.value = parseFloat(value);
			this.unit = String(value).match(/[a-z%]*$/)[0] || 'px';

			this.convert = function(value) {
				return value / base * this.value;
			};

			this.convertFrom = function(value) {
				return value / this.value * base;
			};

			this.toString = function() {
				return this.value + this.unit;
			};

		},

		addClass: function(el, className) {
			var current = el.className;
			el.className = current + (current && ' ') + className;
			return el;
		},

		color: cached(function(value) {
			var parsed = {};
			parsed.color = value.replace(/^rgba\((.*?),\s*([\d.]+)\)/, function($0, $1, $2) {
				parsed.opacity = parseFloat($2);
				return 'rgb(' + $1 + ')';
			});
			return parsed;
		}),

		// has no direct CSS equivalent.
		// @see http://msdn.microsoft.com/en-us/library/system.windows.fontstretches.aspx
		fontStretch: cached(function(value) {
			if (typeof value == 'number') return value;
			if (/%$/.test(value)) return parseFloat(value) / 100;
			return {
				'ultra-condensed': 0.5,
				'extra-condensed': 0.625,
				condensed: 0.75,
				'semi-condensed': 0.875,
				'semi-expanded': 1.125,
				expanded: 1.25,
				'extra-expanded': 1.5,
				'ultra-expanded': 2
			}[value] || 1;
		}),

		getStyle: function(el) {
			var view = document.defaultView;
			if (view && view.getComputedStyle) return new Style(view.getComputedStyle(el, null));
			if (el.currentStyle) return new Style(el.currentStyle);
			return new Style(el.style);
		},

		gradient: cached(function(value) {
			var gradient = {
				id: value,
				type: value.match(/^-([a-z]+)-gradient\(/)[1],
				stops: []
			}, colors = value.substr(value.indexOf('(')).match(/([\d.]+=)?(#[a-f0-9]+|[a-z]+\(.*?\)|[a-z]+)/ig);
			for (var i = 0, l = colors.length, stop; i < l; ++i) {
				stop = colors[i].split('=', 2).reverse();
				gradient.stops.push([ stop[1] || i / (l - 1), stop[0] ]);
			}
			return gradient;
		}),

		quotedList: cached(function(value) {
			// doesn't work properly with empty quoted strings (""), but
			// it's not worth the extra code.
			var list = [], re = /\s*((["'])([\s\S]*?[^\\])\2|[^,]+)\s*/g, match;
			while (match = re.exec(value)) list.push(match[3] || match[1]);
			return list;
		}),

		recognizesMedia: cached(function(media) {
			var el = document.createElement('style'), sheet, container, supported;
			el.type = 'text/css';
			el.media = media;
			try { // this is cached anyway
				el.appendChild(document.createTextNode('/**/'));
			} catch (e) {}
			container = elementsByTagName('head')[0];
			container.insertBefore(el, container.firstChild);
			sheet = (el.sheet || el.styleSheet);
			supported = sheet && !sheet.disabled;
			container.removeChild(el);
			return supported;
		}),

		removeClass: function(el, className) {
			var re = RegExp('(?:^|\\s+)' + className +  '(?=\\s|$)', 'g');
			el.className = el.className.replace(re, '');
			return el;
		},

		supports: function(property, value) {
			var checker = document.createElement('span').style;
			if (checker[property] === undefined) return false;
			checker[property] = value;
			return checker[property] === value;
		},

		textAlign: function(word, style, position, wordCount) {
			if (style.get('textAlign') == 'right') {
				if (position > 0) word = ' ' + word;
			}
			else if (position < wordCount - 1) word += ' ';
			return word;
		},

		textShadow: cached(function(value) {
			if (value == 'none') return null;
			var shadows = [], currentShadow = {}, result, offCount = 0;
			var re = /(#[a-f0-9]+|[a-z]+\(.*?\)|[a-z]+)|(-?[\d.]+[a-z%]*)|,/ig;
			while (result = re.exec(value)) {
				if (result[0] == ',') {
					shadows.push(currentShadow);
					currentShadow = {};
					offCount = 0;
				}
				else if (result[1]) {
					currentShadow.color = result[1];
				}
				else {
					currentShadow[[ 'offX', 'offY', 'blur' ][offCount++]] = result[2];
				}
			}
			shadows.push(currentShadow);
			return shadows;
		}),

		textTransform: (function() {
			var map = {
				uppercase: function(s) {
					return s.toUpperCase();
				},
				lowercase: function(s) {
					return s.toLowerCase();
				},
				capitalize: function(s) {
					return s.replace(/\b./g, function($0) {
						return $0.toUpperCase();
					});
				}
			};
			return function(text, style) {
				var transform = map[style.get('textTransform')];
				return transform ? transform(text) : text;
			};
		})(),

		whiteSpace: (function() {
			var ignore = {
				inline: 1,
				'inline-block': 1,
				'run-in': 1
			};
			var wsStart = /^\s+/, wsEnd = /\s+$/;
			return function(text, style, node, previousElement) {
				if (previousElement) {
					if (previousElement.nodeName.toLowerCase() == 'br') {
						text = text.replace(wsStart, '');
					}
				}
				if (ignore[style.get('display')]) return text;
				if (!node.previousSibling) text = text.replace(wsStart, '');
				if (!node.nextSibling) text = text.replace(wsEnd, '');
				return text;
			};
		})()

	};

	CSS.ready = (function() {

		// don't do anything in Safari 2 (it doesn't recognize any media type)
		var complete = !CSS.recognizesMedia('all'), hasLayout = false;

		var queue = [], perform = function() {
			complete = true;
			for (var fn; fn = queue.shift(); fn());
		};

		var links = elementsByTagName('link'), styles = elementsByTagName('style');

		function isContainerReady(el) {
			return el.disabled || isSheetReady(el.sheet, el.media || 'screen');
		}

		function isSheetReady(sheet, media) {
			// in Opera sheet.disabled is true when it's still loading,
			// even though link.disabled is false. they stay in sync if
			// set manually.
			if (!CSS.recognizesMedia(media || 'all')) return true;
			if (!sheet || sheet.disabled) return false;
			try {
				var rules = sheet.cssRules, rule;
				if (rules) {
					// needed for Safari 3 and Chrome 1.0.
					// in standards-conforming browsers cssRules contains @-rules.
					// Chrome 1.0 weirdness: rules[<number larger than .length - 1>]
					// returns the last rule, so a for loop is the only option.
					search: for (var i = 0, l = rules.length; rule = rules[i], i < l; ++i) {
						switch (rule.type) {
							case 2: // @charset
								break;
							case 3: // @import
								if (!isSheetReady(rule.styleSheet, rule.media.mediaText)) return false;
								break;
							default:
								// only @charset can precede @import
								break search;
						}
					}
				}
			}
			catch (e) {} // probably a style sheet from another domain
			return true;
		}

		function allStylesLoaded() {
			// Internet Explorer's style sheet model, there's no need to do anything
			if (document.createStyleSheet) return true;
			// standards-compliant browsers
			var el, i;
			for (i = 0; el = links[i]; ++i) {
				if (el.rel.toLowerCase() == 'stylesheet' && !isContainerReady(el)) return false;
			}
			for (i = 0; el = styles[i]; ++i) {
				if (!isContainerReady(el)) return false;
			}
			return true;
		}

		DOM.ready(function() {
			// getComputedStyle returns null in Gecko if used in an iframe with display: none
			if (!hasLayout) hasLayout = CSS.getStyle(document.body).isUsable();
			if (complete || (hasLayout && allStylesLoaded())) perform();
			else setTimeout(arguments.callee, 10);
		});

		return function(listener) {
			if (complete) listener();
			else queue.push(listener);
		};

	})();

	function Font(data) {

		var face = this.face = data.face, wordSeparators = {
			'\u0020': 1,
			'\u00a0': 1,
			'\u3000': 1
		};

		this.glyphs = data.glyphs;
		this.w = data.w;
		this.baseSize = parseInt(face['units-per-em'], 10);

		this.family = face['font-family'].toLowerCase();
		this.weight = face['font-weight'];
		this.style = face['font-style'] || 'normal';

		this.viewBox = (function () {
			var parts = face.bbox.split(/\s+/);
			var box = {
				minX: parseInt(parts[0], 10),
				minY: parseInt(parts[1], 10),
				maxX: parseInt(parts[2], 10),
				maxY: parseInt(parts[3], 10)
			};
			box.width = box.maxX - box.minX;
			box.height = box.maxY - box.minY;
			box.toString = function() {
				return [ this.minX, this.minY, this.width, this.height ].join(' ');
			};
			return box;
		})();

		this.ascent = -parseInt(face.ascent, 10);
		this.descent = -parseInt(face.descent, 10);

		this.height = -this.ascent + this.descent;

		this.spacing = function(chars, letterSpacing, wordSpacing) {
			var glyphs = this.glyphs, glyph, kerning, k,
				jumps = [], width = 0,
				i = -1, j = -1, chr;
			while (chr = chars[++i]) {
				glyph = glyphs[chr] || this.missingGlyph;
				if (!glyph) continue;
				if (kerning) {
					width -= k = kerning[chr] || 0;
					jumps[j] -= k;
				}
				width += jumps[++j] = ~~(glyph.w || this.w) + letterSpacing + (wordSeparators[chr] ? wordSpacing : 0);
				kerning = glyph.k;
			}
			jumps.total = width;
			return jumps;
		};

	}

	function FontFamily() {

		var styles = {}, mapping = {
			oblique: 'italic',
			italic: 'oblique'
		};

		this.add = function(font) {
			(styles[font.style] || (styles[font.style] = {}))[font.weight] = font;
		};

		this.get = function(style, weight) {
			var weights = styles[style] || styles[mapping[style]]
				|| styles.normal || styles.italic || styles.oblique;
			if (!weights) return null;
			// we don't have to worry about "bolder" and "lighter"
			// because IE's currentStyle returns a numeric value for it,
			// and other browsers use the computed value anyway
			weight = {
				normal: 400,
				bold: 700
			}[weight] || parseInt(weight, 10);
			if (weights[weight]) return weights[weight];
			// http://www.w3.org/TR/CSS21/fonts.html#propdef-font-weight
			// Gecko uses x99/x01 for lighter/bolder
			var up = {
				1: 1,
				99: 0
			}[weight % 100], alts = [], min, max;
			if (up === undefined) up = weight > 400;
			if (weight == 500) weight = 400;
			for (var alt in weights) {
				if (!hasOwnProperty(weights, alt)) continue;
				alt = parseInt(alt, 10);
				if (!min || alt < min) min = alt;
				if (!max || alt > max) max = alt;
				alts.push(alt);
			}
			if (weight < min) weight = min;
			if (weight > max) weight = max;
			alts.sort(function(a, b) {
				return (up
					? (a >= weight && b >= weight) ? a < b : a > b
					: (a <= weight && b <= weight) ? a > b : a < b) ? -1 : 1;
			});
			return weights[alts[0]];
		};

	}

	function HoverHandler() {

		function contains(node, anotherNode) {
			if (node.contains) return node.contains(anotherNode);
			return node.compareDocumentPosition(anotherNode) & 16;
		}

		function onOverOut(e) {
			var related = e.relatedTarget;
			if (!related || contains(this, related)) return;
			trigger(this, e.type == 'mouseover');
		}

		function onEnterLeave(e) {
			trigger(this, e.type == 'mouseenter');
		}

		function trigger(el, hoverState) {
			// A timeout is needed so that the event can actually "happen"
			// before replace is triggered. This ensures that styles are up
			// to date.
			setTimeout(function() {
				var options = sharedStorage.get(el).options;
				api.replace(el, hoverState ? merge(options, options.hover) : options, true);
			}, 10);
		}

		this.attach = function(el) {
			if (el.onmouseenter === undefined) {
				addEvent(el, 'mouseover', onOverOut);
				addEvent(el, 'mouseout', onOverOut);
			}
			else {
				addEvent(el, 'mouseenter', onEnterLeave);
				addEvent(el, 'mouseleave', onEnterLeave);
			}
		};

	}

	function ReplaceHistory() {

		var list = [], map = {};

		function filter(keys) {
			var values = [], key;
			for (var i = 0; key = keys[i]; ++i) values[i] = list[map[key]];
			return values;
		}

		this.add = function(key, args) {
			map[key] = list.push(args) - 1;
		};

		this.repeat = function() {
			var snapshot = arguments.length ? filter(arguments) : list, args;
			for (var i = 0; args = snapshot[i++];) api.replace(args[0], args[1], true);
		};

	}

	function Storage() {

		var map = {}, at = 0;

		function identify(el) {
			return el.cufid || (el.cufid = ++at);
		}

		this.get = function(el) {
			var id = identify(el);
			return map[id] || (map[id] = {});
		};

	}

	function Style(style) {

		var custom = {}, sizes = {};

		this.extend = function(styles) {
			for (var property in styles) {
				if (hasOwnProperty(styles, property)) custom[property] = styles[property];
			}
			return this;
		};

		this.get = function(property) {
			return custom[property] != undefined ? custom[property] : style[property];
		};

		this.getSize = function(property, base) {
			return sizes[property] || (sizes[property] = new CSS.Size(this.get(property), base));
		};

		this.isUsable = function() {
			return !!style;
		};

	}

	function addEvent(el, type, listener) {
		if (el.addEventListener) {
			el.addEventListener(type, listener, false);
		}
		else if (el.attachEvent) {
			el.attachEvent('on' + type, function() {
				return listener.call(el, window.event);
			});
		}
	}

	function attach(el, options) {
		var storage = sharedStorage.get(el);
		if (storage.options) return el;
		if (options.hover && options.hoverables[el.nodeName.toLowerCase()]) {
			hoverHandler.attach(el);
		}
		storage.options = options;
		return el;
	}

	function cached(fun) {
		var cache = {};
		return function(key) {
			if (!hasOwnProperty(cache, key)) cache[key] = fun.apply(null, arguments);
			return cache[key];
		};
	}

	function getFont(el, style) {
		var families = CSS.quotedList(style.get('fontFamily').toLowerCase()), family;
		for (var i = 0; family = families[i]; ++i) {
			if (fonts[family]) return fonts[family].get(style.get('fontStyle'), style.get('fontWeight'));
		}
		return null;
	}

	function elementsByTagName(query) {
		return document.getElementsByTagName(query);
	}

	function hasOwnProperty(obj, property) {
		return obj.hasOwnProperty(property);
	}

	function merge() {
		var merged = {}, arg, key;
		for (var i = 0, l = arguments.length; arg = arguments[i], i < l; ++i) {
			for (key in arg) {
				if (hasOwnProperty(arg, key)) merged[key] = arg[key];
			}
		}
		return merged;
	}

	function process(font, text, style, options, node, el) {
		var fragment = document.createDocumentFragment(), processed;
		if (text === '') return fragment;
		var separate = options.separate;
		var parts = text.split(separators[separate]), needsAligning = (separate == 'words');
		if (needsAligning && HAS_BROKEN_REGEXP) {
			// @todo figure out a better way to do this
			if (/^\s/.test(text)) parts.unshift('');
			if (/\s$/.test(text)) parts.push('');
		}
		for (var i = 0, l = parts.length; i < l; ++i) {
			processed = engines[options.engine](font,
				needsAligning ? CSS.textAlign(parts[i], style, i, l) : parts[i],
				style, options, node, el, i < l - 1);
			if (processed) fragment.appendChild(processed);
		}
		return fragment;
	}

	function replaceElement(el, options) {
		var name = el.nodeName.toLowerCase();
		if (options.ignore[name]) return;
		var replace = !options.textless[name];
		var style = CSS.getStyle(attach(el, options)).extend(options);
		var font = getFont(el, style), node, type, next, anchor, text, lastElement;
		if (!font) return;
		for (node = el.firstChild; node; node = next) {
			type = node.nodeType;
			next = node.nextSibling;
			if (replace && type == 3) {
				// Node.normalize() is broken in IE 6, 7, 8
				if (anchor) {
					anchor.appendData(node.data);
					el.removeChild(node);
				}
				else anchor = node;
				if (next) continue;
			}
			if (anchor) {
				el.replaceChild(process(font,
					CSS.whiteSpace(anchor.data, style, anchor, lastElement),
					style, options, node, el), anchor);
				anchor = null;
			}
			if (type == 1) {
				if (node.firstChild) {
					if (node.nodeName.toLowerCase() == 'cufon') {
						engines[options.engine](font, null, style, options, node, el);
					}
					else arguments.callee(node, options);
				}
				lastElement = node;
			}
		}
	}

	var HAS_BROKEN_REGEXP = ' '.split(/\s+/).length == 0;

	var sharedStorage = new Storage();
	var hoverHandler = new HoverHandler();
	var replaceHistory = new ReplaceHistory();
	var initialized = false;

	var engines = {}, fonts = {}, defaultOptions = {
		autoDetect: false,
		engine: null,
		//fontScale: 1,
		//fontScaling: false,
		forceHitArea: false,
		hover: false,
		hoverables: {
			a: true
		},
		ignore: {
			applet: 1,
			canvas: 1,
			col: 1,
			colgroup: 1,
			head: 1,
			iframe: 1,
			map: 1,
			optgroup: 1,
			option: 1,
			script: 1,
			select: 1,
			style: 1,
			textarea: 1,
			title: 1,
			pre: 1
		},
		printable: true,
		//rotation: 0,
		//selectable: false,
		selector: (
				window.Sizzle
			||	(window.jQuery && function(query) { return jQuery(query); }) // avoid noConflict issues
			||	(window.dojo && dojo.query)
			||	(window.Ext && Ext.query)
			||	(window.YAHOO && YAHOO.util && YAHOO.util.Selector && YAHOO.util.Selector.query)
			||	(window.$$ && function(query) { return $$(query); })
			||	(window.$ && function(query) { return $(query); })
			||	(document.querySelectorAll && function(query) { return document.querySelectorAll(query); })
			||	elementsByTagName
		),
		separate: 'words', // 'none' and 'characters' are also accepted
		textless: {
			dl: 1,
			html: 1,
			ol: 1,
			table: 1,
			tbody: 1,
			thead: 1,
			tfoot: 1,
			tr: 1,
			ul: 1
		},
		textShadow: 'none'
	};

	var separators = {
		// The first pattern may cause unicode characters above
		// code point 255 to be removed in Safari 3.0. Luckily enough
		// Safari 3.0 does not include non-breaking spaces in \s, so
		// we can just use a simple alternative pattern.
		words: /\s/.test('\u00a0') ? /[^\S\u00a0]+/ : /\s+/,
		characters: '',
		none: /^/
	};

	api.now = function() {
		DOM.ready();
		return api;
	};

	api.refresh = function() {
		replaceHistory.repeat.apply(replaceHistory, arguments);
		return api;
	};

	api.registerEngine = function(id, engine) {
		if (!engine) return api;
		engines[id] = engine;
		return api.set('engine', id);
	};

	api.registerFont = function(data) {
		if (!data) return api;
		var font = new Font(data), family = font.family;
		if (!fonts[family]) fonts[family] = new FontFamily();
		fonts[family].add(font);
		return api.set('fontFamily', '"' + family + '"');
	};

	api.replace = function(elements, options, ignoreHistory) {
		options = merge(defaultOptions, options);
		if (!options.engine) return api; // there's no browser support so we'll just stop here
		if (!initialized) {
			CSS.addClass(DOM.root(), 'cufon-active cufon-loading');
			CSS.ready(function() {
				// fires before any replace() calls, but it doesn't really matter
				CSS.addClass(CSS.removeClass(DOM.root(), 'cufon-loading'), 'cufon-ready');
			});
			initialized = true;
		}
		if (options.hover) options.forceHitArea = true;
		if (options.autoDetect) delete options.fontFamily;
		if (typeof options.textShadow == 'string') {
			options.textShadow = CSS.textShadow(options.textShadow);
		}
		if (typeof options.color == 'string' && /^-/.test(options.color)) {
			options.textGradient = CSS.gradient(options.color);
		}
		else delete options.textGradient;
		if (!ignoreHistory) replaceHistory.add(elements, arguments);
		if (elements.nodeType || typeof elements == 'string') elements = [ elements ];
		CSS.ready(function() {
			for (var i = 0, l = elements.length; i < l; ++i) {
				var el = elements[i];
				if (typeof el == 'string') api.replace(options.selector(el), options, true);
				else replaceElement(el, options);
			}
		});
		return api;
	};

	api.set = function(option, value) {
		defaultOptions[option] = value;
		return api;
	};

	return api;

})();

Cufon.registerEngine('canvas', (function() {

	// Safari 2 doesn't support .apply() on native methods

	var check = document.createElement('canvas');
	if (!check || !check.getContext || !check.getContext.apply) return;
	check = null;

	var HAS_INLINE_BLOCK = Cufon.CSS.supports('display', 'inline-block');

	// Firefox 2 w/ non-strict doctype (almost standards mode)
	var HAS_BROKEN_LINEHEIGHT = !HAS_INLINE_BLOCK && (document.compatMode == 'BackCompat' || /frameset|transitional/i.test(document.doctype.publicId));

	var styleSheet = document.createElement('style');
	styleSheet.type = 'text/css';
	styleSheet.appendChild(document.createTextNode((
		'cufon{text-indent:0;}' +
		'@media screen,projection{' +
			'cufon{display:inline;display:inline-block;position:relative;vertical-align:middle;' +
			(HAS_BROKEN_LINEHEIGHT
				? ''
				: 'font-size:1px;line-height:1px;') +
			'}cufon cufontext{display:-moz-inline-box;display:inline-block;width:0;height:0;overflow:hidden;text-indent:-10000in;}' +
			(HAS_INLINE_BLOCK
				? 'cufon canvas{position:relative;}'
				: 'cufon canvas{position:absolute;}') +
		'}' +
		'@media print{' +
			'cufon{padding:0;}' + // Firefox 2
			'cufon canvas{display:none;}' +
		'}'
	).replace(/;/g, '!important;')));
	document.getElementsByTagName('head')[0].appendChild(styleSheet);

	function generateFromVML(path, context) {
		var atX = 0, atY = 0;
		var code = [], re = /([mrvxe])([^a-z]*)/g, match;
		generate: for (var i = 0; match = re.exec(path); ++i) {
			var c = match[2].split(',');
			switch (match[1]) {
				case 'v':
					code[i] = { m: 'bezierCurveTo', a: [ atX + ~~c[0], atY + ~~c[1], atX + ~~c[2], atY + ~~c[3], atX += ~~c[4], atY += ~~c[5] ] };
					break;
				case 'r':
					code[i] = { m: 'lineTo', a: [ atX += ~~c[0], atY += ~~c[1] ] };
					break;
				case 'm':
					code[i] = { m: 'moveTo', a: [ atX = ~~c[0], atY = ~~c[1] ] };
					break;
				case 'x':
					code[i] = { m: 'closePath' };
					break;
				case 'e':
					break generate;
			}
			context[code[i].m].apply(context, code[i].a);
		}
		return code;
	}

	function interpret(code, context) {
		for (var i = 0, l = code.length; i < l; ++i) {
			var line = code[i];
			context[line.m].apply(context, line.a);
		}
	}

	return function(font, text, style, options, node, el) {

		var redraw = (text === null);

		if (redraw) text = node.getAttribute('alt');

		var viewBox = font.viewBox;

		var size = style.getSize('fontSize', font.baseSize);

		var expandTop = 0, expandRight = 0, expandBottom = 0, expandLeft = 0;
		var shadows = options.textShadow, shadowOffsets = [];
		if (shadows) {
			for (var i = shadows.length; i--;) {
				var shadow = shadows[i];
				var x = size.convertFrom(parseFloat(shadow.offX));
				var y = size.convertFrom(parseFloat(shadow.offY));
				shadowOffsets[i] = [ x, y ];
				if (y < expandTop) expandTop = y;
				if (x > expandRight) expandRight = x;
				if (y > expandBottom) expandBottom = y;
				if (x < expandLeft) expandLeft = x;
			}
		}

		var chars = Cufon.CSS.textTransform(text, style).split('');

		var jumps = font.spacing(chars,
			~~size.convertFrom(parseFloat(style.get('letterSpacing')) || 0),
			~~size.convertFrom(parseFloat(style.get('wordSpacing')) || 0)
		);

		if (!jumps.length) return null; // there's nothing to render

		var width = jumps.total;

		expandRight += viewBox.width - jumps[jumps.length - 1];
		expandLeft += viewBox.minX;

		var wrapper, canvas;

		if (redraw) {
			wrapper = node;
			canvas = node.firstChild;
		}
		else {
			wrapper = document.createElement('cufon');
			wrapper.className = 'cufon cufon-canvas';
			wrapper.setAttribute('alt', text);

			canvas = document.createElement('canvas');
			wrapper.appendChild(canvas);

			if (options.printable) {
				var print = document.createElement('cufontext');
				print.appendChild(document.createTextNode(text));
				wrapper.appendChild(print);
			}
		}

		var wStyle = wrapper.style;
		var cStyle = canvas.style;

		var height = size.convert(viewBox.height);
		var roundedHeight = Math.ceil(height);
		var roundingFactor = roundedHeight / height;
		var stretchFactor = roundingFactor * Cufon.CSS.fontStretch(style.get('fontStretch'));
		var stretchedWidth = width * stretchFactor;

		var canvasWidth = Math.ceil(size.convert(stretchedWidth + expandRight - expandLeft));
		var canvasHeight = Math.ceil(size.convert(viewBox.height - expandTop + expandBottom));

		canvas.width = canvasWidth;
		canvas.height = canvasHeight;

		// needed for WebKit and full page zoom
		cStyle.width = canvasWidth + 'px';
		cStyle.height = canvasHeight + 'px';

		// minY has no part in canvas.height
		expandTop += viewBox.minY;

		cStyle.top = Math.round(size.convert(expandTop - font.ascent)) + 'px';
		cStyle.left = Math.round(size.convert(expandLeft)) + 'px';

		var wrapperWidth = Math.max(Math.ceil(size.convert(stretchedWidth)), 0) + 'px';

		if (HAS_INLINE_BLOCK) {
			wStyle.width = wrapperWidth;
			wStyle.height = size.convert(font.height) + 'px';
		}
		else {
			wStyle.paddingLeft = wrapperWidth;
			wStyle.paddingBottom = (size.convert(font.height) - 1) + 'px';
		}

		var g = canvas.getContext('2d'), scale = height / viewBox.height;

		// proper horizontal scaling is performed later
		g.scale(scale, scale * roundingFactor);
		g.translate(-expandLeft, -expandTop);
		g.save();

		function renderText() {
			var glyphs = font.glyphs, glyph, i = -1, j = -1, chr;
			g.scale(stretchFactor, 1);
			while (chr = chars[++i]) {
				var glyph = glyphs[chars[i]] || font.missingGlyph;
				if (!glyph) continue;
				if (glyph.d) {
					g.beginPath();
					if (glyph.code) interpret(glyph.code, g);
					else glyph.code = generateFromVML('m' + glyph.d, g);
					g.fill();
				}
				g.translate(jumps[++j], 0);
			}
			g.restore();
		}

		if (shadows) {
			for (var i = shadows.length; i--;) {
				var shadow = shadows[i];
				g.save();
				g.fillStyle = shadow.color;
				g.translate.apply(g, shadowOffsets[i]);
				renderText();
			}
		}

		var gradient = options.textGradient;
		if (gradient) {
			var stops = gradient.stops, fill = g.createLinearGradient(0, viewBox.minY, 0, viewBox.maxY);
			for (var i = 0, l = stops.length; i < l; ++i) {
				fill.addColorStop.apply(fill, stops[i]);
			}
			g.fillStyle = fill;
		}
		else g.fillStyle = style.get('color');

		renderText();

		return wrapper;

	};

})());

Cufon.registerEngine('vml', (function() {

	var ns = document.namespaces;
	if (!ns) return;
	ns.add('cvml', 'urn:schemas-microsoft-com:vml');
	ns = null;

	var check = document.createElement('cvml:shape');
	check.style.behavior = 'url(#default#VML)';
	if (!check.coordsize) return; // VML isn't supported
	check = null;

	var HAS_BROKEN_LINEHEIGHT = (document.documentMode || 0) < 8;

	document.write(('<style type="text/css">' +
		'cufoncanvas{text-indent:0;}' +
		'@media screen{' +
			'cvml\\:shape,cvml\\:rect,cvml\\:fill,cvml\\:shadow{behavior:url(#default#VML);display:block;antialias:true;position:absolute;}' +
			'cufoncanvas{position:absolute;text-align:left;}' +
			'cufon{display:inline-block;position:relative;vertical-align:' +
			(HAS_BROKEN_LINEHEIGHT
				? 'middle'
				: 'text-bottom') +
			';}' +
			'cufon cufontext{position:absolute;left:-10000in;font-size:1px;}' +
			'a cufon{cursor:pointer}' + // ignore !important here
		'}' +
		'@media print{' +
			'cufon cufoncanvas{display:none;}' +
		'}' +
	'</style>').replace(/;/g, '!important;'));

	function getFontSizeInPixels(el, value) {
		return getSizeInPixels(el, /(?:em|ex|%)$|^[a-z-]+$/i.test(value) ? '1em' : value);
	}

	// Original by Dead Edwards.
	// Combined with getFontSizeInPixels it also works with relative units.
	function getSizeInPixels(el, value) {
		if (value === '0') return 0;
		if (/px$/i.test(value)) return parseFloat(value);
		var style = el.style.left, runtimeStyle = el.runtimeStyle.left;
		el.runtimeStyle.left = el.currentStyle.left;
		el.style.left = value.replace('%', 'em');
		var result = el.style.pixelLeft;
		el.style.left = style;
		el.runtimeStyle.left = runtimeStyle;
		return result;
	}

	function getSpacingValue(el, style, size, property) {
		var key = 'computed' + property, value = style[key];
		if (isNaN(value)) {
			value = style.get(property);
			style[key] = value = (value == 'normal') ? 0 : ~~size.convertFrom(getSizeInPixels(el, value));
		}
		return value;
	}

	var fills = {};

	function gradientFill(gradient) {
		var id = gradient.id;
		if (!fills[id]) {
			var stops = gradient.stops, fill = document.createElement('cvml:fill'), colors = [];
			fill.type = 'gradient';
			fill.angle = 180;
			fill.focus = '0';
			fill.method = 'sigma';
			fill.color = stops[0][1];
			for (var j = 1, k = stops.length - 1; j < k; ++j) {
				colors.push(stops[j][0] * 100 + '% ' + stops[j][1]);
			}
			fill.colors = colors.join(',');
			fill.color2 = stops[k][1];
			fills[id] = fill;
		}
		return fills[id];
	}

	return function(font, text, style, options, node, el, hasNext) {

		var redraw = (text === null);

		if (redraw) text = node.alt;

		var viewBox = font.viewBox;

		var size = style.computedFontSize || (style.computedFontSize = new Cufon.CSS.Size(getFontSizeInPixels(el, style.get('fontSize')) + 'px', font.baseSize));

		var wrapper, canvas;

		if (redraw) {
			wrapper = node;
			canvas = node.firstChild;
		}
		else {
			wrapper = document.createElement('cufon');
			wrapper.className = 'cufon cufon-vml';
			wrapper.alt = text;

			canvas = document.createElement('cufoncanvas');
			wrapper.appendChild(canvas);

			if (options.printable) {
				var print = document.createElement('cufontext');
				print.appendChild(document.createTextNode(text));
				wrapper.appendChild(print);
			}

			// ie6, for some reason, has trouble rendering the last VML element in the document.
			// we can work around this by injecting a dummy element where needed.
			// @todo find a better solution
			if (!hasNext) wrapper.appendChild(document.createElement('cvml:shape'));
		}

		var wStyle = wrapper.style;
		var cStyle = canvas.style;

		var height = size.convert(viewBox.height), roundedHeight = Math.ceil(height);
		var roundingFactor = roundedHeight / height;
		var stretchFactor = roundingFactor * Cufon.CSS.fontStretch(style.get('fontStretch'));
		var minX = viewBox.minX, minY = viewBox.minY;

		cStyle.height = roundedHeight;
		cStyle.top = Math.round(size.convert(minY - font.ascent));
		cStyle.left = Math.round(size.convert(minX));

		wStyle.height = size.convert(font.height) + 'px';

		var color = style.get('color');
		var chars = Cufon.CSS.textTransform(text, style).split('');

		var jumps = font.spacing(chars,
			getSpacingValue(el, style, size, 'letterSpacing'),
			getSpacingValue(el, style, size, 'wordSpacing')
		);

		if (!jumps.length) return null;

		var width = jumps.total;
		var fullWidth = -minX + width + (viewBox.width - jumps[jumps.length - 1]);

		var shapeWidth = size.convert(fullWidth * stretchFactor), roundedShapeWidth = Math.round(shapeWidth);

		var coordSize = fullWidth + ',' + viewBox.height, coordOrigin;
		var stretch = 'r' + coordSize + 'ns';

		var fill = options.textGradient && gradientFill(options.textGradient);

		var glyphs = font.glyphs, offsetX = 0;
		var shadows = options.textShadow;
		var i = -1, j = 0, chr;

		while (chr = chars[++i]) {

			var glyph = glyphs[chars[i]] || font.missingGlyph, shape;
			if (!glyph) continue;

			if (redraw) {
				// some glyphs may be missing so we can't use i
				shape = canvas.childNodes[j];
				while (shape.firstChild) shape.removeChild(shape.firstChild); // shadow, fill
			}
			else {
				shape = document.createElement('cvml:shape');
				canvas.appendChild(shape);
			}

			shape.stroked = 'f';
			shape.coordsize = coordSize;
			shape.coordorigin = coordOrigin = (minX - offsetX) + ',' + minY;
			shape.path = (glyph.d ? 'm' + glyph.d + 'xe' : '') + 'm' + coordOrigin + stretch;
			shape.fillcolor = color;

			if (fill) shape.appendChild(fill.cloneNode(false));

			// it's important to not set top/left or IE8 will grind to a halt
			var sStyle = shape.style;
			sStyle.width = roundedShapeWidth;
			sStyle.height = roundedHeight;

			if (shadows) {
				// due to the limitations of the VML shadow element there
				// can only be two visible shadows. opacity is shared
				// for all shadows.
				var shadow1 = shadows[0], shadow2 = shadows[1];
				var color1 = Cufon.CSS.color(shadow1.color), color2;
				var shadow = document.createElement('cvml:shadow');
				shadow.on = 't';
				shadow.color = color1.color;
				shadow.offset = shadow1.offX + ',' + shadow1.offY;
				if (shadow2) {
					color2 = Cufon.CSS.color(shadow2.color);
					shadow.type = 'double';
					shadow.color2 = color2.color;
					shadow.offset2 = shadow2.offX + ',' + shadow2.offY;
				}
				shadow.opacity = color1.opacity || (color2 && color2.opacity) || 1;
				shape.appendChild(shadow);
			}

			offsetX += jumps[j++];
		}

		// addresses flickering issues on :hover

		var cover = shape.nextSibling, coverFill, vStyle;

		if (options.forceHitArea) {

			if (!cover) {
				cover = document.createElement('cvml:rect');
				cover.stroked = 'f';
				cover.className = 'cufon-vml-cover';
				coverFill = document.createElement('cvml:fill');
				coverFill.opacity = 0;
				cover.appendChild(coverFill);
				canvas.appendChild(cover);
			}

			vStyle = cover.style;

			vStyle.width = roundedShapeWidth;
			vStyle.height = roundedHeight;

		}
		else if (cover) canvas.removeChild(cover);

		wStyle.width = Math.max(Math.ceil(size.convert(width * stretchFactor)), 0);

		if (HAS_BROKEN_LINEHEIGHT) {

			var yAdjust = style.computedYAdjust;

			if (yAdjust === undefined) {
				var lineHeight = style.get('lineHeight');
				if (lineHeight == 'normal') lineHeight = '1em';
				else if (!isNaN(lineHeight)) lineHeight += 'em'; // no unit
				style.computedYAdjust = yAdjust = 0.5 * (getSizeInPixels(el, lineHeight) - parseFloat(wStyle.height));
			}

			if (yAdjust) {
				wStyle.marginTop = Math.ceil(yAdjust) + 'px';
				wStyle.marginBottom = yAdjust + 'px';
			}

		}

		return wrapper;

	};

})());

/* /_ui/js/classes/flyoutnav.js */
/**
 * @author pop webdev [cn]
 * @version: 0.4.
 * @classDescription: Handles flyout / meganav
 * @dependencies: Prototype v1.6.1
 */
// start FlyoutNav
var FlyoutNav = Class.create ({
    initialize: function(links, flyouts, options)
    {
        this.links = links;
			this.length = this.links.size();
        this.flyouts = flyouts;
		this.options = Object.extend({
			activeClassName: 'active',
			flyoutClassName: 'flyout'
		}, options || {});

        this.flyouts.invoke('hide'); // display block via CSS then hide via JS
        this.outTimeout;
        this.overTimeout;

        var boundLinkOver = this.__LinkOver.bindAsEventListener(this);
        var boundLinkOut = this.__LinkOut.bindAsEventListener(this);
        var boundFlyoutOver = this.__FlyoutOver.bindAsEventListener(this);
        var boundFlyoutOut = this.__FlyoutOut.bindAsEventListener(this);
        this.links.invoke('observe', 'mouseover', boundLinkOver).invoke('observe', 'mouseout', boundLinkOut);
        this.flyouts.invoke('observe', 'mouseover', boundFlyoutOver).invoke('observe', 'mouseout', boundFlyoutOut);
    },
    __LinkOver: function(e)
    {
        var el = e.element();
        for (var i=0; i<this.length; i++)
        {
	        if (this.links[i] == el)
	        {
				clearTimeout(this.outTimeout);
				if (this.flyouts[i].status != 'down')
				{
					this.overTimeout = setTimeout(function()
					{
						this.ShowFlyoutnav(i);
					}.bind(this), 100);
					break;
				}
	        }
        }
    },
    __LinkOut: function(e)
    {
        var el = e.element();
        for (var i=0; i<this.length; i++)
        {
	        if ( (this.links[i] == el) )
	        {
				clearTimeout(this.overTimeout);
				this.outTimeout = setTimeout(function()
				{
					this.HideFlyoutnav(i);
				}.bind(this), 20);
				break;
	        }
        }
    },
    __FlyoutOver: function(e)
    {
        var el = e.findElement('div.'+this.options.flyoutClassName);
        for (var i=0; i<this.length; i++)
        {
	        if (this.flyouts[i] == el)
	        {
				if (this.flyouts[i].status == 'down')
				{
					clearTimeout(this.outTimeout);
					break;
				}
	        }
        }
    },
    __FlyoutOut: function(e)
    {
        var el = e.findElement('div.'+this.options.flyoutClassName);
        for (var i=0; i<this.length; i++)
        {
	        if ( (this.flyouts[i] == el) && (this.flyouts[i].status == 'down') )
	        {
				clearTimeout(this.overTimeout);
				this.outTimeout = setTimeout(function()
				{
					this.HideFlyoutnav(i);
				}.bind(this), 20);
				break;
	        }
        }
    },
    ShowFlyoutnav: function(index)
    {
        for (var i=0; i<this.length; i++)
        {
	        if (i == index)
	        {
				this.flyouts[index].blindDown({
					fps: 100,
					duration: 0.2,
					beforeStart: function() {
						this.links[index].up().addClassName(this.options.activeClassName);
					}.bind(this)
				});
				this.flyouts[index].status = 'down';
			} else {
				if (this.flyouts[i].status == 'down')
				{
					this.HideFlyoutnav(i);
				}
			}
        }
    },
    HideFlyoutnav: function(index)
    {
        for (var i=0; i<this.length; i++)
        {
	        if (i == index)
	        {
				this.flyouts[index].blindUp({
					fps: 100,
					duration: 0.2,
					afterFinish: function() {
						this.links[index].up().removeClassName(this.options.activeClassName);
					}.bind(this)
				});
				this.flyouts[index].status = 'up';
	        }
        }
    }
});
// end FlyoutNav

/* /_ui/js/classes/paginator.js */
/**
 * @author pop webdev [cn]
 * @version: 0.5.
 * @classDescription: Handles Pagination of an inline collection. The collection should be in the form of a <ul>, <ol>, <div>, or <table>.
 * @dependencies: Prototype v1.6.1.
 */
// start Paginator
var Paginator = Class.create({
	initialize: function(pagilist, options)
	{
        this.pagiList   = pagilist;
		this.pagiItems  = this.pagiList.childElements();
		this.itemCount  = this.pagiItems.size();
		// set options
		this.options = Object.extend(
		{
			initialPageIndex: 0,
			itemsPerPage: 10,
			disabledClassName: 'disabled',
			selectedClassName: 'selected',
			viewAll: true, //boolean not implemented yet, for now just hide via css if undesired
			isTable: false //set to true if using a table instead of a list
		}, options || {});
		// init current page
		this.currentPageIndex = this.options.initialPageIndex;

		this.pages = this.pagiItems.eachSlice(this.options.itemsPerPage);
		this.pageCount = this.pages.size();
		if (this.pageCount == 1) {return;} // only one page, no pagination needed

		// add class 'first-row' to first tr tag per page
		if (this.options.isTable)
		{
            for (var i=0; i<this.pageCount; i++)
            {
	            this.pages[i].first().addClassName('first-row');
            }
		}

		// add div.paginav controls
		this.paginavTop		= $('upperpaginav') ? $('upperpaginav') : new Element('div', {id: 'upperpaginav', 'class': 'pagi-nav'});
		this.paginavBottom	= $('lowerpaginav') ? $('lowerpaginav') : new Element('div', {id: 'lowerpaginav', 'class': 'pagi-nav'});

		this._addControlList(this.paginavTop);
		this._addControlList(this.paginavBottom);

		if (this.options.isTable)
		{
			this.pagiList.up('table').insert({before: this.paginavTop});
			this.pagiList.up('table').insert({after: this.paginavBottom});
		} else {
			this.pagiList.insert({before: this.paginavTop});
			this.pagiList.insert({after: this.paginavBottom});
		}

		this.viewPage(this.currentPageIndex);
		this.viewallStatus = false;
	},

	// creates a ul filled with pagination links, attaches an event listener, and appends the node to supplied element.
	_addControlList: function(elDiv){
		var elViewAll = new Element('p', {'class': 'viewall'});
			var elViewAllLink = new Element('a', {'href': '#viewall'}).update('View All');
		elViewAll.insert(elViewAllLink);

		// add event handler
		elViewAllLink.observe('click', this.__ViewAllClick.bindAsEventListener(this));
		// add new nodes to li
		elDiv.insert(elViewAll);

		var elControlList = new Element('ul');

			var elPrevNavItem = new Element('li', {'class': 'prev'});
				var elPrevNavLink = new Element('a', {'href': '#prev', 'title': 'Previous', 'class': 'lnk-prev'}).update('<span class="offscreen">Previous</span>');
				elPrevNavItem.insert(elPrevNavLink);
			elControlList.insert(elPrevNavItem);

			for (var i=0; i < this.pageCount; i++)
			{
				var pageNum = i+1;
				var elPageItem = new Element('li', {'class': 'page'});
					if (i == 0) {elPageItem.addClassName('first');}
					var elPageLink = new Element('a', {'href': '#page_' + pageNum, 'title': 'go to page ' + (pageNum)}).update(pageNum);
					elPageItem.insert(elPageLink);
				elControlList.insert(elPageItem);
			}

			var elNextNavItem = new Element('li', {'class': 'next'});
				var elNextNavLink = new Element('a', {'href': '#next', 'title': 'Next', 'class': 'lnk-next'}).update('<span class="offscreen">Next</span>');
				elNextNavItem.insert(elNextNavLink);
			elControlList.insert(elNextNavItem);

		// add event handler
		elControlList.observe('click', this.__paginavListClick.bindAsEventListener(this));
		// add new nodes to li
		elDiv.insert(elControlList);
	},

	// calls updatePaginav on both top and bottom nav
	updatePaginavs: function()
	{
		this.updatePaginav(this.paginavTop);
		this.updatePaginav(this.paginavBottom);
	},

	// sets disabled and selected classes
	updatePaginav: function(elPaginav)
	{
		// adjust next/previous
		var elPrevNavItem = elPaginav.down('li.prev');
		(this.currentPageIndex > 0) ? elPrevNavItem.removeClassName(this.options.disabledClassName) : elPrevNavItem.addClassName(this.options.disabledClassName);

		var elNextNavItem = elPaginav.down('li.next');
		(this.currentPageIndex < (this.pageCount-1)) ? elNextNavItem.removeClassName(this.options.disabledClassName) : elNextNavItem.addClassName(this.options.disabledClassName);

		var elNavItems = elPaginav.select('li.page');
		//var elNavItems = elPaginav.childElements();
		var len = elNavItems.size();
		for (var i = 0; i < len; i++)
		{
			(i == this.currentPageIndex) ? elNavItems[i].addClassName(this.options.selectedClassName) : elNavItems[i].removeClassName(this.options.selectedClassName);
		}

		var elViewAll = elPaginav.down('p.viewall');
		if (this.viewallStatus == true) {elViewAll.hide();}
		else {elViewAll.show();}
	},

	__ViewAllClick: function(e)
	{
		var el = e.element();
		e.stop();
		this.viewAll();
	},

	__paginavListClick: function(e)
	{
		var el = e.element();
		var elLi, elLnk;
		if (el.nodeName == 'UL') {return;}
		e.stop();

		if (el.nodeName != 'LI') {elLi = $(el).up('li');}
		else {elLi = $(el);}
		elLnk = elLi.down('a');

		var dest = elLnk.hash.replace('#', '');
		switch(dest){
			case 'prev':
				this.viewPreviousPage();
				break;
			case 'next':
				this.viewNextPage();
				break;
			default:
				var pageIndex = /\d+$/.exec(dest)[0];
				this.viewPage((parseInt(pageIndex))-1);
				break;
		}
	},

	viewAll: function()
	{
		this.currentPageIndex = -1;
		this.pagiItems.invoke('show');
		this.viewallStatus = true;
		this.updatePaginavs();
		//$('top').scrollTo();
	},

	viewNextPage: function()
	{
		if (this.currentPageIndex < (this.pageCount-1))
		{
			this.viewPage(this.currentPageIndex + 1);
		}
	},
	viewPreviousPage: function()
	{
		if (this.currentPageIndex > 0)
		{
			this.viewPage(this.currentPageIndex - 1);
		}
	},
	viewPage: function(pageIndex)
	{
	    this.currentPageIndex = pageIndex;
	    this.pagiItems.invoke('hide');
	    this.pages[this.currentPageIndex].invoke('show');
	    //this.pages[this.currentPageIndex].invoke('appear');
	    this.viewallStatus = false;
		this.updatePaginavs();
		//$('top').scrollTo();
	}
});
// end Paginator

/* /_ui/js/classes/modal-window.js */

// start ModalInterstitial
var ModalInterstitial = Class.create ({
    initialize: function(links,options)
    {
		this.elBody = $(document.body);
		this.links = links;
			this.length = this.links.size();
		this.options = Object.extend({
			leftOffset: 0,
			topOffset: 0,
			minTopSpacing: 10
		}, options || {});
		this.lnkCancel = $('btn_cancel_interstitial');
		this.lnkProceed = $('btn_proceed_interstitial');
		this.modalOverlay = $('modaloverlay');
			if (!isIE6) {this.modalOverlay.setOpacity(0.0);}
		this.modalInterstitial = $('modalinterstitial');
			this.width = this.modalInterstitial.getWidth();
			this.height = this.modalInterstitial.getHeight();
			//this.modalInterstitial.remove();
			//this.modalOverlay.insert({after: this.modalInterstitial});
		this.leftPos = ( ( ( document.viewport.getWidth() - this.width ) / 2 ) + this.options.leftOffset ) + 'px';
		this.topPos = ( ( ( document.viewport.getHeight() - this.height ) / 2 ) + this.options.topOffset );
			if (this.topPos <= this.options.minTopSpacing) {this.topPos = this.options.minTopSpacing;} // make sure there is always min spacing at top
			this.topPos = this.topPos + 'px';
			this.modalInterstitial.setStyle({left: this.leftPos, top: this.topPos});
        var bindClickOpen = this.__ClickOpen.bindAsEventListener(this);
        var bindClickClose = this.__ClickClose.bindAsEventListener(this);
        var bindClickContinue = this.__ClickContinue.bindAsEventListener(this);
        this.links.invoke('observe', 'click', bindClickOpen);
        this.modalOverlay.observe('click', bindClickClose);
        this.lnkCancel.observe('click', bindClickClose);
        this.lnkProceed.observe('click', bindClickContinue);
        this.active = false;
    },
    __ClickOpen: function(e)
    {
        e.stop();
        var element = e.findElement('a');
        this.active = true;
		this.links.each(function(el, i)
		{
			if (el == element)
			{
				this.OpenPopover(i);
				throw $break;
			}
		}, this);
    },
    __ClickClose: function(e)
    {
        e.stop();
        if (this.active)
        {
			this.active = false;
			this.ClosePopover();
		}
    },
    __ClickContinue: function(e)
    {
        this.active = false;
        this.ClosePopover();
    },
    OpenPopover: function(i)
    {
        this.lnkProceed.setAttribute('href', this.links[i].href);
		if (isIE6) {
			this.modalOverlay.addClassName('active').setStyle({height: document.body.getHeight()});
			var arrPageScrollOffsets = document.viewport.getScrollOffsets(); //returns array [horiz,vert]
			this.topPos = ((document.viewport.getHeight() - this.height) / 2 ) + arrPageScrollOffsets[1]; // ( (viewport height - player height) / 2 ) + vert offset
			this.topPos = this.topPos + 'px';
			this.modalInterstitial.setStyle({top: this.topPos}).addClassName('active');
			this.elBody.addClassName('modal-overlay-active');
		} else {
			this.modalOverlay.addClassName('active').appear({
				duration: 0.3, from: 0.0, to: 0.8,
				afterFinish: function() {
					this.modalInterstitial.addClassName('active');
					this.elBody.addClassName('modal-overlay-active');
				}.bind(this)
			});
		}
    },
    ClosePopover: function()
    {
		if (isIE6) {
			this.modalOverlay.removeClassName('active');
		} else {
			this.modalOverlay.removeClassName('active').setOpacity(0.0);
		}
        this.modalInterstitial.removeClassName('active');
        this.elBody.removeClassName('modal-overlay-active');
    }
});
// end ModalInterstitial


// start ModalLogin
var ModalLogin = Class.create ({
    initialize: function(links,options)
    {
		this.elBody = $(document.body);
		this.links = links;
			this.length = this.links.size();
		this.options = Object.extend({
			leftOffset: 0,
			topOffset: 0,
			minTopSpacing: 10
		}, options || {});
		this.lnkClose = $('lnk_close_login');
		this.modalOverlay = $('modaloverlay');
			if (!isIE6) {this.modalOverlay.setOpacity(0.0);}
		this.modalLogin = $('modallogin');
			this.width = this.modalLogin.getWidth();
			this.height = this.modalLogin.getHeight();
			//this.modalLogin.remove();
			//this.modalOverlay.insert({after: this.modalLogin});
		this.leftPos = ( ( ( document.viewport.getWidth() - this.width ) / 2 ) + this.options.leftOffset ) + 'px';
		this.topPos = ( ( ( document.viewport.getHeight() - this.height ) / 2 ) + this.options.topOffset );
			if (this.topPos <= this.options.minTopSpacing) {this.topPos = this.options.minTopSpacing;} // make sure there is always min spacing at top
			this.topPos = this.topPos + 'px';
			this.modalLogin.setStyle({left: this.leftPos, top: this.topPos});
        var bindClickOpen = this.__ClickOpen.bindAsEventListener(this);
        var bindClickClose = this.__ClickClose.bindAsEventListener(this);
        this.links.invoke('observe', 'click', bindClickOpen);
        this.modalOverlay.observe('click', bindClickClose);
        this.lnkClose.observe('click', bindClickClose);
        this.active = false;
    },
    __ClickOpen: function(e)
    {
		e.stop();
		var element = e.findElement('a');
		this.active = true;
		this.links.each(function(el, i)
		{
			if (el == element)
			{
				this.OpenPopover(i);
				throw $break;
			}
		}, this);
    },
    __ClickClose: function(e)
    {
		e.stop();
		if (this.active)
		{
			this.active = false;
			this.ClosePopover();
		}
    },
    OpenPopover: function()
    {
		if (isIE6) {
			this.modalOverlay.addClassName('active').setStyle({height: document.body.getHeight()});
			var arrPageScrollOffsets = document.viewport.getScrollOffsets(); //returns array [horiz,vert]
			this.topPos = ((document.viewport.getHeight() - this.height) / 2 ) + arrPageScrollOffsets[1]; // ( (viewport height - player height) / 2 ) + vert offset
			this.topPos = this.topPos + 'px';
			this.modalLogin.setStyle({top: this.topPos}).addClassName('active');
			this.elBody.addClassName('modal-overlay-active');
		} else {
			this.modalOverlay.addClassName('active').appear({
				duration: 0.3, from: 0.0, to: 0.8,
				afterFinish: function() {
					this.modalLogin.addClassName('active');
					this.elBody.addClassName('modal-overlay-active');
				}.bind(this)
			});
		}
    },
    ClosePopover: function()
    {
		if (isIE6) {
			this.modalOverlay.removeClassName('active');
		} else {
			this.modalOverlay.removeClassName('active').setOpacity(0.0);
		}
		this.modalLogin.removeClassName('active');
		this.elBody.removeClassName('modal-overlay-active');
    }
});
// end ModalLogin


// start ModalVideoPlayer
var ModalVideoPlayer = Class.create ({
    initialize: function(links,options)
    {
		this.elBody = $(document.body);
		this.links = links;
			this.length = this.links.size();
		this.options = Object.extend({
			leftOffset: 0,
			topOffset: 0,
			minTopSpacing: 10
		}, options || {});
		this.lnkCloseX = $('lnk_closeX');
		this.modalOverlay = $('modaloverlay');
			this.modalOverlay.setOpacity(0.0);
		this.modalVideoPlayer = $('modalvideoplayer');
			//this.modalVideoPlayer.remove();
			//this.modalOverlay.insert({after: this.modalVideoPlayer});
		this.leftPos = (((this.elBody.getWidth() - this.modalVideoPlayer.getWidth()) / 2) + this.options.leftOffset) + 'px';
		this.topPos = (((this.elBody.getHeight() - this.modalVideoPlayer.getHeight()) / 2) + this.options.topOffset);
			if (this.topPos <= this.options.minTopSpacing) {this.topPos = this.options.minTopSpacing;} // make sure there is always min spacing at top
			this.topPos = this.topPos + 'px';
			this.modalVideoPlayer.setStyle({left: this.leftPos, top: this.topPos});
        var bindClickOpen = this.__ClickOpen.bindAsEventListener(this);
        var bindClickClose = this.__ClickClose.bindAsEventListener(this);
        this.links.invoke('observe', 'click', bindClickOpen);
        this.modalOverlay.observe('click', bindClickClose);
        this.lnkCloseX.observe('click', bindClickClose);
    },
    __ClickOpen: function(e)
    {
		e.stop();
		var element = e.findElement('a');
		//hacky IE6 vertical positioning
		if (isIE6) {
			var arrPageScrollOffsets = document.viewport.getScrollOffsets(); //returns array [horiz,vert]
			this.topPos = arrPageScrollOffsets[1] + (document.viewport.getHeight() /2) - (this.modalVideoPlayer.getHeight() / 2)  + 'px'; //vert offset + (1/2 viewport height) - (1/2 window height)
			this.modalVideoPlayer.setStyle({top: this.topPos});
		}
		this.OpenPopover();
    },
    __ClickClose: function(e)
    {
		e.stop();
		this.ClosePopover();
    },
    OpenPopover: function()
    {
		this.modalOverlay.addClassName('active').appear({
			duration: 0.3, from: 0.0, to: 0.8,
			afterFinish: function() {
				this.modalVideoPlayer.addClassName('active');
			}.bind(this)
		});
    },
    ClosePopover: function()
    {
		this.modalOverlay.removeClassName('active').setOpacity(0.0);
		this.modalVideoPlayer.removeClassName('active');
    }
});
// end ModalVideoPlayer


/* /_ui/js/classes/dropdown-filter.js */

// start DropdownFilter
var DropdownFilter = Class.create({
	initialize: function(selectbox, items, options)
	{
		this.selectbox = selectbox;
			this.selOptions = this.selectbox.childElements();
				this.optsLength = this.selOptions.size();
			this.allVal = this.selOptions[0].value; // get 'all' value
			//this.selOptions[0].selected = 'selected'; // set first to selected on load: functionality moved to this.InitDropdown
		this.name = name;
		this.items = items;
			this.itemsLength = this.items.size();
		this.options = Object.extend({
			selectboxName: 'selectbox'
		}, options || {});
		this.currentVal = this.allVal;
		this.currentIndex = 0;
		this.winlocHash = window.location.hash.replace('#','') || false;
		if (this.winlocHash)
		{
			this.hashPair = $H(this.winlocHash.toQueryParams('&'));
			this.hash = this.hashPair.get(this.options.selectboxName) || false;
			if (this.hash)
			{
				for (var i=0; i<this.optsLength; i++)
				{
					if (this.selOptions[i].value == this.hash)
					{
						this.currentVal = this.hash;
						this.currentIndex = i;
						break;
					}
				}
			}
		}
		this.selectbox.observe('change', this.__Change.bindAsEventListener(this));
		this.ShowHide(this.currentVal); // set initial state
		this.UpdateHash(this.currentVal);
		this.InitDropdown(this.currentIndex);
	},
	__Change: function(e)
	{
		//e.stop();
		//var el = e.element();
		var val = $F(this.selectbox);
		this.ShowHide(val);
		this.UpdateHash(val);
		this.gaEventTracking(val);
	},
	InitDropdown: function(index)
	{
		this.selOptions[index].selected = 'selected'; // set selected on page load
	},
	ShowHide: function(val)
	{
		this.items.invoke('hide');
		if (val == this.allVal) {
			this.items.invoke('appear', {duration: 0.3});
		} else {
			this.items.each(function(item, i) {
				if (item.hasClassName(val)) { item.appear({ duration: 0.3 }); }
			}, this);
		}
	},
	UpdateHash: function(val)
	{
		window.location.hash = this.options.selectboxName + '=' + val;
	},
	gaEventTracking: function(val)
	{
		document.fire('DropdownFilterTracking:ready', {value: val});
	}
});
// end DropdownFilter


// start DualDropdownFilter
var DualDropdownFilter = Class.create({
	initialize: function(selectboxA, selectboxB, items, options)
	{
		this.selectboxA = selectboxA;
			this.selAOptions = this.selectboxA.childElements();
				this.optsALength = this.selAOptions.size();
			this.selAAllVal = this.selAOptions[0].value; // get 'all' value
			//this.selAOptions[0].selected = 'selected'; // set first to selected on page load: functionality moved to this.InitDropdown
		this.selectboxB = selectboxB;
			this.selBOptions = this.selectboxB.childElements();
				this.optsBLength = this.selBOptions.size();
			this.selBAllVal = this.selBOptions[0].value; // get 'all' value
			//this.selBOptions[0].selected = 'selected'; // set first to selected on page load: functionality moved to this.InitDropdown
		this.items = items;
			this.itemsLength = this.items.size();
		this.options = Object.extend({
			selectboxAName: 'selectboxA',
			selectboxBName: 'selectboxB'
		}, options || {});
		this.currentAVal = this.selAAllVal;
		this.currentBVal = this.selBAllVal;
		this.currentAIndex = 0;
		this.currentBIndex = 0;
		this.winlocHash = window.location.hash.replace('#','') || false;
		if (this.winlocHash)
		{
			this.hashPairs = $H(this.winlocHash.toQueryParams('&'));
			this.hashA = this.hashPairs.get(this.options.selectboxAName) || false;
			this.hashB = this.hashPairs.get(this.options.selectboxBName) || false;
			if (this.hashA)
			{
				for (var i=0; i<this.optsALength; i++)
				{
					if (this.selAOptions[i].value == this.hashA)
					{
						this.currentAVal = this.hashA;
						this.currentAIndex = i;
						break;
					}
				}
			}
			if (this.hashB)
			{
				for (var i=0; i<this.optsBLength; i++)
				{
					if (this.selBOptions[i].value == this.hashB)
					{
						this.currentBVal = this.hashB;
						this.currentBIndex = i;
						break;
					}
				}
			}
		}
		this.selectboxA.observe('change', this.__Change.bindAsEventListener(this));
		this.selectboxB.observe('change', this.__Change.bindAsEventListener(this));
		this.ShowHide(this.currentAVal, this.currentBVal); // set initial state
		this.UpdateHash(this.currentAVal, this.currentBVal);
		this.InitDropdown(this.currentAIndex, this.currentBIndex);
	},
	__Change: function(e)
	{
		//e.stop();
		//var el = e.element();
		var valA = $F(this.selectboxA);
		var valB = $F(this.selectboxB);
		this.ShowHide(valA, valB);
		this.UpdateHash(valA, valB);
		this.gaEventTracking(valA, valB);
	},
	InitDropdown: function(indexA, indexB)
	{
		this.selAOptions[indexA].selected = 'selected'; // set selected on page load
		this.selBOptions[indexB].selected = 'selected'; // set selected on page load
	},
	ShowHide: function(valA, valB)
	{
		this.items.invoke('hide');
		var active;

		if (valA == this.selAAllVal && valB == this.selBAllVal)
		{
			this.items.invoke('appear', {duration: 0.3});
		} else {

			if (valA == this.selAAllVal && valB != this.selBAllVal)
			{
				active = 'B';
			}
			else if (valA != this.selAAllVal && valB == this.selBAllVal)
			{
				active = 'A';
			}
			else
			{
				active = 'AB';
			}

			this.items.each(function(item, i)
			{

				switch (active) {
					case 'B':
						if (item.hasClassName(valB)) { item.appear({ duration: 0.3 }); }
						break;
					case 'A':
						if (item.hasClassName(valA)) { item.appear({ duration: 0.3 }); }
						break;
					default: // 'AB'
						if (item.hasClassName(valA) && item.hasClassName(valB)) { item.appear({ duration: 0.3 }); }
						break;
				}

			}, this);

		}

	},
	UpdateHash: function(valA, valB)
	{
		window.location.hash = this.options.selectboxAName + '=' + valA + '&' + this.options.selectboxBName + '=' + valB;
	},
	gaEventTracking: function(valA, valB)
	{
		document.fire('DualDropdownFilterTracking:ready', {valueA: valA, valueB: valB});
	}
});
// end DualDropdownFilter

/* /_ui/js/classes/label-input.js */
/**
 * @author pop webdev [cn]
 * @version: 0.1.
 * @classDescription: inserts label text into text input value
 * @dependencies: Prototype v1.6.1
 */
// start LabelInputText
var LabelInputText = Class.create({
	initialize: function(label,input)
	{
		this.label = label;
			this.labelText = this.label.innerHTML;
		this.input = input;
		this.input.addClassName('inactive');
		if (!this.input.value)
		{
			this.input.value = this.labelText;
		}

		this.input.observe('focus', function() {
			if (this.input.value == this.labelText)
				this.input.value = '';
				this.input.removeClassName('inactive');
		}.bind(this)).observe('blur', function() {
			if (!this.input.value)
				this.input.value = this.labelText;
				this.input.addClassName('inactive');
		}.bind(this));
	}
});
// end LabelInputText

/* /_ui/js/classes/searchbox.js */
/**
 * @author pop webdev [cn]
 * @version: 0.1.
 * @classDescription: insures search input is not empty
 * @dependencies: Prototype v1.6.1
 */
// start VerifySearchbox
var VerifySearchbox = Class.create({
	initialize: function(form,txtLabel,txtInput,submitBtn)
	{
		this.form = form;
		this.txtLabel = txtLabel;
		this.txtInput = txtInput;
		this.submitBtn = submitBtn;
		this.form.observe('keypress', this.__keyPress.bindAsEventListener(this));
		this.submitBtn.observe('click', this.__click.bindAsEventListener(this));
	},
	__keyPress: function(e)
	{
		if ((e.keyCode == Event.KEY_RETURN))
		{
			e.stop();
			var txtInputVal = $F(this.txtInput);
			if (!txtInputVal == '') {
				this.submitBtn.click();
			}
		}
	},
	__click: function(e)
	{
		var txtInputVal = $F(this.txtInput);
		if ((txtInputVal == '') || (txtInputVal == this.txtLabel.innerHTML))
		{
			e.stop();
		}
	}
});
// end VerifySearchbox

/* /_ui/js/classes/fancy-forms.js */
	
var FancyForms = {
	initialize: function() {
		
		this.selects = $$("select");
		this.checkboxesAndRadios = $$("input[type='checkbox'], input[type='radio']");
		this.checkboxRadioSpans = [];
		
		// insert spans for each select list
		this.selects.each(function(currentSelect){
			var options = currentSelect.select("option");
			var selectedText = options.find(function(currentOption){
				return currentOption.selected;
			}).childNodes[0].nodeValue;
			var wrapperSpan = new Element("span", {"class": "select-wrapper"});
			var replacementSpan = new Element("span", {"class": "select "+currentSelect.className}).update(selectedText);
			wrapperSpan.insert({top: replacementSpan});
			currentSelect.insert({before: wrapperSpan});
			currentSelect.addClassName("styled");
		});
		
		// insert spans for each radio button and checkbox
		this.checkboxesAndRadios.each(function(currentEl){
			var replacementSpan = new Element("span",{"class": currentEl.type + " " + currentEl.type + (currentEl.checked ? "_checked" : "_unchecked")});
			currentEl.insert({before: replacementSpan});
			this.checkboxRadioSpans.push(replacementSpan);
			currentEl.addClassName("styled");
		}.bind(this));
		
		this.registerEventHandlers();
	},
	registerEventHandlers: function(){
		this.selects.invoke("observe", "change", this.__selectChange.bindAsEventListener(this));
		this.selects.invoke("observe", "keydown", this.__keyboardSelect.bindAsEventListener(this));
		this.checkboxRadioSpans.invoke("observe", "mousedown", this.__push.bindAsEventListener(this));
		this.checkboxRadioSpans.invoke("observe", "mouseup", this.__check.bindAsEventListener(this));
		
		if(isIE){
			/* IE doesn't fire "change" for checkboxes or radio buttons so you need to 
			   observe focus and the spacebar keyup event to fake it. */
			this.checkboxesAndRadios.invoke("observe", "focus", this.__setToCurrentState.bindAsEventListener(this));
			this.checkboxesAndRadios.invoke("observe", "keyup", function(e){
				if (e.keyCode == 32){
					this.__setToCurrentState.bind(this).defer();
				}
			}.bind(this));			
		} else {
			this.checkboxesAndRadios.invoke("observe", "change", this.__setToCurrentState.bindAsEventListener(this));
		}
	},
	__push: function(e) {
		var span = e.element();
		var input = span.next("input");
		span.className = input.type + " " + input.type + (input.checked ? "_checked_pushed" : "_unchecked_pushed");
		
		// in case you mousedown on a checkbox/radiobutton, move your mouse away, and let go
		document.observe("mouseup", function(e){
			span.className = input.type + " " + input.type + (input.checked ? "_checked" : "_unchecked");
		});		
		
	},
	__check: function(e) {
		var span = e.element();
		var input = span.next("input");
		if(input.checked){
			span.className = input.type + " " + input.type + "_unchecked";
			input.checked = false;
		} else {
			span.className = input.type + " " + input.type + "_checked";
			input.checked = true;
		}
		
		/* uncheck all other radio buttons in the same group and
		   make sure you cannot uncheck an already checked radio button */
		if(input.type == "radio"){
			var groupRadios = $$("input[name='"+input.name+"']").without(input);
			groupRadios.each(function(currentRadio){
				currentRadio.previous("span").className = input.type + " " + input.type + "_unchecked";
				currentRadio.checked = false;
			});
			span.className = input.type + " " + input.type + "_checked";
			input.checked = true;
			input.fire('radio:checked');
		} else if (input.type == "checkbox"){
			input.fire('checkbox:checked');
		}
	},
	__setToCurrentState: function(e) {
		var input = e.findElement();

		if (input.type == "radio"){
			input.fire('radio:checked');
		} else if (input.type == "checkbox"){
			input.fire('checkbox:checked');
		}

		this.checkboxesAndRadios.each(function(currentEl){
			if (currentEl.checked) {
				currentEl.previous("span").className = currentEl.type + " " + currentEl.type + "_checked";
			} else {
				currentEl.previous("span").className = currentEl.type + " " + currentEl.type + "_unchecked";			
			}
		});
	},
	__keyboardSelect: function(e){
		var select = e.element();
		var span = select.previous("span").down("span");
		var options = select.select("option");
		var currentOption = options.find(function(currentOption){
			return currentOption.selected;
		});
		if((e.keyCode == Event.KEY_DOWN || e.keyCode == Event.KEY_RIGHT) && currentOption.next("option")){
			span.update(currentOption.next("option").childNodes[0].nodeValue);
		} else if ((e.keyCode == Event.KEY_UP || e.keyCode == Event.KEY_LEFT) && currentOption.previous("option")){
			span.update(currentOption.previous("option").childNodes[0].nodeValue);
		} else if (e.keyCode == Event.KEY_PAGEDOWN || e.keyCode == Event.KEY_END){
			span.update(options[options.length-1].childNodes[0].nodeValue)	;
		} else if (e.keyCode == Event.KEY_PAGEUP || e.keyCode == Event.KEY_HOME){
			span.update(options[0].childNodes[0].nodeValue);
		}
	},
	__selectChange: function(e) {
		var select = e.element();
		var span = select.previous("span").down("span");
		var options = select.select("option");	
		var value = options.find(function(currentOption){
			return currentOption.selected;
		}).childNodes[0].nodeValue;
		span.update(value);
	}
}
/*
document.observe("dom:loaded", function(){
	if (!isIE6) {FancyForms.initialize();}
});
*/
/* /_ui/js/FoundryFormSansBook.js */
/*!
 * The following copyright notice may not be removed under any circumstances.
 * 
 * Copyright:
 * Copyright � The digitally encoded machine readable outline data for producing
 * the typefaces licensed to you is copyrighted �, 2008 by The Foundry, London. All
 * rights reserved.
 * 
 * Trademark:
 * Please refer to the Copyright section for the font trademark attribution
 * notices.
 * 
 * Description:
 * Copyright � 2008 by The Foundry. All rights reserved.
 * 
 * Manufacturer:
 * The Foundry
 * 
 * Designer:
 * David Quay & Freda Sack
 * 
 * Vendor URL:
 * www.foundrytypes.co.uk
 */
Cufon.registerFont({"w":190,"face":{"font-family":"FoundryFormSansBook","font-weight":400,"font-stretch":"normal","units-per-em":"360","panose-1":"2 0 5 0 5 0 0 2 0 4","ascent":"270","descent":"-90","x-height":"3","bbox":"-52 -333 437 76","underline-thickness":"18","underline-position":"-18","stemh":"7","stemv":"29","unicode-range":"U+0020-U+FB04"},"glyphs":{" ":{"w":90,"k":{"\u00c1":9,"\u00c2":9,"\u00c3":9,"\u00c0":9,"\u00c5":9,"\u00c4":9,"Z":6,"Y":11,"X":11,"W":11,"V":11,"T":22,"A":9}},"\u00d0":{"d":"87,-240v92,-2,121,40,121,120v0,82,-31,125,-129,120r-49,0r0,-115r-34,0r0,-22r34,0r0,-103r57,0xm59,-22v90,5,118,-20,118,-98v0,-80,-29,-105,-118,-99r0,82r57,0r0,22r-57,0r0,93","w":227,"k":{"\uf7e5":9,"\uf7e4":9,"\uf7e3":9,"\uf7e2":9,"\uf7e0":9,"\uf7e1":9,"\uf761":9,"\u00c1":9,"\u00c2":9,"\u0178":13,"\u00c3":9,"\u00c0":9,"\u2026":11,"\u00c6":17,"\u00c5":9,"\u00c4":9,"Y":13,"W":6,"V":6,"T":15,"J":17,"A":9,".":11,",":11,"\u00dd":13}},"\u00f0":{"d":"60,-205r33,-11v-15,-12,-38,-20,-64,-24r3,-18v38,4,65,14,86,33r38,-13r7,19r-30,11v53,54,37,212,-49,212v-43,0,-69,-33,-69,-88v-1,-79,58,-108,117,-69v-6,-23,-12,-34,-23,-47r-41,14xm88,-18v45,-1,52,-67,46,-115v-47,-24,-90,-19,-90,51v0,42,16,64,44,64","w":178},"\u0141":{"d":"166,0r-136,0r0,-111r-23,16r-10,-14r33,-23r0,-108r29,0r0,87r26,-18r10,15r-36,25r0,109r107,0r0,22","w":172,"k":{"\u0153":6,"\u00f5":6,"\u00f6":6,"\u00f4":6,"\u00f2":6,"\u00f3":6,"y":13,"o":6,"Y":43,"W":22,"V":30,"T":50,"Q":19,"O":19}},"\u0142":{"d":"89,-159r-36,25r0,134r-27,0r0,-116r-23,17r-10,-15r33,-23r0,-119r27,0r0,100r25,-18","w":78},"\u0160":{"d":"147,-295r-59,34r-58,-33r9,-15r50,20r49,-20xm93,-137v103,21,78,142,-14,139v-23,0,-41,-3,-68,-11r6,-22v49,15,114,15,114,-34v0,-18,-4,-27,-23,-35v-39,-18,-95,-21,-95,-76v0,-66,76,-77,136,-56r-5,21v-48,-12,-102,-17,-102,32v0,22,5,32,51,42","w":172,"k":{"\uf7ff":11,"\uf7fd":11,"\uf779":11,"\uf777":4,"\uf776":4,"\uf774":11,"\u0178":6,"\u00ff":4,"y":4,"v":4,"Y":6,"T":6,"S":6,"\u00dd":6,"\u0160":6}},"\u0161":{"d":"121,-224r-52,33r-53,-33r8,-15r45,19r44,-18xm122,-50v0,53,-62,63,-111,45r5,-19v34,9,77,8,78,-23v0,-14,-5,-21,-28,-28v-30,-9,-54,-19,-54,-49v-1,-49,56,-60,101,-41r-5,19v-31,-9,-69,-12,-69,19v0,39,83,18,83,77","w":133},"\u00dd":{"d":"145,-282r-87,21r-6,-16r83,-33xm193,-240r-80,135r0,105r-29,0r0,-105r-82,-135r33,0r66,111r64,-111r28,0","w":195,"k":{"\uf7e5":43,"\uf7fc":13,"\uf7fb":13,"\uf7f9":13,"\uf7fa":13,"\uf6fd":22,"\uf6fa":13,"\uf7eb":13,"\uf7ea":13,"\uf7e8":13,"\uf7e9":13,"\uf7e6":13,"\uf7e4":43,"\uf7e3":43,"\uf7e2":43,"\uf7e0":43,"\uf7e1":43,"\uf775":13,"\uf773":22,"\uf770":13,"\uf76f":28,"\uf769":13,"\uf765":13,"\uf761":43,"\u00d2":13,"\u00d4":13,"\u00d3":13,"\u00c1":32,"\u00c2":32,"\u0152":13,"\u00d5":13,"\u00c3":32,"\u00c0":32,"\u00e6":32,"\u00d8":13,"\u00e5":32,"\u00e3":32,"\u00e4":32,"\u00e2":32,"\u00e0":32,"\u00e1":32,"\u00d6":13,"\u00c7":13,"\u00c5":32,"\u00c4":32,"v":17,"u":22,"s":26,"p":24,"o":32,"e":32,"a":32,"S":6,"Q":13,"O":13,"J":43,"G":13,"C":13,"A":32,";":13,":":13,".":43}},"\u00fd":{"d":"157,-170r-75,197v-17,47,-30,52,-72,46r2,-18v38,13,43,-22,58,-57r-68,-168r30,0r52,134r47,-134r26,0xm121,-212r-78,20r-4,-16r73,-31","w":159},"\u00de":{"d":"59,-203v72,-4,129,3,127,69v-2,66,-48,79,-127,74r0,60r-29,0r0,-240r29,0r0,37xm59,-82v60,1,97,1,98,-50v1,-52,-42,-50,-98,-48r0,98","w":196},"\u00fe":{"d":"167,-85v0,81,-61,111,-114,70r0,87r-27,0r0,-328r27,0r0,101v60,-39,114,-17,114,70xm138,-83v0,-73,-30,-76,-85,-55r0,106v54,23,85,14,85,-51","w":182},"\u017d":{"d":"156,-295r-60,34r-57,-33r9,-15r49,20r49,-20xm181,0r-168,0r0,-19r131,-200r-126,0r0,-21r161,0r0,19r-131,199r133,0r0,22","w":193},"\u017e":{"d":"129,-224r-52,33r-53,-33r8,-15r45,19r43,-18xm136,0r-125,0r0,-14r90,-136r-88,0r0,-20r121,0r0,15r-90,136r92,0r0,19","w":146},"\u00bd":{"d":"241,-239r-173,252r-18,-12r173,-253xm89,-113r-22,0r0,-109r-34,2r-2,-16r58,-7r0,130xm284,0r-87,0v-3,-22,13,-25,23,-35v32,-31,37,-46,37,-56v2,-24,-37,-22,-55,-16r-4,-14v33,-11,82,-13,82,28v0,27,-20,44,-55,76r59,0r0,17","w":309},"\u00bc":{"d":"258,-239r-172,252r-18,-12r172,-253xm89,-113r-22,0r0,-109r-34,2r-2,-16r58,-7r0,130xm292,-30r-18,0r0,30r-22,0r0,-30r-63,0r0,-13r64,-84r21,0r0,80r18,0r0,17xm252,-47r0,-52r-39,52r39,0","w":309},"\u00b9":{"d":"89,-113r-22,0r0,-107r-34,3r-2,-16r58,-7r0,127","w":137},"\u00be":{"d":"253,-239r-173,252r-18,-12r173,-253xm43,-171v26,-1,49,3,44,19v-1,28,-32,25,-63,20r-3,16v46,9,91,7,91,-35v0,-15,-10,-25,-24,-29v32,-13,24,-62,-20,-62v-12,0,-23,3,-45,8r5,15v32,-6,50,-10,56,12v1,19,-18,22,-41,21r0,15xm292,-30r-18,0r0,30r-22,0r0,-30r-63,0r0,-13r64,-84r21,0r0,80r18,0r0,17xm252,-47r0,-52r-39,52r39,0","w":309},"\u00b3":{"d":"91,-152v2,-16,-21,-20,-48,-19r0,-15v23,1,47,-1,44,-21v-4,-22,-27,-18,-59,-12r-5,-15v41,-12,89,-14,89,25v0,13,-11,24,-22,29v14,4,26,14,26,29v0,42,-49,43,-95,35r3,-16v33,5,63,8,67,-20","w":137},"\u00b2":{"d":"114,-113r-91,0v-3,-23,15,-26,25,-36v31,-31,38,-45,38,-55v1,-24,-40,-22,-58,-16r-4,-14v33,-12,86,-14,86,28v0,27,-24,44,-59,76r63,0r0,17","w":137},"\u00a6":{"d":"56,-121r-22,0r0,-119r22,0r0,119xm56,44r-22,0r0,-120r22,0r0,120","w":90},"\u2212":{"d":"178,-91r-166,0r0,-22r166,0r0,22"},"\u00d7":{"d":"179,-30r-16,16r-68,-68r-68,68r-16,-16r68,-68r-68,-69r16,-16r68,69r68,-69r16,16r-68,69"},"!":{"d":"62,-240r-8,178r-18,0r-9,-178r35,0xm63,-15v0,10,-8,18,-18,18v-10,0,-18,-8,-18,-18v0,-10,8,-18,18,-18v10,0,18,8,18,18","w":90},"\"":{"d":"105,-168r-24,0r0,-72r24,0r0,72xm57,-168r-24,0r0,-72r24,0r0,72","w":137},"#":{"d":"174,-188r-3,20r-31,0r-6,48r32,0r-3,20r-31,0r-6,52r-22,0r7,-52r-39,0r-6,52r-22,0r6,-52r-33,0r2,-20r33,0r5,-48r-33,0r3,-20r33,0r6,-52r23,0r-7,52r39,0r6,-52r21,0r-6,52r32,0xm118,-168r-38,0r-5,48r38,0"},"$":{"d":"104,-137v48,12,67,24,67,68v0,37,-27,64,-67,68r0,47r-22,0r0,-46v-19,0,-50,-7,-70,-14r6,-20v22,6,46,11,64,11r0,-90v-87,-11,-82,-121,0,-127r0,-34r22,0r0,34v19,1,38,4,54,9r-4,20v-19,-4,-38,-7,-50,-8r0,82xm82,-143r0,-75v-22,3,-35,17,-35,38v0,20,10,31,35,37xm142,-67v0,-22,-9,-32,-38,-40r0,83v26,-5,38,-19,38,-43"},"%":{"d":"250,-239r-173,252r-18,-12r172,-253xm122,-177v0,42,-18,65,-53,65v-36,0,-54,-23,-54,-65v0,-40,19,-65,53,-65v35,0,54,25,54,65xm99,-177v0,-31,-8,-47,-30,-47v-22,0,-30,16,-30,47v0,31,8,47,30,47v22,0,30,-15,30,-47xm294,-64v0,42,-18,66,-53,66v-36,0,-54,-23,-54,-65v0,-40,19,-65,53,-65v35,0,54,24,54,64xm271,-64v0,-31,-8,-47,-30,-47v-22,0,-30,16,-30,47v0,31,8,47,30,47v22,0,30,-15,30,-47","w":309},"&":{"d":"219,-11r-9,16v-20,-7,-30,-14,-46,-29v-48,47,-151,37,-149,-40v0,-34,16,-54,56,-68v-22,-28,-28,-40,-28,-59v0,-32,25,-53,62,-53v36,0,56,18,56,50v0,31,-12,46,-53,64r60,71v10,-17,14,-30,17,-56r21,0v-1,25,-7,46,-23,72v14,17,22,24,36,32xm134,-193v0,-19,-11,-31,-31,-31v-51,0,-33,60,-7,80v29,-14,38,-26,38,-49xm150,-39v-24,-24,-45,-52,-68,-78v-57,18,-50,100,12,99v19,0,38,-7,56,-21","w":229},"'":{"d":"57,-168r-24,0r0,-72r24,0r0,72","w":90},"(":{"d":"110,-226v-58,16,-61,49,-61,128v0,83,16,114,63,126r-4,18v-63,-8,-89,-51,-89,-148v0,-86,16,-131,87,-142","w":119},")":{"d":"14,-244v72,11,86,56,86,142v0,97,-25,140,-88,148r-4,-18v47,-12,63,-43,63,-126v0,-82,-5,-113,-61,-128","w":119},"*":{"d":"148,-194r-41,17r26,37r-13,9r-29,-36r-27,36r-13,-9r24,-37r-43,-17r5,-16r44,15r2,-45r15,0r2,45r44,-15","w":180},"+":{"d":"178,-91r-71,0r0,72r-23,0r0,-72r-72,0r0,-22r72,0r0,-72r23,0r0,72r71,0r0,22"},",":{"d":"66,-31r-45,81r-17,-8r25,-73r37,0","w":90,"k":{"\u2019":22,"\u2018":22,"\u201d":22}},"-":{"d":"122,-91r-104,0r0,-22r104,0r0,22","w":140,"k":{"\uf7e5":13,"\uf6ff":19,"\uf7ff":28,"\uf7fd":28,"\uf7e4":13,"\uf7e3":13,"\uf7e2":13,"\uf7e0":13,"\uf7e1":13,"\uf77a":19,"\uf779":28,"\uf778":28,"\uf777":4,"\uf776":4,"\uf774":37,"\uf76a":22,"\uf761":13,"\u00c1":9,"\u00c2":9,"\u00c3":9,"\u00c0":9,"\u00c5":9,"\u00c4":9,"Z":17,"Y":41,"X":26,"W":19,"V":19,"T":41,"S":4,"J":22,"A":9}},".":{"d":"63,-15v0,10,-8,18,-18,18v-10,0,-18,-8,-18,-18v0,-10,8,-18,18,-18v10,0,18,8,18,18","w":90,"k":{"\uf7ff":35,"\uf7fd":35,"\uf779":35,"\uf777":9,"\uf776":26,"\uf774":35,"\u0178":43,"\u2019":22,"\u2018":22,"\u201d":22,"Y":43,"W":17,"V":32,"T":43,"\u00dd":43}},"\/":{"d":"177,-240r-145,290r-19,-10r145,-289","k":{"\u0133":-9,"\u0131":-9,"\u0153":11,"\u00f8":11,"\u00f5":11,"\u00f6":11,"\u00f4":11,"\u00f2":11,"\u00f3":11,"\u00f1":-9,"\u00ef":-9,"\u00ee":-9,"\u00ec":-9,"\u00ed":-9,"\u00eb":11,"\u00ea":11,"\u00e8":11,"\u00e9":11,"\u00e7":11,"r":-9,"q":11,"o":11,"n":-9,"m":-9,"i":-9,"g":11,"f":-9,"e":11,"d":9,"c":11}},"0":{"d":"177,-122v0,83,-27,125,-81,125v-54,0,-83,-44,-83,-126v0,-77,31,-121,82,-121v54,0,82,42,82,122xm147,-122v0,-68,-16,-99,-52,-99v-35,0,-51,32,-51,100v0,70,15,101,51,101v36,0,52,-30,52,-102"},"1":{"d":"114,0r-28,0r0,-219r-55,5r-3,-20r86,-13r0,247"},"2":{"d":"162,0r-144,0r0,-20r44,-43v58,-55,66,-74,66,-110v0,-58,-50,-51,-104,-38r-4,-20v66,-23,138,-23,138,58v0,47,-12,65,-107,150r111,0r0,23"},"3":{"d":"51,-135v59,-1,68,-5,74,-48v-3,-50,-49,-40,-100,-29r-5,-19v62,-21,133,-26,134,45v0,32,-17,54,-47,60v36,4,54,23,54,57v0,76,-74,81,-145,64r3,-20v55,11,112,14,112,-46v0,-37,-27,-44,-80,-43r0,-21"},"4":{"d":"179,-63r-27,0r0,63r-27,0r0,-63r-114,0r0,-19r100,-158r41,0r0,154r27,0r0,23xm125,-86r0,-133r-84,133r84,0"},"5":{"d":"165,-73v0,76,-74,89,-145,68r3,-20v49,10,112,15,112,-47v0,-55,-51,-56,-106,-47r0,-121r127,0r0,22r-99,0r0,75v62,-10,108,13,108,70"},"6":{"d":"172,-77v0,51,-27,81,-74,81v-51,0,-80,-41,-80,-118v0,-111,55,-151,147,-120r-5,20v-68,-17,-109,-7,-111,80v66,-25,123,-15,123,57xm143,-75v0,-56,-54,-50,-94,-38v0,66,15,95,52,95v28,0,42,-20,42,-57"},"7":{"d":"167,-220r-106,225r-25,-10r102,-213r-122,0r0,-22r151,0r0,20"},"8":{"d":"175,-70v0,46,-29,73,-80,73v-53,0,-80,-23,-80,-69v0,-32,13,-51,39,-59v-54,-26,-33,-129,42,-119v77,-11,94,96,37,116v30,10,42,26,42,58xm140,-181v0,-26,-17,-41,-45,-41v-48,0,-60,59,-23,77v5,3,14,5,36,10v22,-5,32,-21,32,-46xm147,-64v0,-43,-39,-43,-71,-53v-23,7,-33,24,-33,48v0,33,18,50,55,50v31,0,49,-17,49,-45"},"9":{"d":"172,-126v0,111,-55,152,-146,120r4,-20v68,18,109,6,111,-81v-65,26,-123,17,-123,-56v0,-51,28,-81,75,-81v51,0,79,41,79,118xm141,-127v0,-66,-15,-95,-52,-95v-28,0,-42,20,-42,57v0,56,54,50,94,38"},":":{"d":"63,-152v0,10,-8,18,-18,18v-10,0,-18,-8,-18,-18v0,-10,8,-18,18,-18v10,0,18,8,18,18xm63,-15v0,10,-8,18,-18,18v-10,0,-18,-8,-18,-18v0,-10,8,-18,18,-18v10,0,18,8,18,18","w":90},";":{"d":"63,-152v0,10,-8,18,-18,18v-10,0,-18,-8,-18,-18v0,-10,8,-18,18,-18v10,0,18,8,18,18xm63,-31r-45,81r-17,-8r25,-73r37,0","w":90},"<":{"d":"180,-37r-10,23r-160,-77r0,-22r160,-70r10,22r-138,59"},"=":{"d":"178,-121r-166,0r0,-22r166,0r0,22xm178,-61r-166,0r0,-21r166,0r0,21"},">":{"d":"180,-91r-160,77r-10,-23r138,-65r-138,-59r10,-22r160,70r0,22"},"?":{"d":"154,-184v0,39,-8,50,-60,76v-22,11,-22,15,-22,46r-18,0v0,0,-2,-24,-2,-36v9,-41,73,-35,73,-79v0,-57,-56,-45,-106,-34r-5,-18v53,-19,140,-31,140,45xm81,-15v0,10,-8,18,-18,18v-10,0,-18,-8,-18,-18v0,-10,8,-18,18,-18v10,0,18,8,18,18","w":173},"@":{"d":"175,-76v41,-6,59,-29,59,-69v0,-47,-35,-79,-89,-79v-61,0,-107,46,-107,106v0,92,104,133,179,78r8,12v0,0,-36,33,-86,33v-71,0,-123,-53,-123,-124v0,-71,56,-125,128,-125v66,0,111,40,111,99v0,55,-44,94,-105,88r3,-14v-40,23,-77,23,-77,-27v0,-68,44,-113,98,-78r2,-9r21,0xm170,-163v-47,-25,-71,24,-71,63v0,34,31,25,55,14","w":271},"A":{"d":"208,0r-30,0r-23,-64r-104,0r-23,64r-26,0r85,-240r33,0xm147,-86r-45,-129r-43,129r88,0","w":209,"k":{"\uf7ff":19,"\uf7fd":19,"\uf779":19,"\uf777":6,"\uf776":13,"\uf774":17,"\uf76a":-4,"\u00d9":4,"\u00db":4,"\u00da":4,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u0178":32,"\u00ff":9,"\u2019":37,"\u2018":43,"\u201d":37,"\u201c":43,"\u2014":9,"\u2013":9,"\u0152":9,"\u00d5":9,"\u00d8":9,"\u00dc":4,"\u00d6":9,"\u00c7":9,"y":9,"w":2,"v":9,"Y":32,"W":4,"V":19,"U":4,"T":28,"S":-4,"Q":9,"O":9,"J":-6,"G":9,"C":9,"-":9,"\u00dd":32,"\u0160":-4}},"B":{"d":"75,-240v72,-2,99,5,99,57v0,32,-15,50,-48,56v38,4,56,23,56,60v0,69,-73,70,-152,67r0,-240r45,0xm145,-180v0,-42,-37,-40,-86,-39r0,82v51,2,86,-4,86,-43xm59,-22v56,2,90,-2,92,-48v2,-48,-42,-46,-92,-45r0,93","w":199,"k":{"\uf7ff":11,"\uf7fd":11,"\uf779":11,"\u0178":9,"Y":9,"W":6,"V":6,"T":9,"\u00dd":9}},"C":{"d":"185,-13v-93,43,-165,9,-166,-107v-1,-110,69,-145,161,-113r-5,21v-78,-20,-125,-1,-125,89v0,100,47,119,129,89","w":191,"k":{"\uf7ff":17,"\uf7fd":17,"\uf7f6":9,"\uf7f5":9,"\uf7f4":9,"\uf7f2":9,"\uf7f3":9,"\uf779":17,"\uf76f":9,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u00ff":9,"\u0152":9,"\u00d5":9,"\u2026":-4,"\u00d8":9,"\u00d6":9,"\u00c7":9,"y":9,"Q":9,"O":9,"G":9,"C":9,".":-4,",":-4}},"D":{"d":"87,-240v92,-2,121,40,121,120v0,82,-31,125,-129,120r-49,0r0,-240r57,0xm59,-22v90,5,118,-20,118,-98v0,-80,-29,-105,-118,-99r0,197","w":227,"k":{"\uf7e5":9,"\uf7e4":9,"\uf7e3":9,"\uf7e2":9,"\uf7e0":9,"\uf7e1":9,"\uf761":9,"\u00c1":9,"\u00c2":9,"\u0178":13,"\u00c3":9,"\u00c0":9,"\u2026":11,"\u00c6":17,"\u00c5":9,"\u00c4":9,"Y":13,"W":6,"V":6,"T":15,"J":17,"A":9,".":11,",":11,"\u00dd":13}},"E":{"d":"170,0r-140,0r0,-240r138,0r0,21r-109,0r0,82r107,0r0,22r-107,0r0,93r111,0r0,22","w":183},"F":{"d":"166,-219r-107,0r0,82r104,0r0,22r-104,0r0,115r-29,0r0,-240r136,0r0,21","w":176,"k":{"\uf7e5":19,"\uf7e4":19,"\uf7e3":19,"\uf7e2":19,"\uf7e0":19,"\uf7e1":19,"\uf76a":24,"\uf761":19,"\u00c1":22,"\u00c2":22,"\u00c3":22,"\u00c0":22,"\u2026":37,"\u00e6":11,"\u00c6":43,"\u00f5":6,"\u00f6":6,"\u00f4":6,"\u00f2":6,"\u00f3":6,"\u00eb":6,"\u00ea":6,"\u00e8":6,"\u00e9":6,"\u00e5":11,"\u00e3":11,"\u00e4":11,"\u00e2":11,"\u00e0":11,"\u00e1":11,"\u00c5":22,"\u00c4":22,"o":6,"e":6,"a":11,"J":43,"A":22,".":48,",":37}},"G":{"d":"50,-121v2,57,13,101,67,101v15,0,34,-3,52,-8r0,-85r28,0r0,97v-97,45,-178,20,-178,-104v0,-113,73,-145,170,-110r-5,21v-80,-23,-136,-10,-134,88","w":218,"k":{"\uf7ff":17,"\uf7fd":17,"\uf7f6":9,"\uf7f5":9,"\uf7f4":9,"\uf7f2":9,"\uf7f3":9,"\uf779":17,"\uf76f":9,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u00ff":9,"\u0152":9,"\u00d5":9,"\u2026":-4,"\u00d8":9,"\u00d6":9,"\u00c7":9,"y":9,"Q":9,"O":9,"G":9,"C":9,".":-4,",":-4}},"H":{"d":"203,0r-29,0r0,-116r-115,0r0,116r-29,0r0,-240r29,0r0,103r115,0r0,-103r29,0r0,240","w":233},"I":{"d":"59,0r-29,0r0,-240r29,0r0,240","w":89},"J":{"d":"8,-27v57,9,89,14,89,-57r0,-156r29,0r0,158v10,91,-56,90,-122,76","w":154,"k":{"\uf7e5":9,"\uf7e4":9,"\uf7e3":9,"\uf7e2":9,"\uf7e0":9,"\uf7e1":9,"\uf761":9,"\u00c1":11,"\u00c2":11,"\u00c3":11,"\u00c0":11,"\u00c6":11,"\u00c5":11,"\u00c4":11,"A":11}},"K":{"d":"201,0r-36,0r-106,-124r0,124r-29,0r0,-240r29,0r0,109r104,-109r35,0r-108,111","w":204,"k":{"\uf7ff":19,"\uf7fd":19,"\uf7fc":4,"\uf7fb":4,"\uf7f9":4,"\uf7fa":4,"\uf7f6":11,"\uf7f5":11,"\uf7f4":11,"\uf7f2":11,"\uf7f3":11,"\uf779":19,"\uf777":15,"\uf776":15,"\uf775":4,"\uf76f":11,"\u00d2":17,"\u00d4":17,"\u00d3":17,"\u00c1":-4,"\u00c2":-4,"\u00ff":17,"\u2014":22,"\u2013":22,"\u0153":13,"\u0152":17,"\u00d5":17,"\u00c3":-4,"\u00c0":-4,"\u00e6":6,"\u00d8":17,"\u00c6":-4,"\u00fc":6,"\u00fb":6,"\u00f9":6,"\u00fa":6,"\u00f5":13,"\u00f6":13,"\u00f4":13,"\u00f2":13,"\u00f3":13,"\u00eb":13,"\u00ea":13,"\u00e8":13,"\u00e9":13,"\u00e5":6,"\u00e3":6,"\u00e4":6,"\u00e2":6,"\u00e0":6,"\u00e1":6,"\u00d6":17,"\u00c7":17,"\u00c5":-4,"\u00c4":-4,"y":17,"v":17,"u":6,"o":13,"e":13,"a":6,"Q":17,"O":17,"G":17,"C":17,"A":-4,"-":22}},"L":{"d":"166,0r-136,0r0,-240r29,0r0,218r107,0r0,22","w":172,"k":{"\uf7ff":39,"\uf7fd":39,"\uf779":39,"\uf774":39,"\u00d9":11,"\u00db":11,"\u00da":11,"\u00d2":19,"\u00d4":19,"\u00d3":19,"\u00b7":65,"\u0178":43,"\u00ff":13,"\u2019":43,"\u2018":52,"\u201d":43,"\u201c":52,"\u2014":26,"\u2013":26,"\u0153":6,"\u0152":19,"\u00d5":19,"\u00f8":6,"\u00d8":19,"\u00f5":6,"\u00f6":6,"\u00f4":6,"\u00f2":6,"\u00f3":6,"\u00eb":6,"\u00ea":6,"\u00e8":6,"\u00e9":6,"\u00dc":11,"\u00d6":19,"\u00c7":19,"y":13,"t":6,"o":6,"e":6,"Y":43,"W":22,"V":30,"U":11,"T":50,"Q":19,"O":19,"J":-4,"G":19,"C":19,"-":26,"\u00dd":43}},"M":{"d":"261,0r-30,0r-4,-212r-69,212r-35,0r-68,-212r-5,212r-26,0r8,-240r41,0r70,217r69,-217r41,0","w":288},"N":{"d":"203,0r-41,0r-108,-211r0,211r-24,0r0,-240r41,0r108,213r0,-213r24,0r0,240","w":233},"O":{"d":"217,-119v0,80,-35,123,-99,123v-64,0,-99,-43,-99,-124v0,-79,37,-123,100,-123v63,0,98,44,98,124xm50,-119v0,58,13,100,69,100v45,0,67,-32,67,-100v0,-68,-21,-101,-66,-101v-46,0,-70,34,-70,101","w":236,"k":{"\uf7e5":9,"\uf7ff":17,"\uf7fd":17,"\uf7f6":9,"\uf7f5":9,"\uf7f4":9,"\uf7f2":9,"\uf7f3":9,"\uf7e4":9,"\uf7e3":9,"\uf7e2":9,"\uf7e0":9,"\uf7e1":9,"\uf779":17,"\uf778":6,"\uf76f":9,"\uf761":9,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u00c1":9,"\u00c2":9,"\u0178":13,"\u00ff":9,"\u0152":9,"\u00d5":9,"\u00c3":9,"\u00c0":9,"\u2026":11,"\u00d8":9,"\u00c6":13,"\u00d6":9,"\u00c7":9,"\u00c5":9,"\u00c4":9,"y":9,"Z":9,"Y":13,"X":6,"W":6,"V":6,"T":15,"Q":9,"O":9,"J":13,"G":9,"C":9,"A":9,".":11,",":11,"\u00dd":13}},"P":{"d":"186,-171v-3,65,-48,78,-127,73r0,98r-29,0r0,-240v75,0,159,-12,156,69xm59,-120v61,2,98,1,98,-50v0,-51,-44,-49,-98,-48r0,98","w":196,"k":{"\uf7e5":32,"\uf7f8":4,"\uf7f6":4,"\uf7f5":4,"\uf7f4":4,"\uf7f2":4,"\uf7f3":4,"\uf7ee":-9,"\uf7e4":32,"\uf7e3":32,"\uf7e2":32,"\uf7e0":32,"\uf7e1":32,"\uf76f":4,"\uf761":32,"\u00c1":28,"\u00c2":28,"\u0178":4,"\u2014":6,"\u2013":6,"\u0153":4,"\u00c3":28,"\u00c0":28,"\u2026":43,"\u00f8":4,"\u00e6":4,"\u00c6":43,"\u00f5":4,"\u00f6":4,"\u00f4":4,"\u00f2":4,"\u00f3":4,"\u00ef":-11,"\u00ee":-17,"\u00ec":-4,"\u00ed":-9,"\u00eb":4,"\u00ea":4,"\u00e8":4,"\u00e9":4,"\u00e5":4,"\u00e3":4,"\u00e4":4,"\u00e2":4,"\u00e0":4,"\u00e1":4,"\u00c5":28,"\u00c4":28,"o":4,"e":4,"a":4,"Y":4,"J":52,"A":28,".":48,"-":6,",":43,"\u00dd":4}},"Q":{"d":"217,-119v0,76,-31,119,-89,123v-3,44,44,31,80,25r4,19v-58,18,-115,24,-112,-45v-53,-8,-81,-50,-81,-123v0,-79,37,-123,100,-123v63,0,98,44,98,124xm50,-119v0,58,13,100,69,100v45,0,67,-32,67,-100v0,-68,-21,-101,-66,-101v-46,0,-70,34,-70,101","w":236,"k":{"\uf7e5":9,"\uf7ff":17,"\uf7fd":17,"\uf7f6":9,"\uf7f5":9,"\uf7f4":9,"\uf7f2":9,"\uf7f3":9,"\uf7e4":9,"\uf7e3":9,"\uf7e2":9,"\uf7e0":9,"\uf7e1":9,"\uf779":17,"\uf76f":9,"\uf761":9,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u00c1":9,"\u00c2":9,"\u0178":13,"\u00ff":9,"\u0152":9,"\u00d5":9,"\u00c3":9,"\u00c0":9,"\u2026":-4,"\u00d8":9,"\u00d6":9,"\u00c7":9,"\u00c5":9,"\u00c4":9,"y":9,"Z":9,"Y":13,"X":6,"W":6,"V":6,"T":15,"Q":9,"O":9,"J":9,"G":9,"C":9,"A":9,".":11,",":-4,"\u00dd":13}},"R":{"d":"92,-240v62,-3,86,15,86,62v0,34,-17,54,-51,61v35,1,55,77,71,117r-30,0v-24,-50,-19,-119,-109,-107r0,107r-29,0r0,-240r62,0xm149,-175v2,-46,-40,-45,-90,-44r0,90v43,-1,88,7,90,-46","w":204,"k":{"\uf7ff":6,"\uf7fd":6,"\uf7f8":4,"\uf7f6":4,"\uf7f5":4,"\uf7f4":4,"\uf7f2":4,"\uf7f3":4,"\uf779":6,"\uf76f":4,"\u00d2":4,"\u00d4":4,"\u00d3":4,"\u0178":13,"\u2014":9,"\u2013":9,"\u0152":4,"\u00d5":4,"\u00d8":4,"\u00f5":4,"\u00f6":4,"\u00f4":4,"\u00f2":4,"\u00f3":4,"\u00eb":4,"\u00ea":4,"\u00e8":4,"\u00e9":4,"\u00d6":4,"\u00c7":4,"o":4,"e":4,"Y":13,"W":4,"V":4,"T":13,"Q":4,"O":4,"G":4,"C":4,"-":9,"\u00dd":13}},"S":{"d":"93,-137v103,21,78,142,-14,139v-23,0,-41,-3,-68,-11r6,-22v49,15,114,15,114,-34v0,-18,-4,-27,-23,-35v-39,-18,-95,-21,-95,-76v0,-66,76,-77,136,-56r-5,21v-48,-12,-102,-17,-102,32v0,22,5,32,51,42","w":172,"k":{"\uf7ff":11,"\uf7fd":11,"\uf779":11,"\uf777":4,"\uf776":4,"\uf774":11,"\u0178":6,"\u00ff":4,"y":4,"v":4,"Y":6,"T":6,"S":6,"\u00dd":6,"\u0160":6}},"T":{"d":"181,-219r-74,0r0,219r-29,0r0,-219r-74,0r0,-21r177,0r0,21","w":185,"k":{"\uf7e5":22,"\uf684":39,"\uf6ff":32,"\uf7ff":37,"\uf7fd":37,"\uf7fc":22,"\uf7fb":22,"\uf7f9":22,"\uf7fa":22,"\uf6fd":39,"\uf6fa":43,"\uf7f8":43,"\uf7f6":30,"\uf7f5":30,"\uf7f4":30,"\uf7f2":30,"\uf7f3":30,"\uf7f1":39,"\uf7ef":-17,"\uf7ee":-17,"\uf7ec":-17,"\uf7ed":-17,"\uf7eb":22,"\uf7ea":22,"\uf7e8":22,"\uf7e9":22,"\uf7e7":43,"\uf7e6":39,"\uf7e4":22,"\uf7e3":22,"\uf7e2":22,"\uf7e0":22,"\uf7e1":22,"\uf77a":32,"\uf779":37,"\uf777":28,"\uf776":32,"\uf775":39,"\uf773":39,"\uf772":39,"\uf771":43,"\uf76f":43,"\uf76e":39,"\uf76d":41,"\uf769":39,"\uf768":39,"\uf767":43,"\uf765":39,"\uf763":43,"\uf761":41,"\u00d2":15,"\u00d4":15,"\u00d3":15,"\u00c1":28,"\u00c2":28,"\u2014":41,"\u2013":41,"\u0153":43,"\u0152":15,"\u00d5":15,"\u00c3":28,"\u00c0":28,"\u2026":37,"\u00f8":43,"\u00e6":43,"\u00d8":15,"\u00c6":43,"\u00fc":9,"\u00fb":9,"\u00f9":9,"\u00fa":9,"\u00f5":11,"\u00f6":11,"\u00f4":11,"\u00f2":11,"\u00f3":11,"\u00ef":-17,"\u00ee":-17,"\u00ec":-11,"\u00ed":-11,"\u00eb":11,"\u00ea":11,"\u00e8":11,"\u00e9":11,"\u00e7":43,"\u00e5":9,"\u00e3":9,"\u00e4":9,"\u00e2":9,"\u00e0":9,"\u00e1":9,"\u00d6":15,"\u00c7":15,"\u00c5":28,"\u00c4":28,"z":32,"y":37,"w":28,"v":32,"u":32,"s":43,"r":32,"q":43,"o":43,"m":32,"e":43,"d":43,"c":43,"a":43,"Q":15,"O":15,"J":37,"G":15,"C":15,"A":28,";":28,":":28,".":43,"-":41,",":37}},"U":{"d":"117,-20v44,0,59,-16,59,-67r0,-153r25,0r0,142v3,86,-23,93,-88,102v-63,-8,-85,-19,-85,-103r0,-141r29,0r0,162v0,40,20,58,60,58","w":228,"k":{"\u00c1":11,"\u00c2":11,"\u00c3":11,"\u00c0":11,"\u00c6":13,"\u00c5":11,"\u00c4":11,"J":6,"A":11}},"V":{"d":"203,-240r-83,240r-34,0r-84,-240r31,0r72,216r70,-216r28,0","w":204,"k":{"\uf7e5":30,"\uf7fc":4,"\uf7fb":4,"\uf7f9":4,"\uf7fa":4,"\uf6fa":4,"\uf7f8":15,"\uf7f6":15,"\uf7f5":15,"\uf7f4":15,"\uf7f2":15,"\uf6f9":4,"\uf7ef":-17,"\uf7ee":-17,"\uf7ec":-17,"\uf7ed":-17,"\uf7eb":4,"\uf7ea":4,"\uf7e8":4,"\uf7e9":4,"\uf7e6":4,"\uf7e4":30,"\uf7e3":30,"\uf7e2":30,"\uf7e0":30,"\uf7e1":30,"\uf775":4,"\uf76f":15,"\uf76c":4,"\uf769":4,"\uf765":4,"\uf761":30,"\u00d2":6,"\u00d4":6,"\u00d3":15,"\u00c1":19,"\u00c2":19,"\u0178":-2,"\u2014":19,"\u2013":19,"\u0153":19,"\u0152":6,"\u00d5":6,"\u00c3":19,"\u00c0":19,"\u2026":22,"\u00f8":19,"\u00e6":19,"\u00d8":6,"\u00c6":32,"\u00fc":6,"\u00fb":6,"\u00f9":6,"\u00fa":6,"\u00f5":19,"\u00f6":19,"\u00f4":19,"\u00f2":19,"\u00f3":19,"\u00ef":-17,"\u00ee":-17,"\u00ec":-11,"\u00ed":-11,"\u00eb":22,"\u00ea":22,"\u00e8":22,"\u00e9":22,"\u00e5":19,"\u00e3":19,"\u00e4":19,"\u00e2":19,"\u00e0":19,"\u00e1":19,"\u00d6":6,"\u00c7":6,"\u00c5":19,"\u00c4":19,"u":6,"o":19,"e":22,"a":19,"Y":-2,"Q":6,"O":6,"J":32,"G":6,"C":6,"A":19,";":9,":":9,".":32,"-":19,",":22,"\u00dd":-2}},"W":{"d":"277,-240r-54,240r-39,0r-45,-214r-46,214r-37,0r-54,-240r29,0r45,216r47,-216r36,0r46,216r47,-216r25,0","w":279,"k":{"\uf7e5":15,"\uf7fc":4,"\uf7fb":4,"\uf7f9":4,"\uf7fa":4,"\uf6fa":4,"\uf7f8":4,"\uf7f6":4,"\uf7f5":4,"\uf7f4":4,"\uf7f2":4,"\uf7f3":4,"\uf6f9":4,"\uf7ef":-17,"\uf7ee":-17,"\uf7ec":-17,"\uf7ed":-17,"\uf7eb":4,"\uf7ea":4,"\uf7e8":4,"\uf7e9":4,"\uf7e6":4,"\uf7e4":15,"\uf7e3":15,"\uf7e2":15,"\uf7e0":15,"\uf7e1":15,"\uf775":4,"\uf76f":4,"\uf76c":4,"\uf769":4,"\uf765":4,"\uf761":15,"\u00d2":6,"\u00d4":6,"\u00d3":15,"\u00c1":4,"\u00c2":4,"\u0178":-2,"\u2014":19,"\u2013":19,"\u0153":6,"\u0152":6,"\u00d5":6,"\u00c3":4,"\u00c0":4,"\u2026":9,"\u00f8":6,"\u00e6":6,"\u00d8":6,"\u00c6":9,"\u00fc":6,"\u00fb":6,"\u00f9":6,"\u00fa":6,"\u00f5":6,"\u00f6":6,"\u00f4":6,"\u00f2":6,"\u00f3":6,"\u00ef":-17,"\u00ee":-17,"\u00ec":-11,"\u00ed":-11,"\u00eb":6,"\u00ea":6,"\u00e8":6,"\u00e9":6,"\u00e5":6,"\u00e3":6,"\u00e4":6,"\u00e2":6,"\u00e0":6,"\u00e1":6,"\u00d6":6,"\u00c7":6,"\u00c5":4,"\u00c4":4,"u":6,"o":6,"e":6,"a":6,"Y":-2,"Q":6,"O":6,"J":11,"G":6,"C":6,"A":4,";":9,":":9,".":17,"-":19,",":9,"\u00dd":-2}},"X":{"d":"195,0r-35,0r-63,-102r-65,102r-30,0r82,-125r-78,-115r35,0r59,95r60,-95r30,0r-75,115","w":197,"k":{"\uf7ff":13,"\uf7fd":13,"\uf779":13,"\u00d2":6,"\u00d4":6,"\u00d3":6,"\u2014":26,"\u2013":26,"\u0152":6,"\u00d5":6,"\u00d8":6,"\u00d6":6,"\u00c7":6,"Q":6,"O":6,"G":6,"C":6,"-":26}},"Y":{"d":"193,-240r-80,135r0,105r-29,0r0,-105r-82,-135r33,0r66,111r64,-111r28,0","w":195,"k":{"\uf7e5":26,"\uf7fc":13,"\uf7fb":13,"\uf7f9":13,"\uf7fa":13,"\uf6fd":22,"\uf6fa":13,"\uf7f8":28,"\uf7f6":28,"\uf7f5":28,"\uf7f4":28,"\uf7f2":28,"\uf7f3":28,"\uf7ef":-17,"\uf7ee":-17,"\uf7ec":-17,"\uf7ed":-17,"\uf7eb":13,"\uf7ea":13,"\uf7e8":13,"\uf7e9":13,"\uf7e6":13,"\uf7e4":26,"\uf7e3":26,"\uf7e2":26,"\uf7e0":26,"\uf7e1":26,"\uf775":13,"\uf773":22,"\uf770":13,"\uf76f":28,"\uf769":13,"\uf765":13,"\uf761":43,"\u00d2":13,"\u00d4":13,"\u00d3":13,"\u00c1":32,"\u00c2":32,"\u2014":41,"\u2013":41,"\u0153":32,"\u0152":13,"\u00d5":13,"\u00c3":32,"\u00c0":32,"\u2026":37,"\u00f8":32,"\u00e6":32,"\u00d8":13,"\u00c6":43,"\u00fc":22,"\u00fb":22,"\u00f9":22,"\u00fa":22,"\u00f5":17,"\u00f6":17,"\u00f4":17,"\u00f2":17,"\u00f3":17,"\u00ef":-17,"\u00ee":-17,"\u00ec":-11,"\u00eb":11,"\u00ea":11,"\u00e8":11,"\u00e9":11,"\u00e5":11,"\u00e3":11,"\u00e4":11,"\u00e2":11,"\u00e0":11,"\u00e1":11,"\u00d6":13,"\u00c7":13,"\u00c5":32,"\u00c4":32,"v":17,"u":22,"s":26,"p":24,"o":32,"e":32,"a":32,"S":6,"Q":13,"O":13,"J":43,"G":13,"C":13,"A":32,";":13,":":13,".":43,"-":41,",":37,"\u0160":6}},"Z":{"d":"181,0r-168,0r0,-19r131,-200r-126,0r0,-21r161,0r0,19r-131,199r133,0r0,22","w":193,"k":{"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u2014":22,"\u2013":22,"\u0153":6,"\u0152":9,"\u00d5":9,"\u00f8":6,"\u00e6":4,"\u00d8":9,"\u00f5":6,"\u00f6":6,"\u00f4":6,"\u00f2":6,"\u00f3":6,"\u00eb":6,"\u00ea":6,"\u00e8":6,"\u00e9":6,"\u00e5":4,"\u00e3":4,"\u00e4":4,"\u00e2":4,"\u00e0":4,"\u00e1":4,"\u00d6":9,"o":6,"e":6,"a":4,"Q":9,"O":9,"G":9,"-":22}},"[":{"d":"107,45r-77,0r0,-285r77,0r0,20r-49,0r0,245r49,0r0,20","w":119},"\\":{"d":"177,40r-19,10r-145,-290r19,-9"},"]":{"d":"90,45r-77,0r0,-20r49,0r0,-245r-49,0r0,-20r77,0r0,285","w":119},"^":{"d":"187,-80r-21,12r-70,-142r-72,142r-21,-12r82,-160r22,0"},"_":{"d":"180,45r-180,0r0,-19r180,0r0,19","w":180},"`":{"d":"106,-208r-5,16r-77,-20r8,-27","w":129},"a":{"d":"25,-162v59,-16,112,-30,112,53r0,109r-26,0r0,-15v-44,29,-96,30,-96,-34v0,-53,31,-54,95,-53v0,-30,4,-48,-32,-47v-13,0,-29,1,-50,5xm110,-32r0,-53v-55,4,-67,13,-67,37v0,46,56,22,67,16","w":160,"k":{"\u2018":4,"\u201c":4}},"b":{"d":"167,-85v0,82,-62,111,-115,70r0,15r-26,0r0,-256r27,0r0,101v61,-39,114,-17,114,70xm138,-83v0,-73,-28,-76,-85,-55r0,106v55,24,85,14,85,-51","w":182},"c":{"d":"143,-13v-66,34,-128,20,-128,-69v0,-80,56,-112,125,-80r-5,18v-55,-13,-91,-5,-91,60v0,65,43,73,94,54","w":149,"k":{"\u0153":4,"\u2026":-9,"\u00f8":4,"\u00f5":4,"\u00f6":4,"\u00f4":4,"\u00f2":4,"\u00f3":4,"\u00eb":4,"\u00ea":4,"\u00e8":4,"\u00e9":4,"\u00e7":4,"q":4,"o":4,"e":4,"d":4,"c":4,".":-6,",":-9}},"d":{"d":"156,0r-26,0r0,-15v-61,39,-115,18,-115,-69v0,-82,61,-112,115,-71r0,-101r26,0r0,256xm130,-32r0,-106v-56,-23,-86,-14,-86,52v0,73,32,77,86,54","w":182},"e":{"d":"153,-82r-109,0v-1,69,45,71,103,49r5,16v-72,40,-137,26,-137,-61v0,-59,27,-96,72,-96v46,-1,68,34,66,92xm125,-103v0,-34,-12,-49,-35,-49v-26,0,-42,18,-45,52","w":165},"f":{"d":"36,-170v-2,-48,-1,-93,42,-91v19,0,40,6,40,6r-2,18v0,0,-13,-2,-30,-2v-33,0,-21,41,-23,69r47,0r0,20r-47,0r0,150r-27,0r0,-150r-30,0r0,-16","w":116,"k":{"\u2019":-6,"\u201d":-6,"\u0153":13,"\u2026":22,"\u00f8":15,"\u00f5":13,"\u00f6":13,"\u00f4":13,"\u00f2":13,"\u00f3":13,"\u00eb":13,"\u00ea":13,"\u00e8":13,"\u00e9":13,"\u00e7":13,"t":-4,"q":13,"o":13,"g":13,"e":13,"d":13,"c":13,".":22,",":22,")":-4}},"g":{"d":"31,51v65,8,107,6,98,-69v-59,39,-114,16,-114,-68v0,-80,61,-110,114,-69r0,-15r26,0r0,159v7,96,-50,93,-127,79xm129,-36r0,-102v-54,-23,-85,-13,-85,50v0,71,31,77,85,52","w":181,"k":{"j":-4}},"h":{"d":"53,-156v51,-27,104,-31,104,43r0,113r-26,0r0,-104v0,-25,1,-45,-29,-45v-14,0,-31,4,-49,10r0,139r-27,0r0,-256r27,0r0,100","w":181},"i":{"d":"57,-224v0,9,-8,18,-17,18v-10,0,-18,-8,-18,-18v0,-9,8,-17,17,-17v9,0,18,7,18,17xm53,0r-27,0r0,-170r27,0r0,170","w":78},"j":{"d":"58,-224v0,9,-8,18,-17,18v-10,0,-18,-8,-18,-18v0,-9,8,-17,17,-17v9,0,18,7,18,17xm54,10v6,64,-30,70,-81,61r3,-18v37,7,51,-2,51,-40r0,-183r27,0r0,180","w":79,"k":{"j":-4}},"k":{"d":"165,0r-34,0r-78,-86r0,86r-27,0r0,-256r27,0r0,161r76,-75r31,0r-80,77","w":166,"k":{"\u0153":4,"\u00f8":4,"\u00e6":4,"\u00f5":4,"\u00f6":4,"\u00f4":4,"\u00f2":4,"\u00f3":4,"\u00eb":4,"\u00ea":4,"\u00e8":4,"\u00e9":4,"\u00e7":4,"\u00e5":4,"\u00e3":4,"\u00e4":4,"\u00e2":4,"\u00e0":4,"\u00e1":4,"q":4,"o":4,"g":4,"e":4,"d":4,"c":4,"a":4}},"l":{"d":"53,0r-27,0r0,-256r27,0r0,256","w":78,"k":{"\u00b7":22}},"m":{"d":"237,0r-27,0r0,-104v0,-26,2,-46,-24,-46v-12,0,-19,2,-43,11v5,43,1,93,2,139r-27,0r0,-104v0,-26,2,-46,-24,-46v-10,0,-17,2,-41,11r0,139r-27,0r0,-170r26,0r0,14v39,-20,67,-29,88,2v14,-7,40,-20,57,-20v39,0,40,29,40,61r0,113","w":260},"n":{"d":"52,-156v51,-27,105,-32,105,43r0,113r-26,0r0,-104v0,-25,1,-45,-29,-45v-14,0,-31,4,-49,10r0,139r-27,0r0,-170r26,0r0,14","w":181},"o":{"d":"166,-85v0,57,-27,88,-76,88v-48,0,-75,-32,-75,-88v0,-55,28,-89,75,-89v49,0,76,32,76,89xm137,-85v0,-46,-14,-66,-47,-66v-32,0,-46,20,-46,66v0,47,14,66,46,66v32,0,47,-20,47,-66","w":180,"k":{"x":2}},"p":{"d":"167,-85v0,81,-61,111,-114,70r0,87r-27,0r0,-242r26,0r0,15v62,-39,115,-17,115,70xm138,-83v0,-73,-30,-76,-85,-55r0,106v54,23,85,14,85,-51","w":182},"q":{"d":"156,72r-26,0r0,-87v-60,39,-115,18,-115,-69v0,-82,61,-112,115,-71r0,-15r26,0r0,242xm130,-32r0,-106v-56,-23,-86,-14,-86,52v0,73,30,77,86,54","w":182,"k":{"j":-17}},"r":{"d":"105,-147v-21,0,-33,1,-52,10r0,137r-27,0r0,-170r26,0r0,15v21,-14,31,-19,53,-16r0,24","w":107,"k":{"\u00ff":-2,"\u2019":-6,"\u201d":-6,"\u2014":11,"\u2013":11,"\u0153":6,"\u2026":22,"\u00f8":6,"\u00e6":4,"\u00f5":4,"\u00f6":4,"\u00f4":4,"\u00f2":4,"\u00f3":4,"\u00eb":4,"\u00ea":4,"\u00e8":4,"\u00e9":4,"\u00e7":6,"\u00e5":4,"\u00e3":4,"\u00e4":4,"\u00e2":4,"\u00e0":4,"\u00e1":4,"y":-2,"w":-2,"v":-2,"t":-6,"r":-2,"q":4,"o":4,"g":4,"f":-2,"e":4,"d":4,"c":6,"a":4,".":22,"-":11,",":22,")":-4,"\u00fd":-2}},"s":{"d":"122,-50v0,53,-62,63,-111,45r5,-19v34,9,77,8,78,-23v0,-14,-5,-21,-28,-28v-30,-9,-54,-19,-54,-49v-1,-49,56,-60,101,-41r-5,19v-31,-9,-69,-12,-69,19v0,39,83,18,83,77","w":133},"t":{"d":"58,-59v-6,55,8,39,48,34r5,17v-41,19,-80,22,-80,-38r0,-104r-29,0r0,-15r29,-3r0,-47r27,0r0,45r47,0r0,20r-47,0r0,91","w":117,"k":{"\u2014":26,"\u2013":26,"\u0153":6,"\u00f5":6,"\u00f6":6,"\u00f4":6,"\u00f2":6,"\u00f3":6,"\u00eb":4,"\u00ea":4,"\u00e8":4,"\u00e9":4,"o":6,"e":4,"-":26}},"u":{"d":"129,-14v-51,27,-105,31,-105,-43r0,-113r26,0r0,104v0,25,-1,45,29,45v14,0,32,-3,50,-9r0,-140r26,0r0,170r-26,0r0,-14","w":181},"v":{"d":"154,-170r-60,170r-31,0r-61,-170r30,0r48,147r49,-147r25,0","w":156,"k":{"\u00ff":-2,"\u2026":19,"y":-2,"t":-2,".":22,",":19,"\u00fd":-2}},"w":{"d":"227,-170r-42,170r-33,0r-37,-144r-36,144r-34,0r-43,-170r29,0r33,143r37,-143r33,0r36,143r34,-143r23,0","w":229,"k":{"\u00ff":-2,"\u2026":4,"y":-2,"w":-2,"v":-2,"t":-2,".":6,",":4,"\u00fd":-2}},"x":{"d":"150,0r-31,0r-44,-69r-45,69r-28,0r58,-89r-54,-81r34,0r39,63r42,-63r26,0r-54,81","w":152,"k":{"\u0153":2,"\u00f8":2,"\u00f5":2,"\u00f6":2,"\u00f4":2,"\u00f2":2,"\u00f3":2,"\u00eb":2,"\u00ea":2,"\u00e8":2,"\u00e9":2,"\u00e7":2,"q":2,"o":2,"e":2,"d":2,"c":2}},"y":{"d":"157,-170r-75,197v-17,47,-30,52,-72,46r2,-18v38,13,43,-22,58,-57r-68,-168r30,0r52,134r47,-134r26,0","w":159,"k":{"\u00ff":-2,"\u2019":-6,"\u2026":19,"y":-2,"w":-2,"v":-2,"t":-2,".":22,",":19,"\u00fd":-2}},"z":{"d":"149,0r-126,0r0,-14r90,-136r-87,0r0,-20r121,0r0,15r-90,136r92,0r0,19","w":159},"{":{"d":"106,-218v-41,4,-47,-5,-47,43v0,28,6,64,-15,71v28,16,10,61,15,97v-2,32,16,35,47,34r0,20v-77,8,-77,-31,-75,-107v0,-32,-1,-35,-18,-35r0,-19v28,6,18,-37,18,-60v0,-57,18,-66,75,-64r0,20","w":119},"|":{"d":"56,44r-22,0r0,-284r22,0r0,284","w":90},"}":{"d":"14,-238v72,-9,75,29,75,97v0,25,1,26,18,27r0,19v-17,0,-18,3,-18,35v0,74,5,116,-75,107r0,-20v31,1,50,-2,47,-34v4,-36,-13,-81,15,-97v-21,-7,-15,-43,-15,-71v0,-49,-5,-38,-47,-43r0,-20","w":119},"~":{"d":"5,-130v55,-43,117,23,171,-17r9,18v-51,46,-118,-20,-171,17"},"\u00c4":{"d":"208,0r-30,0r-23,-64r-104,0r-23,64r-26,0r85,-240r33,0xm147,-86r-45,-129r-43,129r88,0xm153,-284v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16xm88,-284v0,9,-7,16,-16,16v-9,0,-15,-7,-15,-16v0,-9,6,-16,15,-16v9,0,16,7,16,16","w":209,"k":{"\uf7ff":19,"\uf7fd":19,"\uf779":19,"\uf777":6,"\uf776":13,"\uf774":17,"\uf76a":-4,"\u00d9":4,"\u00db":4,"\u00da":4,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u0178":32,"\u00ff":9,"\u2019":37,"\u2018":43,"\u201d":37,"\u201c":43,"\u2014":9,"\u2013":9,"\u0152":9,"\u00d5":9,"\u00d8":9,"\u00dc":4,"\u00d6":9,"\u00c7":9,"y":9,"w":2,"v":9,"Y":32,"W":4,"V":19,"U":4,"T":28,"S":-4,"Q":9,"O":9,"J":-6,"G":9,"C":9,"-":9,"\u00dd":32,"\u0160":-4}},"\u00c5":{"d":"140,-288v0,19,-16,35,-35,35v-19,0,-34,-16,-34,-35v0,-19,15,-34,34,-34v19,0,35,15,35,34xm125,-288v0,-11,-9,-20,-20,-20v-11,0,-19,9,-19,20v0,11,8,21,19,21v11,0,20,-10,20,-21xm208,0r-30,0r-23,-64r-104,0r-23,64r-26,0r85,-240r33,0xm147,-86r-45,-129r-43,129r88,0","w":209,"k":{"\uf7ff":19,"\uf7fd":19,"\uf779":19,"\uf777":6,"\uf776":13,"\uf774":17,"\uf76a":-4,"\u00d9":4,"\u00db":4,"\u00da":4,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u0178":32,"\u00ff":9,"\u2019":37,"\u2018":43,"\u201d":37,"\u201c":43,"\u2014":9,"\u2013":9,"\u0152":9,"\u00d5":9,"\u00d8":9,"\u00dc":4,"\u00d6":9,"\u00c7":9,"y":9,"w":2,"v":9,"Y":32,"W":4,"V":19,"U":4,"T":28,"S":-4,"Q":9,"O":9,"J":-6,"G":9,"C":9,"-":9,"\u00dd":32,"\u0160":-4}},"\u00c7":{"d":"185,-13v-29,12,-47,15,-62,17r-1,13v17,-1,26,6,26,21v1,32,-29,39,-57,28r4,-14v13,3,32,5,32,-11v0,-12,-14,-12,-26,-10r3,-26v-51,-3,-85,-47,-85,-125v0,-110,69,-145,161,-113r-5,21v-78,-20,-125,-1,-125,89v0,100,47,119,129,89","w":191,"k":{"\uf7ff":17,"\uf7fd":17,"\uf7f6":9,"\uf7f5":9,"\uf7f4":9,"\uf7f2":9,"\uf7f3":9,"\uf779":17,"\uf76f":9,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u00ff":9,"\u0152":9,"\u00d5":9,"\u2026":-4,"\u00d8":9,"\u00d6":9,"\u00c7":9,"y":9,"Q":9,"O":9,"G":9,"C":9,".":-4,",":-4}},"\u00c9":{"d":"149,-282r-87,21r-5,-16r83,-33xm170,0r-140,0r0,-240r138,0r0,21r-109,0r0,82r107,0r0,22r-107,0r0,93r111,0r0,22","w":183},"\u00d1":{"d":"61,-272v23,-29,47,-21,80,-13v7,0,10,-1,18,-9r13,14v-27,41,-69,-6,-99,21xm203,0r-41,0r-108,-211r0,211r-24,0r0,-240r41,0r108,213r0,-213r24,0r0,240","w":233},"\u00d6":{"d":"217,-119v0,80,-35,123,-99,123v-64,0,-99,-43,-99,-124v0,-79,37,-123,100,-123v63,0,98,44,98,124xm50,-119v0,58,13,100,69,100v45,0,67,-32,67,-100v0,-68,-21,-101,-66,-101v-46,0,-70,34,-70,101xm166,-284v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16xm101,-284v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16","w":236,"k":{"\uf7e5":9,"\uf7ff":17,"\uf7fd":17,"\uf7f6":9,"\uf7f5":9,"\uf7f4":9,"\uf7f2":9,"\uf7f3":9,"\uf7e4":9,"\uf7e3":9,"\uf7e2":9,"\uf7e0":9,"\uf7e1":9,"\uf779":17,"\uf778":6,"\uf76f":9,"\uf761":9,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u00c1":9,"\u00c2":9,"\u00ff":9,"\u0152":9,"\u00d5":9,"\u00c3":9,"\u00c0":9,"\u2026":-4,"\u00d8":9,"\u00d6":9,"\u00c7":9,"\u00c5":9,"\u00c4":9,"y":9,"Z":9,"Y":13,"X":6,"W":6,"V":6,"T":15,"Q":9,"O":9,"J":13,"G":9,"C":9,"A":9,".":11,",":-4}},"\u00dc":{"d":"117,-20v44,0,59,-16,59,-67r0,-153r25,0r0,142v3,86,-23,93,-88,102v-63,-8,-85,-19,-85,-103r0,-141r29,0r0,162v0,40,20,58,60,58xm163,-284v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16xm98,-284v0,9,-7,16,-16,16v-9,0,-15,-7,-15,-16v0,-9,6,-16,15,-16v9,0,16,7,16,16","w":228,"k":{"\u00c1":11,"\u00c2":11,"\u00c3":11,"\u00c0":11,"\u00c6":13,"\u00c5":11,"\u00c4":11,"J":6,"A":11}},"\u00e1":{"d":"25,-162v59,-16,112,-30,112,53r0,109r-26,0r0,-15v-44,29,-96,30,-96,-34v0,-53,31,-54,95,-53v0,-30,4,-48,-32,-47v-13,0,-29,1,-50,5xm110,-32r0,-53v-55,4,-67,13,-67,37v0,46,56,22,67,16xm121,-212r-77,20r-5,-16r74,-31","w":160,"k":{"\u2018":4,"\u201c":4}},"\u00e0":{"d":"25,-162v59,-16,112,-30,112,53r0,109r-26,0r0,-15v-44,29,-96,30,-96,-34v0,-53,31,-54,95,-53v0,-30,4,-48,-32,-47v-13,0,-29,1,-50,5xm110,-32r0,-53v-55,4,-67,13,-67,37v0,46,56,22,67,16xm121,-208r-5,16r-77,-20r8,-27","w":160,"k":{"\u2018":4,"\u201c":4}},"\u00e2":{"d":"25,-162v59,-16,112,-30,112,53r0,109r-26,0r0,-15v-44,29,-96,30,-96,-34v0,-53,31,-54,95,-53v0,-30,4,-48,-32,-47v-13,0,-29,1,-50,5xm110,-32r0,-53v-55,4,-67,13,-67,37v0,46,56,22,67,16xm132,-206r-9,15r-44,-20r-44,19r-8,-15r51,-32","w":160,"k":{"\u2018":4,"\u201c":4}},"\u00e4":{"d":"25,-162v59,-16,112,-30,112,53r0,109r-26,0r0,-15v-44,29,-96,30,-96,-34v0,-53,31,-54,95,-53v0,-30,4,-48,-32,-47v-13,0,-29,1,-50,5xm110,-32r0,-53v-55,4,-67,13,-67,37v0,46,56,22,67,16xm129,-222v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16xm64,-222v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16","w":160,"k":{"\u2018":4,"\u201c":4}},"\u00e3":{"d":"25,-162v59,-16,112,-30,112,53r0,109r-26,0r0,-15v-44,29,-96,30,-96,-34v0,-53,31,-54,95,-53v0,-30,4,-48,-32,-47v-13,0,-29,1,-50,5xm110,-32r0,-53v-55,4,-67,13,-67,37v0,46,56,22,67,16xm30,-209v23,-42,61,1,90,-22r13,11v-24,31,-40,22,-72,13v-6,0,-12,3,-18,10","w":160,"k":{"\u2018":4,"\u201c":4}},"\u00e5":{"d":"25,-162v59,-16,112,-30,112,53r0,109r-26,0r0,-15v-44,29,-96,30,-96,-34v0,-53,31,-54,95,-53v0,-30,4,-48,-32,-47v-13,0,-29,1,-50,5xm110,-32r0,-53v-55,4,-67,13,-67,37v0,46,56,22,67,16xm115,-216v0,19,-15,34,-34,34v-19,0,-33,-15,-33,-34v0,-18,15,-33,33,-33v18,0,34,15,34,33xm100,-216v0,-11,-8,-20,-19,-20v-11,0,-18,9,-18,20v0,11,7,20,18,20v11,0,19,-9,19,-20","w":160,"k":{"\u2018":4,"\u201c":4}},"\u00e7":{"d":"143,-13v-35,21,-53,2,-50,29v17,0,24,7,24,21v-1,31,-23,38,-52,28r3,-14v14,3,29,5,29,-11v0,-11,-13,-11,-23,-10r3,-26v-35,-1,-62,-28,-62,-86v0,-80,56,-112,125,-80r-5,18v-55,-13,-91,-5,-91,60v0,65,43,73,94,54","w":149,"k":{"\u0153":4,"\u2026":-9,"\u00f8":4,"\u00f5":4,"\u00f6":4,"\u00f4":4,"\u00f2":4,"\u00f3":4,"\u00eb":4,"\u00ea":4,"\u00e8":4,"\u00e9":4,"\u00e7":4,"q":4,"o":4,"e":4,"d":4,"c":4,".":-6,",":-9}},"\u00e9":{"d":"153,-82r-109,0v-1,69,45,71,103,49r5,16v-72,40,-137,26,-137,-61v0,-59,27,-96,72,-96v46,-1,68,34,66,92xm125,-103v0,-34,-12,-49,-35,-49v-26,0,-42,18,-45,52xm130,-212r-78,20r-4,-16r73,-31","w":165},"\u00e8":{"d":"153,-82r-109,0v-1,69,45,71,103,49r5,16v-72,40,-137,26,-137,-61v0,-59,27,-96,72,-96v46,-1,68,34,66,92xm125,-103v0,-34,-12,-49,-35,-49v-26,0,-42,18,-45,52xm130,-208r-5,16r-77,-20r8,-27","w":165},"\u00ea":{"d":"153,-82r-109,0v-1,69,45,71,103,49r5,16v-72,40,-137,26,-137,-61v0,-59,27,-96,72,-96v46,-1,68,34,66,92xm125,-103v0,-34,-12,-49,-35,-49v-26,0,-42,18,-45,52xm139,-206r-8,15r-45,-20r-43,19r-9,-15r52,-32","w":165},"\u00eb":{"d":"153,-82r-109,0v-1,69,45,71,103,49r5,16v-72,40,-137,26,-137,-61v0,-59,27,-96,72,-96v46,-1,68,34,66,92xm125,-103v0,-34,-12,-49,-35,-49v-26,0,-42,18,-45,52xm135,-222v0,9,-7,16,-16,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,16,7,16,16xm69,-222v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16","w":165},"\u00ed":{"d":"53,0r-27,0r0,-170r27,0r0,170xm80,-212r-77,20r-5,-16r74,-31","w":78},"\u00ec":{"d":"53,0r-27,0r0,-170r27,0r0,170xm80,-208r-4,16r-78,-20r8,-27","w":78},"\u00ee":{"d":"53,0r-27,0r0,-170r27,0r0,170xm92,-206r-8,15r-45,-20r-44,19r-8,-15r52,-32","w":78},"\u00ef":{"d":"53,0r-27,0r0,-170r27,0r0,170xm87,-222v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16xm22,-222v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16","w":78},"\u00f1":{"d":"52,-156v51,-27,105,-32,105,43r0,113r-26,0r0,-104v0,-25,1,-45,-29,-45v-14,0,-31,4,-49,10r0,139r-27,0r0,-170r26,0r0,14xm38,-209v24,-42,61,1,91,-22r12,11v-24,31,-40,22,-72,13v-6,0,-12,3,-18,10","w":181},"\u00f3":{"d":"166,-85v0,57,-27,88,-76,88v-48,0,-75,-32,-75,-88v0,-55,28,-89,75,-89v49,0,76,32,76,89xm137,-85v0,-46,-14,-66,-47,-66v-32,0,-46,20,-46,66v0,47,14,66,46,66v32,0,47,-20,47,-66xm131,-212r-78,20r-4,-16r73,-31","w":180,"k":{"x":2}},"\u00f2":{"d":"166,-85v0,57,-27,88,-76,88v-48,0,-75,-32,-75,-88v0,-55,28,-89,75,-89v49,0,76,32,76,89xm137,-85v0,-46,-14,-66,-47,-66v-32,0,-46,20,-46,66v0,47,14,66,46,66v32,0,47,-20,47,-66xm131,-208r-5,16r-77,-20r8,-27","w":180,"k":{"x":2}},"\u00f4":{"d":"166,-85v0,57,-27,88,-76,88v-48,0,-75,-32,-75,-88v0,-55,28,-89,75,-89v49,0,76,32,76,89xm137,-85v0,-46,-14,-66,-47,-66v-32,0,-46,20,-46,66v0,47,14,66,46,66v32,0,47,-20,47,-66xm142,-206r-8,15r-45,-20r-43,19r-9,-15r52,-32","w":180,"k":{"x":2}},"\u00f6":{"d":"166,-85v0,57,-27,88,-76,88v-48,0,-75,-32,-75,-88v0,-55,28,-89,75,-89v49,0,76,32,76,89xm137,-85v0,-46,-14,-66,-47,-66v-32,0,-46,20,-46,66v0,47,14,66,46,66v32,0,47,-20,47,-66xm138,-222v0,9,-7,16,-16,16v-9,0,-15,-7,-15,-16v0,-9,6,-16,15,-16v9,0,16,7,16,16xm73,-222v0,9,-7,16,-16,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,16,7,16,16","w":180,"k":{"x":2}},"\u00f5":{"d":"166,-85v0,57,-27,88,-76,88v-48,0,-75,-32,-75,-88v0,-55,28,-89,75,-89v49,0,76,32,76,89xm137,-85v0,-46,-14,-66,-47,-66v-32,0,-46,20,-46,66v0,47,14,66,46,66v32,0,47,-20,47,-66xm38,-209v24,-42,61,1,91,-22r12,11v-24,31,-40,22,-72,13v-6,0,-12,3,-18,10","w":180,"k":{"x":2}},"\u00fa":{"d":"129,-14v-51,27,-105,31,-105,-43r0,-113r26,0r0,104v0,25,-1,45,29,45v14,0,32,-3,50,-9r0,-140r26,0r0,170r-26,0r0,-14xm131,-212r-78,20r-4,-16r73,-31","w":181},"\u00f9":{"d":"129,-14v-51,27,-105,31,-105,-43r0,-113r26,0r0,104v0,25,-1,45,29,45v14,0,32,-3,50,-9r0,-140r26,0r0,170r-26,0r0,-14xm131,-208r-5,16r-77,-20r8,-27","w":181},"\u00fb":{"d":"129,-14v-51,27,-105,31,-105,-43r0,-113r26,0r0,104v0,25,-1,45,29,45v14,0,32,-3,50,-9r0,-140r26,0r0,170r-26,0r0,-14xm142,-206r-8,15r-45,-20r-44,19r-8,-15r52,-32","w":181},"\u00fc":{"d":"129,-14v-51,27,-105,31,-105,-43r0,-113r26,0r0,104v0,25,-1,45,29,45v14,0,32,-3,50,-9r0,-140r26,0r0,170r-26,0r0,-14xm139,-222v0,9,-7,16,-16,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,16,7,16,16xm73,-222v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16","w":181},"\u2020":{"d":"168,-147r-58,0r-4,192r-20,0r-5,-192r-59,0r0,-21r58,0r-2,-72r34,0r-1,72r57,0r0,21"},"\u00b0":{"d":"144,-195v0,27,-22,49,-49,49v-27,0,-49,-22,-49,-49v0,-27,22,-49,49,-49v27,0,49,22,49,49xm126,-195v0,-17,-14,-31,-31,-31v-17,0,-31,14,-31,31v0,17,14,32,31,32v17,0,31,-15,31,-32"},"\u00a2":{"d":"172,-19v-23,12,-37,16,-51,19r0,46r-21,0r0,-46v-48,-3,-73,-33,-73,-91v0,-58,27,-91,73,-94r0,-34r21,0r0,34v15,2,30,5,47,11r-5,19v-13,-3,-27,-5,-42,-6r0,136v15,-2,24,-4,45,-13xm100,-25r0,-135v-28,2,-43,25,-43,66v0,42,14,66,43,69"},"\u00a3":{"d":"185,0r-168,0r0,-19v22,-8,29,-63,36,-98r-36,0r0,-20r40,0v10,-56,12,-104,64,-106v19,0,44,7,64,13r-5,19v-53,-15,-85,-13,-89,46r-6,28r76,0r0,20r-80,0v-5,33,-12,71,-31,95r135,0r0,22"},"\u00a7":{"d":"148,-138v29,16,29,72,3,93v29,41,-2,92,-62,92v-19,0,-42,-3,-61,-8r4,-20v43,8,100,12,103,-28v3,-38,-70,-32,-86,-47v-36,-16,-37,-70,-10,-97v-30,-38,-1,-91,53,-91v18,0,40,3,59,9r-5,19v-38,-10,-91,-12,-91,27v0,41,78,34,93,51xm139,-57v16,-20,9,-51,-14,-61v-21,-9,-60,-11,-75,-24v-18,40,-6,64,46,71v24,3,31,8,43,14"},"\u2022":{"d":"124,-102v0,16,-13,29,-29,29v-16,0,-29,-13,-29,-29v0,-16,13,-29,29,-29v16,0,29,13,29,29"},"\u00b6":{"d":"103,27r40,-6r0,-237r-25,0r0,134v0,0,-21,9,-43,9v-35,0,-63,-29,-63,-83v0,-49,30,-84,80,-84r78,0r0,283r-67,0r0,-16"},"\u00df":{"d":"180,-56v0,62,-60,68,-112,51r5,-19v38,8,79,12,79,-29v0,-42,-65,-27,-65,-73v0,-36,45,-45,45,-81v0,-22,-16,-29,-36,-29v-38,0,-45,23,-45,64r0,172r-26,0r0,-180v0,-53,20,-78,71,-78v36,0,62,14,62,48v0,48,-46,56,-46,80v0,29,68,22,68,74"},"\u00ae":{"d":"130,-185v0,32,-26,58,-58,58v-32,0,-59,-26,-59,-58v0,-32,27,-59,59,-59v32,0,58,27,58,59xm120,-185v0,-27,-21,-49,-48,-49v-27,0,-48,22,-48,49v0,27,21,49,48,49v27,0,48,-22,48,-49xm51,-216v0,0,44,-3,43,16v0,8,-4,13,-12,14v8,3,14,19,18,29r-11,0v-6,-13,-7,-31,-27,-25r0,25r-11,0r0,-59xm84,-199v2,-8,-9,-9,-22,-9r0,18v12,0,24,-1,22,-9","w":144},"\u00a9":{"d":"263,-120v0,68,-56,124,-124,124v-68,0,-124,-56,-124,-124v0,-68,56,-124,124,-124v68,0,124,56,124,124xm241,-120v0,-57,-45,-103,-102,-103v-57,0,-102,46,-102,103v0,57,45,103,102,103v57,0,102,-46,102,-103xm184,-67v-55,24,-99,7,-100,-54v-2,-62,45,-78,97,-60r-4,15v-38,-5,-73,-5,-70,45v3,45,30,53,72,39","w":277},"\u2122":{"d":"255,-116r-20,0r-2,-85r-35,85r-17,0r-37,-86r-3,86r-20,0r5,-124r24,0r40,95r39,-95r22,0xm108,-223r-40,0r0,107r-22,0r0,-107r-42,0r0,-17r104,0r0,17","w":281},"\u00b4":{"d":"106,-212r-78,20r-4,-16r74,-31","w":129},"\u00a8":{"d":"113,-222v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16xm48,-222v0,9,-7,16,-16,16v-9,0,-15,-7,-15,-16v0,-9,6,-16,15,-16v9,0,16,7,16,16","w":129},"\u2260":{"d":"178,-61r-94,0r-27,46r-18,-11r20,-35r-47,0r0,-21r59,0r23,-39r-82,0r0,-22r94,0r26,-46r19,11r-20,35r47,0r0,22r-60,0r-22,39r82,0r0,21"},"\u00c6":{"d":"307,0r-137,0r0,-64r-99,0r-41,64r-28,0r154,-240r149,0r0,21r-107,0r0,82r104,0r0,22r-104,0r0,93r109,0r0,22xm170,-86r0,-134r-85,134r85,0","w":320},"\u00d8":{"d":"217,-119v0,80,-35,123,-99,123v-40,0,-60,-18,-60,-18r-18,27r-18,-13r21,-30v0,0,-24,-25,-24,-90v0,-79,36,-123,99,-123v41,0,59,18,59,18r18,-26r18,12r-20,30v0,0,24,24,24,90xm162,-204v0,0,-11,-16,-43,-16v-46,0,-69,35,-69,101v0,41,11,63,11,63xm186,-119v0,-45,-10,-65,-10,-65r-103,149v0,0,16,16,46,16v45,0,67,-32,67,-100","w":236,"k":{"\uf7e5":9,"\uf7ff":17,"\uf7fd":17,"\uf7f6":9,"\uf7f5":9,"\uf7f4":9,"\uf7f2":9,"\uf7f3":9,"\uf7e4":9,"\uf7e3":9,"\uf7e2":9,"\uf7e0":9,"\uf7e1":9,"\uf779":17,"\uf778":6,"\uf76f":9,"\uf761":9,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u00c1":9,"\u00c2":9,"\u00ff":9,"\u0152":9,"\u00d5":9,"\u00c3":9,"\u00c0":9,"\u2026":-4,"\u00d8":9,"\u00d6":9,"\u00c7":9,"\u00c5":9,"\u00c4":9,"y":9,"Z":9,"Y":13,"X":6,"W":6,"V":6,"T":15,"Q":9,"O":9,"J":13,"G":9,"C":9,"A":9,".":11,",":-4}},"\u221e":{"d":"264,-101v0,30,-23,54,-52,54v-28,0,-48,-20,-68,-37v-28,27,-46,38,-67,38v-28,0,-53,-24,-53,-53v0,-30,23,-54,52,-54v23,0,44,12,68,37v19,-19,39,-37,69,-37v28,0,51,22,51,52xm240,-102v0,-16,-14,-28,-32,-28v-21,0,-35,17,-49,30v14,12,33,28,52,28v15,0,29,-14,29,-30xm128,-100v-15,-15,-30,-30,-51,-30v-17,0,-29,13,-29,28v0,50,61,27,80,2","w":288},"\u00b1":{"d":"178,-118r-71,0r0,68r-23,0r0,-68r-72,0r0,-22r72,0r0,-69r23,0r0,69r71,0r0,22xm178,0r-166,0r0,-22r166,0r0,22"},"\u2264":{"d":"180,-64r-10,23r-160,-77r0,-22r160,-70r10,22r-138,59xm177,0r-167,0r0,-22r167,0r0,22"},"\u2265":{"d":"180,-118r-160,77r-10,-23r138,-65r-138,-59r10,-22r160,70r0,22xm180,0r-167,0r0,-22r167,0r0,22"},"\u00a5":{"d":"192,-240r-69,103r44,0r0,19r-58,0r0,29r58,0r0,20r-58,0r0,69r-28,0r0,-69r-58,0r0,-20r58,0r0,-29r-58,0r0,-19r41,0r-66,-103r32,0r66,104r69,-104r27,0"},"\u00b5":{"d":"57,-69v-8,69,36,51,76,37r0,-138r27,0r0,170r-27,0r0,-13v-33,16,-49,22,-76,10r0,48r-27,0r0,-215r27,0r0,101"},"\u2202":{"d":"87,-258v74,0,82,59,82,136v0,84,-26,125,-78,125v-45,0,-70,-32,-70,-87v0,-81,54,-111,118,-67v-4,-92,-37,-93,-109,-80r-3,-18v22,-5,46,-9,60,-9xm94,-18v35,0,50,-51,47,-115v-51,-23,-91,-21,-92,46v0,45,15,69,45,69"},"\u2211":{"d":"180,0r-170,0r0,-21r87,-102r-85,-96r0,-21r166,0r0,22r-131,0r83,92r-87,102r137,0r0,24"},"\u220f":{"d":"226,-219r-25,0r0,219r-28,0r0,-219r-98,0r0,219r-28,0r0,-219r-25,0r0,-21r204,0r0,21","w":247},"\u03c0":{"d":"163,-54v-3,41,5,35,36,32r4,18v-40,13,-67,10,-67,-46r0,-98r-67,0r0,148r-27,0r0,-148r-25,0r0,-22r171,0r0,22r-25,0r0,94","w":209},"\u222b":{"d":"30,53v37,9,52,-4,52,-40r0,-219v-1,-58,37,-62,84,-46r-5,19v-39,-5,-53,-17,-53,38r0,205v6,64,-30,70,-81,61"},"\u00aa":{"d":"22,-233v42,-10,82,-22,82,37r0,75r-19,0r0,-10v-31,20,-70,20,-70,-23v0,-36,23,-37,69,-37v0,-22,3,-34,-23,-33v-9,0,-22,1,-37,4xm84,-143r0,-36v-40,3,-48,8,-48,25v0,33,42,14,48,11","w":131},"\u00ba":{"d":"120,-180v0,39,-19,62,-54,62v-35,0,-55,-23,-55,-62v0,-38,21,-61,55,-61v35,0,54,22,54,61xm99,-180v0,-32,-10,-46,-33,-46v-22,0,-34,15,-34,46v0,32,12,46,34,46v23,0,33,-14,33,-46","w":131},"\u2126":{"d":"219,0r-85,0r0,-19v35,-6,52,-37,52,-98v0,-72,-21,-104,-68,-104v-45,0,-68,35,-68,100v0,64,16,96,52,102r0,19r-85,0r0,-22r38,0v-24,-22,-36,-55,-36,-103v0,-76,36,-119,99,-119v63,0,99,44,99,122v0,46,-13,79,-37,100r39,0r0,22","w":236},"\u00e6":{"d":"15,-48v0,-53,32,-52,96,-52v0,-30,2,-50,-34,-49v-13,0,-29,1,-50,5r-3,-18v44,-13,91,-23,107,12v45,-52,123,-16,113,68r-109,0v-1,68,45,71,103,49r5,16v-35,16,-50,21,-70,21v-30,0,-46,-21,-46,-21v-31,14,-52,21,-69,21v-22,0,-43,-19,-43,-52xm217,-103v-1,-34,-12,-49,-35,-49v-26,0,-42,19,-45,52xm118,-32v0,0,-9,-13,-9,-43r0,-7v-54,3,-66,10,-66,34v0,42,44,25,75,16","w":257,"k":{"\u2018":4,"\u201c":4}},"\u00f8":{"d":"166,-85v0,57,-27,88,-76,88v-30,0,-43,-12,-43,-12r-16,21r-16,-12r17,-23v0,0,-17,-20,-17,-62v0,-55,28,-89,75,-89v30,0,44,13,44,13r15,-20r16,11r-16,23v0,0,17,17,17,62xm120,-142v0,0,-8,-9,-30,-9v-32,0,-46,20,-46,66v0,25,5,39,5,39xm137,-85v0,-26,-5,-39,-5,-39r-71,96v0,0,7,9,29,9v32,0,47,-20,47,-66","w":180},"\u00bf":{"d":"129,-156v0,10,-8,18,-18,18v-10,0,-18,-8,-18,-18v0,-10,8,-18,18,-18v10,0,18,8,18,18xm159,59v-54,18,-139,28,-139,-46v0,-39,8,-49,60,-75v22,-11,22,-15,22,-46r18,0v0,0,2,23,2,35v-9,41,-73,35,-73,80v0,57,56,44,106,33","w":173},"\u00a1":{"d":"63,-156v0,10,-8,18,-18,18v-10,0,-18,-8,-18,-18v0,-10,8,-18,18,-18v10,0,18,8,18,18xm63,69r-35,0r8,-177r18,0","w":90},"\u00ac":{"d":"178,-69r-23,0r0,-52r-143,0r0,-22r166,0r0,74"},"\u221a":{"d":"221,-237r-85,237r-23,0r-51,-118r-40,0r0,-22r58,0r45,107r74,-212","w":243},"\u0192":{"d":"185,-232r-5,20v-18,-5,-33,-7,-43,-7v-43,2,-34,50,-45,82r71,0r0,20r-74,0v-19,71,-16,152,-63,193r-15,-12v33,-41,33,-120,49,-181r-36,0r0,-20r40,0v10,-55,13,-104,64,-106v21,0,36,5,57,11"},"\u2248":{"d":"5,-133v53,-44,115,21,171,-17r9,18v-52,47,-118,-22,-171,17xm5,-73v55,-43,116,21,171,-17r9,18v-51,46,-117,-20,-171,17"},"\u2206":{"d":"194,0r-198,0r87,-240r22,0xm157,-22r-64,-178r-63,178r127,0"},"\u00ab":{"d":"132,-21r-15,9r-44,-74r44,-74r15,9r-25,65xm81,-21r-17,9r-55,-74r55,-74r17,9r-35,65","w":147},"\u00bb":{"d":"139,-86r-56,74r-16,-9r35,-65r-35,-65r16,-9xm75,-86r-44,74r-16,-9r26,-65r-26,-65r16,-9","w":147},"\u2026":{"d":"318,-15v0,10,-8,18,-18,18v-10,0,-18,-8,-18,-18v0,-10,8,-18,18,-18v10,0,18,8,18,18xm198,-15v0,10,-8,18,-18,18v-10,0,-18,-8,-18,-18v0,-10,8,-18,18,-18v10,0,18,8,18,18xm78,-15v0,10,-8,18,-18,18v-10,0,-18,-8,-18,-18v0,-10,8,-18,18,-18v10,0,18,8,18,18","w":360,"k":{"\u2019":22,"\u2018":22,"\u201d":22}},"\u00c0":{"d":"151,-277r-5,16r-88,-21r10,-28xm208,0r-30,0r-23,-64r-104,0r-23,64r-26,0r85,-240r33,0xm147,-86r-45,-129r-43,129r88,0","w":209,"k":{"\uf7ff":19,"\uf7fd":19,"\uf779":19,"\uf777":6,"\uf776":13,"\uf774":17,"\uf76a":-4,"\u00d9":4,"\u00db":4,"\u00da":4,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u0178":32,"\u00ff":9,"\u2019":6,"\u2018":43,"\u201d":37,"\u201c":43,"\u2014":9,"\u2013":9,"\u0152":9,"\u00d5":9,"\u00d8":9,"\u00dc":4,"\u00d6":9,"\u00c7":9,"y":9,"w":2,"v":9,"Y":32,"W":4,"V":19,"U":4,"T":28,"S":-4,"Q":9,"O":9,"J":-6,"G":9,"C":9,"-":9,"\u00dd":32,"\u0160":-4}},"\u00c3":{"d":"49,-272v23,-29,47,-21,80,-13v7,0,11,-1,19,-9r13,14v-27,41,-69,-6,-99,21xm208,0r-30,0r-23,-64r-104,0r-23,64r-26,0r85,-240r33,0xm147,-86r-45,-129r-43,129r88,0","w":209,"k":{"\uf7ff":19,"\uf7fd":19,"\uf779":19,"\uf777":6,"\uf776":13,"\uf774":17,"\uf76a":-4,"\u00d9":4,"\u00db":4,"\u00da":4,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u0178":32,"\u00ff":9,"\u2019":37,"\u2018":43,"\u201d":37,"\u201c":43,"\u2014":9,"\u2013":9,"\u0152":9,"\u00d5":9,"\u00d8":9,"\u00dc":4,"\u00d6":9,"\u00c7":9,"y":9,"w":2,"v":9,"Y":32,"W":4,"V":19,"U":4,"T":28,"S":-4,"Q":9,"O":9,"J":-6,"G":9,"C":9,"-":9,"\u00dd":32,"\u0160":-4}},"\u00d5":{"d":"62,-272v23,-29,47,-21,80,-13v7,0,11,-1,19,-9r13,14v-27,41,-69,-6,-99,21xm217,-119v0,80,-35,123,-99,123v-64,0,-99,-43,-99,-124v0,-79,37,-123,100,-123v63,0,98,44,98,124xm50,-119v0,58,13,100,69,100v45,0,67,-32,67,-100v0,-68,-21,-101,-66,-101v-46,0,-70,34,-70,101","w":236,"k":{"\uf7e5":9,"\uf7ff":17,"\uf7fd":17,"\uf7f6":9,"\uf7f5":9,"\uf7f4":9,"\uf7f2":9,"\uf7f3":9,"\uf7e4":9,"\uf7e3":9,"\uf7e2":9,"\uf7e0":9,"\uf7e1":9,"\uf779":17,"\uf778":6,"\uf76f":9,"\uf761":9,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u00c1":9,"\u00c2":9,"\u00ff":9,"\u0152":9,"\u00d5":9,"\u00c3":9,"\u00c0":9,"\u2026":-4,"\u00d8":9,"\u00d6":9,"\u00c7":9,"\u00c5":9,"\u00c4":9,"y":9,"Z":9,"Y":13,"X":6,"W":6,"V":6,"T":15,"Q":9,"O":9,"J":13,"G":9,"C":9,"A":9,".":11,",":-4}},"\u0152":{"d":"19,-120v0,-82,30,-120,130,-120r145,0r0,21r-106,0r0,82r105,0r0,22r-105,0r0,93r110,0r0,22r-158,0v-91,3,-121,-40,-121,-120xm50,-120v0,76,24,103,109,98r0,-197v-87,-3,-109,25,-109,99","w":310},"\u0153":{"d":"271,-82r-109,0v-1,69,45,71,103,49r5,16v-35,16,-51,21,-71,21v-20,0,-41,-10,-52,-31v-38,59,-142,27,-132,-57v-9,-86,99,-122,134,-55v40,-64,134,-36,122,57xm243,-103v-1,-34,-12,-49,-35,-49v-26,0,-42,19,-45,52xm135,-85v0,-46,-13,-66,-45,-66v-30,0,-46,21,-46,66v0,46,15,66,46,66v31,0,45,-20,45,-66","w":283},"\u2013":{"d":"173,-91r-166,0r0,-22r166,0r0,22","w":180,"k":{"\uf6ff":19,"\uf7ff":28,"\uf7fd":28,"\uf7e4":13,"\uf7e3":13,"\uf7e2":13,"\uf7e0":13,"\uf7e1":13,"\uf77a":19,"\uf779":28,"\uf778":28,"\uf777":4,"\uf776":4,"\uf774":37,"\uf76a":22,"\uf761":13,"\u00c1":9,"\u00c2":9,"\u00c3":9,"\u00c0":9,"\u00c5":9,"\u00c4":9,"Z":17,"Y":41,"X":26,"W":19,"V":19,"T":41,"S":4,"J":22,"A":9}},"\u2014":{"d":"316,-91r-272,0r0,-22r272,0r0,22","w":360,"k":{"\uf6ff":19,"\uf7ff":28,"\uf7fd":28,"\uf7e4":13,"\uf7e3":13,"\uf7e2":13,"\uf7e0":13,"\uf7e1":13,"\uf77a":19,"\uf779":28,"\uf778":28,"\uf777":4,"\uf776":4,"\uf774":37,"\uf76a":22,"\uf761":13,"\u00c1":9,"\u00c2":9,"\u00c3":9,"\u00c0":9,"\u00c5":9,"\u00c4":9,"Z":17,"Y":41,"X":26,"W":19,"V":19,"T":41,"S":4,"J":22,"A":9}},"\u201c":{"d":"135,-235r-33,67r-38,0r55,-76xm78,-235r-34,67r-37,0r55,-76","w":147,"k":{"\uf7f6":24,"\uf7f5":24,"\uf7f4":24,"\uf7f2":24,"\uf7f3":24,"\uf7e4":52,"\uf7e3":52,"\uf7e2":52,"\uf7e0":52,"\uf7e1":52,"\uf76f":24,"\uf76a":73,"\uf761":52,"\u00d2":11,"\u00d4":11,"\u00d3":11,"\u00c1":43,"\u00c2":43,"\u00d5":11,"\u00c3":43,"\u00c0":43,"\u00bf":65,"\u00e6":17,"\u00d8":11,"\u00f5":28,"\u00f6":28,"\u00f4":28,"\u00f2":28,"\u00f3":28,"\u00f1":11,"\u00e5":17,"\u00e3":17,"\u00e4":17,"\u00e2":17,"\u00e0":17,"\u00e1":17,"\u00d6":11,"\u00c5":43,"\u00c4":43,"o":28,"n":11,"a":17,"O":11,"J":73,"A":43}},"\u201d":{"d":"132,-240r-55,76r-16,-9r34,-67r37,0xm75,-240r-54,76r-17,-9r34,-67r37,0","w":147,"k":{"\uf7e4":60,"\uf7e3":60,"\uf7e2":60,"\uf7e0":60,"\uf7e1":60,"\uf76a":78,"\uf761":63,"\u00c1":52,"\u00c2":52,"\u00c3":52,"\u00c0":52,"\u00e6":22,"\u00e5":22,"\u00e3":22,"\u00e4":22,"\u00e2":22,"\u00e0":22,"\u00e1":22,"\u00c5":52,"\u00c4":52,"a":22,"J":78,"A":52}},"\u2018":{"d":"78,-235r-34,67r-37,0r55,-76","w":90,"k":{"\uf7f6":24,"\uf7f5":24,"\uf7f4":24,"\uf7f2":24,"\uf7f3":24,"\uf7e4":52,"\uf7e3":52,"\uf7e2":52,"\uf7e0":52,"\uf7e1":52,"\uf76f":24,"\uf76a":78,"\uf761":52,"\u00d2":11,"\u00d4":11,"\u00d3":11,"\u00c1":43,"\u00c2":43,"\u00d5":11,"\u00c3":43,"\u00c0":43,"\u00bf":65,"\u00e6":17,"\u00d8":11,"\u00f5":28,"\u00f6":28,"\u00f4":28,"\u00f2":28,"\u00f3":28,"\u00f1":11,"\u00e5":17,"\u00e3":17,"\u00e4":17,"\u00e2":17,"\u00e0":17,"\u00e1":17,"\u00d6":11,"\u00c5":43,"\u00c4":43,"o":28,"n":11,"a":17,"O":11,"J":73,"A":43}},"\u2019":{"d":"75,-240r-54,76r-17,-9r34,-67r37,0","w":90,"k":{"\uf6fd":28,"\uf6fa":30,"\uf7f8":30,"\uf7f6":30,"\uf7f5":30,"\uf7f4":30,"\uf7f2":30,"\uf7f3":30,"\uf7e7":30,"\uf7e4":60,"\uf7e3":60,"\uf7e2":60,"\uf7e0":60,"\uf7e1":60,"\uf777":24,"\uf776":24,"\uf774":22,"\uf773":28,"\uf771":30,"\uf76f":30,"\uf76a":78,"\uf767":30,"\uf763":30,"\uf761":63,"\u00c1":52,"\u00c2":52,"\u0153":32,"\u00c3":52,"\u00c0":52,"\u00f8":32,"\u00e6":22,"\u00f5":32,"\u00f6":32,"\u00f4":32,"\u00f2":32,"\u00f3":32,"\u00eb":32,"\u00ea":32,"\u00e8":32,"\u00e9":32,"\u00e7":32,"\u00e5":22,"\u00e3":22,"\u00e4":22,"\u00e2":22,"\u00e0":22,"\u00e1":22,"\u00c5":52,"\u00c4":52,"v":26,"t":6,"s":28,"r":17,"q":32,"o":32,"e":32,"d":28,"c":32,"a":22,"J":78,"A":52,"\u0161":28}},"\u00f7":{"d":"111,-173v0,9,-7,16,-16,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,16,7,16,16xm178,-91r-166,0r0,-22r166,0r0,22xm111,-31v0,9,-7,16,-16,16v-9,0,-16,-7,-16,-16v0,-9,7,-15,16,-15v9,0,16,6,16,15"},"\u25ca":{"d":"183,-122r-75,122r-26,0r-75,-122r75,-118r26,0xm155,-122r-60,-96r-60,96r60,100"},"\u00ff":{"d":"157,-170r-75,197v-17,47,-30,52,-72,46r2,-18v38,13,43,-22,58,-57r-68,-168r30,0r52,134r47,-134r26,0xm131,-222v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16xm66,-222v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16","w":159,"k":{"\u00ff":-2,"y":-2,"w":-2,"v":-2,"t":-2,".":22,"\u00fd":-2}},"\u0178":{"d":"193,-240r-80,135r0,105r-29,0r0,-105r-82,-135r33,0r66,111r64,-111r28,0xm147,-284v0,9,-7,16,-16,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,16,7,16,16xm81,-284v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16","w":195,"k":{"\uf7fc":13,"\uf7fb":13,"\uf7f9":13,"\uf7fa":13,"\uf6fd":22,"\uf6fa":13,"\uf7eb":13,"\uf7ea":13,"\uf7e8":13,"\uf7e9":13,"\uf7e6":13,"\uf7e4":43,"\uf7e3":43,"\uf7e2":43,"\uf7e0":43,"\uf7e1":43,"\uf775":13,"\uf773":22,"\uf770":13,"\uf76f":28,"\uf769":13,"\uf765":13,"\uf761":43,"\u00d2":13,"\u00d4":13,"\u00d3":13,"\u00c1":32,"\u00c2":32,"\u0152":13,"\u00d5":13,"\u00c3":32,"\u00c0":32,"\u00e6":32,"\u00d8":13,"\u00e9":32,"\u00e5":32,"\u00e3":32,"\u00e4":32,"\u00e2":32,"\u00e0":32,"\u00e1":32,"\u00d6":13,"\u00c7":13,"\u00c5":32,"\u00c4":32,"v":17,"u":22,"s":26,"p":24,"o":32,"e":32,"a":32,"S":6,"Q":13,"O":13,"J":43,"G":13,"C":13,"A":32,";":13,":":13,".":43}},"\u2044":{"d":"139,-239r-173,252r-18,-12r172,-253","w":86},"\u20ac":{"d":"194,-12v-77,36,-140,15,-155,-67r-32,0r0,-19r30,0r-1,-39r-29,0r0,-20r32,0v7,-73,75,-105,149,-77r-5,21v-62,-17,-105,0,-114,56r67,0r0,20r-69,0v-2,2,0,44,1,39r68,0r0,19r-65,0v16,62,52,69,116,46"},"\u2039":{"d":"81,-21r-17,9r-55,-74r55,-74r17,9r-35,65","w":95},"\u203a":{"d":"87,-86r-56,74r-16,-9r35,-65r-35,-65r16,-9","w":95},"\u2021":{"d":"168,-79r-59,0r-3,124r-20,0r-4,-124r-60,0r0,-21r60,0r-1,-47r-59,0r0,-21r58,0r-2,-72r34,0r-1,72r57,0r0,21r-58,0r-1,47r59,0r0,21"},"\u00b7":{"d":"63,-126v0,10,-8,18,-18,18v-10,0,-18,-8,-18,-18v0,-10,8,-18,18,-18v10,0,18,8,18,18","w":90,"k":{"l":22}},"\u201a":{"d":"71,-31r-55,76r-16,-9r34,-67r37,0","w":90,"k":{"W":17,"V":35,"T":39}},"\u201e":{"d":"128,-31r-55,76r-16,-9r34,-67r37,0xm71,-31r-55,76r-16,-9r34,-67r37,0","w":147,"k":{"W":17,"V":35,"T":39}},"\u2030":{"d":"250,-239r-173,252r-18,-12r172,-253xm122,-177v0,42,-18,65,-53,65v-36,0,-54,-23,-54,-65v0,-40,19,-65,53,-65v35,0,54,25,54,65xm99,-177v0,-31,-8,-47,-30,-47v-22,0,-30,16,-30,47v0,31,8,47,30,47v22,0,30,-15,30,-47xm294,-64v0,42,-18,66,-53,66v-36,0,-54,-23,-54,-65v0,-40,19,-65,53,-65v35,0,54,24,54,64xm271,-64v0,-31,-8,-47,-30,-47v-22,0,-30,16,-30,47v0,31,8,47,30,47v22,0,30,-15,30,-47xm431,-64v0,42,-18,66,-53,66v-36,0,-54,-23,-54,-65v0,-40,20,-65,54,-65v35,0,53,24,53,64xm408,-64v0,-31,-8,-47,-30,-47v-22,0,-30,16,-30,47v0,31,8,47,30,47v22,0,30,-15,30,-47","w":446},"\u00c2":{"d":"163,-275r-9,14r-49,-20r-49,20r-10,-14r60,-34xm208,0r-30,0r-23,-64r-104,0r-23,64r-26,0r85,-240r33,0xm147,-86r-45,-129r-43,129r88,0","w":209,"k":{"\uf7ff":19,"\uf7fd":19,"\uf779":19,"\uf777":6,"\uf776":13,"\uf774":17,"\uf76a":-4,"\u00d9":4,"\u00db":4,"\u00da":4,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u0178":32,"\u00ff":9,"\u2019":37,"\u2018":43,"\u201d":37,"\u201c":43,"\u2014":9,"\u2013":9,"\u0152":9,"\u00d5":9,"\u00d8":9,"\u00dc":4,"\u00d6":9,"\u00c7":9,"y":9,"w":2,"v":9,"Y":32,"W":4,"V":19,"U":4,"T":28,"S":-4,"Q":9,"O":9,"J":-6,"G":9,"C":9,"-":9,"\u00dd":32,"\u0160":-4}},"\u00ca":{"d":"159,-275r-9,14r-50,-20r-49,20r-9,-14r59,-34xm170,0r-140,0r0,-240r138,0r0,21r-109,0r0,82r107,0r0,22r-107,0r0,93r111,0r0,22","w":183},"\u00c1":{"d":"151,-282r-87,21r-6,-16r83,-33xm208,0r-30,0r-23,-64r-104,0r-23,64r-26,0r85,-240r33,0xm147,-86r-45,-129r-43,129r88,0","w":209,"k":{"\uf7ff":19,"\uf7fd":19,"\uf779":19,"\uf777":6,"\uf776":13,"\uf774":17,"\uf76a":-4,"\u00d9":4,"\u00db":4,"\u00da":4,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u0178":32,"\u00ff":9,"\u2019":37,"\u2018":43,"\u201d":37,"\u201c":43,"\u2014":9,"\u2013":9,"\u0152":9,"\u00d5":9,"\u00d8":9,"\u00dc":4,"\u00d6":9,"\u00c7":9,"y":9,"w":2,"v":9,"Y":32,"W":4,"V":19,"U":4,"T":28,"S":-4,"Q":9,"O":9,"J":-6,"G":9,"C":9,"-":9,"\u00dd":32,"\u0160":-4}},"\u00cb":{"d":"170,0r-140,0r0,-240r138,0r0,21r-109,0r0,82r107,0r0,22r-107,0r0,93r111,0r0,22xm147,-284v0,9,-7,16,-16,16v-9,0,-15,-7,-15,-16v0,-9,6,-16,15,-16v9,0,16,7,16,16xm82,-284v0,9,-7,16,-16,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,16,7,16,16","w":183},"\u00c8":{"d":"141,-277r-5,16r-87,-21r9,-28xm170,0r-140,0r0,-240r138,0r0,21r-109,0r0,82r107,0r0,22r-107,0r0,93r111,0r0,22","w":183},"\u00cd":{"d":"91,-282r-87,21r-6,-16r83,-33xm59,0r-29,0r0,-240r29,0r0,240","w":89},"\u00ce":{"d":"103,-275r-9,14r-50,-20r-48,20r-10,-14r59,-34xm59,0r-29,0r0,-240r29,0r0,240","w":89},"\u00cf":{"d":"59,0r-29,0r0,-240r29,0r0,240xm93,-284v0,9,-7,16,-16,16v-9,0,-15,-7,-15,-16v0,-9,6,-16,15,-16v9,0,16,7,16,16xm28,-284v0,9,-7,16,-16,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,16,7,16,16","w":89},"\u00cc":{"d":"91,-277r-5,16r-88,-21r10,-28xm59,0r-29,0r0,-240r29,0r0,240","w":89},"\u00d3":{"d":"165,-282r-88,21r-5,-16r83,-33xm217,-119v0,80,-35,123,-99,123v-64,0,-99,-43,-99,-124v0,-79,37,-123,100,-123v63,0,98,44,98,124xm50,-119v0,58,13,100,69,100v45,0,67,-32,67,-100v0,-68,-21,-101,-66,-101v-46,0,-70,34,-70,101","w":236,"k":{"\uf7e5":9,"\uf7ff":17,"\uf7fd":17,"\uf7f6":9,"\uf7f5":9,"\uf7f4":9,"\uf7f2":9,"\uf7f3":9,"\uf7e4":9,"\uf7e3":9,"\uf7e2":9,"\uf7e0":9,"\uf7e1":9,"\uf779":17,"\uf778":6,"\uf76f":9,"\uf761":9,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u00c1":9,"\u00c2":9,"\u00ff":9,"\u0152":9,"\u00d5":9,"\u00c3":9,"\u00c0":9,"\u2026":-4,"\u00d8":9,"\u00d6":9,"\u00c7":9,"\u00c5":9,"\u00c4":9,"y":9,"Z":9,"Y":13,"X":6,"W":6,"V":6,"T":15,"Q":9,"O":9,"J":13,"G":9,"C":9,"A":9,".":11,",":-4}},"\u00d4":{"d":"177,-275r-9,14r-50,-20r-49,20r-9,-14r59,-34xm217,-119v0,80,-35,123,-99,123v-64,0,-99,-43,-99,-124v0,-79,37,-123,100,-123v63,0,98,44,98,124xm50,-119v0,58,13,100,69,100v45,0,67,-32,67,-100v0,-68,-21,-101,-66,-101v-46,0,-70,34,-70,101","w":236,"k":{"\uf7e5":9,"\uf7ff":17,"\uf7fd":17,"\uf7f6":9,"\uf7f5":9,"\uf7f4":9,"\uf7f2":9,"\uf7f3":9,"\uf7e4":9,"\uf7e3":9,"\uf7e2":9,"\uf7e0":9,"\uf7e1":9,"\uf779":17,"\uf778":6,"\uf76f":9,"\uf761":9,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u00c1":9,"\u00c2":9,"\u00ff":9,"\u0152":9,"\u00d5":9,"\u00c3":9,"\u00c0":9,"\u2026":-4,"\u00d8":9,"\u00d6":9,"\u00c7":9,"\u00c5":9,"\u00c4":9,"y":9,"Z":9,"Y":13,"X":6,"W":6,"V":6,"T":15,"Q":9,"O":9,"J":13,"G":9,"C":9,"A":9,".":11,",":-4}},"\uf8ff":{"d":"307,-141v0,80,-64,145,-144,145v-80,0,-145,-65,-145,-145v0,-80,65,-145,145,-145v80,0,144,65,144,145xm136,-152v-9,-65,29,-88,82,-64r-4,18v-26,-5,-54,-14,-51,24r0,22r45,0r0,20r-45,0r0,111v66,0,119,-54,119,-120v0,-65,-53,-120,-119,-120v-66,0,-119,55,-119,121v0,62,44,106,92,117r0,-109r-29,0r0,-17","w":325},"\u00d2":{"d":"165,-277r-6,16r-87,-21r9,-28xm217,-119v0,80,-35,123,-99,123v-64,0,-99,-43,-99,-124v0,-79,37,-123,100,-123v63,0,98,44,98,124xm50,-119v0,58,13,100,69,100v45,0,67,-32,67,-100v0,-68,-21,-101,-66,-101v-46,0,-70,34,-70,101","w":236,"k":{"\uf7e5":9,"\uf7ff":17,"\uf7fd":17,"\uf7f6":9,"\uf7f5":9,"\uf7f4":9,"\uf7f2":9,"\uf7f3":9,"\uf7e4":9,"\uf7e3":9,"\uf7e2":9,"\uf7e0":9,"\uf7e1":9,"\uf779":17,"\uf778":6,"\uf76f":9,"\uf761":9,"\u00d2":9,"\u00d4":9,"\u00d3":9,"\u00c1":9,"\u00c2":9,"\u00ff":9,"\u0152":9,"\u00d5":9,"\u00c3":9,"\u00c0":9,"\u2026":-4,"\u00d8":9,"\u00d6":9,"\u00c7":9,"\u00c5":9,"\u00c4":9,"y":9,"Z":9,"Y":13,"X":6,"W":6,"V":6,"T":15,"Q":9,"O":9,"J":13,"G":9,"C":9,"A":9,".":11,",":-4}},"\u00da":{"d":"162,-282r-88,21r-5,-16r83,-33xm117,-20v44,0,59,-16,59,-67r0,-153r25,0r0,142v3,86,-23,93,-88,102v-63,-8,-85,-19,-85,-103r0,-141r29,0r0,162v0,40,20,58,60,58","w":228,"k":{"\u00c1":11,"\u00c2":11,"\u00c3":11,"\u00c0":11,"\u00c6":13,"\u00c5":11,"\u00c4":11,"J":6,"A":11}},"\u00db":{"d":"174,-275r-9,14r-50,-20r-49,20r-9,-14r59,-34xm117,-20v44,0,59,-16,59,-67r0,-153r25,0r0,142v3,86,-23,93,-88,102v-63,-8,-85,-19,-85,-103r0,-141r29,0r0,162v0,40,20,58,60,58","w":228,"k":{"\u00c1":11,"\u00c2":11,"\u00c3":11,"\u00c0":11,"\u00c6":13,"\u00c5":11,"\u00c4":11,"J":6,"A":11}},"\u00d9":{"d":"161,-277r-5,16r-88,-21r10,-28xm117,-20v44,0,59,-16,59,-67r0,-153r25,0r0,142v3,86,-23,93,-88,102v-63,-8,-85,-19,-85,-103r0,-141r29,0r0,162v0,40,20,58,60,58","w":228,"k":{"\u00c1":11,"\u00c2":11,"\u00c3":11,"\u00c0":11,"\u00c6":13,"\u00c5":11,"\u00c4":11,"J":6,"A":11}},"\u0131":{"d":"53,0r-27,0r0,-170r27,0r0,170","w":78},"\u02c6":{"d":"117,-206r-8,15r-45,-20r-43,19r-9,-15r52,-32","w":129},"\u02dc":{"d":"13,-209v24,-41,61,1,91,-22r12,11v-23,31,-40,21,-72,13v-6,0,-12,3,-18,10","w":129},"\u00af":{"d":"119,-206r-108,0r0,-19r108,0r0,19","w":129},"\u02d8":{"d":"115,-237v-2,27,-21,43,-50,43v-30,0,-49,-16,-51,-43r19,0v1,26,63,26,63,0r19,0","w":129},"\u02d9":{"d":"80,-216v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-15,16,-15v9,0,15,6,15,15","w":129},"\u02da":{"d":"98,-216v0,19,-14,34,-33,34v-19,0,-34,-15,-34,-34v0,-18,16,-33,34,-33v18,0,33,15,33,33xm84,-216v0,-11,-8,-20,-19,-20v-11,0,-19,9,-19,20v0,11,8,20,19,20v11,0,19,-9,19,-20","w":129},"\u00b8":{"d":"90,37v-1,30,-23,38,-51,28r3,-14v14,3,29,5,29,-11v0,-11,-13,-11,-23,-10r3,-33r17,0r-1,19v17,0,23,7,23,21","w":129},"\u02dd":{"d":"125,-235r-44,48r-14,-12r39,-53xm63,-235r-44,48r-15,-12r40,-53","w":129},"\u02db":{"d":"91,50v6,20,-1,19,-31,19v-15,0,-32,-10,-32,-34v0,-30,28,-45,50,-35v-21,1,-47,52,-11,53v15,0,24,-3,24,-3","w":129},"\uf761":{"d":"177,0r-29,0r-18,-49r-84,0r-18,49r-26,0r72,-186r30,0xm122,-70r-35,-92r-33,92r68,0","w":179,"k":{"\uf7ff":26,"\uf7fd":26,"\uf7fc":4,"\uf7fb":4,"\uf7f9":4,"\uf7fa":4,"\uf6fd":-2,"\uf6fa":6,"\uf7f8":6,"\uf7f6":6,"\uf7f5":6,"\uf7f4":6,"\uf7f2":6,"\uf7f3":6,"\uf7e7":6,"\uf779":26,"\uf777":6,"\uf776":17,"\uf775":4,"\uf774":26,"\uf773":-2,"\uf771":6,"\uf76f":6,"\uf76a":-4,"\uf767":6,"\uf763":6,"\u2019":30,"\u2018":43,"\u201d":30,"\u201c":43,"\u2014":13,"\u2013":13,"-":13}},"\uf762":{"d":"26,-186v60,0,121,-8,119,45v0,22,-8,36,-29,42v24,6,36,20,36,46v1,55,-62,56,-126,53r0,-186xm118,-139v0,-31,-29,-27,-65,-27r0,58v39,1,71,-4,65,-31xm107,-26v29,-16,20,-72,-29,-61r-25,0r0,66v21,0,48,0,54,-5","w":167,"k":{"\uf7ff":11,"\uf7fd":11,"\uf779":11,"\uf777":4,"\uf776":4}},"\uf763":{"d":"150,-11v-75,34,-134,10,-135,-81v-1,-85,56,-114,130,-88r-5,21v-60,-15,-96,-4,-96,64v0,78,33,87,99,64","w":156,"k":{"\uf7fc":2,"\uf7fb":2,"\uf7f9":2,"\uf7fa":2,"\uf6fa":9,"\uf7f8":9,"\uf7f6":9,"\uf7f5":9,"\uf7f4":9,"\uf7f2":9,"\uf7f3":9,"\uf7e7":9,"\uf775":2,"\uf771":9,"\uf76f":9,"\uf767":9,"\uf763":9,"\u2026":-9,".":-6,",":-9}},"\uf764":{"d":"73,-186v73,-3,99,31,99,93v0,64,-28,98,-106,93r-40,0r0,-186r47,0xm53,-21v68,3,90,-13,90,-72v0,-60,-22,-77,-90,-73r0,145","w":187,"k":{"\uf7e5":6,"\uf7ff":11,"\uf7fd":11,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf779":11,"\uf777":11,"\uf776":4,"\uf774":13,"\uf76a":11,"\uf761":6}},"\uf765":{"d":"143,0r-117,0r0,-186r116,0r0,20r-89,0r0,58r86,0r0,21r-86,0r0,66r90,0r0,21","w":154},"\uf766":{"d":"140,-166r-87,0r0,58r84,0r0,21r-84,0r0,87r-27,0r0,-186r114,0r0,20","w":148,"k":{"\uf7e5":15,"\uf7e4":15,"\uf7e3":15,"\uf7e2":15,"\uf7e0":15,"\uf7e1":15,"\uf76a":37,"\uf761":15,"\u2019":-4,"\u201d":-4,"\u2026":41,".":43,",":41}},"\uf767":{"d":"161,-13v-77,37,-146,15,-146,-80v0,-87,62,-114,142,-85r-5,20v-65,-15,-106,-12,-108,64v0,36,9,75,52,75v12,0,25,-2,39,-6r0,-65r26,0r0,77","w":178,"k":{"\uf7ff":9,"\uf7fd":9,"\uf779":9}},"\uf768":{"d":"168,0r-26,0r0,-87r-89,0r0,87r-27,0r0,-186r27,0r0,77r89,0r0,-77r26,0r0,186","w":194},"\uf769":{"d":"53,0r-27,0r0,-186r27,0r0,186","w":78},"\uf76a":{"d":"105,-64v8,72,-48,70,-103,59r4,-20v19,3,30,4,39,4v35,0,33,-19,33,-45r0,-120r27,0r0,122","w":128,"k":{"\uf7e5":6,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf761":6}},"\uf76b":{"d":"170,0r-35,0r-82,-95r0,95r-27,0r0,-186r27,0r0,84r81,-84r34,0r-86,87","w":173,"k":{"\uf7e5":-2,"\uf7f6":11,"\uf7f5":11,"\uf7f4":11,"\uf7f2":11,"\uf7f3":11,"\uf7e4":-2,"\uf7e3":-2,"\uf7e2":-2,"\uf7e0":-2,"\uf7e1":-2,"\uf76f":11,"\uf767":11,"\uf761":-2,"\u2014":22,"\u2013":22,"-":22}},"\uf76c":{"d":"139,0r-113,0r0,-186r27,0r0,165r86,0r0,21","w":143,"k":{"\uf7ff":37,"\uf7fd":37,"\uf7fc":6,"\uf7fb":6,"\uf7f9":6,"\uf7fa":6,"\uf6fa":11,"\uf7f8":11,"\uf7f6":11,"\uf7f5":11,"\uf7f4":11,"\uf7f2":11,"\uf7f3":11,"\uf7e7":11,"\uf779":37,"\uf777":15,"\uf776":26,"\uf775":6,"\uf774":39,"\uf771":11,"\uf76f":11,"\uf76a":-4,"\uf767":11,"\uf763":11,"\u00b7":65,"\u2019":35,"\u2018":37,"\u201d":35,"\u201c":37,"\u2014":24,"\u2013":24,"-":24}},"\uf76d":{"d":"220,0r-25,0r-6,-155r-54,155r-31,0r-53,-155r-6,155r-23,0r9,-186r36,0r54,159r53,-159r36,0","w":243,"k":{"\uf7ff":4,"\uf7fd":4,"\uf7f6":2,"\uf7f5":2,"\uf7f4":2,"\uf7f2":2,"\uf7f3":2,"\uf779":4,"\uf76f":2}},"\uf76e":{"d":"170,0r-36,0r-85,-156r0,156r-23,0r0,-186r37,0r84,155r0,-155r23,0r0,186","w":196},"\uf76f":{"d":"179,-92v0,62,-28,96,-82,96v-54,0,-82,-35,-82,-97v0,-61,29,-96,82,-96v53,0,82,36,82,97xm150,-92v0,-51,-17,-75,-52,-75v-35,0,-54,24,-54,74v0,38,10,75,54,75v35,0,52,-23,52,-74","w":194,"k":{"\uf7e5":6,"\uf7ff":11,"\uf7fd":11,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf779":11,"\uf778":6,"\uf776":4,"\uf774":13,"\uf76d":2,"\uf761":6}},"\uf770":{"d":"134,-176v42,37,18,116,-60,102r-21,0r0,74r-27,0r0,-186v36,1,90,-6,108,10xm110,-100v30,-19,20,-78,-34,-65r-23,0r0,70v21,0,54,0,57,-5","w":163,"k":{"\uf7e5":22,"\uf7ff":3,"\uf7fd":3,"\uf7e4":22,"\uf7e3":22,"\uf7e2":22,"\uf7e0":22,"\uf7e1":22,"\uf779":3,"\uf761":22,"\u2026":41,".":43,",":41}},"\uf771":{"d":"179,-92v0,62,-29,92,-73,95v1,33,36,21,65,17r4,17v-49,15,-94,20,-94,-34v-38,-6,-66,-34,-66,-96v0,-61,29,-96,82,-96v53,0,82,36,82,97xm150,-92v0,-51,-17,-75,-52,-75v-35,0,-54,24,-54,74v0,38,10,75,54,75v35,0,52,-23,52,-74","w":194},"\uf772":{"d":"26,-186v59,0,122,-8,122,49v0,24,-11,39,-34,46v24,5,38,63,51,91r-29,0v-19,-37,-16,-91,-83,-81r0,81r-27,0r0,-186xm120,-135v2,-34,-29,-32,-67,-31r0,64v42,0,66,1,67,-33","w":171,"k":{"\uf7ff":9,"\uf7fd":9,"\uf6fa":4,"\uf7f8":4,"\uf7f6":4,"\uf7f5":4,"\uf7f4":4,"\uf7f2":4,"\uf7f3":4,"\uf7e7":4,"\uf779":9,"\uf776":3,"\uf774":9,"\uf771":4,"\uf76f":4,"\uf767":4,"\uf763":4,"\u2014":4,"\u2013":4,"-":4}},"\uf773":{"d":"78,-108v84,16,67,113,-12,110v-19,0,-33,-3,-57,-10r6,-20v39,11,88,13,90,-23v0,-12,-3,-19,-17,-25v-31,-13,-77,-16,-77,-60v0,-53,64,-63,114,-44r-5,21v-37,-8,-79,-16,-81,20v0,15,5,24,39,31","w":147,"k":{"\uf7e5":2,"\uf7ff":4,"\uf7fd":4,"\uf6fd":4,"\uf7e4":2,"\uf7e3":2,"\uf7e2":2,"\uf7e0":2,"\uf7e1":2,"\uf779":4,"\uf774":4,"\uf773":4,"\uf761":2}},"\uf774":{"d":"153,-166r-61,0r0,166r-27,0r0,-166r-61,0r0,-20r149,0r0,20","w":156,"k":{"\uf7e5":26,"\uf7ff":-4,"\uf7fd":-4,"\uf7f6":13,"\uf7f5":13,"\uf7f4":13,"\uf7f2":13,"\uf7f3":13,"\uf7e4":26,"\uf7e3":26,"\uf7e2":26,"\uf7e0":26,"\uf7e1":26,"\uf779":-4,"\uf76f":13,"\uf76d":4,"\uf76a":26,"\uf761":26,"\u2019":-4,"\u2014":37,"\u2013":37,"\u2026":32,".":35,"-":37,",":32}},"\uf775":{"d":"98,-19v35,-3,46,-10,45,-49r0,-118r24,0r0,110v3,66,-22,74,-73,80v-49,-7,-70,-15,-70,-81r0,-109r26,0v8,64,-29,171,48,167","k":{"\uf7e5":6,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf761":6}},"\uf776":{"d":"171,-186r-69,186r-31,0r-69,-186r31,0r55,161r56,-161r27,0","w":172,"k":{"\uf7e5":17,"\uf7ff":-2,"\uf7fd":-2,"\uf6fa":4,"\uf7f8":4,"\uf7f6":4,"\uf7f5":4,"\uf7f4":4,"\uf7f2":4,"\uf7f3":4,"\uf7e7":4,"\uf7e4":17,"\uf7e3":17,"\uf7e2":17,"\uf7e0":17,"\uf7e1":17,"\uf779":-2,"\uf771":4,"\uf76f":4,"\uf767":4,"\uf763":4,"\uf761":17,"\u2014":4,"\u2013":4,"\u2026":24,".":26,"-":4,",":24}},"\uf777":{"d":"230,-186r-46,186r-35,0r-32,-160r-36,160r-35,0r-44,-186r30,0r32,161r37,-161r35,0r32,161r38,-161r24,0","w":231,"k":{"\uf7e5":6,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf761":6,"\u2026":6,".":9,",":6}},"\uf778":{"d":"166,0r-33,0r-50,-75r-52,75r-29,0r67,-97r-64,-89r34,0r47,69r47,-69r29,0r-62,89","w":168,"k":{"\uf6fa":6,"\uf7f8":6,"\uf7f6":6,"\uf7f5":6,"\uf7f4":6,"\uf7f2":6,"\uf7f3":6,"\uf7e7":6,"\uf771":6,"\uf76f":6,"\uf767":6,"\uf763":6,"\u2014":28,"\u2013":28,"-":28}},"\uf779":{"d":"164,-186r-68,105r0,81r-26,0r0,-81r-68,-105r32,0r51,81r51,-81r28,0","w":166,"k":{"\uf7e5":26,"\uf6fd":3,"\uf6fa":11,"\uf7f8":11,"\uf7f6":11,"\uf7f5":11,"\uf7f4":11,"\uf7f2":11,"\uf7f3":11,"\uf7e7":11,"\uf7e4":26,"\uf7e3":26,"\uf7e2":26,"\uf7e0":26,"\uf7e1":26,"\uf774":-4,"\uf773":3,"\uf771":11,"\uf76f":11,"\uf76d":4,"\uf767":11,"\uf763":11,"\uf761":26,"\u2019":-4,"\u2014":28,"\u2013":28,"\u2026":32,".":35,"-":28,",":35}},"\uf77a":{"d":"151,0r-140,0r0,-18r105,-148r-101,0r0,-20r134,0r0,18r-104,147r106,0r0,21","w":161,"k":{"\uf6fa":6,"\uf7f8":6,"\uf7f6":6,"\uf7f5":6,"\uf7f4":6,"\uf7f2":6,"\uf7f3":6,"\uf76f":6,"\u2014":17,"\u2013":17,"-":17}},"\uf7e1":{"d":"177,0r-29,0r-18,-49r-84,0r-18,49r-26,0r72,-186r30,0xm122,-70r-35,-92r-33,92r68,0xm131,-228r-78,21r-4,-16r73,-32","w":179,"k":{"\uf7ff":26,"\uf7fd":26,"\uf7fc":4,"\uf7fb":4,"\uf7f9":4,"\uf7fa":4,"\uf6fd":-2,"\uf6fa":6,"\uf7f8":6,"\uf7f6":6,"\uf7f5":6,"\uf7f4":6,"\uf7f2":6,"\uf7f3":6,"\uf7e7":6,"\uf779":26,"\uf777":6,"\uf776":17,"\uf775":4,"\uf774":26,"\uf773":-2,"\uf771":6,"\uf76f":6,"\uf76a":-4,"\uf767":6,"\uf763":6,"\u2019":30,"\u2018":43,"\u201d":30,"\u201c":43,"\u2014":13,"\u2013":13,"-":13}},"\uf7e0":{"d":"177,0r-29,0r-18,-49r-84,0r-18,49r-26,0r72,-186r30,0xm122,-70r-35,-92r-33,92r68,0xm131,-223r-5,16r-77,-21r8,-27","w":179,"k":{"\uf7ff":26,"\uf7fd":26,"\uf7fc":4,"\uf7fb":4,"\uf7f9":4,"\uf7fa":4,"\uf6fd":-2,"\uf6fa":6,"\uf7f8":6,"\uf7f6":6,"\uf7f5":6,"\uf7f4":6,"\uf7f2":6,"\uf7f3":6,"\uf7e7":6,"\uf779":26,"\uf777":6,"\uf776":17,"\uf775":4,"\uf774":26,"\uf773":-2,"\uf771":6,"\uf76f":6,"\uf76a":-4,"\uf767":6,"\uf763":6,"\u2019":30,"\u2018":43,"\u201d":30,"\u201c":43,"\u2014":13,"\u2013":13,"-":13}},"\uf7e2":{"d":"177,0r-29,0r-18,-49r-84,0r-18,49r-26,0r72,-186r30,0xm122,-70r-35,-92r-33,92r68,0xm142,-221r-8,15r-45,-20r-43,19r-9,-15r52,-33","w":179,"k":{"\uf7ff":26,"\uf7fd":26,"\uf7fc":4,"\uf7fb":4,"\uf7f9":4,"\uf7fa":4,"\uf6fd":-2,"\uf6fa":6,"\uf7f8":6,"\uf7f6":6,"\uf7f5":6,"\uf7f4":6,"\uf7f2":6,"\uf7f3":6,"\uf7e7":6,"\uf779":26,"\uf777":6,"\uf776":17,"\uf775":4,"\uf774":26,"\uf773":-2,"\uf771":6,"\uf76f":6,"\uf76a":-4,"\uf767":6,"\uf763":6,"\u2019":30,"\u2018":43,"\u201d":30,"\u201c":43,"\u2014":13,"\u2013":13,"-":13}},"\uf7e3":{"d":"177,0r-29,0r-18,-49r-84,0r-18,49r-26,0r72,-186r30,0xm122,-70r-35,-92r-33,92r68,0xm38,-224v20,-29,43,-22,72,-13v5,0,10,-3,19,-10r12,12v-24,31,-40,22,-72,13v-6,0,-12,3,-18,10","w":179,"k":{"\uf7ff":26,"\uf7fd":26,"\uf7fc":4,"\uf7fb":4,"\uf7f9":4,"\uf7fa":4,"\uf6fd":-2,"\uf6fa":6,"\uf7f8":6,"\uf7f6":6,"\uf7f5":6,"\uf7f4":6,"\uf7f2":6,"\uf7f3":6,"\uf7e7":6,"\uf779":26,"\uf777":6,"\uf776":17,"\uf775":4,"\uf774":26,"\uf773":-2,"\uf771":6,"\uf76f":6,"\uf76a":-4,"\uf767":6,"\uf763":6,"\u2019":30,"\u2018":43,"\u201d":30,"\u201c":43,"\u2014":13,"\u2013":13,"-":13}},"\uf7e4":{"d":"177,0r-29,0r-18,-49r-84,0r-18,49r-26,0r72,-186r30,0xm122,-70r-35,-92r-33,92r68,0xm138,-237v0,9,-7,16,-16,16v-9,0,-15,-7,-15,-16v0,-9,6,-16,15,-16v9,0,16,7,16,16xm73,-237v0,9,-7,16,-16,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,16,7,16,16","w":179,"k":{"\uf7ff":26,"\uf7fd":26,"\uf7fc":4,"\uf7fb":4,"\uf7f9":4,"\uf7fa":4,"\uf6fd":-2,"\uf6fa":6,"\uf7f8":6,"\uf7f6":6,"\uf7f5":6,"\uf7f4":6,"\uf7f2":6,"\uf7f3":6,"\uf7e7":6,"\uf779":26,"\uf777":6,"\uf776":17,"\uf775":4,"\uf774":26,"\uf773":-2,"\uf771":6,"\uf76f":6,"\uf76a":-4,"\uf767":6,"\uf763":6,"\u2019":30,"\u2018":43,"\u201d":30,"\u201c":43,"\u2014":13,"\u2013":13,"-":13}},"\uf7e6":{"d":"255,0r-116,0r0,-49r-76,0r-33,49r-28,0r127,-186r123,0r0,20r-86,0r0,58r84,0r0,21r-84,0r0,66r89,0r0,21xm139,-70r0,-92r-62,92r62,0","w":265},"\uf7e7":{"d":"150,-11v-34,18,-59,1,-54,27v17,0,24,7,24,21v-1,31,-23,38,-52,28r4,-14v13,3,28,5,28,-11v0,-11,-13,-11,-23,-10r3,-27v-37,-4,-65,-35,-65,-95v0,-85,56,-114,130,-88r-5,21v-60,-15,-96,-4,-96,64v0,78,33,87,99,64","w":156,"k":{"\uf7fc":2,"\uf7fb":2,"\uf7f9":2,"\uf7fa":2,"\uf6fa":9,"\uf7f8":9,"\uf7f6":9,"\uf7f5":9,"\uf7f4":9,"\uf7f2":9,"\uf7f3":9,"\uf7e7":9,"\uf775":2,"\uf771":9,"\uf76f":9,"\uf767":9,"\uf763":9,"\u2026":-9,".":-6,",":-9}},"\uf7f0":{"d":"73,-186v73,-3,99,31,99,93v0,64,-28,98,-106,93r-40,0r0,-87r-25,0r0,-21r25,0r0,-78r47,0xm53,-21v68,3,90,-13,90,-72v0,-60,-22,-77,-90,-73r0,58r43,0r0,21r-43,0r0,66","w":187,"k":{"\uf7e5":6,"\uf7ff":11,"\uf7fd":11,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf779":11,"\uf777":11,"\uf776":4,"\uf774":13,"\uf76a":11,"\uf761":6}},"\uf7e9":{"d":"143,0r-117,0r0,-186r116,0r0,20r-89,0r0,58r86,0r0,21r-86,0r0,66r90,0r0,21xm125,-228r-77,21r-5,-16r74,-32","w":154},"\uf7e8":{"d":"143,0r-117,0r0,-186r116,0r0,20r-89,0r0,58r86,0r0,21r-86,0r0,66r90,0r0,21xm125,-223r-5,16r-77,-21r8,-27","w":154},"\uf7ea":{"d":"143,0r-117,0r0,-186r116,0r0,20r-89,0r0,58r86,0r0,21r-86,0r0,66r90,0r0,21xm136,-221r-8,15r-44,-20r-44,19r-9,-15r52,-33","w":154},"\uf7eb":{"d":"143,0r-117,0r0,-186r116,0r0,20r-89,0r0,58r86,0r0,21r-86,0r0,66r90,0r0,21xm132,-237v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16xm67,-237v0,9,-7,16,-16,16v-9,0,-15,-7,-15,-16v0,-9,6,-16,15,-16v9,0,16,7,16,16","w":154},"\uf7ed":{"d":"53,0r-27,0r0,-186r27,0r0,186xm80,-228r-77,21r-5,-16r74,-32","w":78},"\uf7ec":{"d":"53,0r-27,0r0,-186r27,0r0,186xm80,-223r-4,16r-78,-21r8,-27","w":78},"\uf7ee":{"d":"53,0r-27,0r0,-186r27,0r0,186xm92,-221r-8,15r-45,-20r-44,19r-8,-15r52,-33","w":78},"\uf7ef":{"d":"53,0r-27,0r0,-186r27,0r0,186xm87,-237v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16xm22,-237v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16","w":78},"\uf6f9":{"d":"139,0r-113,0r0,-75r-19,13r-9,-13r28,-20r0,-91r27,0r0,72r25,-18r10,14r-35,24r0,73r86,0r0,21","w":143,"k":{"\uf7ff":37,"\uf7fd":37,"\uf7fc":6,"\uf7fb":6,"\uf7f9":6,"\uf7fa":6,"\uf6fa":11,"\uf7f8":11,"\uf7f6":11,"\uf7f5":11,"\uf7f4":11,"\uf7f2":11,"\uf7f3":11,"\uf7e7":11,"\uf779":37,"\uf777":15,"\uf776":26,"\uf775":6,"\uf774":39,"\uf771":11,"\uf76f":11,"\uf76a":-4,"\uf767":11,"\uf763":11,"\u00b7":65,"\u2019":35,"\u2018":37,"\u201d":35,"\u201c":37,"\u2014":24,"\u2013":24,"-":24}},"\uf7f1":{"d":"170,0r-36,0r-85,-156r0,156r-23,0r0,-186r37,0r84,155r0,-155r23,0r0,186xm46,-224v20,-29,43,-22,72,-13v5,0,10,-3,19,-10r12,12v-23,31,-40,21,-72,13v-6,0,-12,3,-18,10","w":196},"\uf7f3":{"d":"179,-92v0,62,-28,96,-82,96v-54,0,-82,-35,-82,-97v0,-61,29,-96,82,-96v53,0,82,36,82,97xm150,-92v0,-51,-17,-75,-52,-75v-35,0,-54,24,-54,74v0,38,10,75,54,75v35,0,52,-23,52,-74xm138,-228r-77,21r-5,-16r74,-32","w":194,"k":{"\uf7e5":6,"\uf7ff":11,"\uf7fd":11,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf778":6,"\uf776":4,"\uf774":13,"\uf76d":2,"\uf761":6}},"\uf7f2":{"d":"179,-92v0,62,-28,96,-82,96v-54,0,-82,-35,-82,-97v0,-61,29,-96,82,-96v53,0,82,36,82,97xm150,-92v0,-51,-17,-75,-52,-75v-35,0,-54,24,-54,74v0,38,10,75,54,75v35,0,52,-23,52,-74xm138,-223r-4,16r-78,-21r8,-27","w":194,"k":{"\uf7e5":6,"\uf7ff":11,"\uf7fd":11,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf779":11,"\uf778":6,"\uf776":4,"\uf774":13,"\uf76d":2,"\uf761":6}},"\uf7f4":{"d":"179,-92v0,62,-28,96,-82,96v-54,0,-82,-35,-82,-97v0,-61,29,-96,82,-96v53,0,82,36,82,97xm150,-92v0,-51,-17,-75,-52,-75v-35,0,-54,24,-54,74v0,38,10,75,54,75v35,0,52,-23,52,-74xm150,-221r-9,15r-44,-20r-44,19r-8,-15r51,-33","w":194,"k":{"\uf7e5":6,"\uf7ff":11,"\uf7fd":11,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf779":11,"\uf778":6,"\uf776":4,"\uf774":13,"\uf76d":2,"\uf761":6}},"\uf7f5":{"d":"179,-92v0,62,-28,96,-82,96v-54,0,-82,-35,-82,-97v0,-61,29,-96,82,-96v53,0,82,36,82,97xm150,-92v0,-51,-17,-75,-52,-75v-35,0,-54,24,-54,74v0,38,10,75,54,75v35,0,52,-23,52,-74xm46,-224v20,-29,42,-22,72,-13v5,0,9,-3,18,-10r13,12v-24,30,-40,22,-72,13v-6,0,-12,3,-18,10","w":194,"k":{"\uf7e5":6,"\uf7ff":11,"\uf7fd":11,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf779":11,"\uf778":6,"\uf776":4,"\uf774":13,"\uf76d":2,"\uf761":6}},"\uf7f6":{"d":"179,-92v0,62,-28,96,-82,96v-54,0,-82,-35,-82,-97v0,-61,29,-96,82,-96v53,0,82,36,82,97xm150,-92v0,-51,-17,-75,-52,-75v-35,0,-54,24,-54,74v0,38,10,75,54,75v35,0,52,-23,52,-74xm145,-237v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16xm80,-237v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16","w":194,"k":{"\uf7e5":6,"\uf7ff":11,"\uf7fd":11,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf779":11,"\uf778":6,"\uf776":4,"\uf774":13,"\uf76d":2,"\uf761":6}},"\uf7f8":{"d":"179,-92v0,83,-68,117,-130,83r-14,20r-19,-12r17,-23v-12,-17,-18,-40,-18,-69v0,-82,67,-117,129,-83r15,-20r18,12r-17,23v13,17,19,40,19,69xm130,-156v-41,-28,-86,-2,-86,64v0,30,7,44,7,44xm98,-18v51,0,61,-75,45,-120r-79,109v8,7,20,11,34,11","w":194,"k":{"\uf7e5":6,"\uf7ff":11,"\uf7fd":11,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf779":11,"\uf778":6,"\uf776":4,"\uf774":13,"\uf76d":2,"\uf761":6}},"\uf6fa":{"d":"15,-93v0,-64,27,-93,106,-93r121,0r0,20r-87,0r0,58r85,0r0,21r-85,0r0,66r89,0r0,21r-130,0v-72,3,-99,-31,-99,-93xm44,-93v0,57,19,76,85,72r0,-145v-68,-3,-85,16,-85,73","w":254},"\uf7fe":{"d":"134,-145v42,38,18,116,-60,102r-21,0r0,43r-27,0r0,-186r27,0r0,30v30,0,68,-2,81,11xm110,-69v30,-19,20,-78,-34,-65r-23,0r0,70v21,0,54,0,57,-5","w":163},"\uf6fd":{"d":"78,-108v84,16,67,113,-12,110v-19,0,-33,-3,-57,-10r6,-20v39,11,88,13,90,-23v0,-12,-3,-19,-17,-25v-31,-13,-77,-16,-77,-60v0,-53,64,-63,114,-44r-5,21v-37,-8,-79,-16,-81,20v0,15,5,24,39,31xm123,-239r-52,33r-53,-33r8,-16r45,20r43,-18","w":147,"k":{"\uf7e5":2,"\uf7ff":4,"\uf7fd":4,"\uf6fd":4,"\uf7e4":2,"\uf7e3":2,"\uf7e2":2,"\uf7e0":2,"\uf7e1":2,"\uf779":4,"\uf774":4,"\uf773":4,"\uf761":2}},"\uf7fa":{"d":"98,-19v35,-3,46,-10,45,-49r0,-118r24,0r0,110v3,66,-22,74,-73,80v-49,-7,-70,-15,-70,-81r0,-109r26,0v8,64,-29,171,48,167xm136,-228r-77,21r-5,-16r74,-32","k":{"\uf7e5":6,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf761":6}},"\uf7f9":{"d":"98,-19v35,-3,46,-10,45,-49r0,-118r24,0r0,110v3,66,-22,74,-73,80v-49,-7,-70,-15,-70,-81r0,-109r26,0v8,64,-29,171,48,167xm136,-223r-4,16r-78,-21r9,-27","k":{"\uf7e5":6,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf761":6}},"\uf7fb":{"d":"98,-19v35,-3,46,-10,45,-49r0,-118r24,0r0,110v3,66,-22,74,-73,80v-49,-7,-70,-15,-70,-81r0,-109r26,0v8,64,-29,171,48,167xm148,-221r-9,15r-44,-20r-44,19r-9,-15r52,-33","k":{"\uf7e5":6,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf761":6}},"\uf7fc":{"d":"98,-19v35,-3,46,-10,45,-49r0,-118r24,0r0,110v3,66,-22,74,-73,80v-49,-7,-70,-15,-70,-81r0,-109r26,0v8,64,-29,171,48,167xm144,-237v0,9,-7,16,-16,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,16,7,16,16xm78,-237v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16","k":{"\uf7e5":6,"\uf7e4":6,"\uf7e3":6,"\uf7e2":6,"\uf7e0":6,"\uf7e1":6,"\uf761":6}},"\uf7fd":{"d":"164,-186r-68,105r0,81r-26,0r0,-81r-68,-105r32,0r51,81r51,-81r28,0xm124,-228r-77,21r-5,-16r74,-32","w":166,"k":{"\uf7e5":26,"\uf6fd":3,"\uf6fa":11,"\uf7f8":11,"\uf7f6":11,"\uf7f5":11,"\uf7f4":11,"\uf7f2":11,"\uf7f3":11,"\uf7e7":11,"\uf7e4":26,"\uf7e3":26,"\uf7e2":26,"\uf7e0":26,"\uf7e1":26,"\uf774":-4,"\uf773":3,"\uf771":11,"\uf76f":11,"\uf76d":4,"\uf767":11,"\uf763":11,"\uf761":26,"\u2019":-4,"\u2014":28,"\u2013":28,"\u2026":32,".":35,"-":28,",":32}},"\uf7ff":{"d":"164,-186r-68,105r0,81r-26,0r0,-81r-68,-105r32,0r51,81r51,-81r28,0xm131,-237v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16xm66,-237v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16","w":166,"k":{"\uf7e5":26,"\uf6fd":3,"\uf6fa":11,"\uf7f8":11,"\uf7f6":11,"\uf7f5":11,"\uf7f4":11,"\uf7f2":11,"\uf7f3":11,"\uf7e7":11,"\uf7e4":26,"\uf7e3":26,"\uf7e2":26,"\uf7e0":26,"\uf7e1":26,"\uf774":-4,"\uf773":3,"\uf771":11,"\uf76f":11,"\uf76d":4,"\uf767":11,"\uf763":11,"\uf761":26,"\u2019":-4,"\u2014":28,"\u2013":28,"\u2026":32,".":35,"-":28,",":32}},"\uf6ff":{"d":"151,0r-140,0r0,-18r105,-148r-101,0r0,-20r134,0r0,18r-104,147r106,0r0,21xm133,-239r-52,33r-53,-33r8,-16r45,20r44,-18","w":161,"k":{"\uf7f6":6,"\uf7f5":6,"\uf7f4":6,"\uf7f2":6,"\uf7f3":6,"\uf76f":6,"\u2014":17,"\u2013":17,"-":17}},"\uf726":{"d":"184,-11r-9,16v-18,-6,-26,-11,-38,-22v-40,36,-125,26,-123,-34v0,-26,13,-41,44,-52v-38,-36,-24,-85,31,-86v30,0,48,14,48,40v0,24,-10,36,-41,49r44,50v7,-11,10,-22,12,-42r21,0v-1,21,-6,38,-18,57v10,12,17,18,29,24xm112,-148v0,-14,-10,-22,-25,-22v-38,1,-22,42,-4,56v21,-10,29,-18,29,-34xm122,-31v-19,-18,-34,-38,-52,-57v-42,13,-37,72,11,70v14,0,28,-4,41,-13","w":198},"\uf730":{"d":"165,-94v0,60,-29,97,-76,97v-47,0,-76,-36,-76,-96v0,-62,28,-97,76,-97v48,0,76,36,76,96xm136,-94v0,-50,-15,-74,-48,-74v-33,0,-46,24,-46,75v0,50,15,75,47,75v33,0,47,-24,47,-76","w":177},"\uf731":{"d":"71,0r-26,0r0,-162r-38,4r-3,-19r67,-12r0,189","w":99},"\uf732":{"d":"145,0r-134,0r0,-17v85,-71,102,-92,102,-120v0,-19,-12,-30,-38,-30v-23,0,-57,9,-57,9r-4,-20v55,-19,128,-21,127,40v0,38,-33,67,-94,117r98,0r0,21","w":159},"\uf733":{"d":"40,-87v56,0,62,-5,68,-45v-4,-46,-44,-38,-94,-27r-3,-19v59,-19,123,-22,124,44v0,30,-16,51,-44,56v34,4,51,21,51,53v0,71,-71,77,-136,60r3,-18v52,9,105,12,105,-43v0,-34,-24,-42,-74,-41r0,-20","w":152},"\uf734":{"d":"166,-4r-31,0r0,47r-25,0r0,-47r-104,0r0,-19r90,-163r39,0r0,160r31,0r0,22xm110,-26r0,-139r-76,139r76,0","w":176},"\uf735":{"d":"148,-31v0,72,-69,85,-135,66r2,-19v46,10,104,14,104,-45v0,-50,-47,-56,-98,-46r0,-111r118,0r0,20r-92,0r0,70v51,-11,101,10,101,65","w":156},"\uf736":{"d":"154,-73v0,48,-25,76,-69,76v-48,0,-74,-39,-74,-111v0,-104,51,-142,136,-112r-4,18v-64,-15,-101,-6,-103,76v60,-23,114,-15,114,53xm127,-71v0,-52,-50,-47,-88,-36v0,62,14,89,49,89v26,0,39,-18,39,-53","w":163},"\uf737":{"d":"154,-167r-99,210r-24,-10r95,-199r-113,0r0,-20r141,0r0,19","w":168},"\uf738":{"d":"118,-120v69,22,41,123,-36,123v-49,0,-73,-21,-73,-65v0,-30,11,-48,35,-56v0,0,-28,-8,-28,-50v0,-38,25,-62,67,-62v41,0,66,21,66,58v0,44,-31,52,-31,52xm125,-171v0,-24,-16,-39,-42,-39v-46,0,-57,58,-22,74v5,3,13,5,33,10v21,-5,31,-21,31,-45xm131,-60v-1,-41,-35,-41,-67,-51v-22,7,-30,23,-30,46v0,32,16,48,51,48v29,0,46,-17,46,-43","w":165},"\uf739":{"d":"152,-78v0,104,-52,141,-136,111r4,-18v64,17,101,7,103,-76v-60,23,-114,15,-114,-53v0,-48,25,-76,69,-76v48,0,74,40,74,112xm124,-80v0,-62,-14,-89,-49,-89v-26,0,-39,18,-39,53v0,53,50,48,88,36","w":163},"\uf6c9":{"d":"112,-282r-88,21r-5,-16r83,-33","w":129},"\uf6ce":{"d":"112,-277r-6,16r-87,-21r9,-28","w":129},"\ueff7":{"d":"123,-275r-9,14r-50,-20r-48,20r-10,-14r60,-34","w":129},"\ueff5":{"d":"9,-272v23,-29,47,-21,80,-13v7,0,11,-1,19,-9r12,14v-27,41,-68,-6,-99,21","w":129},"\uf6cb":{"d":"113,-284v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16xm48,-284v0,9,-7,16,-16,16v-9,0,-15,-7,-15,-16v0,-9,6,-16,15,-16v9,0,16,7,16,16","w":129},"\uf6d0":{"d":"117,-268r-104,0r0,-22r104,0r0,22","w":129},"\uefee":{"d":"96,-311r19,0v-4,28,-21,43,-51,43v-30,0,-47,-15,-50,-43r19,0v3,27,61,27,63,0","w":129},"\ueff3":{"d":"99,-288v0,19,-15,35,-34,35v-19,0,-35,-16,-35,-35v0,-19,16,-34,35,-34v19,0,34,15,34,34xm84,-288v0,-11,-8,-20,-19,-20v-11,0,-20,9,-20,20v0,11,9,21,20,21v11,0,19,-10,19,-21","w":129},"\u02c7":{"d":"117,-224r-51,33r-54,-33r9,-15r44,19r44,-18","w":129},"\uf6ca":{"d":"125,-295r-60,34r-57,-33r9,-15r49,20r49,-20","w":129},"\uf6cf":{"d":"125,-316r-44,48r-14,-12r39,-53xm63,-316r-44,48r-15,-12r40,-53","w":129},"\uefed":{"d":"65,-300v9,0,15,7,15,16v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16","w":129},"\ueff2":{"d":"90,37v-1,30,-23,38,-51,28r3,-14v14,3,29,5,29,-11v0,-11,-13,-11,-23,-10r3,-33r17,0r-1,19v17,0,23,7,23,21","w":129},"\ueff1":{"d":"91,50v6,20,-1,19,-31,19v-15,0,-32,-10,-32,-34v0,-30,28,-45,50,-35v-21,1,-47,52,-11,53v15,0,24,-3,24,-3","w":129},"\uf684":{"d":"53,0r-27,0r0,-186r27,0r0,186xm183,-64v8,71,-47,70,-102,59r4,-20v19,3,29,4,38,4v35,0,34,-19,34,-45r0,-120r26,0r0,122","w":207},"\u0132":{"d":"59,0r-29,0r0,-240r29,0r0,240xm98,-27v57,9,88,13,88,-57r0,-156r29,0r0,158v11,92,-55,90,-121,76","w":243},"\u014a":{"d":"203,0v8,81,-60,82,-121,67r4,-21v51,9,92,12,89,-46r-121,-211r0,211r-24,0r0,-240r41,0r104,183r0,-183r28,0r0,240","w":233},"\u0133":{"d":"57,-224v0,9,-8,18,-17,18v-10,0,-18,-8,-18,-18v0,-9,8,-17,17,-17v9,0,18,7,18,17xm53,0r-27,0r0,-170r27,0r0,170xm132,-224v0,9,-8,18,-17,18v-10,0,-17,-8,-17,-18v0,-9,8,-17,17,-17v9,0,17,7,17,17xm129,10v6,64,-30,70,-81,61r2,-18v36,7,52,-2,52,-40r0,-183r27,0r0,180","w":154,"k":{"j":-4}},"\u014b":{"d":"52,-156v51,-27,105,-32,105,43r0,123v6,64,-30,70,-81,61r3,-18v36,7,52,-2,52,-40r0,-117v0,-25,1,-45,-29,-45v-14,0,-31,4,-49,10r0,139r-27,0r0,-170r26,0r0,14","w":181},"\uf67b":{"d":"170,8v8,72,-48,71,-102,59r4,-20v19,3,29,4,38,4v38,0,34,-21,34,-51r-95,-156r0,156r-23,0r0,-186r37,0r81,133r0,-133r26,0r0,194","w":196},"\u03a9":{"d":"219,0r-85,0r0,-19v35,-6,52,-37,52,-98v0,-72,-21,-104,-68,-104v-45,0,-68,35,-68,100v0,64,16,96,52,102r0,19r-85,0r0,-22r38,0v-24,-22,-36,-55,-36,-103v0,-76,36,-119,99,-119v63,0,99,44,99,122v0,46,-13,79,-37,100r39,0r0,22","w":236},"\u2116":{"d":"203,0r-41,0r-108,-211r0,211r-24,0r0,-240r41,0r108,213r0,-213r24,0r0,240xm342,-180v0,39,-20,62,-55,62v-35,0,-55,-23,-55,-62v0,-38,21,-61,55,-61v35,0,55,22,55,61xm319,-180v0,-30,-10,-44,-32,-44v-21,0,-32,15,-32,44v0,30,11,44,32,44v22,0,32,-14,32,-44","w":352},"\u20a3":{"d":"166,-219r-107,0r0,82r104,0r0,22r-104,0r0,115r-29,0r0,-240r136,0r0,21xm269,-114v-21,0,-33,1,-52,10r0,104r-27,0r0,-137r26,0r0,15v20,-13,32,-19,53,-16r0,24","w":271},"\u20a7":{"d":"186,-171v-3,65,-48,78,-127,73r0,98r-29,0r0,-240v75,0,159,-12,156,69xm59,-120v61,2,98,1,98,-50v0,-51,-44,-49,-98,-48r0,98xm255,-59v-6,55,8,39,48,34r5,17v-41,19,-80,22,-80,-38r0,-104r-29,0r0,-15r29,-3r0,-47r27,0r0,45r47,0r0,20r-47,0r0,91xm409,-47v0,-39,-93,-28,-83,-77v-1,-49,56,-60,101,-41r-4,19v-31,-9,-69,-12,-69,19v0,39,83,18,83,77v0,53,-63,63,-112,45r5,-19v34,9,79,9,79,-23","w":447},"\u20a4":{"d":"153,-79r-79,0v-5,21,-12,45,-24,57r135,0r0,22r-168,0r0,-19v15,-10,22,-24,28,-60r-21,0r0,-19r25,0r8,-39r-33,0r0,-20r36,0v11,-55,15,-86,61,-86v19,0,44,7,64,13r-5,19v-58,-19,-87,-5,-91,54r64,0r0,20r-68,0r-7,39r75,0r0,19"},"\u2113":{"d":"109,-39v17,13,-18,48,-32,44v-31,-7,-26,-32,-20,-77v-16,20,-31,14,-16,-2v3,-3,14,-14,18,-19v20,-103,42,-151,71,-151v14,0,23,11,23,29v0,47,-29,84,-63,118v-10,54,-12,62,-12,75v0,6,2,9,6,9v8,4,17,-20,25,-26xm94,-120v29,-33,45,-65,45,-93v-1,-23,-17,-18,-23,0v-6,19,-15,52,-22,93","w":180},"\u212e":{"d":"59,-45v34,57,132,53,171,3r19,0v-24,28,-62,47,-105,47v-73,0,-134,-54,-134,-120v0,-66,61,-120,134,-120v74,1,134,54,133,123r-218,1r0,66xm228,-186v-32,-57,-139,-55,-169,2v2,21,-3,48,2,65r167,-2r0,-65","w":287},"\u2012":{"d":"178,-91r-166,0r0,-22r166,0r0,22"},"\u00a4":{"d":"186,-47r-16,16r-19,-19v-28,27,-84,27,-112,0r-20,19r-15,-16r21,-21v-17,-26,-17,-82,-1,-109r-20,-21r15,-16r19,19v27,-28,86,-28,114,0r18,-19r16,16r-20,21v17,27,15,83,-1,109xm149,-123v0,-50,-21,-71,-54,-71v-33,0,-54,21,-54,72v0,50,22,71,54,71v33,0,54,-20,54,-72"},"\u2070":{"d":"122,-177v0,42,-18,65,-53,65v-36,0,-54,-23,-54,-65v0,-40,19,-65,53,-65v35,0,54,25,54,65xm99,-177v0,-31,-8,-47,-30,-47v-22,0,-30,16,-30,47v0,31,8,47,30,47v22,0,30,-15,30,-47","w":137},"\u2074":{"d":"123,-144r-21,0r0,31r-21,0r0,-31r-66,0r0,-13r66,-83r21,0r0,79r21,0r0,17xm81,-161r0,-52r-41,52r41,0","w":137},"\u2075":{"d":"114,-155v0,43,-49,50,-91,38r3,-16v29,7,61,7,64,-21v3,-28,-44,-21,-62,-17r0,-69r81,0r0,19r-59,0r0,30v31,-6,64,2,64,36","w":137},"\u2076":{"d":"116,-155v0,28,-18,43,-47,43v-33,0,-46,-28,-46,-62v0,-59,41,-82,90,-60r-4,15v-32,-9,-62,-6,-63,31v34,-12,71,-3,70,33xm93,-155v0,-23,-27,-24,-47,-17v1,29,8,43,25,43v14,0,22,-11,22,-26","w":137},"\u2077":{"d":"114,-224r-62,116r-20,-10r58,-103r-71,0r0,-19r95,0r0,16","w":137},"\u2078":{"d":"96,-180v38,16,20,74,-28,68v-50,6,-62,-50,-29,-68v-32,-18,-9,-62,30,-62v25,0,44,12,44,35v0,17,-14,26,-17,27xm76,-185v20,-5,21,-41,-7,-41v-13,0,-24,6,-24,19v0,15,20,21,31,22xm95,-149v0,-29,-54,-32,-53,-2v0,15,11,24,28,24v14,0,25,-8,25,-22","w":137},"\u2079":{"d":"114,-178v0,60,-39,77,-90,60r4,-16v33,9,62,5,62,-32v-32,11,-69,5,-69,-31v0,-28,17,-45,46,-45v32,0,47,25,47,64xm44,-198v1,24,29,23,47,17v-1,-26,-8,-43,-25,-43v-16,0,-22,10,-22,26","w":137},"\u207d":{"d":"17,-177v0,-48,15,-73,53,-77r1,12v-43,3,-42,129,0,131r-1,12v-37,-3,-53,-28,-53,-78","w":87},"\u207e":{"d":"71,-177v0,50,-17,75,-54,78r0,-12v41,-3,41,-128,0,-131r0,-12v38,4,54,29,54,77","w":87},"\u2080":{"d":"122,-64v0,42,-18,66,-53,66v-36,0,-54,-23,-54,-65v0,-40,19,-65,53,-65v35,0,54,24,54,64xm99,-64v0,-31,-8,-47,-30,-47v-22,0,-30,16,-30,47v0,31,8,47,30,47v22,0,30,-15,30,-47","w":137},"\u2081":{"d":"89,0r-22,0r0,-109r-34,2r-2,-15r58,-8r0,130","w":137},"\u2082":{"d":"112,0r-87,0v-3,-22,13,-25,23,-35v32,-31,37,-46,37,-56v2,-24,-37,-22,-55,-16r-4,-14v33,-11,82,-13,82,28v0,27,-20,44,-55,76r59,0r0,17","w":137},"\u2083":{"d":"89,-39v5,-15,-19,-21,-44,-18v1,-7,-4,-19,7,-16v36,7,47,-36,12,-37v-8,0,-12,1,-34,5r-5,-16v41,-12,85,-12,85,26v0,13,-9,23,-20,28v14,4,24,14,24,29v1,42,-47,45,-91,35r3,-16v32,5,62,8,63,-20","w":137},"\u2084":{"d":"120,-30r-18,0r0,30r-22,0r0,-30r-63,0r0,-13r64,-84r21,0r0,80r18,0r0,17xm80,-47r0,-52r-39,52r39,0","w":137},"\u2085":{"d":"114,-41v0,43,-50,50,-91,37r3,-15v29,6,64,6,64,-21v0,-29,-43,-23,-62,-18r0,-69r81,0r0,19r-59,0r0,31v31,-6,64,2,64,36","w":137},"\u2086":{"d":"116,-42v0,28,-18,44,-47,44v-33,0,-46,-28,-46,-62v-2,-59,40,-81,90,-61r-4,16v-31,-10,-62,-7,-63,30v34,-12,71,-3,70,33xm93,-41v0,-22,-26,-24,-47,-18v1,29,8,44,25,44v14,0,22,-11,22,-26","w":137},"\u2087":{"d":"114,-111r-62,116r-20,-9r58,-104r-71,0r0,-19r95,0r0,16","w":137},"\u2088":{"d":"96,-67v36,17,20,75,-28,69v-48,6,-61,-50,-29,-68v-28,-14,-10,-70,30,-62v42,-9,54,51,27,61xm76,-72v19,-5,19,-43,-7,-41v-13,0,-23,7,-23,20v0,15,19,20,30,21xm94,-36v0,-19,-24,-22,-36,-24v-22,9,-18,47,12,47v14,0,24,-9,24,-23","w":137},"\u2089":{"d":"114,-65v0,60,-39,79,-90,60r4,-16v33,10,62,6,62,-31v-32,11,-69,4,-69,-32v0,-28,17,-44,46,-44v32,0,47,24,47,63xm44,-84v1,24,29,21,47,16v6,-46,-46,-59,-47,-16","w":137},"\u208d":{"d":"17,-64v0,-48,15,-72,53,-76r1,11v-43,3,-42,129,0,131r-1,12v-37,-3,-53,-28,-53,-78","w":87},"\u208e":{"d":"71,-64v0,50,-17,75,-54,78r0,-12v41,-3,41,-128,0,-131r0,-11v38,4,54,28,54,76","w":87},"\u2153":{"d":"244,-239r-173,252r-18,-12r173,-253xm89,-113r-22,0r0,-109r-34,2r-2,-16r58,-7r0,130xm217,-57v25,-3,49,3,44,18v-1,28,-32,25,-63,20r-3,16v45,10,91,8,91,-35v0,-15,-10,-25,-24,-29v32,-12,23,-61,-20,-61v-12,0,-23,2,-45,7r5,16v32,-6,51,-12,55,11v3,19,-17,22,-40,21r0,16","w":309},"\u2154":{"d":"249,-239r-173,252r-18,-12r172,-253xm217,-57v25,-3,49,3,44,18v-1,28,-32,25,-63,20r-3,16v45,10,91,8,91,-35v0,-15,-10,-25,-24,-29v32,-12,23,-61,-20,-61v-12,0,-23,2,-45,7r5,16v32,-6,51,-12,55,11v3,19,-17,22,-40,21r0,16xm110,-113r-87,0v-3,-22,15,-25,23,-36v33,-30,37,-45,37,-55v2,-24,-37,-22,-55,-16r-4,-14v32,-13,82,-14,82,28v0,27,-20,44,-55,76r59,0r0,17","w":309},"\u215b":{"d":"249,-239r-173,252r-18,-12r173,-253xm89,-113r-22,0r0,-109r-34,2r-2,-16r58,-7r0,130xm269,-67v33,14,20,78,-29,69v-48,6,-61,-50,-29,-68v-27,-15,-9,-70,30,-62v41,-9,54,50,28,61xm248,-72v19,-5,19,-43,-7,-41v-13,0,-22,7,-22,20v0,15,18,20,29,21xm266,-36v0,-19,-24,-22,-36,-24v-22,9,-18,47,12,47v14,0,24,-9,24,-23","w":309},"\u215c":{"d":"248,-239r-173,252r-18,-12r173,-253xm43,-171v26,-1,49,3,44,19v-1,28,-32,25,-63,20r-3,16v46,9,91,7,91,-35v0,-15,-10,-25,-24,-29v32,-13,24,-62,-20,-62v-12,0,-23,3,-45,8r5,15v32,-6,50,-10,56,12v1,19,-18,22,-41,21r0,15xm269,-67v33,14,20,78,-29,69v-48,6,-61,-50,-29,-68v-27,-15,-9,-70,30,-62v41,-9,54,50,28,61xm248,-72v19,-5,19,-43,-7,-41v-13,0,-22,7,-22,20v0,15,18,20,29,21xm266,-36v0,-19,-24,-22,-36,-24v-22,9,-18,47,12,47v14,0,24,-9,24,-23","w":309},"\u215d":{"d":"246,-239r-173,252r-18,-12r173,-253xm114,-155v0,43,-49,50,-91,38r3,-16v29,7,61,7,64,-21v3,-28,-44,-21,-62,-17r0,-69r81,0r0,19r-59,0r0,30v31,-6,64,2,64,36xm269,-67v33,14,20,78,-29,69v-48,6,-61,-50,-29,-68v-27,-15,-9,-70,30,-62v41,-9,54,50,28,61xm248,-72v19,-5,19,-43,-7,-41v-13,0,-22,7,-22,20v0,15,18,20,29,21xm266,-36v0,-19,-24,-22,-36,-24v-22,9,-18,47,12,47v14,0,24,-9,24,-23","w":309},"\u215e":{"d":"233,-239r-173,252r-18,-12r173,-253xm114,-224r-62,116r-20,-10r58,-103r-71,0r0,-19r95,0r0,16xm269,-67v33,14,20,78,-29,69v-48,6,-61,-50,-29,-68v-27,-15,-9,-70,30,-62v41,-9,54,50,28,61xm248,-72v19,-5,19,-43,-7,-41v-13,0,-22,7,-22,20v0,15,18,20,29,21xm266,-36v0,-19,-24,-22,-36,-24v-22,9,-18,47,12,47v14,0,24,-9,24,-23","w":309},"\uf661":{"d":"122,-177v0,42,-18,65,-53,65v-36,0,-54,-23,-54,-65v0,-40,19,-65,53,-65v35,0,54,25,54,65xm99,-177v0,-31,-8,-47,-30,-47v-22,0,-30,16,-30,47v0,31,8,47,30,47v22,0,30,-15,30,-47","w":137},"\uf662":{"d":"89,-113r-22,0r0,-109r-34,2r-2,-16r58,-7r0,130","w":137},"\uf663":{"d":"112,-113r-87,0v-3,-22,15,-25,23,-36v33,-30,37,-45,37,-55v2,-24,-37,-22,-55,-16r-4,-14v32,-13,82,-14,82,28v0,27,-20,44,-55,76r59,0r0,17","w":137},"\uf664":{"d":"89,-152v4,-15,-17,-20,-44,-19v1,-7,-3,-18,7,-15v36,7,47,-36,12,-37v-8,0,-12,0,-34,4r-5,-15v40,-13,85,-14,85,25v0,13,-9,24,-20,29v14,4,24,14,24,29v1,42,-46,44,-91,35r3,-16v32,5,62,8,63,-20","w":137},"\uf665":{"d":"120,-144r-18,0r0,31r-22,0r0,-31r-63,0r0,-13r64,-83r21,0r0,79r18,0r0,17xm80,-161r0,-52r-39,52r39,0","w":137},"\uf666":{"d":"114,-155v0,43,-49,50,-91,38r3,-16v29,7,61,7,64,-21v3,-28,-44,-21,-62,-17r0,-69r81,0r0,19r-59,0r0,30v31,-6,64,2,64,36","w":137},"\uf667":{"d":"116,-155v0,28,-18,43,-47,43v-33,0,-46,-28,-46,-62v0,-59,41,-82,90,-60r-4,15v-32,-9,-62,-6,-63,31v34,-12,71,-3,70,33xm93,-155v0,-23,-27,-24,-47,-17v1,29,8,43,25,43v14,0,22,-11,22,-26","w":137},"\uf668":{"d":"114,-224r-62,116r-20,-10r58,-103r-71,0r0,-19r95,0r0,16","w":137},"\uf669":{"d":"96,-180v36,16,19,74,-28,68v-49,7,-60,-50,-29,-68v-28,-14,-10,-70,30,-62v25,0,43,12,43,35v0,17,-13,26,-16,27xm76,-185v19,-5,20,-41,-7,-41v-13,0,-23,6,-23,19v0,15,19,21,30,22xm94,-149v0,-19,-24,-22,-36,-24v-21,9,-18,46,12,46v14,0,24,-8,24,-22","w":137},"\uf66a":{"d":"114,-178v0,60,-39,77,-90,60r4,-16v33,9,62,5,62,-32v-32,11,-69,5,-69,-31v0,-28,17,-45,46,-45v32,0,47,25,47,64xm44,-198v1,24,29,23,47,17v-1,-26,-8,-43,-25,-43v-16,0,-22,10,-22,26","w":137},"\uf66b":{"d":"17,-177v0,-48,15,-73,53,-77r1,12v-43,3,-42,129,0,131r-1,12v-37,-3,-53,-28,-53,-78","w":87},"\uf66c":{"d":"71,-177v0,50,-17,75,-54,78r0,-12v41,-3,41,-128,0,-131r0,-12v38,4,54,29,54,77","w":87},"\ue002":{"d":"189,-12v-77,36,-140,15,-155,-67r-32,0r0,-19r30,0r-1,-39r-29,0r0,-20r31,0v8,-73,76,-105,150,-77r-5,21v-62,-17,-105,0,-114,56r67,0r0,20r-69,0v-2,2,0,44,1,39r68,0r0,19r-65,0v16,62,52,69,116,46","w":180},"\uf639":{"d":"172,-122v0,83,-27,125,-81,125v-54,0,-83,-44,-83,-126v0,-77,31,-121,82,-121v54,0,82,42,82,122xm141,-122v0,-68,-15,-99,-51,-99v-35,0,-51,32,-51,100v0,70,15,101,51,101v36,0,51,-30,51,-102","w":180},"\uf6dc":{"d":"109,0r-28,0r0,-219r-55,5r-3,-20r86,-13r0,247","w":180},"\uf63a":{"d":"157,0r-144,0r0,-20r44,-43v58,-55,66,-74,66,-110v0,-58,-50,-51,-104,-38r-4,-20v66,-23,138,-23,138,58v0,47,-12,65,-107,150r111,0r0,23","w":180},"\uf63b":{"d":"46,-135v59,-1,68,-5,74,-48v-4,-50,-49,-41,-100,-29r-5,-19v62,-21,133,-26,134,45v0,32,-17,54,-47,60v36,4,54,23,54,57v0,76,-74,81,-145,64r3,-20v55,11,112,14,112,-46v0,-37,-27,-44,-80,-43r0,-21","w":180},"\uf63c":{"d":"174,-63r-27,0r0,63r-27,0r0,-63r-114,0r0,-19r100,-158r41,0r0,154r27,0r0,23xm120,-86r0,-133r-84,133r84,0","w":180},"\uf63d":{"d":"160,-73v0,76,-74,89,-145,68r3,-20v49,10,112,15,112,-47v0,-55,-51,-56,-106,-47r0,-121r127,0r0,22r-99,0r0,75v62,-10,108,13,108,70","w":180},"\uf63e":{"d":"167,-77v0,51,-27,81,-74,81v-51,0,-80,-41,-80,-118v0,-111,55,-152,146,-120r-4,20v-68,-17,-109,-7,-111,80v66,-25,123,-15,123,57xm138,-75v0,-56,-54,-50,-94,-38v0,66,15,95,52,95v28,0,42,-20,42,-57","w":180},"\uf63f":{"d":"162,-220r-106,225r-25,-10r101,-213r-121,0r0,-22r151,0r0,20","w":180},"\uf640":{"d":"170,-70v0,46,-29,73,-80,73v-53,0,-80,-23,-80,-69v0,-32,13,-51,39,-59v-54,-26,-33,-129,42,-119v77,-11,94,96,37,116v30,10,42,26,42,58xm135,-181v0,-26,-17,-41,-45,-41v-48,0,-60,59,-23,77v5,3,14,5,36,10v22,-5,32,-21,32,-46xm142,-64v0,-43,-39,-43,-71,-53v-23,7,-33,24,-33,48v0,33,18,50,55,50v31,0,49,-17,49,-45","w":180},"\uf641":{"d":"167,-126v0,111,-55,152,-146,120r4,-20v68,18,109,6,111,-81v-65,26,-123,17,-123,-56v0,-51,27,-81,74,-81v51,0,80,41,80,118xm136,-127v0,-66,-15,-95,-52,-95v-28,0,-42,20,-42,57v0,56,54,50,94,38","w":180},"\uf64e":{"d":"194,-12v-77,36,-140,15,-155,-67r-32,0r0,-19r30,0r-1,-39r-29,0r0,-20r32,0v7,-73,75,-105,149,-77r-5,21v-62,-17,-105,0,-114,56r67,0r0,20r-69,0v-2,2,0,44,1,39r68,0r0,19r-65,0v16,62,52,69,116,46"},"\uf653":{"d":"104,-137v48,12,67,24,67,68v0,37,-27,64,-67,68r0,47r-22,0r0,-46v-19,0,-50,-7,-70,-14r6,-20v22,6,46,11,64,11r0,-90v-87,-11,-82,-121,0,-127r0,-34r22,0r0,34v19,1,38,4,54,9r-4,20v-19,-4,-38,-7,-50,-8r0,82xm82,-143r0,-75v-22,3,-35,17,-35,38v0,20,10,31,35,37xm142,-67v0,-22,-9,-32,-38,-40r0,83v26,-5,38,-19,38,-43"},"\uf654":{"d":"172,-19v-23,12,-37,16,-51,19r0,46r-21,0r0,-46v-48,-3,-73,-33,-73,-91v0,-58,27,-91,73,-94r0,-34r21,0r0,34v15,2,30,5,47,11r-5,19v-13,-3,-27,-5,-42,-6r0,136v15,-2,24,-4,45,-13xm100,-25r0,-135v-28,2,-43,25,-43,66v0,42,14,66,43,69"},"\uf651":{"d":"185,0r-168,0r0,-19v22,-8,29,-63,36,-98r-36,0r0,-20r40,0v10,-56,12,-104,64,-106v19,0,44,7,64,13r-5,19v-53,-15,-85,-13,-89,46r-6,28r76,0r0,20r-80,0v-5,33,-12,71,-31,95r135,0r0,22"},"\uf64f":{"d":"185,-232r-5,20v-18,-5,-33,-7,-43,-7v-43,2,-34,50,-45,82r71,0r0,20r-74,0v-19,71,-16,152,-63,193r-15,-12v33,-41,33,-120,49,-181r-36,0r0,-20r40,0v10,-55,13,-104,64,-106v21,0,36,5,57,11"},"\uf652":{"d":"192,-240r-69,103r44,0r0,19r-58,0r0,29r58,0r0,20r-58,0r0,69r-28,0r0,-69r-58,0r0,-20r58,0r0,-29r-58,0r0,-19r41,0r-66,-103r32,0r66,104r69,-104r27,0"},"\uf643":{"d":"171,-94v0,60,-29,97,-76,97v-47,0,-76,-36,-76,-96v0,-62,28,-97,76,-97v48,0,76,36,76,96xm142,-94v0,-50,-15,-74,-48,-74v-33,0,-46,24,-46,75v0,50,15,75,47,75v33,0,47,-24,47,-76"},"\uf644":{"d":"116,0r-25,0r0,-162r-38,4r-3,-19r66,-12r0,189"},"\uf645":{"d":"160,0r-134,0r0,-17v85,-71,102,-92,102,-120v0,-19,-12,-30,-38,-30v-23,0,-57,9,-57,9r-3,-20v55,-20,127,-20,127,40v0,38,-34,67,-95,117r98,0r0,21"},"\uf646":{"d":"58,-87v56,0,63,-6,69,-45v-4,-46,-44,-38,-94,-27r-3,-19v59,-19,122,-22,124,44v0,30,-16,51,-44,56v34,4,51,21,51,53v0,71,-71,77,-136,60r3,-18v52,9,105,12,105,-43v0,-35,-25,-42,-75,-41r0,-20"},"\uf647":{"d":"172,-4r-30,0r0,47r-25,0r0,-47r-104,0r0,-19r90,-163r39,0r0,160r30,0r0,22xm117,-26r0,-139r-76,139r76,0"},"\uf648":{"d":"165,-31v0,72,-69,85,-135,66r2,-19v46,10,104,14,104,-45v0,-51,-48,-56,-99,-46r0,-111r119,0r0,20r-93,0r0,70v52,-11,102,10,102,65"},"\uf649":{"d":"168,-73v0,48,-26,76,-70,76v-48,0,-74,-39,-74,-111v0,-104,52,-143,136,-112r-3,18v-65,-15,-102,-6,-104,76v61,-23,115,-16,115,53xm140,-71v0,-52,-49,-46,-87,-36v0,62,13,89,48,89v26,0,39,-18,39,-53"},"\uf64a":{"d":"164,-167r-98,210r-25,-10r95,-199r-113,0r0,-20r141,0r0,19"},"\uf64b":{"d":"130,-120v68,22,42,123,-35,123v-49,0,-74,-21,-74,-65v0,-30,12,-48,36,-56v0,0,-29,-8,-29,-50v0,-38,25,-62,67,-62v41,0,67,21,67,58v0,44,-32,52,-32,52xm138,-171v0,-24,-17,-39,-43,-39v-46,0,-57,58,-22,74v5,3,14,5,34,10v21,-5,31,-21,31,-45xm144,-60v0,-40,-37,-41,-67,-51v-22,7,-31,23,-31,46v0,32,17,48,52,48v29,0,46,-17,46,-43"},"\uf64c":{"d":"166,-78v0,104,-52,141,-136,111r3,-18v64,17,101,7,103,-76v-60,23,-114,15,-114,-53v0,-48,25,-76,69,-76v48,0,75,40,75,112xm137,-80v0,-62,-13,-89,-48,-89v-26,0,-40,18,-40,53v0,53,50,48,88,36"},"\uf655":{"d":"122,-64v0,42,-18,66,-53,66v-36,0,-54,-23,-54,-65v0,-40,19,-65,53,-65v35,0,54,24,54,64xm99,-64v0,-31,-8,-47,-30,-47v-22,0,-30,16,-30,47v0,31,8,47,30,47v22,0,30,-15,30,-47","w":137},"\uf656":{"d":"89,0r-22,0r0,-109r-34,2r-2,-15r58,-8r0,130","w":137},"\uf657":{"d":"112,0r-87,0v-3,-22,13,-25,23,-35v32,-31,37,-46,37,-56v2,-24,-37,-22,-55,-16r-4,-14v33,-11,82,-13,82,28v0,27,-20,44,-55,76r59,0r0,17","w":137},"\uf658":{"d":"89,-39v5,-15,-19,-21,-44,-18v1,-7,-4,-19,7,-16v36,7,47,-36,12,-37v-8,0,-12,1,-34,5r-5,-16v41,-12,85,-12,85,26v0,13,-9,23,-20,28v14,4,24,14,24,29v1,42,-47,45,-91,35r3,-16v32,5,62,8,63,-20","w":137},"\uf659":{"d":"120,-30r-18,0r0,30r-22,0r0,-30r-63,0r0,-13r64,-84r21,0r0,80r18,0r0,17xm80,-47r0,-52r-39,52r39,0","w":137},"\uf65a":{"d":"114,-41v0,43,-50,50,-91,37r3,-15v29,6,64,6,64,-21v0,-29,-43,-23,-62,-18r0,-69r81,0r0,19r-59,0r0,31v31,-6,64,2,64,36","w":137},"\uf65b":{"d":"116,-42v0,28,-18,44,-47,44v-33,0,-46,-28,-46,-62v-2,-59,40,-81,90,-61r-4,16v-31,-10,-62,-7,-63,30v34,-12,71,-3,70,33xm93,-41v0,-22,-26,-24,-47,-18v1,29,8,44,25,44v14,0,22,-11,22,-26","w":137},"\uf65c":{"d":"114,-111r-62,116r-20,-9r58,-104r-71,0r0,-19r95,0r0,16","w":137},"\uf65d":{"d":"96,-67v36,17,20,75,-28,69v-48,6,-61,-50,-29,-68v-28,-14,-10,-70,30,-62v42,-9,54,51,27,61xm76,-72v19,-5,19,-43,-7,-41v-13,0,-23,7,-23,20v0,15,19,20,30,21xm94,-36v0,-19,-24,-22,-36,-24v-22,9,-18,47,12,47v14,0,24,-9,24,-23","w":137},"\uf65e":{"d":"114,-65v0,60,-39,79,-90,60r4,-16v33,10,62,6,62,-31v-32,11,-69,4,-69,-32v0,-28,17,-44,46,-44v32,0,47,24,47,63xm44,-84v1,24,29,21,47,16v6,-46,-46,-59,-47,-16","w":137},"\uf62c":{"d":"17,-64v0,-48,15,-72,53,-76r1,11v-43,3,-42,129,0,131r-1,12v-37,-3,-53,-28,-53,-78","w":87},"\uf62d":{"d":"71,-64v0,50,-17,75,-54,78r0,-12v41,-3,41,-128,0,-131r0,-11v38,4,54,28,54,76","w":87},"\uf7e5":{"d":"177,0r-29,0r-18,-49r-84,0r-18,49r-26,0r72,-186r30,0xm122,-70r-35,-92r-33,92r68,0xm90,-268v18,0,33,16,33,34v0,19,-14,33,-33,33v-19,0,-34,-14,-34,-33v0,-18,16,-34,34,-34xm90,-254v-10,0,-19,9,-19,20v0,11,9,20,19,20v10,0,18,-9,18,-20v0,-11,-8,-20,-18,-20","w":179},"\u0130":{"d":"59,0r-29,0r0,-240r29,0r0,240xm60,-286v0,9,-6,16,-15,16v-9,0,-16,-7,-16,-16v0,-9,7,-16,16,-16v9,0,15,7,15,16","w":89},"\u00a0":{"w":90,"k":{"\u00c1":9,"\u00c2":9,"\u00c3":9,"\u00c0":9,"\u00c5":9,"\u00c4":9,"Z":6,"Y":11,"X":11,"W":11,"V":11,"T":22,"A":9}}}});

/* /_ui/js/signin.js */

// start SignIn
var SignIn = Class.create ({
	initialize: function(input,link,options)
	{
		this.input = input;
		this.link = link;
		this.options = Object.extend({
			redirectURL: 'signin.html',
			queryParam: 'signin'
		}, options || {});
		this.redirect = this.options.redirectURL + '?' + this.options.queryParam + '=';
		this.link.observe('click', this.__Click.bindAsEventListener(this));
	},
	__Click: function(e)
	{
		e.stop();
		var el = e.findElement('a');
		var val = $F(this.input);
		this.Go(val);
	},
	Go: function(val)
	{
		document.location = this.redirect + val;
	}
});
// end SignIn

document.observe('dom:loaded', function(){
	if ($('signinflyout')) {
		ActivateSignInFlyout = new SignIn(
			$$('div#signinflyout fieldset.personal-banking-signin input.text')[0],
			$$('div#signinflyout fieldset.personal-banking-signin a.btn-signin')[0],
			{ redirectURL: rootVirtual + '/personal.aspx', queryParam: 'login' }
		);
	}
	if ($('signinbox')) {
		ActivateSignIn = new SignIn(
			$$('div#signinbox fieldset.personal-banking-signin input.text')[0],
			$$('div#signinbox fieldset.personal-banking-signin a.btn-signin')[0],
			{ redirectURL: rootVirtual + '/personal.aspx', queryParam: 'login' }
		);
	}
});

/* /_ui/js/scripts.js */

// Add a class name to the body as a global flag that the user has javascript.
// Instantiate global JS widgets.
document.observe('dom:loaded', function(){
	$(document.body).addClassName('js-enabled');
	MainnavFlyoutNav = new FlyoutNav( $$('div#mainnav a.mn-lnk'), $$('div#mainnav div.flyoutnav'), { activeClassName: 'hover', flyoutClassName: 'flyoutnav' } );
	UtilityFlyoutNav = new FlyoutNav( $$('div#utilitynav a.un-lnk'), $$('div#utilitynav div.miniflyout'), { activeClassName: 'hover', flyoutClassName: 'miniflyout' } );
	SignInFlyout = new FlyoutNav( $$('div#utilitynav a.signin-trigger'), $$('div#utilitynav div.signinflyout'), { activeClassName: 'hover', flyoutClassName: 'signinflyout' } );
	GoogleSearchLabelInput = new LabelInputText( $$('fieldset#searchbox label')[0], $$('fieldset#searchbox input[type=text]')[0] );
	GoogleSearchbox = new VerifySearchbox( $('cse_search_box'), $$('fieldset#searchbox label')[0], $$('fieldset#searchbox input[type=text]')[0], $$('fieldset#searchbox input[type=submit]')[0] );
	if ($('modalinterstitial'))
	{
		ExternalLinkInterstitial = new ModalInterstitial( $$('a[rel=external]'), {topOffset: -100, minTopSpacing: 150} );
	}
	if ($('modallogin'))
	{
		WholesaleLendingLogin = new ModalLogin( $$('a[rel=login]'), {topOffset: -100, minTopSpacing: 150} );
	}
});
// end js-enabled


// start IE CSS3 shims
var IE = {
	addClasses: function(selectorClassPair) {
		for (var selector in selectorClassPair) {
			var elements = $$(selector), cssClass = selectorClassPair[selector];
			elements.invoke("addClassName", cssClass);
		}
	}
}
document.observe("dom:loaded", function(){
	if (isIE6) {
		IE.addClasses({
			//"input[type=text]": "text"
		});
	}
	if (isIE) {
		IE.addClasses({
			"table.jobs-listing-tbl tr:nth-child(odd)": "nth-child-odd",
			"table.jobs-listing-tbl tr:nth-child(even)": "nth-child-even"
		});
	}
});
// end IE CSS3 shims


// start SelectAndGo
var SelectAndGo = Class.create ({
	initialize: function(selectbox)
	{
		this.selectbox = selectbox;
			this.sbOptions = this.selectbox.childElements();
			this.length = this.sbOptions.size();
		//always set the first option as default
		this.sbOptions[0].selected = 'selected';
		this.selectbox.observe('change', this.__Change.bindAsEventListener(this));
	},
	__Change: function(e)
	{
		var sbVal = $F(this.selectbox);
		//if first option, do nothing (should never fire)
		if (sbVal == this.sbOptions[0].value){return;}
		this.GoLink(sbVal);
	},
	GoLink: function(sbVal)
	{
		document.location = sbVal;
	}
});
// end SelectAndGo


// start ImageMapHovers
var ImageMapHovers = Class.create ({
	initialize: function(areas,overlay)
	{
		this.areas = areas;
			this.length = this.areas.size();
		this.overlay = overlay;
		var boundAreaEnter = this.__Enter.bindAsEventListener(this);
		var boundAreaLeave = this.__Leave.bindAsEventListener(this);
		this.areas.invoke('observe', 'mouseover', boundAreaEnter).invoke('observe', 'mouseout', boundAreaLeave);
	},
	__Enter: function(e)
	{
		//e.stop();
		var el = e.element();
		for (var i=0; i<this.length; i++)
		{
			if (this.areas[i] == el)
			{
				this.HoverOn(i);
				break;
			}
		}
	},
	__Leave: function(e)
	{
		//e.stop();
		var el = e.element();
		for (var i=0; i<this.length; i++)
		{
			if (this.areas[i] == el)
			{
				this.HoverOff();
				break;
			}
		}
	},
	HoverOn: function(i)
	{
		this.overlay.className = this.areas[i].className;
	},
	HoverOff: function()
	{
		this.overlay.className = '';
	}
});
// end ImageMapHovers


// start Revealer
var Revealer = Class.create ({
	initialize: function(links,items)
	{
		this.links = links;
			this.length = this.links.size();
		this.items = items;
		this.items.invoke('hide');

		var boundLinkClick = this.__Click.bindAsEventListener(this);
		this.links.invoke('observe', 'click', boundLinkClick);

	},
	__Click: function(e)
	{
		e.stop();
		var el = e.findElement('a');
		for (var i=0; i<this.length; i++)
		{
			if (this.links[i] == el)
			{
				this.ShowHide(i);
				break;
			}
		}
	},
	ShowHide: function(i)
	{
		if (this.links[i].hasClassName('active'))
		{
			this.links[i].removeClassName('active');
			Effect.BlindUp(this.items[i], { duration: 0.2 });
		} else {
			this.links[i].addClassName('active');
			Effect.BlindDown(this.items[i], { duration: 0.2 });
		}
	}
});
// end Revealer


// start IframeBuster
var IframeBuster = Class.create ({
	initialize: function(link)
	{
		this.link = link;
		this.interval = setInterval(function()
		{
			this.BustOut();
		}.bind(this), 3000);
	},
	BustOut: function(e)
	{
		window.parent.location = this.link.href;
	}
});
// end IframeBuster


// start PrintPage
var PrintPage = Class.create ({
	initialize: function(link)
	{
		this.link = link;
		this.link.observe('click', this.__Click.bindAsEventListener(this));
	},
	__Click: function(e)
	{
		e.stop();
		this.Print();
	},
	Print: function()
	{
		window.print();
	}
});
// end PrintPage


// start TextareaMaxlength
var TextareaMaxlength = Class.create ({
	initialize: function(textarea, maxlength)
	{
		this.textarea = textarea;
		this.maxlength = maxlength;
		this.textarea.observe('keyup', this.__Keyup.bindAsEventListener(this));
	},
	__Keyup: function(e)
	{
		e.stop();
		this.Enforce();
	},
	Enforce: function()
	{
		if ($F(this.textarea).length >= this.maxlength)
		{
			this.textarea.value = $F(this.textarea).substring(0, this.maxlength);
		}
	}
});
// end TextareaMaxlength


// start PopupWindow
var PopupWindow = Class.create ({
	initialize: function(link, width, height, extras)
	{
		this.winName = 'popup';
		this.altWidth = 640;
		this.altHeight = 360;
		this.altExtras = 'location=no,menubar=no,statusbar=no,toolbar=no,scrollbars=no,resizable=yes';
		this.link = link;
		this.url = link.getAttribute('href');
		this.w = width || this.altWidth;
		this.h = height || this.altHeight;
		this.x = extras || this.altExtras;
		this.features = 'width=' + this.w + ',height=' + this.h + ',' + this.x;
		this.link.observe('click', this.__Click.bindAsEventListener(this));
	},
	__Click: function(e)
	{
		e.stop();
		var win = window.open(this.url, this.winName, this.features);
		win.focus();
	}
});
// end PopupWindow


// start ClosePopup
var ClosePopup = Class.create ({
	initialize: function(link)
	{
		this.link = link;
		this.link.observe('click', this.__Click.bindAsEventListener(this));
	},
	__Click: function(e)
	{
		e.stop();
		window.close();
	}
});
// end ClosePopup


/* /_ui/js/cufon-config.js */

// ********** start: Cufon config **********

Cufon.replace('h1:not(.no-cufon):not(.article-title)', {
    fontFamily: 'FoundryFormSansBook'
});

Cufon.replace('div.homepage-layout div.highlight-box h2', {
    fontFamily: 'FoundryFormSansBook'
});

Cufon.replace('div.quotebox div.quotebox-inner h3', {
    fontFamily: 'FoundryFormSansBook'
});

Cufon.replace('div#signinbox div.signinbox-inner-content h3', {
    fontFamily: 'FoundryFormSansBook'
});


/* examples */
/*
Cufon.replace('h2.shadow', {
    fontFamily: 'FoundryFormSansBook',
	textShadow: '#666666 -1px 1px'
});

Cufon.replace('div#mainnav a', {
    fontFamily: 'FoundryFormSansBook',
	hover: true
});
*/

// ********** end: Cufon config **********