/*  Prototype JavaScript framework, version 1.5.1.1
 *  (c) 2005-2007 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.5.1.1',

  Browser: {
    IE:     !!(window.attachEvent && !window.opera),
    Opera:  !!window.opera,
    WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
    Gecko:  navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1
  },

  BrowserFeatures: {
    XPath: !!document.evaluate,
    ElementExtensions: !!window.HTMLElement,
    SpecificElementExtensions:
      (document.createElement('div').__proto__ !==
       document.createElement('form').__proto__)
  },

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

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

var Class = {
  create: function() {
    return function() {
      this.initialize.apply(this, arguments);
    }
  }
}

var Abstract = new Object();

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

Object.extend(Object, {
  inspect: function(object) {
    try {
      if (object === undefined) return 'undefined';
      if (object === null) return 'null';
      return object.inspect ? object.inspect() : object.toString();
    } catch (e) {
      if (e instanceof RangeError) return '...';
      throw e;
    }
  },

  toJSON: function(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 (object.ownerDocument === document) return;
    var results = [];
    for (var property in object) {
      var value = Object.toJSON(object[property]);
      if (value !== undefined)
        results.push(property.toJSON() + ': ' + value);
    }
    return '{' + results.join(', ') + '}';
  },

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

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

  clone: function(object) {
    return Object.extend({}, object);
  }
});

Function.prototype.bind = function() {
  var __method = this, args = $A(arguments), object = args.shift();
  return function() {
    return __method.apply(object, args.concat($A(arguments)));
  }
}

Function.prototype.bindAsEventListener = function(object) {
  var __method = this, args = $A(arguments), object = args.shift();
  return function(event) {
    return __method.apply(object, [event || window.event].concat(args));
  }
}

Object.extend(Number.prototype, {
  toColorPart: function() {
    return this.toPaddedString(2, 16);
  },

  succ: function() {
    return this + 1;
  },

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

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

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

Date.prototype.toJSON = function() {
  return '"' + this.getFullYear() + '-' +
    (this.getMonth() + 1).toPaddedString(2) + '-' +
    this.getDate().toPaddedString(2) + 'T' +
    this.getHours().toPaddedString(2) + ':' +
    this.getMinutes().toPaddedString(2) + ':' +
    this.getSeconds().toPaddedString(2) + '"';
};

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

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

var PeriodicalExecuter = Class.create();
PeriodicalExecuter.prototype = {
  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);
  },

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

  onTimerEvent: function() {
    if (!this.currentlyExecuting) {
      try {
        this.currentlyExecuting = true;
        this.callback(this);
      } finally {
        this.currentlyExecuting = false;
      }
    }
  }
}
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, {
  gsub: function(pattern, replacement) {
    var result = '', source = this, match;
    replacement = arguments.callee.prepareReplacement(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;
  },

  sub: function(pattern, replacement, count) {
    replacement = this.gsub.prepareReplacement(replacement);
    count = count === undefined ? 1 : count;

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

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

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

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

  stripTags: function() {
    return this.replace(/<\/?[^>]+>/gi, '');
  },

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

  extractScripts: function() {
    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];
    });
  },

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

  escapeHTML: function() {
    var self = arguments.callee;
    self.text.data = this;
    return self.div.innerHTML;
  },

  unescapeHTML: function() {
    var div = document.createElement('div');
    div.innerHTML = this.stripTags();
    return div.childNodes[0] ? (div.childNodes.length > 1 ?
      $A(div.childNodes).inject('', function(memo, node) { return memo+node.nodeValue }) :
      div.childNodes[0].nodeValue) : '';
  },

  toQueryParams: function(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 (hash[key].constructor != Array) hash[key] = [hash[key]];
          hash[key].push(value);
        }
        else hash[key] = value;
      }
      return hash;
    });
  },

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

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

  times: function(count) {
    var result = '';
    for (var i = 0; i < count; i++) result += this;
    return result;
  },

  camelize: function() {
    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;
  },

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

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

  dasherize: function() {
    return this.gsub(/_/,'-');
  },

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

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

  unfilterJSON: function(filter) {
    return this.sub(filter || Prototype.JSONFilter, '#{1}');
  },

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

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

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

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

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

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

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

if (Prototype.Browser.WebKit || Prototype.Browser.IE) Object.extend(String.prototype, {
  escapeHTML: function() {
    return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
  },
  unescapeHTML: function() {
    return this.replace(/&amp;/g,'&').replace(/&lt;/g,'<').replace(/&gt;/g,'>');
  }
});

String.prototype.gsub.prepareReplacement = function(replacement) {
  if (typeof replacement == 'function') return replacement;
  var template = new Template(replacement);
  return function(match) { return template.evaluate(match) };
}

String.prototype.parseQuery = String.prototype.toQueryParams;

Object.extend(String.prototype.escapeHTML, {
  div:  document.createElement('div'),
  text: document.createTextNode('')
});

with (String.prototype.escapeHTML) div.appendChild(text);

var Template = Class.create();
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
Template.prototype = {
  initialize: function(template, pattern) {
    this.template = template.toString();
    this.pattern  = pattern || Template.Pattern;
  },

  evaluate: function(object) {
    return this.template.gsub(this.pattern, function(match) {
      var before = match[1];
      if (before == '\\') return match[2];
      return before + String.interpret(object[match[3]]);
    });
  }
}

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

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

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

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

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

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

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

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

  grep: function(pattern, iterator) {
    var results = [];
    this.each(function(value, index) {
      var stringValue = value.toString();
      if (stringValue.match(pattern))
        results.push((iterator || Prototype.K)(value, index));
    })
    return results;
  },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Object.extend(Enumerable, {
  map:     Enumerable.collect,
  find:    Enumerable.detect,
  select:  Enumerable.findAll,
  member:  Enumerable.include,
  entries: Enumerable.toArray
});
var $A = Array.from = function(iterable) {
  if (!iterable) return [];
  if (iterable.toArray) {
    return iterable.toArray();
  } else {
    var results = [];
    for (var i = 0, length = iterable.length; i < length; i++)
      results.push(iterable[i]);
    return results;
  }
}

if (Prototype.Browser.WebKit) {
  $A = Array.from = function(iterable) {
    if (!iterable) return [];
    if (!(typeof iterable == 'function' && iterable == '[object NodeList]') &&
      iterable.toArray) {
      return iterable.toArray();
    } else {
      var results = [];
      for (var i = 0, length = iterable.length; i < length; i++)
        results.push(iterable[i]);
      return results;
    }
  }
}

Object.extend(Array.prototype, Enumerable);

if (!Array.prototype._reverse)
  Array.prototype._reverse = Array.prototype.reverse;

Object.extend(Array.prototype, {
  _each: function(iterator) {
    for (var i = 0, length = this.length; i < length; i++)
      iterator(this[i]);
  },

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

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

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

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

  flatten: function() {
    return this.inject([], function(array, value) {
      return array.concat(value && value.constructor == Array ?
        value.flatten() : [value]);
    });
  },

  without: function() {
    var values = $A(arguments);
    return this.select(function(value) {
      return !values.include(value);
    });
  },

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

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

  reduce: function() {
    return this.length > 1 ? this : this[0];
  },

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

  clone: function() {
    return [].concat(this);
  },

  size: function() {
    return this.length;
  },

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

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

Array.prototype.toArray = Array.prototype.clone;

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

if (Prototype.Browser.Opera){
  Array.prototype.concat = function() {
    var array = [];
    for (var i = 0, length = this.length; i < length; i++) array.push(this[i]);
    for (var i = 0, length = arguments.length; i < length; i++) {
      if (arguments[i].constructor == Array) {
        for (var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
          array.push(arguments[i][j]);
      } else {
        array.push(arguments[i]);
      }
    }
    return array;
  }
}
var Hash = function(object) {
  if (object instanceof Hash) this.merge(object);
  else Object.extend(this, object || {});
};

Object.extend(Hash, {
  toQueryString: function(obj) {
    var parts = [];
    parts.add = arguments.callee.addPair;

    this.prototype._each.call(obj, function(pair) {
      if (!pair.key) return;
      var value = pair.value;

      if (value && typeof value == 'object') {
        if (value.constructor == Array) value.each(function(value) {
          parts.add(pair.key, value);
        });
        return;
      }
      parts.add(pair.key, value);
    });

    return parts.join('&');
  },

  toJSON: function(object) {
    var results = [];
    this.prototype._each.call(object, function(pair) {
      var value = Object.toJSON(pair.value);
      if (value !== undefined) results.push(pair.key.toJSON() + ': ' + value);
    });
    return '{' + results.join(', ') + '}';
  }
});

Hash.toQueryString.addPair = function(key, value, prefix) {
  key = encodeURIComponent(key);
  if (value === undefined) this.push(key);
  else this.push(key + '=' + (value == null ? '' : encodeURIComponent(value)));
}

Object.extend(Hash.prototype, Enumerable);
Object.extend(Hash.prototype, {
  _each: function(iterator) {
    for (var key in this) {
      var value = this[key];
      if (value && value == Hash.prototype[key]) continue;

      var pair = [key, value];
      pair.key = key;
      pair.value = value;
      iterator(pair);
    }
  },

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

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

  merge: function(hash) {
    return $H(hash).inject(this, function(mergedHash, pair) {
      mergedHash[pair.key] = pair.value;
      return mergedHash;
    });
  },

  remove: function() {
    var result;
    for(var i = 0, length = arguments.length; i < length; i++) {
      var value = this[arguments[i]];
      if (value !== undefined){
        if (result === undefined) result = value;
        else {
          if (result.constructor != Array) result = [result];
          result.push(value)
        }
      }
      delete this[arguments[i]];
    }
    return result;
  },

  toQueryString: function() {
    return Hash.toQueryString(this);
  },

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

  toJSON: function() {
    return Hash.toJSON(this);
  }
});

function $H(object) {
  if (object instanceof Hash) return object;
  return new Hash(object);
};

// Safari iterates over shadowed properties
if (function() {
  var i = 0, Test = function(value) { this.key = value };
  Test.prototype.key = 'foo';
  for (var property in new Test('bar')) i++;
  return i > 1;
}()) Hash.prototype._each = function(iterator) {
  var cache = [];
  for (var key in this) {
    var value = this[key];
    if ((value && value == Hash.prototype[key]) || cache.include(key)) continue;
    cache.push(key);
    var pair = [key, value];
    pair.key = key;
    pair.value = value;
    iterator(pair);
  }
};
ObjectRange = Class.create();
Object.extend(ObjectRange.prototype, Enumerable);
Object.extend(ObjectRange.prototype, {
  initialize: function(start, end, exclusive) {
    this.start = start;
    this.end = end;
    this.exclusive = exclusive;
  },

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

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

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

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 (typeof responder[callback] == 'function') {
        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 = function() {};
Ajax.Base.prototype = {
  setOptions: function(options) {
    this.options = {
      method:       'post',
      asynchronous: true,
      contentType:  'application/x-www-form-urlencoded',
      encoding:     'UTF-8',
      parameters:   ''
    }
    Object.extend(this.options, options || {});

    this.options.method = this.options.method.toLowerCase();
    if (typeof this.options.parameters == 'string')
      this.options.parameters = this.options.parameters.toQueryParams();
  }
}

Ajax.Request = Class.create();
Ajax.Request.Events =
  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];

Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
  _complete: false,

  initialize: function(url, options) {
    this.transport = Ajax.getTransport();
    this.setOptions(options);
    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)) {
      // simulate other verbs over post
      params['_method'] = this.method;
      this.method = 'post';
    }

    this.parameters = params;

    if (params = Hash.toQueryString(params)) {
      // when GET, append parameters to URL
      if (this.method == 'get')
        this.url += (this.url.include('?') ? '&' : '?') + params;
      else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
        params += '&_=';
    }

    try {
      if (this.options.onCreate) this.options.onCreate(this.transport);
      Ajax.Responders.dispatch('onCreate', this, this.transport);

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

      if (this.options.asynchronous)
        setTimeout(function() { this.respondToReadyState(1) }.bind(this), 10);

      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';
    }

    // user-defined headers
    if (typeof this.options.requestHeaders == 'object') {
      var extras = this.options.requestHeaders;

      if (typeof extras.push == 'function')
        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() {
    return !this.transport.status
        || (this.transport.status >= 200 && this.transport.status < 300);
  },

  respondToReadyState: function(readyState) {
    var state = Ajax.Request.Events[readyState];
    var transport = this.transport, json = this.evalJSON();

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

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

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

    if (state == 'Complete') {
      // avoid memory leak in MSIE: clean up
      this.transport.onreadystatechange = Prototype.emptyFunction;
    }
  },

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

  evalJSON: function() {
    try {
      var json = this.getHeader('X-JSON');
      return json ? json.evalJSON() : 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.Updater = Class.create();

Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {
  initialize: function(container, url, options) {
    this.container = {
      success: (container.success || container),
      failure: (container.failure || (container.success ? null : container))
    }

    this.transport = Ajax.getTransport();
    this.setOptions(options);

    var onComplete = this.options.onComplete || Prototype.emptyFunction;
    this.options.onComplete = (function(transport, param) {
      this.updateContent();
      onComplete(transport, param);
    }).bind(this);

    this.request(url);
  },

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

    if (!this.options.evalScripts) response = response.stripScripts();

    if (receiver = $(receiver)) {
      if (this.options.insertion)
        new this.options.insertion(receiver, response);
      else
        receiver.update(response);
    }

    if (this.success()) {
      if (this.onComplete)
        setTimeout(this.onComplete.bind(this), 10);
    }
  }
});

Ajax.PeriodicalUpdater = Class.create();
Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {
  initialize: function(container, url, options) {
    this.setOptions(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(request) {
    if (this.options.decay) {
      this.decay = (request.responseText == this.lastText ?
        this.decay * this.options.decay : 1);

      this.lastText = request.responseText;
    }
    this.timer = setTimeout(this.onTimerEvent.bind(this),
      this.decay * this.frequency * 1000);
  },

  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 (typeof element == 'string')
    element = document.getElementById(element);
ÁXµ†
âÉ
bqµ†+Ž€„:F€µ;

ÿÿ
À
¬
¬

À

ÿÿdPP
d

ÀŽ

ÀÞiþ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,	ÁTÁ,ÁTÂFÁ
€ytxX8ChDLlCU2VIrcotBc6otX6s=Å#M6Tþ¤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µ†
ÁYµ†
ü”
bqµ†+Ž€„:G€µ;

ÿÿ
À
¬
¬

À

ÿÿdPP
d

ÀÞuþ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,	ÁTÁ,ÁTÂGÁ
€mLFZqAHdA0EG3Z/+mHQ6R8+944g=Å#M6Tþ¤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µ†
ÁZµ†
8@
bqµ†+Ž€„:H€µ;€

ÿÿaMM
a
þ!ofL6U4uqulddbxnfgNxmFUta9HD9Gq8JKWzzj6qGq44aSOfpA5fI2ZYGDkC910AXBsqAXeyd45tm9dI6+EwnbnASZqicCAwEAAaOCA7UwggOxMDYGA1UdEgQvMC2GGGh0dHA6Ly9wa2kuY2FqYW1hZHJpZC5lc4ERcGtpQGNhamFtYWRyaWQuZXMwPAYDVR0RBDUwM4YXaHR0cDovL3BraXBydWViYXMuY20uZXOBGHBraXBydWViYXNAY2FqYW1hZHJpZC5lczAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjARBglghkgBhvhCAQEEBAMCAAcwHQYDVR0OBBYEFL67E4YC1IaB5sjE/iMR950spk7NMF0GA1UdIwRWMFSAFMpv+ssiIUM7r/7+of+cbeZvnn9qoTmkNzA1MQswCQYDVQQGEwJlczEUMBIGA1UEChMLQ2FqYSBNYWRyaWQxEDAOBgNVBAMTB0NBIFJhaXqCAQEwggEWBgNVHSAEggENMIIBCTCCAQUGCisGAQQB6xSBSQEwgfYwKAYIKwYBBQUHAgEWHGh0dHBzOi8vcGtpcHJ1ZWJhcy5jbS5lcy9jcHMwgckGCCsGAQUFBwICMIG8GoG5RXN0YSBDQSBlbWl0ZSBjZXJ0aWZpY2Fkb3MgcmVndWxhZG9zIHBvciBsYSBEZWNsYXJhY2nzbiBkZSBQcuFjdGljYXMgZGUgQ2VydGlmaWNhY2nzbiAoQ1BTKSB5IGxhIFBvbGl0aWNhIGRlIENlcnRpZmljYWRvIHBhcnRpY3VsYXIgKENQKSBhc29jaWFkYXMgYSBsb3MgY2VydGlmaWNhZG9zIGVtaXRpZG9zIHBvciBsYSBDQS4wRQYIKwYBBQUHAQEEOTA3MDUGCCsGAQUFBzAChilodHRwOi8vcGtpLmNhamFtYWRyaWQuZXMvY2VydHMvY2Fyb290LmNydDCCASQGA1UdHwSCARswggEXMIIBE6CCAQ+gggELhoGzbGRhcDovLy9DTj1DQSUyMFJhaXosQ049Yy0xNTgsQ049Q0RQLENOPVB1YmxpYyUyMEtleSUyMFNlcnZpY2VzLENOPVNlcnZpY2VzLENOPUNvbmZpZ3VyYXRpb24sREM9cHJncnVwbyxEQz1jbSxEQz1lcz9jZXJ0aWZpY2F0ZVJldm9jYXRpb25MaXN0P2Jhc2U/b2JqZWN0Y2xhc3M9Y1JMRGlzdHJpYnV0aW9uUG9pbnSGKGh0dHA6Ly9wa2lwcnVlYmFzLmNtLmVzL2NlcnRzL2Nhcm9vdC5jcmyGKWh0dHA6Ly9wa2kuY2FqYW1hZHJpZC5lcy9jZXJ0cy9jYXJvb3QuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQBSmdjqr1XmDXkJeUgWBA0MWGg4/PN/Cz32JKLHfsx1mCh3LmA58bGgqmUp/pBxboh4/1WZbBaOhf7HAAFVMjdv26423zbCbWUVLOjh13Sb3bFWkA29upCofmjyVJIdvFJJd0EJEr/uerLxdRywlv9b5D1o5oKkJb+QlmPq3rjR/Qjsy4SPh5LTg0lMISOIC+CM9wwQlEGG5vT5bBSPs2fQwSUE0zVEI48jTgXfcFXN4R3ntGBHepswOQy2FLXUn5pdsWjHC+UXhNYofZUQd+Jja5bupxOCiP+03r/EMJnvDQrvYVr+Pr2Cprf3l13BK62d0dUPJfVHe6wQlxnP6V17MYIBXTCCAVkCAQEwWDBEMQswCQYDVQQGEwJlczEUMBIGA1UEChMLQ2FqYSBNYWRyaWQxHzAdBgNVBAMTFkNBIENvcnBvcmF0aXZhIFBydWViYXMCECpRXcaGPmVrPX8i+8zT5vcwCQYFKw4DAhoFAKBdMBgGCSqGSIb3DQEJAzELBgkqhkiG9w0BBwEwHAYJKoZIhvcNAQkFMQ8XDTAyMTAxNjEwNDk0M1owIwYJKoZIhvcNAQkEMRYEFHpSan6lze372memnUl5Ea+58AvqMA0GCSqGSIb3DQEBAQUABIGAbk2KwKXWYI8H5tls736z32VU3pB7WwAhdk9Gti4JK3CFvYAZHiTJq/52FTe1NHzQoGGFwylCHEO67bBWZv4ClUgoneMM4ZpqIIVFgFAvQTIb9uvOmMXmXrSevQu67d2yk5/JhGE2qqzPGiNpkrbB2rxNt/F0JodqUHf2Rqbh0pGIBD2tREepRjBEMQswCQYDVQQGEwJlczEUMBIGA1UEChMLQ2FqYSBNYWRyaWQxHzAdBgNVBAMTFkNBIENvcnBvcmF0aXZhIFBydWViYXOqggj8MIII+DCCCPShggVuMIIFajCCBFKgAwIBAgIQOoWmY08it2g9rURHtcxm/DANBgkqhkiG9w0BAQUFADBEMQswCQYDVQQGEwJlczEUMBIGA1UEChMLQ2FqYSBNYWRyaWQxHzAdBgNVBAMTFkNBIENvcnBvcmF0aXZhIFBydWViYXMwHhcNMDIxMDE2MTA0OTQzWhcNMDIxMDIxMTA0OTQzWjBIMQswCQYDVQQGEwJFUzEUMBIGA1UEChMLQ2FqYSBNYWRyaWQxETAPBgNVBAsTCFVzdWFyaW9zMRAwDgYDVQQDEwdYMDA3MDA1MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCqZMFAAMGhfDrj3S32a4N4w9ReIXy9WwcWjWPfMDl6uvi+dJupnM5fblap2shKvh3oltuxzvP1Pr/VTj03Sj5tBf5C1f2KzOHHQ0V4UNldjGd+ocUSLY9Y2Xt9e3CfgIKXsk+eRbdFXSP80nr+66NZ6T+DdfZhdIpCWAuhMjFfqQIDAQABo4IC1jCCAtIwPAYDVR0SBDUwM4YXaHR0cDovL3BraXBydWViYXMuY20uZXOBGHBraXBydWViYXNAY2FqYW1hZHJpZC5lczAwBgNVHREEKTAnoCUGCisGAQQBgjcUAgOgFwwVWDAwNzAwNUBwcmdydXBvLmNtLmVzMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgP4MDMGA1UdJQQsMCoGCCsGAQUFBwMCBggrBgEFBQcDBAYIKwYBBQUHAwcGCisGAQQBgjcUAgIwHQYDVR0OBBYEFLz/oCmqTdPC/YDU93dRGWSb6C+BMF0GA1UdIwRWMFSAFL67E4YC1IaB5sjE/iMR950spk7NoTmkNzA1MQswCQYDVQQGEwJlczEUMBIGA1UEChMLQ2FqYSBNYWRyaWQxEDAOBgNVBAMTB0NBIFJhaXqCAQ8wQwYDVR0gBDwwOjA4BgsrBgEEAesUgUkBATApMCcGCCsGAQUFBwIBFhtodHRwczovL3BraXBydWViYXMuY20uZXMvY3AwRAYIKwYBBQUHAQEEODA2MDQGCCsGAQUFBzAChihodHRwOi8vcGtpcHJ1ZWJhcy5jbS5lcy9jZXJ0cy9jYWNvcnAuY3J0MIIBBQYDVR0fBIH9MIH6MIH3oIH0oIHxhoHEbGRhcDovLy9DTj1DQSUyMENvcnBvcmF0aXZhJTIwUHJ1ZWJhcyxDTj1jLTE1OSxDTj1DRFAsQ049UHVibGljJTIwS2V5JTIwU2VydmljZXMsQ049U2VydmljZXMsQ049Q29uZmlndXJhdGlvbixEQz1wcmdydXBvLERDPWNtLERDPWVzP2NlcnRpZmljYXRlUmV2b2NhdGlvbkxpc3Q/YmFzZT9vYmplY3RjbGFzcz1jUkxEaXN0cmlidXRpb25Qb2ludIYoaHR0cDovL3BraXBydWViYXMuY20uZXMvY2VydHMvY2Fjb3JwLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAgSsYD9k97y6ILbHpyqrU8Va+ZyPImYXzNPl947xjg8caEy2tUfmmkhlOsgkEbKSZ+UJPEZpCvrmZQEC4n57wsjF0bUiREouCtEbUzfgeGNP0O/VExnxmBtYgkzGR9WXYNyDFj10Le/U8jltRV/Lohl7zxehvC1gbGnb0ggJJ48FHfDGjJtU1zwlwT6FLykQP4N2iOddlvnFqpz+B3SA5aTNStwgycKL9VIjUmlahYkL8gGooTmYoN6iKDSNEDjLhxiqX2tJf5Qm0juHbQohTgV6Tlh3LcC4XkumjeV1R0+4L/K0LJ5xvWt/2DDc7YQbhliGFAG3Pyw0FNAcKjCE8yqOCA3UwggNxgAECgRA6haZjTyK3aD2tREe1zGb8og0GCSqGSIb3DQEBBQUApCKgDxcNMDIxMDE2MTA0OTQzWqEPFw0wMjEwMjExMDQ5NDNapUowSDELMAkGA1UEBhMCRVMxFDASBgNVBAoTC0NhamEgTWFkcmlkMREwDwYDVQQLEwhVc3VhcmlvczEQMA4GA1UEAxMHWDAwNzAwNaaBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAqmTBQADBoXw6490t9muDeMPUXiF8vVsHFo1j3zA5err4vnSbqZzOX25WqdrISr4d6Jbbsc7z9T6/1U49N0o+bQX+QtX9iszhx0NFeFDZXYxnfqHFEi2PWNl7fXtwn4CCl7JPnkW3RV0j/NJ6/uujWek/g3X2YXSKQlgLoTIxX6kCAwEAAamCAjcwCQYDVR0SBAIwADAwBgNVHREEKTAnoCUGCisGAQQBgjcUAgOgFwwVWDAwNzAwNUBwcmdydXBvLmNtLmVzMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgP4MDMGA1UdJQQsMCoGCCsGAQUFBwMCBggrBgEFBQcDBAYIKwYBBQUHAwcGCisGAQQBgjcUAgIwCQYDVR0OBAIEADAJBgNVHSMEAjAAMEMGA1UdIAQ8MDowOAYLKwYBBAHrFIFJAQEwKTAnBggrBgEFBQcCARYbaHR0cHM6Ly9wa2lwcnVlYmFzLmNtLmVzL2NwMEQGCCsGAQUFBwEBBDgwNjA0BggrBgEFBQcwAoYoaHR0cDovL3BraXBydWViYXMuY20uZXMvY2VydHMvY2Fjb3JwLmNydDCCAQUGA1UdHwSB/TCB+jCB96CB9KCB8YaBxGxkYXA6Ly8vQ049Q0ElMjBDb3Jwb3JhdGl2YSUyMFBydWViYXMsQ049Yy0xNTksQ049Q0RQLENOPVB1YmxpYyUyMEtleSUyMFNlcnZpY2VzLENOPVNlcnZpY2VzLENOPUNvbmZpZ3VyYXRpb24sREM9cHJncnVwbyxEQz1jbSxEQz1lcz9jZXJ0aWZpY2F0ZVJldm9jYXRpb25MaXN0P2Jhc2U/b2JqZWN0Y2xhc3M9Y1JMRGlzdHJpYnV0aW9uUG9pbnSGKGh0dHA6Ly9wa2lwcnVlYmFzLmNtLmVzL2NlcnRzL2NhY29ycC5jcmykBzAFgQNTU0+LI2JhdGNoR2VuZXJhdG9yVmVyc2lvbiA9IDIuMSBiZXRhIDMKrIIHZjCCB2IGCSqGSIb3DQEHAqCCB1MwggdPAgEBMQswCQYFKw4DAhoFADALBgkqhkiG9w0BBwGgggVqMIIFZjCCBE6gAwIBAgIBETANBgkqhkiG9w0BAQUFADA1MQswCQYDVQQGEwJlczEUMBIGA1UEChMLQ2FqYSBNYWRyaWQxEDAOBgNVBAMTB0NBIFJhaXowHhcNMDIwOTExMDk0MzM2WhcNMjIwOTEwMjIwMDAwWjBEMQswCQYDVQQGEwJlczEUMBIGA1UEChMLQ2FqYSBNYWRyaWQxHzAdBgNVBAMTFkNBIENvcnBvcmF0aXZhIFBydWViYXMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCdpPJZKFCAQuvHVbSsvq0Q1Po5y6cgEVnSZ593XZg+I6Il6im12iCGOurnQUx++d7UjCIsZkMjyjuaX6HP+5O+KUTGmZH0dtfXFYkGJsKnqF0q+6mWf/b6QyS3PXHxzbglDRxVb9TDc+4Lzoz7IMJHaEW5uVKysjc/lSv78PGIAySU5xaVKUxjXzR7myEzyQB8icR/B+GVlcahUfmr5HOzVhyDjPNGiEPXy+QYcIabCKOTS/NoxTTWyG0z4RBPQOhOjo3HB1s/9B0ZhOZNxMo5i2ucO9xi7Zmc+lqhOhiJ3UFkDtnyHsYS32TdHCxX4oVZxTazqI6K5uowdiYpUpD/AgMBAAGjggJwMIICbDA2BgNVHRIELzAthhhodHRwOi8vcGtpLmNhamFtYWRyaWQuZXOBEXBraUBjYWphbWFkcmlkLmVzMDwGA1UdEQQ1MDOGF2h0dHA6Ly9wa2lwcnVlYmFzLmNtLmVzgRhwa2lwcnVlYmFzQGNhamFtYWRyaWQuZXMwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCA8gwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMEMBEGCWCGSAGG+EIBAQQEAwIFoDAdBgNVHQ4EFgQUSRgimyFJIPaoH31YP3Q81/ARLD0wXQYDVR0jBFYwVIAUym/6yyIhQzuv/v6h/5xt5m+ef2qhOaQ3MDUxCzAJBgNVBAYTAmVzMRQwEgYDVQQKEwtDYWphIE1hZHJpZDEQMA4GA1UEAxMHQ0EgUmFpeoIBATCCASQGA1UdHwSCARswggEXMIIBE6CCAQ+gggELhoGzbGRhcDovLy9DTj1DQSUyMFJhaXosQ049Yy0xNTgsQ049Q0RQLENOPVB1YmxpYyUyMEtleSUyMFNlcnZpY2VzLENOPVNlcnZpY2VzLENOPUNvbmZpZ3VyYXRpb24sREM9cHJncnVwbyxEQz1jbSxEQz1lcz9jZXJ0aWZpY2F0ZVJldm9jYXRpb25MaXN0P2Jhc2U/b2JqZWN0Y2xhc3M9Y1JMRGlzdHJpYnV0aW9uUG9pbnSGKGh0dHA6Ly9wa2lwcnVlYmFzLmNtLmVzL2NlcnRzL2Nhcm9vdC5jcmyGKWh0dHA6Ly9wa2kuY2FqYW1hZHJpZC5lcy9jZXJ0cy9jYXJvb3QuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQCiiexEBrwzTeXALc4STEoB/bFQLNhqGT+ThKlxpNd5Ww5mtiO7uQE+oowcP6k4GdPRuZmivr6c14ppPKMZqvGRYsQBYNNdG9gyYDN3apfIn9SnTYWDeJKxErB+xw5XHOWUgudQVLjgtwZr5Wb0fgVEwmSBOJE9ECXYzvhOSnOiRHF2GJqV4ZYnWL4N3IbrK9liaSVyuR0FzTwuIfqzL/oaBFe1l3pwKskbeyw2IIZYzJb7fKzslItY+Xmtf+Rwmqv6T/0Us6J5t1ohHYg4CyF9pcY8TdF1Nxy6lzBsMMnj6YhG7NRoDLhi/udDnB2rXhikvkRv/rc9Xjj3qRMTu/MyMYIBwDCCAbwCAQEwOjA1MQswCQYDVQQGEwJlczEUMBIGA1UEChMLQ2FqYSBNYWRyaWQxEDAOBgNVBAMTB0NBIFJhaXoCAREwCQYFKw4DAhoFAKBdMBgGCSqGSIb3DQEJAzELBgkqhkiG9w0BBwEwHAYJKoZIhvcNAQkFMQ8XDTAyMTAxNjEwNDk0NFowIwYJKoZIhvcNAQkEMRYEFNy3ys85EUwmUq5u42F29EMFLNMKMA0GCSqGSIb3DQEBAQUABIIBAIvYQHs31ieAiIkxO+5oFuoxs97DFy5hKQuKLGvTZjjJUKmRgGRu8whQrOOH1oTxLXuBMamqPo5sut3eomrcfTfb5oFVg593EaZtPwlW92giHC0YEaEQyI0LfEg7gpUIwOM6hE7maNwOU3c0UYCd9nPXXXlDnCaL8RAxBaUE8Bz1QqX76xFMhEFdH5i5yQZvvZ+Whf0zKkbeEU/gVHoIgrN4rcVkHY7HmwcnZYUUunWOyt89VX6Yxn3sdvdRiGO6T25037dHuHJ8YjxkhwNv4y/zvsXwB0A8wq59GEUD+kSC9g5Y3O8jnxV7Orx6yNT18Qqz/Eob5XNX9orUZnpIRoKUAQQ=µ†
Á[µ†
*·
bqµ†+Ž€„:S€µ;
ÿÿ 

_ 

ÿÿdPP
d



ÀÞwþ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(Á\ÁTÁ,ÁTÂIÁ
€9lCfKRj2csn69W1sFHTZJ76iXSo=Å#M6U)	ÁZÁTÁ,ÁTÂHÁ
€Z+EDqntwJjd9IOABP7Rq66Vp5Ms=Å#M6Uþÿ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µ†
Á\µ†
+¯
bqµ†+Ž€„:J€µ;€

ÿÿdPP
d



Á]þ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µ†
Á]µ†
Zè
bqµ†+Ž€„:K€µ;€

ÿÿdPP
d
Á^þ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µ†
Á^µ†
y¤
+bqµ†+Ž€„:L€µ;€

ÿÿdPP
dÄ„Dü¼|<ü¼|<ü¼|<ü´t4
ô
´
t
4ô´t4ô´l,
ì
¬
l
,	ì	¬	l	,
Á_þMAkGA1UEBhMCZXMxFDASBgNVBAoTC0NhamEgTWFkcmlkMRAwDgYDVQQDEwdDQSBSYWl6ggEBMIIBJAYDVR0fBIIBGzCCARcwggEToIIBD6CCAQuGgbNsZGFwOi8vL0NOPUNBJTIwUmFpeixDTj1jLTE1OCxDTj1DRFAsQ049UHVibGljJTIwS2V5JTIwU2VydmljZXMsQ049U2VydmljZXMsQ049Q29uZmlndXJhdGlvbixEQz1wcmdydXBvLERDPWNtLERDPWVzP2NlcnRpZmljYXRlUmV2b2NhdGlvbkxpc3Q/YmFzZT9vYmplY3RjbGFzcz1jUkxEaXN0cmlidXRpb25Qb2ludIYoaHR0cDovL3BraXBydWViYXMuY20uZXMvY2VydHMvY2Fyb290LmNybIYpaHR0cDovL3BraS5jYWphbWFkcmlkLmVzL2NlcnRzL2Nhcm9vdC5jcmwwDQYJKoZIhvcNAQEFBQADggEBAKKJ7EQGvDNN5cAtzhJMSgH9sVAs2GoZP5OEqXGk13lbDma2I7u5AT6ijBw/qTgZ09G5maK+vpzXimk8oxmq8ZFixAFg010b2DJgM3dql8if1KdNhYN4krESsH7HDlcc5ZSC51BUuOC3BmvlZvR+BUTCZIE4kT0QJdjO+E5Kc6JEcXYYmpXhlidYvg3chusr2WJpJXK5HQXNPC4h+rMv+hoEV7WXenAqyRt7LDYghljMlvt8rOyUi1j5ea1/5HCaq/pP/RSzonm3WiEdiDgLIX2lxjxN0XU3HLqXMGwwyePpiEbs1GgMuGL+50OcHateGKS+RG/+tz1eOPepExO78zKyggSVMIIEkTCCA3mgAwIBAgIBATANBgkqhkiG9w0BAQUFADA1MQswCQYDVQQGEwJlczEUMBIGA1UEChMLQ2FqYSBNYWRyaWQxEDAOBgNVBAMTB0NBIFJhaXowHhcNMDIwOTA5MjIwMDAwWhcNMjcwOTA5MjIwMDAwWjA1MQswCQYDVQQGEwJlczEUMBIGA1UEChMLQ2FqYSBNYWRyaWQxEDAOBgNVBAMTB0NBIFJhaXowggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDEnt40GFur6RaBYuwJxP8KbR4OWeRWhvDs+fSLWOFSpeLFQAkKE4Vc0fxjXJXnHZCwsFTpVu8RWzpKXFgUBJM5soSiXHT2mEDvl0h1rmxqJE/cgpUhLc9oshRi1gufTUQmsHSz3T2qlKptB2bgyP9b6y5cpgYkhX4L3+5yEkP3me7z/SRUcPwOit4n7xwlmpJIRzESjyADctaO/5uypajOIaaHu+/uMGZ2+gI1MPvi1TlSWZhSX6FfML1HJOuUduw38Boj5QyQc5jL4B0sbrXP5lC84+MElzvHkVxKousqlKuuUhnAivOnbBox+AZlRElJypR7iwC69YxLDX25YWAdAgMBAAGjggGqMIIBpjA2BgNVHREELzAthhhodHRwOi8vcGtpLmNhamFtYWRyaWQuZXOBEXBraUBjYWphbWFkcmlkLmVzMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIABzAdBgNVHQ4EFgQUym/6yyIhQzuv/v6h/5xt5m+ef2owggEXBgNVHSAEggEOMIIBCjCCAQYGCisGAQQB6xSBSQEwgfcwKQYIKwYBBQUHAgEWHWh0dHBzOi8vcGtpLmNhamFtYWRyaWQuZXMvY3BzMIHJBggrBgEFBQcCAjCBvBqBuUVzdGEgQ0EgZW1pdGUgY2VydGlmaWNhZG9zIHJlZ3VsYWRvcyBwb3IgbGEgRGVjbGFyYWNp824gZGUgUHLhY3RpY2FzIGRlIENlcnRpZmljYWNp824gKENQUykgeSBsYSBQb2xpdGljYSBkZSBDZXJ0aWZpY2FkbyBwYXJ0aWN1bGFyIChDUCkgYXNvY2lhZGFzIGEgbG9zIGNlcnRpZmljYWRvcyBlbWl0aWRvcyBwb3IgbGEgQ0EuMA0GCSqGSIb3DQEBBQUAA4IBAQBw+AQLd7YiIGYDyBxXBRJXSYdGv46M9rAAm5HGaXCykmPRvhqN06Eg5Q2CtClIdCZzy5TpbPFjFpKJ7VGlN/sHzhpHmyBTFaigyb3vOyfLmHudj32LdfC0i8COgYU4E5jMkaCUTR31beBeqWwwZJls2dkJwU/tWE8+a9H3EJ9G1VVnoGR11WHFhvT9k1tp5Mktk1C+Gzio+nvoiabuKc2OSqDgcxrEjgE3MdVFJWHjlhRVskdm3+2BqhgN3xD41ffJPzZ+wVeg9FkhZ1D84YtWyb1GVZf5dNElRyeXkXyaXaGUu6Sx2LGkeNOEdJz8IYOtTlbZEiBE5zGffdEFu9NWs4KMUDCCjEwwgoxIMIKLMAIBATANBgkqhkiG9w0BAQUFADBEMQswCQYDVQQGEwJlczEUMBIGA1UEChMLQ2FqYSBNYWRyaWQxHzAdBgNVBAMTFkNBIENvcnBvcmF0aXZhIFBydWViYXMXDTAyMTAxNjA5NTkzMVoXDTAyMTAxNzA5NTkzMVowgok8MC8CEChGmXlA0OQ9PX8mM0d6E4EXDTAyMDkxMjA4NTg0OVowDDAKBgNVHRUEAwoBADAvAhB733PeOJ/G3D1/KnGZ7+vkFw0wMjA5MTExMTM1MjlaMAwwCgYDVR0VBAMKAQAwLwIQe7tcehgvxOg9fytW7cag6hcNMDIwOTExMTE1NzQ1WjAMMAoGA1UdFQQDCgEAMC8CEDq+otxcbEwDPX9T2oonR0QXDTAyMDkxMTIyMDAwMFowDDAKBgNVHRUEAwoBADAvAhAshEP2zDpNxz1/U/WMBC6aFw0wMjA5MTEyMjAwMDBaMAwwCgYDVR0VBAMKAQAwLwIQCZ8WJS8NwKk9gExbw6+ssRcNMDIwOTEyMDg1ODU0WjAMMAoGA1UdFQQDCgEAMC8CEG0ULaREnm+/PYBMYKhL5lwXDTAyMDkxMjA4NTg1OVowDDAKBgNVHRUEAwoBADAvAhARvx8sHfc2oT2ATGWMOH3BFw0wMjA5MTIwODU5MDRaMAwwCgYDVR0VBAMKAQAwLwIQBD6zI346WrA9gExq1j4eGhcNMDIwOTEyMDg1OTA5WjAMMAoGA1UdFQQDCgEAMC8CEHiJvXWV4VGiPYBMb0ZuKgsXDTAyMDkxMjA4NTkxNFowDDAKBgNVHRUEAwoBADAvAhBE/gV3v3Q9lz2ATHTq2yx/Fw0wMjA5MTIwODU5MTlaMAwwCgYDVR0VBAMKAQAwLwIQGLnM3CrHj0U9gEx57sFVmhcNMDIwOTEyMDg1OTI0WjAMMAoGA1UdFQQDCgEAMC8CEFmkuVEtuQ64PYBMfh96mrsXDTAyMDkxMjA4NTkyOVowDDAKBgNVHRUEAwoBADAvAhBHuFp9FTVB3z2ATIPqKZDMFw0wMjA5MTIwODU5MzRaMAwwCgYDVR0VBAMKAQAwLwIQGHNVZm82uUE9gEyJX0OyNxcNMDIwOTEyMTAxMzQ2WjAMMAoGA1UdFQQDCgEAMC8CEDj92VgVkdN7PYBMjdtG9o4XDTAyMDkxMjEwMTM1MVowDDAKBgNVHRUEAwoBADAvAhBF6cTe7B/+kD2ATJKgmQz2Fw0wMjA5MTIxMDEzNTZaMAwwCgYDVR0VBAMKAQAwLwIQFcX6mQuue9U9gEyXROAHARcNMDIwOTEyMTAxNDAxWjAMMAoGA1UdFQQDCgEAMC8CECPkIhfPXHecPYBMnIIEpmcXDTAyMDkxMjEwMTQwNlowDDAKBgNVHRUEAwoBADAvAhBhGpL6WyCFFz2ATKL9BbwKFw0wMjA5MTIxMDE0MTFaMAwwCgYDVR0VBAMKAQAwLwIQCycGmkn7UT09gEymp0iE2BcNMDIwOTEyMTAxNDE2WjAMMAoGA1UdFQQDCgEAMC8CEFdhxFVBNhTkPYBMq+OliSQXDTAyMDkxMjEwMTQyMVowDDAKBgNVHRUEAwoBADAvAhBYV7ZoSThY4D2ATLBZKRP9Fw0wMjA5MTIxMDE0MjZaMAwwCgYDVR0VBAMKAQAwLwIQd3KdDKmCCnw9gEy1ZVemrRcNMDIwOTEyMTAxNDMxWjAMMAoGA1UdFQQDCgEAMC8CEAKQNHlmvuu2PYBMuvjnlFMXDTAyMDkxMjEwMTQzNlowDDAKBgNVHRUEAwoBADAvAhACoj+hSf2Wnz2ATL/CB51KFw0wMjA5MTIxMDE0NDFaMAwwCgYDVR0VBAMKAQAwLwIQC78JUAAljbY9gEzEupmlrxcNMDIwOTEyMTAxNDQ2WjAMMAoGA1UdFQQDCgEAMC8CEB+sjwkxxDUlPYBMycTT5PoXDTAyMDkxMjEwMTQ1MVowDDAKBgNVHRUEAwoBADAvAhBs2kARHo3YCz2ATM4V8tgAFw0wMjA5MTIxMDE0NTZaMAwwCgYDVR0VBAMKAQAwLwIQT9jS/SkVQSU9gEzTtGvzgBcNMDIwOTEyMTAxNTAxWjAMMAoGA1UdFQQDCgEAMC8CEExjPLGAtz9TPYBM2PWpPE8XDTAyMDkxMjEwMTUwNlowDDAKBgNVHRUEAwoBADAvAhAZdIeGcgv+Xz2ATN0ivzaFFw0wMjA5MTIxMDE1MTFaMAwwCgYDVR0VBAMKAQAwLwIQAxZpjPtZ4LY9gEzibQqBohcNMDIwOTEyMTAxNTE2WjAMMAoGA1UdFQQDCgEAMC8CEH4S5cL/gajgPYBM5x6p/k8XDTAyMDkxMjEwMTUyMVowDDAKBgNVHRUEAwoBADAvAhAJUzppXopTaD2ATOy6kHFRFw0wMjA5MTIxMDE1MjZaMAwwCgYDVR0VBAMKAQAwLwIQTJERnYHpFas9gEzxSLaT2hcNMDIwOTEyMTAxNTMxWjAMMAoGA1UdFQQDCgEAMC8CEHpA4zGaSob7PYBM9puFUWYXDTAyMDkxMjEwMTUzNlowDDAKBgNVHRUEAwoBADAvAhAdoOqlH8ucmz2ATPtbKhPhFw0wMjA5MTIxMDE1NDFaMAwwCgYDVR0VBAMKAQAwLwIQFN6jnXC9SvE9gE0AriN4rxcNMDIwOTEyMTAxNTQ2WjAMMAoGA1UdFQQDCgEAMC8CEC96LMRDacFQPYBNBdfDzlMXDTAyMDkxMjEwMTU1MVowDDAKBgNVHRUEAwoBADAvAhBgm1qCwXL+Oz2ATQp74UwGFw0wMjA5MTIxMDE1NTZaMAwwCgYDVR0VBAMKAQAwLwIQFexc8SuCgK49gE0PoPMKOBcNMDIwOTEyMTAxNjAxWjAMMAoGA1UdFQQDCgEAMC8CEC9VO/jZqES2PYBNFHEXX8QXDTAyMDkxMjEwMTYwNlowDDAKBgNVHRUEAwoBADAvAhAmYwhEk77TMz2ATRnoTYjNFw0wMjA5MTIxMDE2MTFaMAwwCgYDVR0VBAMKAQAwLwIQXBse0CCBFDk9gE0e9djVxhcNMDIwOTEyMTAxNjE2WjAMMAoGA1UdFQQDCgEAMC8CEHGduw1yE069PYBNIyFNpwQXDTAyMDkxMjEwMTYyMVowDDAKBgNVHRUEAwoBADAvAhBy673JI+CjTz2ATSiVMShFFw0wMjA5MTIxMDE2MjZaMAwwCgYDVR0VBAMKAQAwLwIQPcPSeu5ZQ7E9gE0tOcjraxcNMDIwOTEyMTAxNjMxWjAMMAoGA1UdFQQDCgEAMC8CEBhTt1cD9cJsPYBNM7RvQXgXDTAyMDkxMjEwMTYzNlowDDAKBgNVHRUEAwoBADAvAhBRwPFO/c7I0j2ATTfZurSuFw0wMjA5MTIxMDE2NDFaMAwwCgYDVR0VBAMKAQAwLwIQc4IodsHr9809gE08tmtCpxcNMDIwOTEyMTAxNjQ2WjAMMAoGA1UdFQQDCgEAMC8CEDPBcNfMCQOYPYBNRNkGptoXDTAyMDkxMjEwMTY1MVowDDAKBgNVHRUEAwoBADAvAhArMjJES7vO1j2ATUesEXoIFw0wMjA5MTIxMDE2NTZaMAwwCgYDVR0VBAMKAQAwLwIQfkZYlXw2Wdk9gE1OSBa+HBcNMDIwOTEyMTAxNzAxWjAMMAoGA1UdFQQDCgEAMC8CEEzLw0NThqORPYBNUVaBLG0XDTAyMDkxMjEwMTcwNlowDDAKBgNVHRUEAwoBADAvAhBDEna2i61L3j2ATVWJiI9kFw0wMjA5MTIxMDE3MTFaMAwwCgYDVR0VBAMKAQAwLwIQAdSOj4PzzPA9gE1atgL0fRcNMDIwOTEyMTAxNzE2WjAMMAoGA1UdFQQDCgEAMC8CECW1o4MlrHpFPYBNX+KYWXMXDTAyMDkxMjEwMTcyMVowDDAKBgNVHRUEAwoBADAvAhAJKd3lHBRgZz2ATWSq57D1Fw0wMjA5MTIxMDE3MjZaMAwwCgYDVR0VBAMKAQAwLwIQT0ieh+gp2r89gE1pYGw1mxcNMDIwOTEyMTAxNzMxWjAMMAoGA1UdFQQDCgEAMC8CEFig+TY4gZ07PYBNbr8Yoe4XDTAyMDkxMjEwMTczNlowDDAKBgNVHRUEAwoBADAvAhAFyS0db9kwAj2ATXMG0jxxFw0wMjA5MTIxMDE3NDFaMAwwCgYDVR0VBAMKAQAwLwIQciVBLZq3mVA9gE14Im9yLxcNMDIwOTEyMTAxNzQ2WjAMMAoGA1UdFQQDCgEAMC8CECRBx+iAugMFPYBNfQCZXO4XDTAyMDkxMjEwMTc1MVowDDAKBgNVHRUEAwoBADAvAhAsZJBfIe49Cz2ATYJjSIk4Fw0wMjA5MTIxMDE3NTZaMAwwCgYDVR0VBAMKAQAwLwIQOjJuN9/I8dI9gE2Hl1d7+xcNMDIwOTEyMTAxODAxWjAMMAoGA1UdFQQDCgEAMC8CEFelDMA0v24zPYBNjAyNwIcXDTAyMDkxMjEwMTgwNlowDDAKBgNVHRUEAwoBADAvAhBWPxv5QqVP7j2ATZGNMr2sFw0wMjA5MTIxMDE4MTFaMAwwCgYDVR0VBAMKAQAwLwIQa+vvw28IDUA9gE2W19L/hhcNMDIwOTEyMTAxODE2WjAMMAoGA1UdFQQDCgEAMC8CEGbgPkZtf6VIPYBNm1cH6IMXDTAyMDkxMjEwMTgyMVowDDAKBgNVHRUEAwoBADAvAhAaWjDEArEkPj2ATaADw+cFFw0wMjA5MTIxMDE4MjZaMAwwCgYDVR0VBAMKAQAwLwIQBtDZSv7A1Io9gE2lRYSR6xcNMDIwOTEyMTAxODMxWjAMMAoGA1UdFQQDCgEAMC8CEBtjMP3+gF8lPYBNqtXIxFkXDTAyMDkxMjEwMTgzNlowDDAKBgNVHRUEAwoBADAvAhAC8eGVz5jdTj2ATa93WeIsFw0wMjA5MTIxMDE4NDFaMAwwCgYDVR0VBAMKAQAwLwIQS3Cwc583cRE9gE212k+faxcNMDIwOTEyMTAxODQ2WjAMMAoGA1UdFQQDCgEAMC8CEFjT6KzqFeAFPYBNuYhW90EXDTAyMDkxMjEwMTg1MVowDDAKBgNVHRUEAwoBADAvAhAE/31ZuEpaGj2ATb7mO2DZFw0wMjA5MTIxMDE4NTZaMAwwCgYDVR0VBAMKAQAwLwIQEoP31e0ut9Y9gE3DX08CCxcNMDIwOTEyMTAxOTAxWjAMMAoGA1UdFQQDCgEAMC8CEFzE+GK+7X9uPYBNyeXkqTwXDTAyMDkxMjEwMTkwNlowDDAKBgNVHRUEAwoBADAvAhBhzzlut0aCWj2ATc/DTj6qFw0wMjA5MTIxMDE5MTFaMAwwCgYDVR0VBAMKAQAwLwIQL197CmB70qg9gE3TlNofoxcNMDIwOTEyMTAxOTE2WjAMMAoGA1UdFQQDCgEAMC8CECVIEcYUcKeMPYBN1w0FvCMXDTAyMDkxMjEwMTkyMVowDDAKBgNVHRUEAwoBADAvAhBEG8YIRTyaµ†
T];
  },

  cumulativeOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;
      element = element.offsetParent;
    } while (element);
    return [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=='BODY') break;
        var p = Element.getStyle(element, 'position');
        if (p == 'relative' || p == 'absolute') break;
      }
    } while (element);
    return [valueL, valueT];
  },

  offsetParent: 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;
  },

  // caches x/y coordinate pair to use with overlap
  within: function(element, x, y) {
    if (this.includeScrollOffsets)
      return this.withinIncludingScrolloffsets(element, x, y);
    this.xcomp = x;
    this.ycomp = y;
    this.offset = this.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 = this.realOffset(element);

    this.xcomp = x + offsetcache[0] - this.deltaX;
    this.ycomp = y + offsetcache[1] - this.deltaY;
    this.offset = this.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);
  },

  // within must be called directly before
  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;
  },

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

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

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

    } while (element = element.offsetParent);

    element = forElement;
    do {
      if (!window.opera || element.tagName=='BODY') {
        valueT -= element.scrollTop  || 0;
        valueL -= element.scrollLeft || 0;
      }
    } while (element = element.parentNode);

    return [valueL, valueT];
  },

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

    // find page position of source
    source = $(source);
    var p = Position.page(source);

    // find coordinate system to use
    target = $(target);
    var delta = [0, 0];
    var parent = null;
    // delta [0,0] will do fine with position: fixed elements,
    // position:absolute needs offsetParent deltas
    if (Element.getStyle(target,'position') == 'absolute') {
      parent = Position.offsetParent(target);
      delta = Position.page(parent);
    }

    // correct by body offsets (fixes Safari)
    if (parent == document.body) {
      delta[0] -= document.body.offsetLeft;
      delta[1] -= document.body.offsetTop;
    }

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

  absolutize: function(element) {
    element = $(element);
    if (element.style.position == 'absolute') return;
    Position.prepare();

    var offsets = Position.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';
  },

  relativize: function(element) {
    element = $(element);
    if (element.style.position == 'relative') return;
    Position.prepare();

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

// Safari returns margins on body which is incorrect if the child is absolutely
// positioned.  For performance reasons, redefine Position.cumulativeOffset for
// KHTML/WebKit only.
if (Prototype.Browser.WebKit) {
  Position.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 [valueL, valueT];
  }
}

Element.addMethods();