/*  Prototype JavaScript framework, version 1.4.0
 *  (c) 2005 Sam Stephenson <sam@conio.net>
 *
 *  THIS FILE IS AUTOMATICALLY GENERATED. When sending patches, please diff
 *  against the source tree, available from the Prototype darcs repository.
 *
 *  Prototype is freely distributable under the terms of an MIT-style license.
 *
 *  For details, see the Prototype web site: http://prototype.conio.net/
 *
/*--------------------------------------------------------------------------*/

var Prototype = {
  Version: '1.4.0',
  ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',

  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 (property in source) {
    destination[property] = source[property];
  }
  return destination;
}

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

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;
  return function(event) {
    return __method.call(object, event || window.event);
  }
}

Object.extend(Number.prototype, {
  toColorPart: function() {
    var digits = this.toString(16);
    if (this < 16) return '0' + digits;
    return digits;
  },

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

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

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

    for (var i = 0; i < arguments.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() {
    setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
  },

  onTimerEvent: function() {
    if (!this.currentlyExecuting) {
      try {
        this.currentlyExecuting = true;
        this.callback();
      } finally {
        this.currentlyExecuting = false;
      }
    }
  }
}

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

function $() {
  var elements = new Array();

  for (var i = 0; i < arguments.length; i++) {
    var element = arguments[i];
    if (typeof element == 'string')
      element = document.getElementById(element);

    if (arguments.length == 1)
      return element;

    elements.push(element);
  }

  return elements;
}
Object.extend(String.prototype, {
  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(eval);
  },

  escapeHTML: function() {
    var div = document.createElement('div');
    var text = document.createTextNode(this);
    div.appendChild(text);
    return div.innerHTML;
  },

  unescapeHTML: function() {
    var div = document.createElement('div');
    div.innerHTML = this.stripTags();
    return div.childNodes[0] ? div.childNodes[0].nodeValue : '';
  },

  toQueryParams: function() {
    var pairs = this.match(/^\??(.*)$/)[1].split('&');
    return pairs.inject({}, function(params, pairString) {
      var pair = pairString.split('=');
      params[pair[0]] = pair[1];
      return params;
    });
  },

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

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

    var camelizedString = this.indexOf('-') == 0
      ? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1)
      : oStringList[0];

    for (var i = 1, len = oStringList.length; i < len; i++) {
      var s = oStringList[i];
      camelizedString += s.charAt(0).toUpperCase() + s.substring(1);
    }

    return camelizedString;
  },

  inspect: function() {
    return "'" + this.replace('\\', '\\\\').replace("'", '\\\'') + "'";
  }
});

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

var $break    = new Object();
var $continue = new Object();

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

  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 = true;
    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(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;
  },

  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.collect(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 (value >= (result || value))
        result = value;
    });
    return result;
  },

  min: function(iterator) {
    var result;
    this.each(function(value, index) {
      value = (iterator || Prototype.K)(value, index);
      if (value <= (result || value))
        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.collect(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.collect(Prototype.K);
  },

  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) {
      iterator(value = collections.pluck(index));
      return value;
    });
  },

  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; i < iterable.length; i++)
      results.push(iterable[i]);
    return results;
  }
}

Object.extend(Array.prototype, Enumerable);

Array.prototype._reverse = Array.prototype.reverse;

Object.extend(Array.prototype, {
  _each: function(iterator) {
    for (var i = 0; i < this.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 != undefined || value != null;
    });
  },

  flatten: function() {
    return this.inject([], function(array, value) {
      return array.concat(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; i < this.length; i++)
      if (this[i] == object) return i;
    return -1;
  },

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

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

  inspect: function() {
    return '[' + this.map(Object.inspect).join(', ') + ']';
  }
});
var Hash = {
  _each: function(iterator) {
    for (key in this) {
      var value = this[key];
      if (typeof value == 'function') 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($H(this), function(mergedHash, pair) {
      mergedHash[pair.key] = pair.value;
      return mergedHash;
    });
  },

  toQueryString: function() {
    return this.map(function(pair) {
      return pair.map(encodeURIComponent).join('=');
    }).join('&');
  },

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

function $H(object) {
  var hash = Object.extend({}, object || {});
  Object.extend(hash, Enumerable);
  Object.extend(hash, Hash);
  return hash;
}
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;
    do {
      iterator(value);
      value = value.succ();
    } while (this.include(value));
  },

  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 ActiveXObject('Msxml2.XMLHTTP')},
      function() {return new ActiveXObject('Microsoft.XMLHTTP')},
      function() {return new XMLHttpRequest()}
    ) || false;
  },

  activeRequestCount: 0
}

Ajax.Responders = {
  responders: [],

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

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

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

  dispatch: function(callback, request, transport, json) {
    this.each(function(responder) {
      if (responder[callback] && 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,
      parameters:   ''
    }
    Object.extend(this.options, options || {});
  },

  responseIsSuccess: function() {
    return this.transport.status == undefined
        || this.transport.status == 0
        || (this.transport.status >= 200 && this.transport.status < 300);
  },

  responseIsFailure: function() {
    return !this.responseIsSuccess();
  }
}

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

Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
  initialize: function(url, options) {
    this.transport = Ajax.getTransport();
    this.setOptions(options);
    this.request(url);
  },

  request: function(url) {
    var parameters = this.options.parameters || '';
    if (parameters.length > 0) parameters += '&_=';

    try {
      this.url = url;
      if (this.options.method == 'get' && parameters.length > 0)
        this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;

      Ajax.Responders.dispatch('onCreate', this, this.transport);

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

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

      this.setRequestHeaders();

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

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

  setRequestHeaders: function() {
    var requestHeaders =
      ['X-Requested-With', 'XMLHttpRequest',
       'X-Prototype-Version', Prototype.Version];

    if (this.options.method == 'post') {
      requestHeaders.push('Content-type',
        'application/x-www-form-urlencoded');

      /* Force "Connection: close" for Mozilla browsers to work around
       * a bug where XMLHttpReqeuest sends an incorrect Content-length
       * header. See Mozilla Bugzilla #246651.
       */
      if (this.transport.overrideMimeType)
        requestHeaders.push('Connection', 'close');
    }

    if (this.options.requestHeaders)
      requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);

    for (var i = 0; i < requestHeaders.length; i += 2)
      this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]);
  },

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

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

  evalJSON: function() {
    try {
      return eval(this.header('X-JSON'));
    } catch (e) {}
  },

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

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

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

      if ((this.header('Content-type') || '').match(/^text\/javascript/i))
        this.evalResponse();
    }

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

    /* Avoid memory leak in MSIE: clean up the oncomplete event handler */
    if (event == 'Complete')
      this.transport.onreadystatechange = Prototype.emptyFunction;
  },

  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.containers = {
      success: container.success ? $(container.success) : $(container),
      failure: 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, object) {
      this.updateContent();
      onComplete(transport, object);
    }).bind(this);

    this.request(url);
  },

  updateContent: function() {
    var receiver = this.responseIsSuccess() ?
      this.containers.success : this.containers.failure;
    var response = this.transport.responseText;

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

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

    if (this.responseIsSuccess()) {
      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.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);
  }
});
document.getElementsByClassName = function(className, parentElement) {
  var children = ($(parentElement) || document.body).getElementsByTagName('*');
  return $A(children).inject([], function(elements, child) {
    if (child.className.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
      elements.push(child);
    return elements;
  });
}

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

if (!window.Element) {
  var Element = new Object();
}

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

  toggle: function() {
    for (var i = 0; i < arguments.length; i++) {
      var element = $(arguments[i]);
      Element[Element.visible(element) ? 'hide' : 'show'](element);
    }
  },

  hide: function() {
    for (var i = 0; i < arguments.length; i++) {
      var element = $(arguments[i]);
      element.style.display = 'none';
    }
  },

  show: function() {
    for (var i = 0; i < arguments.length; i++) {
      var element = $(arguments[i]);
      element.style.display = '';
    }
  },

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

  update: function(element, html) {
    $(element).innerHTML = html.stripScripts();
    setTimeout(function() {html.evalScripts()}, 10);
  },

  getHeight: function(element) {
    element = $(element);
    return element.offsetHeight;
  },

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

  hasClassName: function(element, className) {
    if (!(element = $(element))) return;
    return Element.classNames(element).include(className);
  },

  addClassName: function(element, className) {
    if (!(element = $(element))) return;
    return Element.classNames(element).add(className);
  },

  removeClassName: function(element, className) {
    if (!(element = $(element))) return;
    return Element.classNames(element).remove(className);
  },

  // removes whitespace-only text node children
  cleanWhitespace: function(element) {
    element = $(element);
    for (var i = 0; i < element.childNodes.length; i++) {
      var node = element.childNodes[i];
      if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
        Element.remove(node);
    }
  },

  empty: function(element) {
    return $(element).innerHTML.match(/^\s*$/);
  },

  scrollTo: function(element) {
    element = $(element);
    var x = element.x ? element.x : element.offsetLeft,
        y = element.y ? element.y : element.offsetTop;
    window.scrollTo(x, y);
  },

  getStyle: function(element, style) {
    element = $(element);
    var value = element.style[style.camelize()];
    if (!value) {
      if (document.defaultView && document.defaultView.getComputedStyle) {
        var css = document.defaultView.getComputedStyle(element, null);
        value = css ? css.getPropertyValue(style) : null;
      } else if (element.currentStyle) {
        value = element.currentStyle[style.camelize()];
      }
    }

    if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
      if (Element.getStyle(element, 'position') == 'static') value = 'auto';

    return value == 'auto' ? null : value;
  },

  setStyle: function(element, style) {
    element = $(element);
    for (name in style)
      element.style[name.camelize()] = style[name];
  },

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

    // All *Width and *Height properties give 0 on elements with display none,
    // so enable the element temporarily
    var els = element.style;
    var originalVisibility = els.visibility;
    var originalPosition = els.position;
    els.visibility = 'hidden';
    els.position = 'absolute';
    els.display = '';
    var originalWidth = element.clientWidth;
    var originalHeight = element.clientHeight;
    els.display = 'none';
    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';
      // Opera returns the offset relative to the positioning context, when an
      // element is position relative but top and left have not been defined
      if (window.opera) {
        element.style.top = 0;
        element.style.left = 0;
      }
    }
  },

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

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

  undoClipping: function(element) {
    element = $(element);
    if (element._overflow) return;
    element.style.overflow = element._overflow;
    element._overflow = undefined;
  }
});

