// ターゲットにイベントハンドラを関連付ける
function pushEventListener(target, event, listener, useCapture)
{
  if (target)
  {
    if (target.addEventListener)
      target.addEventListener(event, listener, useCapture);
    else
      if (target.attachEvent)
        target.attachEvent("on" + event, listener);
  }
  return;
}

// ターゲットからイベントハンドラを取り除く
function pullEventListener(target, event, listener, useCapture)
{
  if (target)
  {
    if (target.removeEventListener)
      target.removeEventListener(event, listener, useCapture);
    else
      if (target.detachEvent)
        target.detachEvent("on" + event, listener);
  }
  return;
}

// 名前を識別子として有効な名前に置換する
function canonicalizeIdentifier(name)
{
  var reserved;
  reserved = ["abstract", "boolean", "break", "byte", "case", "catch",
    "char", "class", "const", "continue", "debugger", "default",
    "delete", "do", "double", "else", "enum", "export", "extends",
    "false", "final", "finally", "float", "for", "function", "goto",
    "if", "implements", "import", "in", "instanceof", "int", "interface",
    "long", "native", "new", "null", "package", "private", "protected",
    "public", "return", "short", "static", "super", "switch",
    "synchronized", "this", "throw", "throws", "transient", "true",
    "try", "typeof", "var", "void", "volatile", "while", "with"];
  name = String(name).replace(/[^0-9_a-z]/ig, "_");
  if (!name.length || name.match(/^[0-9]/) || arrayIndexOf(reserved, name) >= 0)
    name = "_" + name;
  return name;
}

// ターゲットにオブジェクトを関連付ける
function putUserData(target, key, data, handler)
{
  if (target)
  {
    key = canonicalizeIdentifier(key);
    if (data === null || typeof data == "undefined")
      delete target["m_" + key];
    else
      target["m_" + key] = data;
  }
  return;
}

// ターゲットからオブジェクトを取り出す
function takeUserData(target, key)
{
  key = canonicalizeIdentifier(key);
  if (target && ("m_" + key in target))
    return target["m_" + key];
  else
    return null;
}

// 値がオブジェクトかどうかを返す
function isObject(value)
{
  var t;
  t = typeof value;
  return value != null && (t == "object" || t == "function");
}

// value が undefined でないかどうかを返す
function isSet(value)
{
  return typeof value != "undefined";
}

// source オブジェクトの属性を destination にコピーする (浅いコピー)
function copyObjectProperies(source, destination, names)
{
  var i;
  if (isObject(source) && isObject(destination))
  {
    if (isObject(names))
      for (i = 0; i < names.length; ++i)
      {
        if ((typeof names[i] == "string" || typeof names[i] == "number") &&
            isSet(source[names[i]]))
          destination[names[i]] = source[names[i]];
      }
    else
    {
      if ((typeof names == "string" || typeof names == "number") &&
          isSet(source[names]))
        destination[names] = source[names];
    }
  }
  return;
}

// 配列の先頭から item に一致するものをがあればその序数を返す
function arrayIndexOf(array, item)
{
  var a, i, index;
  if (isObject(array))
    for (i = 0; i < array.length; ++i)
    {
      if (array[i] == item)
        return i;
    }
  return -1;
}

// 配列の末尾に要素を加える
function arrayPush(array, item)
{
  var i;
  if (isObject(array))
    for (i = 1; i < arguments.length; ++i)
      array[array.length] = arguments[i];
  return;
}

// element.className に token が含まれているかどうかを調べる
function classContains(element, token)
{
  var a;
  if (isObject(element) && typeof element.className == "string")
  {
    a = element.className.split(/[, ]+/);
    if (arrayIndexOf(a, token) >= 0)
      return true;
  }
  return false;
}

// element.className に token を追加する。
function classAdd(element, token)
{
  var a;
  if (isObject(element) && typeof element.className == "string")
  {
    a = element.className.split(/[, ]+/);
    if (arrayIndexOf(a, token) < 0)
      element.className += " " + String(token);
  }
  return;
}

// element.className に token を削除する。
function classRemove(element, token)
{
  var a, i;
  if (isObject(element) && typeof element.className == "string")
  {
    a = element.className.split(/[, ]+/);
    i = arrayIndexOf(a, token);
    if (i >= 0)
    {
      delete a[i];
      element.className = a.join(" ");
    }
  }
  return;
}