var Toggle = new Object();
Toggle.display = Element.toggle;

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

Abstract.Insertion = function(adjacency) {
  this.adjacency = adjacency;
}

Abstract.Insertion.prototype = {
  initialize: function(element, content) {
    this.element = $(element);
    this.content = content.stripScripts();

    if (this.adjacency && this.element.insertAdjacentHTML) {
      try {
        this.element.insertAdjacentHTML(this.adjacency, this.content);
      } catch (e) {
        if (this.element.tagName.toLowerCase() == 'tbody') {
          this.insertContent(this.contentFromAnonymousTable());
        } else {
          throw e;
        }
      }
    } else {
      this.range = this.element.ownerDocument.createRange();
      if (this.initializeRange) this.initializeRange();
      this.insertContent([this.range.createContextualFragment(this.content)]);
    }

    setTimeout(function() {content.evalScripts()}, 10);
  },

  contentFromAnonymousTable: function() {
    var div = document.createElement('div');
    div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';
    return $A(div.childNodes[0].childNodes[0].childNodes);
  }
}

var Insertion = new Object();

Insertion.Before = Class.create();
Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
  initializeRange: function() {
    this.range.setStartBefore(this.element);
  },

  insertContent: function(fragments) {
    fragments.each((function(fragment) {
      this.element.parentNode.insertBefore(fragment, this.element);
    }).bind(this));
  }
});

Insertion.Top = Class.create();
Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
  initializeRange: function() {
    this.range.selectNodeContents(this.element);
    this.range.collapse(true);
  },

  insertContent: function(fragments) {
    fragments.reverse(false).each((function(fragment) {
      this.element.insertBefore(fragment, this.element.firstChild);
    }).bind(this));
  }
});

Insertion.Bottom = Class.create();
Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
  initializeRange: function() {
    this.range.selectNodeContents(this.element);
    this.range.collapse(this.element);
  },

  insertContent: function(fragments) {
    fragments.each((function(fragment) {
      this.element.appendChild(fragment);
    }).bind(this));
  }
});

Insertion.After = Class.create();
Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
  initializeRange: function() {
    this.range.setStartAfter(this.element);
  },

  insertContent: function(fragments) {
    fragments.each((function(fragment) {
      this.element.parentNode.insertBefore(fragment,
        this.element.nextSibling);
    }).bind(this));
  }
});

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

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(this.toArray().concat(classNameToAdd).join(' '));
  },

  remove: function(classNameToRemove) {
    if (!this.include(classNameToRemove)) return;
    this.set(this.select(function(className) {
      return className != classNameToRemove;
    }).join(' '));
  },

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

Object.extend(Element.ClassNames.prototype, Enumerable);
var Field = {
  clear: function() {
    for (var i = 0; i < arguments.length; i++)
      $(arguments[i]).value = '';
  },

  focus: function(element) {
    $(element).focus();
  },

  present: function() {
    for (var i = 0; i < arguments.length; i++)
      if ($(arguments[i]).value == '') return false;
    return true;
  },

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

  activate: function(element) {
    element = $(element);
    element.focus();
    if (element.select)
      element.select();
  }
}

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

var Form = {
  serialize: function(form) {
    var elements = Form.getElements($(form));
    var queryComponents = new Array();

    for (var i = 0; i < elements.length; i++) {
      var queryComponent = Form.Element.serialize(elements[i]);
      if (queryComponent)
        queryComponents.push(queryComponent);
    }

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

  getElements: function(form) {
    form = $(form);
    var elements = new Array();

    for (tagName in Form.Element.Serializers) {
      var tagElements = form.getElementsByTagName(tagName);
      for (var j = 0; j < tagElements.length; j++)
        elements.push(tagElements[j]);
    }
    return elements;
  },

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

    if (!typeName && !name)
      return inputs;

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

    return matchingInputs;
  },

  disable: function(form) {
    var elements = Form.getElements(form);
    for (var i = 0; i < elements.length; i++) {
      var element = elements[i];
      element.blur();
      element.disabled = 'true';
    }
  },

  enable: function(form) {
    var elements = Form.getElements(form);
    for (var i = 0; i < elements.length; i++) {
      var element = elements[i];
      element.disabled = '';
    }
  },

  findFirstElement: function(form) {
    return Form.getElements(form).find(function(element) {
      return element.type != 'hidden' && !element.disabled &&
        ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
    });
  },

  focusFirstElement: function(form) {
    Field.activate(Form.findFirstElement(form));
  },

  reset: function(form) {
    $(form).reset();
  }
}

Form.Element = {
  serialize: function(element) {
    element = $(element);
    var method = element.tagName.toLowerCase();
    var parameter = Form.Element.Serializers[method](element);

    if (parameter) {
      var key = encodeURIComponent(parameter[0]);
      if (key.length == 0) return;

      if (parameter[1].constructor != Array)
        parameter[1] = [parameter[1]];

      return parameter[1].map(function(value) {
        return key + '=' + encodeURIComponent(value);
      }).join('&');
    }
  },

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

    if (parameter)
      return parameter[1];
  }
}

Form.Element.Serializers = {
  input: function(element) {
    switch (element.type.toLowerCase()) {
      case 'submit':
      case 'hidden':
      case 'password':
      case 'text':
        return Form.Element.Serializers.textarea(element);
      case 'checkbox':
      case 'radio':
        return Form.Element.Serializers.inputSelector(element);
    }
    return false;
  },

  inputSelector: function(element) {
    if (element.checked)
      return [element.name, element.value];
  },

  textarea: function(element) {
    return [element.name, element.value];
  },

  select: function(element) {
    return Form.Element.Serializers[element.type == 'select-one' ?
      'selectOne' : 'selectMany'](element);
  },

  selectOne: function(element) {
    var value = '', opt, index = element.selectedIndex;
    if (index >= 0) {
      opt = element.options[index];
      value = opt.value;
      if (!value && !('value' in opt))
        value = opt.text;
    }
    return [element.name, value];
  },

  selectMany: function(element) {
    var value = new Array();
    for (var i = 0; i < element.length; i++) {
      var opt = element.options[i];
      if (opt.selected) {
        var optValue = opt.value;
        if (!optValue && !('value' in opt))
          optValue = opt.text;
        value.push(optValue);
      }
    }
    return [element.name, value];
  }
}

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

var $F = Form.Element.getValue;

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

Abstract.TimedObserver = function() {}
Abstract.TimedObserver.prototype = {
  initialize: function(element, frequency, callback) {
    this.frequency = frequency;
    this.element   = $(element);
    this.callback  = callback;

    this.lastValue = this.getValue();
    this.registerCallback();
  },

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

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

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

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

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

Abstract.EventObserver = function() {}
Abstract.EventObserver.prototype = {
  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() {
    var elements = Form.getElements(this.element);
    for (var i = 0; i < elements.length; i++)
      this.registerCallback(elements[i]);
  },

  registerCallback: function(element) {
    if (element.type) {
      switch (element.type.toLowerCase()) {
        case 'checkbox':
        case 'radio':
          Event.observe(element, 'click', this.onElementEvent.bind(this));
          break;
        case 'password':
        case 'text':
        case 'textarea':
        case 'select-one':
        case 'select-multiple':
          Event.observe(element, 'change', this.onElementEvent.bind(this));
          break;
      }
    }
  }
}

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

Form.EventObserver = Class.create();
Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
  getValue: function() {
    return Form.serialize(this.element);
  }
});
if (!window.Event) {
  var Event = new Object();
}