// HTML と特殊文字を実体参照に置換する
function replaceEntities(str)
{
  str = str.replace(/&/g, '&amp;');
  str = str.replace(/</g, '&lt;');
  str = str.replace(/>/g, '&gt;');
  str = str.replace(/"/g, '&quot;');
  return str;
}

// 実体参照を元に戻す
function replaceEntityReferences(str)
{
  str = str.replace(/&(amp|lt|gt|quot);/g, function(match)
  {
    switch (match)
    {
      case '&amp;':  return '&';
      case '&lt;':   return '<';
      case '&gt;':   return '>';
      case '&quot;': return '"';
    }
  });
  return str;
}

// 文字列の前後のスペースを取り除く
function trim(str)
{
  str = String(str);
  str = str.replace(/^[\x00\t\n\x0B\r ]+/, "");
  str = str.replace(/[\x00\t\n\x0B\r ]+$/, "");
  return str;
}

// str1, str2, ... を separator で区切って連結する
function trimConnect(separator, str1)
{
  var a, i, str;
  a = [];
  for (i = 1; i < arguments.length; ++i)
  {
    str = trim(arguments[i]);
    if (str.length)
      arrayPush(a, str);
  }
  return a.join(separator);
}

// <INPUT> 要素を作成する
function createInputElement(owner, type, name)
{
  var input;
  input = null;
  if (owner && owner.createElement)
  {
    if (owner.all)
    {
      input = owner.createElement('<INPUT TYPE="' + replaceEntities(type) +
          '" ' + (name ? 'NAME="' + replaceEntities(name) + '" ' : '') +
          '>');
    }
    else
      if ((input = owner.createElement("INPUT")))
      {
        input.type = type;
        name && (input.name = name);
      }
  }
  return input;
}

// classList に含まれる要素のうち classToken が含まれるものを抽出し、配列として返す
function snapElementsByClassName(nodeList, classToken)
{
  var a, e, i;
  a = [];
  if (isObject(nodeList) && nodeList.item)
  {
    for (i = 0; i < nodeList.length; ++i)
    {
      if ((e = nodeList[i]) && e.nodeType == 1 &&
          classContains(e, classToken))
      {
        arrayPush(a, e);
      }
    }
  }
  return a;
}

// parent の卑属の要素のうち、className が一致するものを抽出し、配列として返す。
function snapElementsByTagName(parent, tagName, classToken)
{
  var a, es, e, i;
  a = [];
  if (isObject(parent) && parent.getElementsByTagName &&
      (es = parent.getElementsByTagName(tagName)) && es.item)
  {
    if (classToken)
      a = snapElementsByClassName(es, classToken);
    else
    {
      for (i = 0; i < es.length; ++i)
        if ((e = es.item(i)))
          arrayPush(a, e);
    }
  }
  return a;
}

// element に含まれるテキストを返す
function getContentText(element)
{
  var text, i, child;
  text = "";
  if (isObject(element))
  {
    // element
    if (element.nodeType == 1)
    {
      if (element.childNodes)
        for (i = 0; i < element.childNodes.length; ++i)
          if ((child = element.childNodes.item(i)))
            text += getContentText(child);
    }
    else
      if (element.nodeType == 3)
        text = element.nodeValue;
  }
  return text;
}

// 指定されたノードまたはその尊属について tagName と一致する要素を返す
function getAncestorElement(node, tagName)
{
  if (isObject(node) && node.nodeType == 1)
  {
    if (tagName == "*" || String(node.nodeName).toUpperCase() == String(tagName))
      return node;
    else
      return getAncestorElement(node.parentNode, tagName);
  }
  return null;
}

// 要素に含まれるすべての子を削除する
function removeAllChildren(element)
{
  var i, child;
  if (isObject(element) && element.removeChild && element.childNodes &&
      element.childNodes.item)
    for (i = element.childNodes.length - 1; i >= 0; i--)
      if ((child = element.childNodes.item(i)) && element.removeChild)
        element.removeChild(child);
  return;
}

// 特定のリンクをボタンに置き換える
function linkButtonLoad(evt)
{
  var doc, a1, a, b, i, id;
  if ((doc = document) && (a1 = snapElementsByTagName(doc, "A", "button")))
  {
    for (i = 0; i < a1.length; ++i)
    {
      if ((a = a1[i]) && a.parentNode && a.parentNode.replaceChild &&
          (b = createInputElement(doc, "BUTTON", a.Name)))
      {
        copyObjectProperies(a, b, ["accessKey", "className", "tabIndex"]);
        b.value = getContentText(a);
        putUserData(b, "href", a.href, null);
        putUserData(b, "target", a.target, null);
        a.parentNode.replaceChild(b, a);
        if (a.id)
          b.id = a.id;
        pushEventListener(b, "click", linkButtonClick, false);
      }
    }
  }
  return;
}

// 置き換えたボタンがクリックされたときの動作
function linkButtonClick(evt)
{
  var b, href, target;
  if ((evt || (evt = window.event)) &&
      (b = getAncestorElement(evt.target || evt.srcElement, "INPUT")))
  {
    href   = takeUserData(b, "href");
    target = takeUserData(b, "target")
    if ((!target || !window.open || !window.open(href, target)) &&
        document.location)
      document.location.href = href;
  }
  return;
}

// 指定された要素がキーボードフォーカスを持つかどうかをテストする
function hasFocus(element)
{
  var doc;
  if (element && (doc = element.document || element.ownerDocument))
    return element == doc.activeElement;
  else
    return false;
}

// 検索ボックスの背景を設定する
function searchFormKeywordLoad(evt)
{
  var ks, i, k;
  if ((ks = snapElementsByTagName(document, "INPUT", "search-form-keyword")))
  {
    for (i = 0; i < ks.length; ++i)
      if ((k = ks[i]))
      {
        pushEventListener(k, "focus", searchFormKeywordFocus, false);
        pushEventListener(k, "blur", searchFormKeywordFocus, false);
        if (!hasFocus(k) && k.value == "")
          classAdd(k, "no-value-no-focus");
      }
  }
  return;
}

// 検索ボックスの背景の状態を切り替える
function searchFormKeywordFocus(evt)
{
  var k;
  if ((evt || (evt = window.event)) &&
      (k = getAncestorElement(evt.target || evt.srcElement, "INPUT")))
  {
    if (String(evt.type).toUpperCase() == "BLUR" && k.value == "")
      classAdd(k, "no-value-no-focus");
    else
      classRemove(k, "no-value-no-focus");
  }
  return;
}

// 必須項目を含むフォームを探す
function essentialLoad(evt)
{
  var doc, i, j, f, e, es, type;
  if ((doc = document) && doc.forms && doc.forms.item)
  {
    for (i = 0; i < doc.forms.length; ++i)
      if ((f = doc.forms.item(i)) &&
          (es = snapElementsByClassName(f.elements, "essential")))
      {
        for (j = 0; j < es.length; ++j)
          if ((e = es[j]))
          {
            type = String(e.type).toUpperCase();
            if (type == "SUBMIT" || type == "IMAGE")
            {
              pushEventListener(e, "click", essentialSubmitClick, false);
            }
          }
      }
  }
  return;
}

// 必須項目を含むフォームが送信されるときに、入力内容が埋まっているかどうかテストする
function essentialSubmitClick(evt)
{
  var f, empties, es, i, e, type, value, flag, j, o;
  if ((evt || (evt = window.event)) &&
      (f = getAncestorElement(evt.target || evt.srcElement, "FORM")))
  {
    empties = [];
    es = snapElementsByClassName(f.elements, "essential");
    for (i = 0; i < es.length; ++i)
      if ((e = es[i]) && e.name && !e.disabled)
      {
        type = String(e.type).toUpperCase();
        if (type == "TEXT" || type == "PASSWORD" || type == "TEXTAREA")
        {
          if (!e.readOnly)
          {
            value = trim(e.value);
            if (!value.length)
              arrayPush(empties, e);
          }
        }
        else
        {
          if (type == "SELECT-ONE")
          {
            if (e.options &&
                (e.options.length > 0 && e.selectedIndex < 0 ||
                 e.options.length > 1 && e.selectedIndex < 1))
              arrayPush(empties, e);
          }
          else
            if (type == "SELECT-MULTIPLE")
            {
               if ((flag = e.options && e.options.item && e.options.length > 0))
                 for (j = 0; j < e.options.length; ++j)
                   if ((o = e.options.item(j)) && o.selected)
                   {
                     flag = 0;
                     break;
                   }
               if (flag)
               {
                 arrayPush(empties, e);
               }
            }
        }
      }
    if (empties.length)
    {
      alertEmptyMessage(empties);
      if (evt.preventDefault)
        evt.preventDefault();
      else
        evt.returnValue = false;
    }
  }
  return;
}

// 入力内容が埋まっていない場合の警告表示
function alertEmptyMessage(empties)
{
  var messages, i, e, l, type, text, c;
  messages = [];
  for (i = 0; i < empties.length; ++i)
  {
    if ((e = empties[i]))
    {
      text = "";
      if ((l = searchElementLabel(e)))
        text = trim(getContentText(l)).replace(/ *:$/, "");
      if (!text)
        for (l = e.previousSibling; l; l = l.previousSibling)
          if (l.nodeType == 3)
          {
            text = trim(l.nodeValue).replace(/ *:$/, "");
            break;
          }
/*      if (!text)
        for (l = e.nextSibling; l; l = l.nextSibling)
          if (l.nodeType == 3)
          {
            (text = trim(l.nodeValue).replace(/ *:$/, ""));
            break;
          }*/
      if (!text)
      {
      label1:
        for (c = e.parentNode; c; c = c.parentNode)
        {
          type = String(c.nodeName).toUpperCase();
          if ((type == "TD" || type == "TH"))
          {
            for (l = c.previousSibling; l; l = l.previousSibling)
              if ((text = trim(getContentText(l)).replace(/ *:$/, "")))
                break label1;
            for (l = c.nextSibling; l; l = l.nextSibling)
              if ((text = trim(getContentText(l)).replace(/ *:$/, "")))
                break label1;
            break;
          }
        }
      }
      if (!text)
        text = e.name;

      type = String(e.type).toUpperCase();
      if (type == "SELECT-ONE" || type == "SELECT-MULTIPLE")
        arrayPush(messages, text + "が選択されていません。");
      else
        arrayPush(messages, text + "が入力されていません。");
    }
  }
  alert(messages.join("\n"));
  return;
}

// フォーム要素に対応するラベルを探す
function searchElementLabel(elementFor)
{
  var doc, ls, l, i;
  if (isObject(elementFor))
  {
    if (elementFor.id &&
        (doc = elementFor.ownerDocument || elementFor.document) &&
        doc.getElementsByTagName &&
        (ls = doc.getElementsByTagName("LABEL")) && ls.item)
    {
      for (i = 0; i < ls.length; ++i)
        if ((l = ls.item(i)) && l.htmlFor == elementFor.id)
          return l;
    }
    return getAncestorElement(elementFor.parentNode, "LABEL");
  }
  return null;
}

// マウスイベントの絶対座標を計算する
function getAbsolutePoint(evt, point)
{
  var p, doc;
  if (evt && point)
  {
    point.left = evt.clientX;
    point.top = evt.clientY;
    if ((p = evt.target || evt.srcElement) &&
        (doc = p.ownerDocument || p.document))
    {
      if (doc.documentElement &&  typeof doc.compatMode == "string" &&
          doc.compatMode != "BackCompat")
        p = doc.documentElement;
      else
        p = doc.body;
      if (p)
      {
        point.left += p.scrollLeft;
        point.top += p.scrollTop;
      }
      if (evt.srcElement)
      {
        point.left -= 2;
        point.top -= 2;
      }
    }
  }
  return;
}

// 要素の絶対座標を計算する
function getAbsoluteOrigin(element, point)
{
  var p;
  if (point)
  {
    point.left = point.top = 0;
    for (p = element; p; p = p.offsetParent)
    {
      point.left += p.offsetLeft;
      point.top  += p.offsetTop;
    }
  }
  return;
}

// XMLHttpRequest を使って GET 要求を送る
function sendHttpGetRequest(url, funcLoad, params)
{
  var req;
  req = null;
  if (typeof window.ActiveXObject == "function")
    req = new ActiveXObject("Microsoft.XMLHTTP");
  else if (window.XMLHttpRequest)
    req = new XMLHttpRequest();
  if (req)
  {
    req.open("GET", url, true);
    req.onreadystatechange = function()
    {
      if (req.readyState == 4)
        funcLoad(req, params);
      return;
    };
    req.send(null);
  }
  return req;
}

// select要素からすべてのoptionを取り除く
function removeAllOptionsFromSelect(select)
{
  var i;
  if (select && select.options && select.remove)
    for (i = select.options.length; i >= 0; --i)
      select.remove(i);
  return;
}

// 新しい option 要素を作成して、select の末尾に追加する
function addOptionToSelect(select, text, value)
{
  var doc, o;
  if (select && select.add &&
      (doc = select.ownerDocument || select.document) &&
      doc.createElement && (o = doc.createElement("OPTION")))
  {
    o.text = text;
    o.value = value || text;
    select.add(o, typeof window.ActiveXObject == "function" ? -1 : null);
  }
  return o;
}

// 指定された value を持つ option 要素を選択する
function selectOptionByValue(select, value)
{
  var i, o;
  if (select && select.options && select.options.item)
    for (i = 0; i < select.options.length; ++i)
      if ((o = select.options.item(i)) && o.value == value)
      {
        o.selected = true;
        break;
      }
  return;
}

function getSelectedOption(select)
{
  var i, o;
  o = null;
  if (select && select.options && select.options.item)
  {
    i = select.selectedIndex;
    if (i >= 0 && i < select.options.length)
      o = select.options.item(i);
  }
  return o;
}

// rc1 が rc2 と重なり合っているかどうかを返す
function isRectIntersect(rc1, rc2)
{
  return rc1 && rc2 &&
         (rc2.left >= rc1.left && rc2.left < rc1.right ||
          rc2.right >= rc1.left && rc2.right < rc1.right ||
          rc1.left >= rc2.left && rc1.left < rc2.right ||
          rc1.right >= rc2.left && rc1.right < rc2.right) &&
         (rc2.top >= rc1.top && rc2.top < rc1.bottom ||
          rc2.bottom >= rc1.top && rc2.bottom < rc1.bottom ||
          rc1.top >= rc2.top && rc1.top < rc2.bottom ||
          rc1.bottom >= rc2.top && rc1.bottom < rc2.bottom);
}

// 背後に隠れるべき select 要素を非表示にする
function hideBackSelectElements(front)
{
  var doc, ss, s, i, p, p1, p2;
  showBackSelectElements(front);
  if (front && front.currentStyle && (doc = front.document))
  {
    front.m_back_select = [];
    p1 = {left: 0, top: 0};
    getAbsoluteOrigin(front, p1);
    p1.right = p1.left + front.offsetWidth;
    p1.bottom = p1.top + front.offsetHeight;
    ss = snapElementsByTagName(doc, "SELECT");
label1:
    for (i = 0; i < ss.length; ++i)
    {
      if ((s = ss[i]) && s.currentStyle &&
          String(s.currentStyle.visibility).toUpperCase() != "HIDDEN")
      {
        for (p = s.parentNode; p; p = p.parentNode)
          if (p == front)
            break label1;
        p2 = {left: 0, top: 0};
        getAbsoluteOrigin(s, p2);
        p2.right = p2.left + s.offsetWidth;
        p2.bottom = p2.top + s.offsetHeight;
        if (isRectIntersect(p1, p2))
        {
          s.style.visibility = "hidden";
          arrayPush(front.m_back_select, s);
        }
      }
    }
  }
  return;
}

// 非表示にした select 要素を復活させる
function showBackSelectElements(front)
{
  var ss, s, i;
  if (front && (ss = front.m_back_select))
    for (i = 0; i < ss.length; ++i)
      if ((s = ss[i]))
        s.style.visibility = "visible";
  return;
}

// メニューの強調表示
function menuHighlightLoad(evt)
{
  var doc, ms, m, i, ls, l, j, aa, a, k;
  if ((doc = document) && (ms = snapElementsByTagName(doc, "DIV", "menu")))
  {
    for (i = 0; i < ms.length; ++i)
      if ((m = ms[i]) && (ls = snapElementsByTagName(m, "LI", null)))
      {
        for (j = 0; j < ls.length; ++j)
          if ((l = ls[j]))
          {
            pushEventListener(l, "mouseover", menuHighlightHover, false);
            pushEventListener(l, "mouseout", menuHighlightHover, false);
            if ((aa = snapElementsByTagName(l, "A", null)))
            {
              for (k = 0; k < aa.length; ++k)
                if ((a = aa[k]))
                {
                  putUserData(l, "a", a, null);
                  pushEventListener(a, "focus", menuHighlightHover, false);
                  pushEventListener(a, "blur", menuHighlightHover, false);
                }
            }
          }
      }
  }
  return;
}

// メニューの強調表示の切り替え
function menuHighlightHover(evt)
{
  var l, a, mouseIsIn;
  if ((evt || (evt = window.event)) &&
      (l = getAncestorElement(evt.target || evt.srcElement, "LI")))
  {
    a = takeUserData(l, "a");
    mouseIsIn = takeUserData(l, "mouseIsIn");
    switch (String(evt.type).toUpperCase())
    {
      case "FOCUS":
        menuHighlightToggle(l, true);
        break;
      case "BLUR":
        if (!mouseIsIn)
          menuHighlightToggle(l, false);
        break;
      case "MOUSEOVER":
        putUserData(l, "mouseIsIn", true, null);
        menuHighlightToggle(l, true);
        break;
      case "MOUSEOUT":
        putUserData(l, "mouseIsIn", false, null);
        if (!hasFocus(a))
          menuHighlightToggle(l, false);
    }
  }
  return;
}

// 実際に切り替える
function menuHighlightToggle(l, isHighligh)
{
  if (isHighligh)
    classAdd(l, "highlight");
  else
    classRemove(l, "highlight");
  return;
}

// NodeList::namedItem() のラッパー
function getNamedItem(nodeList, name)
{
  if (isObject(nodeList))
  {
    if (nodeList.namedItem)
      return nodeList.namedItem(name);
    else if (nodeList.item)
      return nodeList.item(name);
  }
  return null;
}

// HTMLFrom::elements のうち、その name が配列 names に含まれる要素を
// 探して、"m_" + name をキー、オブジェクトを値とするオブジェクトを
// 返す。
function findFormElements(form, names)
{
  var elements, element, i, key;
  elements = {};
  if (form && form.elements)
  {
    for (i = 0; i < names.length; ++i)
    {
      key = "m_" + canonicalizeIdentifier(names[i]);
      if ((element = getNamedItem(form.elements, names[i])))
        elements[key] = element;
    }
  }
  return elements;
}

function setTimeoutParam(func, ms, param)
{
  var timer;
  if (typeof func == "function")
  {
    timer = setTimeout(function() { return func(param); }, ms);
  }
  return timer;
}

function setIntervalParam(func, ms, param)
{
  var timer;
  if (typeof func == "function")
  {
    timer = setInterval(function() { return func(param); }, ms);
  }
  return timer;
}

// オブジェクトのプロパティを表示する (デバッグ用)
function objectToString(obj)
{
  var p, i;
  p = [];
  if (isObject(obj))
  {
    for (i in obj)
    {
      arrayPush(p, i + ": " + String(obj[i]).replace(/[\r\n]+/g, " "));
    }
    return p.join(",\n");
  }
  return String(obj);
}

// 情報バーの初期化
function infoBarLoad(evt)
{
  var doc, body, first, divs, div, i, buttons, button, j;
  if ((doc = document) && (body = doc.body) && body.insertBefore &&
      (divs = snapElementsByTagName(body, "DIV", "info-bar")))
  {
    first = body.firstChild;
    for (i = 0; i < divs.length; ++i)
      if ((div = divs[i]))
      {
        body.insertBefore(div, first);
        if ((buttons = snapElementsByTagName(div, "A", "info-bar-close")))
        {
          for (j = 0; j < buttons.length; ++j)
            if ((button = buttons[j]))
            {
              button.m_div = div;
              pushEventListener(button, "click", infoBarCloseClick, false);
            }
        }
      }
  }
  return;
}

// 情報バーの閉じるボタン
function infoBarCloseClick(evt)
{
  var button, div, parent;
  if ((evt || (evt = window.event)) &&
      (button = getAncestorElement(evt.target || evt.srcElement, "A")) &&
      (div = button.m_div) && (parent = div.parentNode) &&
      parent.removeChild && parent.removeChild(div))
  {
    if (evt.preventDefault)
      evt.preventDefault();
    else
      evt.returnValue = false;
  }
  return;
}

// 処理の開始
function scriptLoad(evt)
{
  linkButtonLoad(evt);
  searchFormKeywordLoad(evt);
  essentialLoad(evt);
  menuHighlightLoad(evt);
  infoBarLoad(evt);
  return;
}

pushEventListener(this, "load", scriptLoad, false);