Object.extend(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,

  element: function(event) {
    return event.target || event.srcElement;
  },

  isLeftClick: function(event) {
    return (((event.which) && (event.which == 1)) ||
            ((event.button) && (event.button == 1)));
  },

  pointerX: function(event) {
    return event.pageX || (event.clientX +
      (document.documentElement.scrollLeft || document.body.scrollLeft));
  },

  pointerY: function(event) {
    return event.pageY || (event.clientY +
      (document.documentElement.scrollTop || document.body.scrollTop));
  },

  stop: function(event) {
    if (event.preventDefault) {
      event.preventDefault();
      event.stopPropagation();
    } else {
      event.returnValue = false;
      event.cancelBubble = true;
    }
  },

  // find the first node with the given tagName, starting from the
  // node the event was triggered on; traverses the DOM upwards
  findElement: function(event, tagName) {
    var element = Event.element(event);
    while (element.parentNode && (!element.tagName ||
        (element.tagName.toUpperCase() != tagName.toUpperCase())))
      element = element.parentNode;
    return element;
  },

  observers: false,

  _observeAndCache: function(element, name, observer, useCapture) {
    if (!this.observers) this.observers = [];
    if (element.addEventListener) {
      this.observers.push([element, name, observer, useCapture]);
      element.addEventListener(name, observer, useCapture);
    } else if (element.attachEvent) {
      this.observers.push([element, name, observer, useCapture]);
      element.attachEvent('on' + name, observer);
    }
  },

  unloadCache: function() {
    if (!Event.observers) return;
    for (var i = 0; i < Event.observers.length; i++) {
      Event.stopObserving.apply(this, Event.observers[i]);
      Event.observers[i][0] = null;
    }
    Event.observers = false;
  },

  observe: function(element, name, observer, useCapture) {
    var element = $(element);
    useCapture = useCapture || false;

    if (name == 'keypress' &&
        (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
        || element.attachEvent))
      name = 'keydown';

    this._observeAndCache(element, name, observer, useCapture);
  },

  stopObserving: function(element, name, observer, useCapture) {
    var element = $(element);
    useCapture = useCapture || false;

    if (name == 'keypress' &&
        (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
        || element.detachEvent))
      name = 'keydown';

    if (element.removeEventListener) {
      element.removeEventListener(name, observer, useCapture);
    } else if (element.detachEvent) {
      element.detachEvent('on' + name, observer);
    }
  }
});

/* prevent memory leaks in IE */
Event.observe(window, 'unload', Event.unloadCache, false);
var Position = {
  // set to true if needed, warning: firefox performance problems
  // NOT neeeded for page scrolling, only if draggable contained in
  // scrollable elements
  includeScrollOffsets: false,

  // must be called before calling withinIncludingScrolloffset, every time the
  // page is scrolled
  prepare: function() {
    this.deltaX =  window.pageXOffset
                || document.documentElement.scrollLeft
                || document.body.scrollLeft
                || 0;
    this.deltaY =  window.pageYOffset
                || document.documentElement.scrollTop
                || document.body.scrollTop
                || 0;
  },

  realOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.scrollTop  || 0;
      valueL += element.scrollLeft || 0;
      element = element.parentNode;
    } while (element);
    return [valueL, valueT];
  },

  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) {
        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;
  },

  clone: function(source, target) {
    source = $(source);
    target = $(target);
    target.style.position = 'absolute';
    var offsets = this.cumulativeOffset(source);
    target.style.top    = offsets[1] + 'px';
    target.style.left   = offsets[0] + 'px';
    target.style.width  = source.offsetWidth + 'px';
    target.style.height = source.offsetHeight + 'px';
  },

  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 {
      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 (/Konqueror|Safari|KHTML/.test(navigator.userAgent)) {
  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];
  }
}



// Ver: 4.1
var nOP=0,nOP5=0,nIE=0,nIE4=0,nIE5=0,nNN=0,nNN4=0,nNN6=0,nMAC=0,nIEM=0,nIEW=0,nDM=0,nVER=0.0,st_delb=0,st_addb=0,st_reg=1;stnav();var st_ttb=nIE||nOP&&(nVER>=6&&nVER<7);
var stT2P=["static","absolute","absolute"],stHAL=["left","center","right"],stVAL=["top","middle","bottom"],stREP=["no-repeat","repeat-x","repeat-y","repeat"],stBDS=["none","solid","double","dotted","dashed","groove","ridge"];
var st_max=10,st_ht="",st_gc=0,st_rl=null,st_cl,st_ct,st_cw,st_ch,st_cm=0,st_cp,st_ci,st_ri=/Stm([0-9]*)p([0-9]*)i([0-9]*)e/,st_rp=/Stm([0-9]*)p([0-9]*)i/,st_ims=[],st_ms=[],st_load=0,st_scr=null;
var st_rsp=new RegExp(" +");
if(nNN4){stitovn=stevfn('stitov',1);stitoun=stevfn('stitou',1);stitckn=stevfn('stitck',1);stppovn=stevfn('stppov',0);stppoun=stevfn('stppou',0);}
if(nIE4||nNN4)window.onerror=function(m,u,l){return !confirm("Java Script Error\n"+"\nDescription:"+m+"\nSource:"+u+"\nLine:"+l+"\n\nSee more details?");}
if(nDM)window.onload=st_onload;
if(nIEM||nOP5)window.onunload=function(){if(st_rl){clearInterval(st_rl);st_rl=null;}return true;}
if(typeof(st_js)=='undefined'){
if(nDM&&!nNN4)
{
	var s="<STYLE>\n.st_tbcss,.st_tdcss,.st_divcss,.st_ftcss{border:none;padding:0px;margin:0px;}\n</STYLE>";
	for(var i=0;i<st_max;i++)
		s+="<FONT ID=st_gl"+i+"></FONT>";
	if(nIEW&&nVER>=5.0&&document.body)
		document.body.insertAdjacentHTML("AfterBegin",s);
	else
		document.write(s);
}st_js=1;}
function stm_bm(a)
{
	st_ms[st_cm]=
	{
		ps:[],
		mei:st_cm,
		ids:"Stm"+st_cm+"p",
		hdid:null,
		cked:0,
		tfrm:window,
		sfrm:window,
		mcff:"",
		mcfd:0,
		mcfx:0,
		mcfy:0,
		mnam:a[0],
		mver:a[1],
		mweb:a[2],
		mbnk:stbuf(a[2]+a[3]),
		mtyp:a[4],
		mcox:a[5],
		mcoy:a[6],
		maln:stHAL[a[7]],
		mcks:a[8],
		msdv:a[9],
		msdh:a[10],
		mhdd:nNN4?Math.max(100,a[11]):a[11],
		mhds:a[12],
		mhdo:a[13],
		mhdi:a[14],
		args:a.slice(0)
	};
}
function stm_bp(l,a)
{
	var op=st_cp;var oi=st_ci;st_cp=st_ms[st_cm].ps.length;st_ci=0;
	var m=st_ms[st_cm];
	m.ps[st_cp]=
	{
	is:[],
	mei:st_cm,
	ppi:st_cp,
	ids:"Stm"+st_cm+"p"+st_cp+"i",
	par:(st_cp?[st_cm,op,oi]:null),
	tmid:null,
	citi:-1,
	issh:0,
	isst:!st_cp&&m.mtyp==0,
	isck:!st_cp&&m.mcks,
	exed:0,
	pver:a[0],
	pdir:a[1],
	poffx:a[2],
	poffy:a[3],
	pspc:a[4],
	ppad:a[5],
	plmw:a[6],
	prmw:a[7],
	popc:a[8],
	pesh:a[9]?a[9]:"Normal",
	pesi:a[10],
	pehd:a[11]?a[11]:"Normal",
	pehi:a[12],
	pesp:a[13],
	pstp:a[14],
	psds:nIEW?a[15]:0,
	pscl:a[16],
	pbgc:a[17],
	pbgi:stbuf(stgsrc(a[18],m,0)),
	pbgr:stREP[a[19]],
	pbds:stBDS[a[20]],
	ipbw:a[21],
	pbdc:(!nDM||nNN4)?a[22].split(st_rsp)[0]:a[22],
	args:a.slice(0)
	};
	var p=m.ps[st_cp];
	if(st_cp)	stgpar(p).sub=[st_cm,st_cp];
	p.zind=!st_cp?1000:stgpar(stgpar(p)).zind+10;
	p.pbgd=stgbg(p.pbgc,p.pbgi,p.pbgr);
	if(nIEW&&nVER>=5.5)
	{
		p.efsh=p.pesh=="Normal"?"stnm":"stft";
		p.efhd=p.pehd=="Normal"?"stnm":"stft";
	}
	else if(nIEW&&(nVER>=5.0||nVER>=4.0&&!p.isst))
	{
		p.efsh=p.pesi>=0?"stft":"stnm";
		p.efhd=p.pehi>=0?"stft":"stnm";
	}
	else
		p.efsh=p.efhd="stnm";
	eval(l+"=p;");
}
function stm_bpx(l,r,a)
{
	var p=eval(r);
	stm_bp(l,a.concat(p.args.slice(a.length)));
}
function stm_ai(l,a)
{
	st_ci=st_ms[st_cm].ps[st_cp].is.length;
	var m=st_ms[st_cm];
	var p=m.ps[st_cp];
	if(a[0]==6)
		p.is[st_ci]=
		{
		ssiz:a[1],
		ibgc:[a[2]],
		simg:stbuf(stgsrc(a[3],m,1)),
		simw:a[4],
		simh:a[5],
		simb:a[6],
		args:a.slice(0)
		};
	else
		p.is[st_ci]=
		{
		itex:a[0]?a[1]:a[1].replace(new RegExp(" ","g"),nMAC?"&#160;":"&nbsp;"),
		iimg:[stbuf(stgsrc(a[2],m,0)),stbuf(stgsrc(a[3],m,0))],
		iimw:a[4],
		iimh:a[5],
		iimb:a[6],
		iurl:a[7],
		itgt:a[8],
		istt:a[9],
		itip:a[10],
		iicn:[stbuf(stgsrc(a[11],m,1)),stbuf(stgsrc(a[12],m,1))],
		iicw:a[13],
		iich:a[14],
		iicb:a[15],
		iarr:[stbuf(stgsrc(a[16],m,1)),stbuf(stgsrc(a[17],m,1))],
		iarw:a[18],
		iarh:a[19],
		iarb:a[20],
		ihal:stHAL[a[21]],
		ival:stVAL[a[22]],
		ibgc:nOP5&&nVER<7.0&&a[24]&&a[26]?["transparent","transparent"]:[nOP5&&nVER<7.0||!a[24]?a[23]:"transparent",nOP5&&nVER<7.0||!a[26]?a[25]:"transparent"],
		ibgi:[stbuf(stgsrc(a[27],m,0)),stbuf(stgsrc(a[28],m,0))],
		ibgr:[stREP[a[29]],stREP[a[30]]],
		ibds:stBDS[a[31]],
		ipbw:a[32],
		ibdc:(!nDM||nNN4)?[a[33].split(st_rsp)[0],a[34].split(st_rsp)[0]]:[a[33],a[34]],
		itxc:[a[35],a[36]],
		itxf:[a[37],a[38]],
		itxd:[stgdec(a[39]),stgdec(a[40])],
		args:a.slice(0)
		};
	var it=st_ms[st_cm].ps[st_cp].is[st_ci];
	it.ityp=a[0];
	it.mei=st_cm;
	it.ppi=st_cp;
	it.iti=st_ci;
	it.ids=p.ids+st_ci+"e";
	it.sub=null;
	it.tmid=null;
	if(it.ityp!=6)
		it.ibgd=[stgbg(it.ibgc[0],it.ibgi[0],it.ibgr[0]),stgbg(it.ibgc[1],it.ibgi[1],it.ibgr[1])];
	eval(l+"=it;");
}
function stm_aix(l,r,a)
{
	var i=eval(r);
	stm_ai(l,a.concat(i.args.slice(a.length)));
}
function stm_ep()
{
	var m=st_ms[st_cm];
	var p=m.ps[st_cp];
	var i=stgpar(p);
	if(i)
	{
		st_cm=i.mei;
		st_cp=i.ppi;
		st_ci=i.iti;
	}
	if(p.is.length==0)
	{
		m.ps.length--;
		if(i)
			i.sub=null;
	}
}
function stm_em()
{
	var m=st_ms[st_cm];
	if(m.ps.length==0)
	{
		st_ms.length--;
		return;
	}
	var mh="";
	var mc="<STYLE TYPE='text/css'>\n";
	var l=nDM?m.ps.length:1;
	for(var ppi=0;ppi<l;ppi++)
	{
		var p=m.ps[ppi];
		var ph=stpbtx(p);
		if(p.isst&&m.maln!="left")
			ph="<TABLE STYLE='border:none;padding:0px;' CELLPADDING=0 CELLSPACING=0 ALIGN="+m.maln+"><TD class=st_tdcss>"+ph;
		for(var iti=0;iti<p.is.length;iti++)
		{
			var i=p.is[iti];
			var ih="";
			ih+=p.pver ? "<TR ID="+i.ids+"TR>" : "";
			ih+=stittx(i);
			ih+=(p.pver ? "</TR>" : "");
			ph+=ih;
			if(i.ityp!=6)
			{
				mc+="."+i.ids+"TX0{"+sttcss(i,0)+"}\n";
				mc+="."+i.ids+"TX1{"+sttcss(i,1)+"}\n";
			}
		}
		ph+=stpetx(p);
		if(p.isst&&m.maln!="left")
			ph+="</TD></TABLE>";
		if(p.isst||nNN4||!nDM)
			mh+=ph;
		else
			st_ht+=ph;
	}
	mc+="</STYLE>";
	if(!nDM||nNN4)
		document.write(mc);
	if(mh)
		document.write(mh);
	if(nDM&&!(nIEM||(nIEW&&nVER<5.0)))
	{
		if(st_ht)
		{
			var o=stgobj('st_gl'+st_gc,'font');
			if(nNN6)
				o.innerHTML=st_ht;
			else if(nIE&&nVER>=5.0)
				o.insertAdjacentHTML("BeforeEnd",st_ht);
			else
				o.document.write(st_ht);
			st_gc++;
			st_ht='';
		}
		if(!nOP&&!nNN)
			stpre(m);
	}
	st_cm++;st_cp=0;st_ci=0;
}
function stpbtx(p)
{
	var s="";
	if(nNN4||!nDM)
	{
		s+=p.isst?"<ILAYER":"<LAYER";
		s+=" VISIBILITY=hide";
		s+=" ID="+p.ids;
		s+=" Z-INDEX="+p.zind;
		s+="><LAYER>";
		s+="<TABLE BORDER=0 CELLSPACING=0 CELLPADDING="+p.pspc;
		s+=" BACKGROUND='"+p.pbgi+"'";
		s+=" BGCOLOR="+(p.pbgi||p.pbgc=="transparent"?"''":p.pbgc);
		s+=">";
	}
	else
	{
		var ds="position:"+stT2P[p.ppi?1:stgme(p).mtyp]+";";
		ds+="z-index:"+p.zind+";";
		ds+="visibility:hidden;";
		s+=st_ttb ? "<TABLE class=st_tbcss CELLPADDING=0 CELLSPACING=0" : "<DIV class=st_divcss";
		s+=stppev(p);
		s+=" ID="+p.ids;
		s+=" STYLE='";
		if(nIEM)
			s+="width:1px;";
		else if(nIE)
			s+="width:0px;";
		s+=stfcss(p);
		s+=ds;
		s+="'>";
		if(st_ttb)
			s+="<TD class=st_tdcss ID="+p.ids+"TTD>";
		s+="<TABLE class=st_tbcss CELLSPACING=0 CELLPADDING=0";
		s+=" ID="+p.ids+"TB";
		s+=" STYLE='";
		s+=stpcss(p);
		if(nIEW)
			s+="margin:"+p.psds+"px;";
		s+="'>";
	}
	return s;
}
function stpetx(p)
{
	var s="</TABLE>";
	if(nNN4||!nDM)
		s+="</LAYER></LAYER>";
	else if(st_ttb)
		s+="</TD></TABLE>";
	else
		s+="</DIV>";
	return s;
}
function stittx(i)
{
	var s="";
	var p=stgpar(i);
	if(nNN4||!nDM)
	{
		s+="<TD WIDTH=1 NOWRAP>";
		s+="<FONT STYLE='font-size:1pt;'>";
		s+="<ILAYER ID="+i.ids+"><LAYER";
		if(i.ipbw&&i.ityp!=6)
			s+=" BGCOLOR="+i.ibdc[0];
		s+=">";
		for(var l=0;l<(nNN4?2:1);l++)
		{
			if(i.ityp==6&&l)
				break;
			s+="<LAYER Z-INDEX=10 VISIBILITY="+(l?"HIDE":"SHOW");
			if(i.ityp!=6)
			{
				s+=" LEFT="+i.ipbw+" TOP="+i.ipbw;
			}
			s+=">";
			s+="<TABLE ALIGN=LEFT WIDTH=100% BORDER=0 CELLSPACING=0 CELLPADDING="+(i.ityp==6 ? 0 : p.ppad);
			s+=" BACKGROUND='"+(i.ityp!=6?i.ibgi[l]:"")+"'";
			s+=" BGCOLOR="+(i.ityp!=6&&i.ibgi[l]||i.ibgc[l]=="transparent"?"''":i.ibgc[l])
			s+=">";
			if(i.ityp==6)
			{
				s+="<TD NOWRAP VALIGN=TOP"+
					" HEIGHT="+(p.pver ? i.ssiz : "100%")+
					" WIDTH="+(p.pver ? "100%" : i.ssiz)+
					" STYLE='font-size:0pt;'"+
					">";
				s+=stgimg(i.simg,i.ids+"LINE",i.simw,i.simh,0);
				s+="</TD>";
			}
			else
			{
				if(p.pver&&p.plmw||!p.pver&&i.iicw)
				{
					s+="<TD ALIGN=CENTER VALIGN=MIDDLE";
					s+=stgiws(i);
					s+=">";
					s+=stgimg(i.iicn[l],"",i.iicw,i.iich,i.iicb);
					s+="</TD>";
				}
				s+="<TD WIDTH=100% NOWRAP ALIGN="+i.ihal+" VALIGN="+i.ival+">";
				s+="<A "+stgurl(i)+" CLASS='"+(i.ids+"TX"+l)+"'>";
				if(i.ityp==2)
					s+=stgimg(i.iimg[l],i.ids+"IMG",i.iimw,i.iimh,i.iimb);
				else
				{
					s+="<IMG SRC=\""+stgme(i).mbnk+"\" WIDTH=1 HEIGHT=1 BORDER=0 ALIGN=ABSMIDDLE>";
					s+=i.itex;
				}
				s+="</A>";
				s+="</TD>";
				if(p.pver&&p.prmw||!p.pver&&i.iarw)
				{
					s+="<TD ALIGN=CENTER VALIGN=MIDDLE";
					s+=stgaws(i);
					s+=">";
					s+=stgimg(i.iarr[l],"",i.iarw,i.iarh,i.iarb);
					s+="</TD>";
				}
			}
			s+="</TABLE>";
			if(i.ipbw&&i.ityp!=6)
				s+="<BR CLEAR=ALL><SPACER HEIGHT=1 WIDTH="+i.ipbw+"></SPACER><SPACER WIDTH=1 HEIGHT="+i.ipbw+"></SPACER>";
			s+="</LAYER>";
		}
		if(i.ityp!=6)
			s+="<LAYER Z-INDEX=20></LAYER>";
		s+="</LAYER></ILAYER>"
		s+="</FONT>";
		s+="</TD>";
	}
	else
	{
		s+="<TD class=st_tdcss NOWRAP VALIGN="+(nIE ? "MIDDLE" : "TOP");
		s+=" STYLE='"
			s+="padding:"+p.pspc+"px;";
		s+="'";
		s+=" ID="+p.ids+i.iti;
		if(nIEW)
			s+=" HEIGHT=100%";
		s+=">";
		if(!nOP&&!nIE)
		{
			s+="<DIV class=st_divcss ID="+i.ids;
			s+=stitev(i);
			s+=" STYLE=\""+sticss(i,0);
			s+="\"";
			s+=">";
		}
		s+="<TABLE class=st_tbcss CELLSPACING=0 CELLPADDING=0";
		if(!nOP)
			s+=" HEIGHT=100%";
		s+=" STYLE=\"";
		if(nOP||nIE)
			s+=sticss(i,0);
		s+="\"";
		if(nOP||nIE)
			s+=stitev(i);
		if(p.pver||nIEM)
			s+=" WIDTH=100%";
		s+=" ID="+(nOP||nIE ? i.ids : (i.ids+"TB"));
		if(!nOP)
			s+=" TITLE="+stquo(i.ityp!=6 ? i.itip : "");
		s+=">";
		if(i.ityp==6)
		{
			s+="<TD class=st_tdcss NOWRAP VALIGN=TOP"+
				" ID="+i.ids+"MTD"+
				" HEIGHT="+(p.pver ? i.ssiz : "100%")+
				" WIDTH="+(p.pver ? "100%" : i.ssiz)+
				">";
			s+=stgimg(i.simg,i.ids+"LINE",i.simw,i.simh,0);
			s+="</TD>";
		}
		else
		{
			if(p.pver&&p.plmw||!p.pver&&i.iicw)
			{
				s+="<TD class=st_tdcss NOWRAP ALIGN=CENTER VALIGN=MIDDLE HEIGHT=100%";
				s+=" STYLE=\"padding:"+p.ppad+"px\"";
				s+=" ID="+i.ids+"LTD";
				s+=stgiws(i);
				s+=">";
				s+=stgimg(i.iicn[0],i.ids+"ICON",i.iicw,i.iich,i.iicb);
				s+="</TD>";
			}
			s+="<TD class=st_tdcss NOWRAP HEIGHT=100% STYLE=\"";
			s+="color:"+i.itxc[0]+";";
			s+="padding:"+p.ppad+"px;";
			s+="\"";
			s+=" ID="+i.ids+"MTD";
			s+=" ALIGN="+i.ihal;
			s+=" VALIGN="+i.ival+">";
			s+="<FONT class=st_ftcss ID="+i.ids+"TX STYLE=\""+sttcss(i,0)+"\">";
			if(i.ityp==2)
				s+=stgimg(i.iimg[0],i.ids+"IMG",i.iimw,i.iimh,i.iimb);
			else
				s+=i.itex;
			s+="</FONT>";
			s+="</TD>";
			if(p.pver&&p.prmw||!p.pver&&i.iarw)
			{
				s+="<TD class=st_tdcss NOWRAP ALIGN=CENTER VALIGN=MIDDLE HEIGHT=100%";
				s+=" STYLE=\"padding:"+p.ppad+"px\"";
				s+=" ID="+i.ids+"RTD";
				s+=stgaws(i);
				s+=">";
				s+=stgimg(i.iarr[0],i.ids+"ARROW",i.iarw,i.iarh,i.iarb);
				s+="</TD>";
			}
		}
		s+="</TABLE>";
		if(!nOP&&!nIE)
			s+="</DIV>";
		s+="</TD>";
	}
	return s;
}
function stpcss(p)
{
	var s="";
	s+="border-style:"+p.pbds+";";
	s+="border-width:"+p.ipbw+"px;";
	s+="border-color:"+p.pbdc+";";
	if(nIE)
		s+="background:"+p.pbgd+";";
	else
	{
		s+="background-color:"+(p.pbgc)+";";
		if(p.pbgi)
		{
			s+="background-image:url("+p.pbgi+");";
			s+="background-repeat:"+p.pbgr+";";
		}
	}
	return s;
}
function stfcss(p)
{
	var s="";
	if(nIEW&&(nVER>=5.0||!p.isst))
	{
		var dx=nVER>=5.5?"progid:DXImageTransform.Microsoft." : "";
		s+="filter:";
		if(nVER>=5.5)
		{
			if(p.pesh!="Normal")
				s+=p.pesh+" ";
		}
		else
		{
			if(p.pesi<24&&p.pesi>=0)
				s+="revealTrans(Transition="+p.pesi+",Duration="+((110-p.pesp)/100)+") ";
		}
		s+=dx+"Alpha(opacity="+p.popc+") ";
		if(p.psds)
		{
			if(p.pstp==1)
				s+=dx+"dropshadow(color="+p.pscl+",offx="+p.psds+",offy="+p.psds+",positive=1) ";
			else
				s+=dx+"Shadow(color="+p.pscl+",direction=135,strength="+p.psds+") ";
		}
		if(nVER>=5.5)
		{
			if(p.pehd!="Normal")
				s+=p.pehd+" ";
		}
		else
		{
			if(p.pehi<24&&p.pehi>=0)
				s+="revealTrans(Transition="+p.pehi+",Duration="+((110-p.pesp)/100)+") ";
		}
		s+=";";
	}
	return s;
}
function sticss(i,n)
{
	var s="";
	if(i.ityp!=6)
	{
		s+="border-style:"+i.ibds+";";
		s+="border-width:"+i.ipbw+"px;";
		s+="border-color:"+i.ibdc[n]+";";
		if(!nIEM&&i.ibgi[n])
		{
			s+="background-image:url("+i.ibgi[n]+");";
			s+="background-repeat:"+i.ibgr[n]+";";
		}
	}
	if(nIEM&&i.ityp!=6)
		s+="background:"+i.ibgd[n]+";";
	else
		s+="background-color:"+i.ibgc[n]+";";
	s+="cursor:"+stgcur(i)+";";
	return s;
}
function sttcss(i,n)
{
	var s="";
	s+="cursor:"+stgcur(i)+";";
	s+="font:"+i.itxf[n]+";";
	s+="text-decoration:"+i.itxd[n]+";";
	if(!nDM||nNN4)
		s+="background-color:transparent;color:"+i.itxc[n];
	return s;
}
function stitov(e,o,i)
{
	if(nIEW)
	{
		if(!i.layer)
			i.layer=o;
		if(!stgpar(i).issh||(e.fromElement&&o.contains(e.fromElement)))
			return;
	}
	else
	{
		if(!stgpar(i).issh||(!nNN&&(e.fromElement&&e.fromElement.id&&e.fromElement.id.indexOf(i.ids)>=0)))
			return;
	}
	if(nNN4)
		stglay(i).document.layers[0].captureEvents(Event.CLICK);
	var m=stgme(i);
	if(!i.ppi&&m.mcff)
		stfrm(m);
	var w=m.sfrm;
	if(w!=window)
		m=w.stmenu(m.mnam);
	if(m.hdid)
	{
		w.clearTimeout(m.hdid);
		m.hdid=null;
	}
	var cii=stgpar(i).citi;
	var ci=null;
	if(cii>=0)
		ci=stgpar(i).is[cii];
	var p=stgpar(i);
	if(!p.isck||stgme(i).cked)
	{
		if(p.citi!=i.iti)
		{
			if(p.citi>=0)
			{
				sthdit(p.is[p.citi]);
				p.citi=-1;
			}
			stshit(i);
			p.citi=i.iti;
		}
		else
		{
			var p=stgtsub(i);
			if(p&&!p.issh)
				stshit(i);
		}
	}
	if(i.istt)
		window.status=i.istt;
}
function stitou(e,o,i)
{
	if(nIEW)
	{
		if(!stgpar(i).issh||e.toElement&&o.contains(e.toElement))
			return;
	}
	else
	{
		if(!stgpar(i).issh||(!nNN&&(e.toElement&&e.toElement.id&&e.toElement.id.indexOf(i.ids)>=0)))
			return;
	}
	if(nNN4)
		stglay(i).document.layers[0].releaseEvents(Event.CLICK);
	var p=stgtsub(i);
	if(!p||!p.issh)
	{
		stshst(i,0);
		stgpar(i).citi=-1;
	}
	else if(p&&p.issh&&!p.exed)
		sthdit(i);
	window.status="";
}
function stitck(e,o,i)
{
	if(e.button&&e.button>=2)
		return;
	var m=stgme(i);
	var p=stgpar(i);
	if(p.isck)
	{
		m.cked=!m.cked;
		if(m.cked)
		{
			stshit(i);
			p.citi=i.iti;
		}
		else
		{
			sthdit(i);
			p.citi=-1;
		}
	}
	if(!nNN4&&!(p.isck&&stgsub(i))&&i.iurl)
	{
		if(i.iurl.toLowerCase().indexOf("javascript:")==0)
			eval(i.iurl.substring(11,i.iurl.length));
		else if(i.itgt=="_self")
			window.location.href=i.iurl;
		else if(i.itgt=="_parent")
			window.parent.location.href=i.iurl;
		else if(i.itgt=="_top")
			window.top.location.href=i.iurl;
		else
		{
			for(var co=window;co!=co.parent;co=co.parent)
			{
				if(typeof(co.parent.frames[i.itgt])!="undefined")
				{
					co.parent.frames[i.itgt].location.href=i.iurl;
					return;
				}
			}
			window.open(i.iurl,i.itgt);
		}
	}
}
function stppov(e,o,p)
{
	if(nIEW)
	{
		if(!p.layer)
			p.layer=o;
		if(!p.issh||(e.fromElement&&o.contains(e.fromElement)))
			return;
	}
	else
	{
		if(!p.issh||(!nNN&&(e.fromElement&&e.fromElement.id&&e.fromElement.id.indexOf(p.ids)>=0)))
			return;
	}
	var m=stgme(p);
	var w=m.sfrm;
	if(w!=window)
		m=w.stmenu(m.mnam);
	if(m.hdid)
	{
		w.clearTimeout(m.hdid);
		m.hdid=null;
	}
}
function stppou(e,o,p)
{
	if(nIEW)
	{
		if(!p.issh||(e.toElement&&o.contains(e.toElement)))
			return;
	}
	else
	{
		if(!p.issh||(!nNN&&(e.toElement&&e.toElement.id&&e.toElement.id.indexOf(p.ids)>=0)))
			return;
	}
	var m=stgme(p);
	var w=m.sfrm;
	if(w!=window)
		m=w.stmenu(m.mnam);
	if(m.hdid)
		w.clearTimeout(m.hdid);
	m.hdid=w.setTimeout("sthdall(st_ms['"+m.mei+"'],0);",m.mhdd);
}
function stshst(i,n)
{
	if(nNN4)
	{
		var ls=stgstlay(i);
		ls[n].parentLayer.bgColor=i.ibdc[n];
		ls[n].visibility="show";
		ls[1-n].visibility="hide";
	}
	else
	{
		var os=stglay(i).style;
		if(nIEM)
		{
			if(i.ibgd[0]!=i.ibgd[1])	os.background=i.ibgd[n];
		}
		else
		{
			if(i.ibgc[0]!=i.ibgc[1])
			{
				if(nOP&&nVER<6)
					os.background=i.ibgc[n];
				else
					os.backgroundColor=i.ibgc[n];
			}
			if(i.ibgi[0]!=i.ibgi[1])	os.backgroundImage="url("+(i.ibgi[n]?i.ibgi[n]:stgme(i).mbnk)+")";
			if(i.ibgr[0]!=i.ibgr[1])	os.backgroundRepeat=i.ibgr[n];
		}
		if(i.ibdc[0]!=i.ibdc[1])	os.borderColor=i.ibdc[n];
		var t;
		if(i.iicn[0]!=i.iicn[1])
		{
			t=stgobj(i.ids+'ICON','IMG');
			if(t)	t.src=i.iicn[n];
		}
		if(i.iarr[0]!=i.iarr[1])
		{
			t=stgobj(i.ids+'ARROW','IMG');
			if(t)	t.src=i.iarr[n];
		}
		if(i.ityp==2&&i.iimg[0]!=i.iimg[1])
		{
			t=stgobj(i.ids+'IMG','IMG');
			if(t)	t.src=i.iimg[n];
		}
		if (!i.txstyle)	i.txstyle=stgobj(i.ids+"TX",'FONT').style;
		t=i.txstyle;
		if(i.itxf[0]!=i.itxf[1])
			t.font=i.itxf[n];
		if(i.itxd[0]!=i.itxd[1])
			t.textDecoration=i.itxd[n];
		if(nOP)	stgobj(i.ids+'MTD','td').style.color=i.itxc[n];
		else	t.color=i.itxc[n];
	}
}
function stshpp(p)
{
	stshow(p);
}
function sthdpp(p)
{
	if(p.citi>=0)
	{
		var t=stgsub(p.is[p.citi]);
		if(t&&t.issh)
			sthdpp(t);
		stshst(p.is[p.citi],0);
		p.citi=-1;
	}
	sthide(p);
}
function stshit(i)
{
	var w=stgme(i).tfrm;
	var p=stgtsub(i);
	if(p&&!p.issh)
		w.stshpp(p);
	stshst(i,1);
}
function sthdit(i)
{
	var w=stgme(i).tfrm;
	var p=stgtsub(i);
	if(p&&p.issh)
		w.sthdpp(p);
	stshst(i,0);
}
function stshow(p)
{
	var d=p.ppi&&stgpar(stgpar(p)).pver ? stgme(p).msdv : stgme(p).msdh;
	p.exed=0;
	if(!p.rc)
		stgxy(p);
	if(p.tmid)
	{
		clearTimeout(p.tmid);
		p.tmid=null;
		stwels(1,p)
	}
	if(d>0)
		p.tmid=setTimeout(stsdstr(p,1),d);
	p.issh=1;
	if(d<=0)
		eval(stsdstr(p,1));
}
function sthide(p)
{
	if(p.tmid)
	{
		clearTimeout(p.tmid);
		p.tmid=null;
	}
	if(p.issh&&!p.exed)
	{
		p.exed=0;
		p.issh=0;
	}
	else
	{
		p.exed=0;
		p.issh=0;
		eval(stsdstr(p,0));
	}
}
function stshx(p)
{
	var ly=stglay(p);
	if(nNN4)
	{
		ly.visibility='show';
		if(!p.fixed)
		{
			ly.resizeBy(p.ipbw*2,p.ipbw*2);
			ly=ly.document.layers[0];
			ly.moveTo(p.ipbw,p.ipbw);
			ly.onmouseover=stppovn;
			ly.onmouseout=stppoun;
			for(var l=p.is.length-1;l>=0;l--)
			{
				var i=p.is[l];
				if(i.ityp!=6)
				{
					var ls=stgstlay(i);
					ls[2].resizeTo(ls[0].parentLayer.clip.width,ls[0].parentLayer.clip.height);
					if(stgcur(i)=="hand")
					{
						with(ls[2].document)
						{
							open();
							write("<A "+stgurl(i)+"\"><IMG BORDER=0 SRC='"+stgme(i).mbnk+"' WIDTH="+ls[2].clip.width+" HEIGHT="+ls[2].clip.height+"></A>");
							close();
						}
					}
					ls[0].resizeBy(-i.ipbw,-i.ipbw);
					ls[1].resizeBy(-i.ipbw,-i.ipbw);
					ly=stglay(i).document.layers[0];
					ly.onmouseover=stitovn;
					ly.onmouseout=stitoun;
					ly.onclick=stitckn;
				}
			}
			if(p.ipbw)
				setTimeout("var pp=st_ms["+p.mei+"].ps["+p.ppi+"];stglay(pp).bgColor=pp.pbdc;",1);
			p.fixed=1;
		}
	}
	else
	{
		ly.style.visibility='visible';
		if(nIE5)
			ly.filters['Alpha'].opacity=p.popc;
	}
}
function sthdx(p)
{
	var ly=stglay(p);
	if(nNN4)
		ly.visibility='hide';
	else
	{
		if(nIE5)
			ly.filters['Alpha'].opacity=0;
		ly.style.visibility='hidden';
	}
}
function sthdall(m,f)
{
	var w=m.sfrm;
	var s=w==window?m:w.stmenu(m.mnam);
	s.cked=0;
	var p=s.ps[0];
	if(p.issh)
	{
		if(p.citi>=0)
		{
			w.sthdit(p.is[p.citi]);
			p.citi=-1;
		}
		if(s.mtyp==2&&f)
			w.sthide(p);
	}
	s.hdid=null;
}
function stnmsh(p)
{
	stmvto(stgxy(p),p);
	stwels(-1,p);
	stshx(p);
}
function stnmhd(p)
{
	sthdx(p);
	stwels(1,p);
}
function stftsh(p)
{
	if(nVER<5.5)
		stshfx(p);
	else if(st_reg)
		eval("try{stshfx(p);} catch(er){st_reg=0;stnmsh(p);}");
	else
		stnmsh(p);
}
function stfthd(p)
{
	if(nVER<5.5)
		sthdfx(p);
	else if(st_reg)
		eval("try{sthdfx(p);}catch(er){st_reg=0;stnmhd(p);}");
	else
		stnmhd(p);
}
function stshfx(p)
{
	var t=stglay(p).filters[0];
	if(nVER>=5.5)
		t.enabled=1;
	if(t.Status!=0)
		t.stop();
	stmvto(stgxy(p),p);
	stwels(-1,p);
	t.apply();
	stshx(p);
	t.play();
}
function sthdfx(p)
{
	var t=stglay(p).filters[stglay(p).filters.length-1];
	if(nVER>=5.5)
		t.enabled=1;
	if(t.Status!=0)
		t.stop();
	t.apply();
	sthdx(p);
	stwels(1,p);
	t.play();
}
function ststxy(m,xy)
{
	m.mcox=xy[0];
	m.mcoy=xy[1];
}
function stnav()
{
	var v=navigator.appVersion;
	var a=navigator.userAgent;
	nMAC=v.indexOf("Mac")>=0;
	nOP=a.indexOf("Opera")>=0;
	if(nOP)
	{
		nVER=parseFloat(a.substring(a.indexOf("Opera ")+6,a.length));
		nOP5=nVER>=5.12&&!nMAC&&a.indexOf("MSIE 5.0")>=0;
		if(nVER>=7)	nOP5=1;
	}
	else
	{
		nIE=document.all ? 1 : 0;
		if(nIE)
		{
			nIE4=(eval(v.substring(0,1)>=4));
			nVER=parseFloat(a.substring(a.indexOf("MSIE ")+5,a.length));
			nIE5=nVER>=5.0&&nVER<5.5&&!nMAC;
			nIEM=nIE4&&nMAC;
			nIEW=nIE4&&!nMAC;
		}
		else
		{
			nNN4=navigator.appName.toLowerCase()=="netscape"&&v.substring(0,1)=="4" ? 1 : 0;
			if(!nNN4)
			{
				nNN6=(document.getElementsByTagName("*") && a.indexOf("Gecko")!=-1);
				if(nNN6)
				{
					nVER=parseInt(navigator.productSub);
					if(a.indexOf("Netscape")>=0)
					{
						st_delb=nVER<20001108+1;
						st_addb=nVER>20020512-1;
					}
					else
					{
						st_delb=nVER<20010628+1;
						st_addb=nVER>20011221-1;
					}
				}
			}
			else
				nVER=parseFloat(v);
			nNN=nNN4||nNN6;
		}
	}
	nDM=nOP5||nIE4||nNN;
}
function stckpg()
{
	var w=st_cw;
	var h=st_ch;
	var l=st_cl;
	var t=st_ct;
	st_cw=stgcw();
	st_ch=stgch();
	st_cl=stgcl();
	st_ct=stgct();
	if(((nOP&&nVER<7.0)||nNN4)&&(st_cw-w||st_ch-h))
		document.location.reload();
	else if(st_cl-l||st_ct-t)
		stscr();
}
function st_onload()
{
	if(nIEM||nOP5||nNN||(nIEW&&nVER<5.0))
	{
		if(st_ht)
			document.body.insertAdjacentHTML('BeforeEnd',st_ht);
		for(i=0;i<st_ms.length;i++)
			stpre(st_ms[i]);
	}
	st_load=1;
	if(!nNN4)
	{
		for(var i=0;i<st_ms.length;i++)
		{
			var m=st_ms[i];
			for(var j=0;j<m.ps.length;j++)
			{
				var p=m.ps[j];
				if(p.issh&&p.exed)
					stwels(-1,p);
			}
		}
	}
}
function stpre(m)
{
	var p=m.ps[m.ps.length-1];
	var i=p.is[p.is.length-1];
	while(1)
		if(stglay(i)) break;
	if(!nNN4)
		stfix(m);
	if(m.mtyp!=2)
		stshow(m.ps[0]);
	if(nIE||nNN6)
		window.onscroll=new Function("if(st_scr)clearTimeout(st_scr);st_scr=setTimeout('stscr();',nIEM ?500:0);");
	else if(!st_rl)
	{
		st_cw=stgcw();
		st_ch=stgch();
		st_cl=stgcl();
		st_ct=stgct();
		st_rl=setInterval("stckpg();",500);
	}
	m.ready=1;
}
function stfix(m)
{
	for(var l=0;l<m.ps.length;l++)
	{
		var p=m.ps[l];
		if(nOP&&nVER<6.0)
			stglay(p).style.pixelWidth=parseInt(stgobj(p.ids+"TB",'table').style.pixelWidth);
		if(nIE5)
			stglay(p).style.width=stglay(p).offsetWidth;
		else if(nIEM||!nIE)
		{
			if(!p.pver)
			{
				var ii=0;
				var fi=stgobj(p.ids+ii);
				var h=parseInt(nOP ? fi.style.pixelHeight : fi.offsetHeight);
				if(h)
				{
					for(ii=0;ii<p.is.length;ii++)
					{
						var i=p.is[ii];
						var lys=stglay(i).style;
						var th=h-2*p.pspc;
						if(nOP)
							lys.pixelHeight=th;
						else if(i.ityp==6||nIE)
							lys.height=th+'px';
						else
							lys.height=th-2*i.ipbw+'px';
						if(nIEM)
						{
							var fh=h-2*p.pspc;
							var lt=stgobj(i.ids+"LTD");
							var rt=stgobj(i.ids+"RTD");
							if(lt)
								lt.style.height=fh+'px';
							stgobj(i.ids+"MTD").style.height=fh+'px';
							if(rt)
								rt.style.height=fh+'px';
						}
					}
				}
			}
			else if(nOP)
			{
				for(var ii=0;ii<p.is.length;ii++)
				{
					var i=p.is[ii];
					if(i.ityp!=6)
					{
						var fi=stgobj(p.ids+ii);
						var it=stglay(i);
						var w=parseInt(fi.style.pixelWidth);
						var h=parseInt(it.style.pixelHeight);
						if(w)
							it.style.pixelWidth=w-2*p.pspc;
						if(h)
							it.style.pixelHeight=h;
					}
				}
			}
		}
	}
}
function stscr()
{
	for(var l=0;l<st_ms.length;l++)
	{
		var m=st_ms[l];
		if(m)
		{
			sthdall(m,0);
			if(m.mtyp==1)
			{
				var p=m.ps[0];
				stwels(1,p);
				stmvto(stgxy(m.ps[0]),p);
				stwels(-1,p);
			}
		}
	}
}
function stwels(c,p)
{
	var m=stgme(p);
	if(!st_load||nNN4||nOP||p.isst)	return;
	if(m.mhds&&!nNN6)	stwtag("SELECT",c,p);
	if(m.mhdo)	stwtag("OBJECT",c,p);
	if(m.mhdi&&!nNN6&&!(nIEW&&nVER>=5.5))	stwtag("IFRAME",c,p);
}
function stwtag(tg,c,o)
{
	var es=nNN6 ? document.getElementsByTagName(tg) : document.all.tags(tg);
	var l;
	for(l=0;l<es.length;l++)
	{
		var e=es.item(l);
		var f=0;
		for(var t=e.offsetParent;t;t=t.offsetParent)
			if(t.id&&t.id.indexOf("Stm")>=0)
				f=1;
		if(f)
			continue;
		else if(stwover(e,o))
		{
			if(e.visLevel)
				e.visLevel+=c;
			else
				e.visLevel=c;
			if(e.visLevel==-1)
			{
				if(typeof(e.visSave)=='undefined')
					e.visSave=e.style.visibility;
				e.style.visibility="hidden";
			}
			else if(e.visLevel==0)
				e.style.visibility=e.visSave;
		}
	}
}
function stmvto(xy,p)
{
	if(xy&&(p.ppi||stgme(p).mtyp!=0))
	{
		var l=stglay(p);
		if(nNN4)
			l.moveToAbsolute(xy[0],xy[1]);
		else if(nOP)
		{
			var ls=l.style;
			ls.pixelLeft=xy[0];
			ls.pixelTop=xy[1];
		}
		else
		{
			var ls=l.style;
			ls.left=xy[0]+'px';
			ls.top=xy[1]+'px';
		}
		p.rc=[xy[0],xy[1],p.rc[2],p.rc[3]];
	}
}
function stsdstr(p,iss)
{
	return	"var pp=st_ms["+p.mei+"].ps["+p.ppi+"];pp.tmid=null;"+(iss? p.efsh+"sh(" : p.efhd+"hd(")+"pp);pp.exed=1;"
}
function stwover(e,o)
{
	var l=0;
	var t=0;
	var w=e.offsetWidth;
	var h=e.offsetHeight;
	if(w)
		e._wd=w;
	else
		w=e._wd;
	if(h)
		e._ht=h;
	else
		h=e._ht;
	while(e)
	{
		l+=e.offsetLeft;
		t+=e.offsetTop;
		e=e.offsetParent;
	}
	return ((l<o.rc[2]+o.rc[0]) && (l+w>o.rc[0]) && (t<o.rc[3]+o.rc[1]) && (t+h>o.rc[1]));
}
function stevfn(pr,isi)
{
	var s=isi ? 'st_ri' : 'st_rp';
	s+='.exec(this.parentLayer.id);mei=RegExp.$1;ppi=parseInt(RegExp.$2);';
	if(isi)	s+='iti=parseInt(RegExp.$3);return '+pr+'(e,this,st_ms[mei].ps[ppi].is[iti]);';
	else	s+='return '+pr+'(e,this,st_ms[mei].ps[ppi]);';
	return new Function('e',s);
}
function stppev(p)
{
	var s=" onMouseOver='stppov(event,this,st_ms["+p.mei+"].ps["+p.ppi+"]);'";
	s+=" onMouseOut='stppou(event,this,st_ms["+p.mei+"].ps["+p.ppi+"]);'";
	return s;
}
function stitev(i)
{
	if(i.ityp==6)	return '';
	var s=" onMouseOver='stitov(event,this,st_ms["+i.mei+"].ps["+i.ppi+"].is["+i.iti+"]);'";
	s+=" onMouseOut='stitou(event,this,st_ms["+i.mei+"].ps["+i.ppi+"].is["+i.iti+"]);'";
	s+=" onClick='stitck(event,this,st_ms["+i.mei+"].ps["+i.ppi+"].is["+i.iti+"]);'";
	return s;
}
function stquo(n)
{
	return "\""+n+"\"";
}
function stgurl(i)
{
	return " HREF=" + stquo(i.iurl=="" ? "#" : i.iurl.replace(new RegExp("\"","g"),"&quot;")) + " TARGET=" + stquo(i.iurl==""||i.iurl.toLowerCase().indexOf('javascript:')==0 ? "_self" : i.itgt);
}
function stgdec(v)
{
	if(v)
	{
		var s='';
		if(v&1)
			s+='underline ';
		if(v&2)
			s+='line-through ';
		if(v&4)
			s+='overline';
		return s;
	}
	else
		return 'none';
}
function stgimg(src,id,w,h,b)
{
	var s='<IMG SRC=';
	s+=stquo(src);
	if(id)
		s+=' ID='+id;
	if(w>0)
		s+=' WIDTH='+w;
	else if(nNN)
		s+=' WIDTH=0';
	if(h>0)
		s+=' HEIGHT='+h;
	else if(nNN)
		s+=' HEIGHT=0';
	s+=' BORDER='+b+'>';
	return s;
}
function stgbg(c,im,r)
{
	var s=c;
	if(im)
		s+=" url("+im+") "+r;
	return s;
}
function stgcur(i)
{
	if(nNN6)
		return "default";
	return i.ityp!=6&&((i.ppi==0&&stgme(i).mcks&&stgsub(i))||i.iurl) ? "hand" : "default";
}
function stgiws(o)
{
	if(stgpar(o).pver)
		return stgpar(o).plmw>0 ? " WIDTH="+(stgpar(o).plmw+2) : "";
	else
		return o.iicw>0 ? " WIDTH="+(o.iicw+2) : "";
}
function stgaws(o)
{
	if(stgpar(o).pver)
		return stgpar(o).prmw>0 ? " WIDTH="+(stgpar(o).prmw+2) : "";
	else
		return o.iarw>0 ? " WIDTH="+(o.iarw+2) : "";
}
function stgme(ip)
{
	return st_ms[ip.mei];
}
function stgpar(ip)
{
	if(typeof(ip.iti)!="undefined")
		return st_ms[ip.mei].ps[ip.ppi];
	else
		return !ip.par ? null : st_ms[ip.par[0]].ps[ip.par[1]].is[ip.par[2]];
}
function stgsub(i)
{
	return !i.sub ? null : st_ms[i.sub[0]].ps[i.sub[1]];
}
function stgcl()
{
	return parseInt(nNN||nOP ? window.pageXOffset : document.body.scrollLeft);
}
function stgct()
{
	return parseInt(nNN||nOP ? window.pageYOffset : document.body.scrollTop);
}
function stgcw()
{
	return parseInt(nNN||nOP ? window.innerWidth : (nIEW&&document.compatMode=="CSS1Compat" ? document.documentElement.clientWidth : document.body.clientWidth));
}
function stgch()
{
	return parseInt(nNN||nOP ? window.innerHeight : (nIEW&&document.compatMode=="CSS1Compat" ? document.documentElement.clientHeight : document.body.clientHeight));
}
function stgobj(id,t)
{
	if(nNN6)
		return document.getElementById(id);
	else if(nNN4)
		return document.layers[id];
	else
		return t ? document.all.tags(t)[id] : document.all[id];
}
function stglay(ip)
{
	if(!ip.layer)
	{
		if(typeof(ip.iti)=='undefined')
			ip.layer=stgobj(ip.ids,st_ttb ? 'table' : 'div');
		else
			ip.layer=nNN4 ? stglay(stgpar(ip)).document.layers[0].document.layers[ip.ids] : stgobj(ip.ids,nIEW ? 'table' : null);
	}
	return ip.layer;
}
function stgstlay(i)
{
	return stglay(i).document.layers[0].document.layers;
}
function stgrc(ip)
{
	if(nNN4)
	{
		var ly=stglay(ip);
		return [ly.pageX,ly.pageY,ly.clip.width,ly.clip.height];
	}
	else
	{
		var l=0,t=0;
		var ly=stglay(ip);
		var w=typeof(ip.rc)=="undefined"?parseInt(nOP&&nVER<7?ly.style.pixelWidth:ly.offsetWidth):ip.rc[2];
		var h=typeof(ip.rc)=="undefined"?parseInt(nOP&&nVER<7?ly.style.pixelHeight:ly.offsetHeight):ip.rc[3];
		while(ly)
		{
			l+=parseInt(ly.offsetLeft);
			t+=parseInt(ly.offsetTop);
			ly=ly.offsetParent;
		}
		if(nIEM)
		{
			l+=parseInt(document.body.leftMargin);
			l-=ip.ipbw;
			t-=ip.ipbw;
		}
		if(typeof(ip.iti)!='undefined')
		{
			if(st_delb)
			{
				l-=ip.ipbw;
				t-=ip.ipbw;
			}
			if(st_addb)
			{
				l+=stgpar(ip).ipbw;
				t+=stgpar(ip).ipbw;
			}
		}
		return [l,t,w,h];
	}
}
function stgxy(p)
{
	var x=p.poffx;
	var y=p.poffy;
	var sr=stgrc(p);
	p.rc=sr;
	if(p.ppi==0)
	{
		if(stgme(p).mtyp==2)
			return [stgme(p).mcox,stgme(p).mcoy];
		else if(stgme(p).mtyp==1)
			return [eval(stgme(p).mcox),eval(stgme(p).mcoy)];
		else
			return [sr[0],sr[1]];
	}
	var ir=stgirc(stgpar(p));
	var cl=stgcl();
	var ct=stgct();
	var cr=cl+stgcw();
	var cb=ct+stgch();
	if(p.pdir==1)
		x=p.poffx+ir[0]-sr[2]+p.psds;
	else if(p.pdir==2)
		x=p.poffx+ir[0]+ir[2]-p.psds;
	else
		x=p.poffx+ir[0]-p.psds;
	if(x+sr[2]>cr)
		x=cr-sr[2];
	if(x<cl)
		x=cl;
	if(p.pdir==3)
		y=p.poffy+ir[1]-sr[3]+p.psds;
	else if(p.pdir==4)
		y=p.poffy+ir[1]+ir[3]-p.psds;
	else
		y=p.poffy+ir[1]-p.psds;
	if(y+sr[3]>cb)
		y=cb-sr[3];
	if(y<ct)
		y=ct;
	return [x,y];
}
function stbuf(s)
{
	if(s)
	{
		var i=new Image();
		st_ims[st_ims.length]=i;
		i.src=s;
	}
	return s;
}
function stgsrc(s,m,f)
{
	if(s=='')
		return f ? m.mbnk : '';
	var sr=s.toLowerCase();
	if(sr.indexOf('http://')==0||(sr.indexOf(':')==1&&sr.charCodeAt(0)>96&&sr.charCodeAt(0)<123)||sr.indexOf('ftp://')==0||sr.indexOf('/')==0||sr.indexOf('gopher')==0)
		return s;
	else
		return m.mweb+s;
}
function showFloatMenuAt(n,x,y)
{
	if(nDM)
	{
		var m=stmenu(n);
		if(m&&typeof(m.ready)!="undefined"&&m.mtyp==2&&m.ps.length&&!m.ps[0].issh)
		{
			ststxy(m,[x,y]);
			stshow(m.ps[0]);
		}
	}
}
function hideMenu(n)
{
	var m=stmenu(n);
	var w=m.sfrm;
	if(w!=window)
		m=w.stmenu(n);
	if(m.hdid)
	{
		w.clearTimeout(m.hdid);
		m.hdid=null;
	}
	w.sthdall(m,1);
}
function stmenu(n)
{
	for(var l=st_ms.length-1;l>=0;l--)
		if(st_ms[l].mnam==n)
			return st_ms[l];
	return null;
}
function stgtsub(i)
{
	var m=stgme(i);
	var w=m.tfrm;
	if(i.ppi||w==window)
		return stgsub(i);
	m=w.stmenu(m.mnam);
	return w.stgsub(m.ps[i.ppi].is[i.iti]);
}
function stgirc(i)
{
	var m=stgme(i);
	var w=m.sfrm;
	if(i.ppi||w==window)
		return stgrc(i);
	m=w.stmenu(m.mnam);
	var rc=w.stgrc(m.ps[0].is[i.iti]);
	var x=rc[0]-w.stgcl();
	var y=rc[1]-w.stgct();
	switch(m.mcfd)
	{
		case 0:y-=w.stgch();break;
		case 1:y+=stgch();break;
		case 2:x-=w.stgcw();break;
		case 3:x+=stgcw();break;
	}
	x+=stgcl()+m.mcfx;
	y+=stgct()+m.mcfy;
	return [x,y,rc[2],rc[3]];
}
function stfrm(m)
{
	var a=m.mcff.split(".");
	var w="top";
	for(var l=0;l<a.length-1;l++)
		if(typeof(eval(w+"."+a[l]))=="undefined")
			return 0;
	w=eval("top."+m.mcff);
	if(typeof(w.st_load)!="undefined"&&w.st_load)
	{
		var t=w.stmenu(m.mnam);
		if(typeof(t)=="object")
		{
			if(w!=window)
			{
				if(t.mhdd<1000)
					m.mhdd=t.mhdd=1000;
				hideMenu(m.mnam);
				m.sfrm=t.sfrm=window;
				m.tfrm=t.tfrm=w;
			}
			m.mcff="";
			return 1;
		}
	}
	return 0;
}