//setStyle(
//    document.getElementById('divId'),
//    'height: 180px; text-align: left; overflow-y: scroll;'
//);

var setStyle = function (elm, style) {
    var rules = (function (style) {
        var css, v,
                rules = {},
                div = document.createElement('div');

        div.innerHTML = '<div style="' + style + '"></div>';
        css = div.childNodes[0].style;
        for (var i in css) {
            (
                i !== 'cssText' &&
                (typeof i === 'string' || i instanceof String)
            ) &&
            (v = css[i]) &&
            (rules[i] = v);
        }

        return rules;
    })(style);

    for (var rule in rules) if (rules.hasOwnProperty(rule)) {
        elm.style[rule] = rules[rule];
    }

    return elm;
};

var soundex = function (s) {
     var a = s
             .substring(1, s.length)
             .toLowerCase()
             .split(''),
         r = '',
         codes = {
             a: '', e: '', i: '', o: '', u: '',
             b: 1, f: 1, p: 1, v: 1,
             c: 2, g: 2, j: 2, k: 2, q: 2, s: 2, x: 2, z: 2,
             d: 3, t: 3,
             l: 4,
             m: 5, n: 5,
             r: 6
         };
 
     r = s[0].toUpperCase() +
         a
         .filter(function (v, i, a) { return v !== a[i + 1]; })
         .map(function (v, i, a) { return codes[v] }).join('');
 
     return (r + '000').slice(0, 4);
};

// http://www.dustindiaz.com/smallest-domready-ever
var ready = function (f) {
  (/in/.test(document.readyState)) ?
    setTimeout('ready(' + f + ')', 9) :
    f();
};

var typs = {};

(function (self) {
     var values = [
               'Function',
               'Object',
               'Array',
               'String',
               'Number',
               'Date',
               'RegExp',
               'Boolean',
               'Null',
               'Error'
          ];

     for (var i in values) if (values.hasOwnProperty(i)) {
          var value = values[i];

          self['is' + value] = (function (v) {
               return function (o) {
                      var r = '';

                      try {
                          r = (o === null) ?
                                   'Null' :
                                   Object
                                       .prototype
                                       .toString
                                       .call(o)
                                       .replace(/^\[object\s(\w+)\]$/, '$1');
                      } catch (e) {
                          r = 'Undefined';
                      }

                      return !!(r === v);
               };
          })(value);
     }
})(typs);

alert(typs.isFunction(Object)); // --> true

var NodeFilter = {
    FILTER_ACCEPT: 1,
    FILTER_REJECT: 2,
    FILTER_SKIP: 3,
    SHOW_ALL: -1,
    SHOW_ELEMENT: 1,
    SHOW_ATTRIBUTE: 2,
    SHOW_TEXT: 4,
    SHOW_CDATA_SECTION: 8,
    SHOW_ENTITY_REFERENCE: 16,
    SHOW_ENTITY: 32,
    SHOW_PROCESSING_INSTRUCTIONS: 64,
    SHOW_COMMENT: 128,
    SHOW_DOCUMENT: 256,
    SHOW_DOCUMENT_TYPE: 512,
    SHOW_DOCUMENT_FRAGMENT: 1024,
    SHOW_NOTATION: 2048
};

var TreeWalker = function (root, whatToShow, filter, expandEntityReferences) {
    this.root = root;
    this.whatToShow = whatToShow;
    this.filter = filter;
    this.expandEntityReferences = expandEntityReferences;
    this.currentNode = root;
    this.NodeFilter = NodeFilter;
};

TreeWalker.prototype.parentNode = function () {
    var testNode = this.currentNode;

    do {
        if (
            testNode !== this.root &&
            testNode.parentNode &&
            testNode.parentNode !== this.root
        ) {
            testNode = testNode.parentNode;
        } else {
            return null;
        }
    } while (this._getFilteredStatus(testNode) !== this.NodeFilter.FILTER_ACCEPT);
    (testNode) && (this.currentNode = testNode);

    return testNode;
};

TreeWalker.prototype.firstChild = function () {
    var testNode = this.currentNode.firstChild;

    while(testNode) {
        if(this._getFilteredStatus(testNode) === this.NodeFilter.FILTER_ACCEPT) {
            break;
        }
        testNode = testNode.nextSibling;
    }
    (testNode) && (this.currentNode = testNode);

    return testNode;
};

TreeWalker.prototype.lastChild = function () {
    var testNode = this.currentNode.lastChild;

    while (testNode) {
        if(this._getFilteredStatus(testNode) === this.NodeFilter.FILTER_ACCEPT) {
            break;
        }
        testNode = testNode.previousSibling;
    }
    (testNode) && (this.currentNode = testNode);

    return testNode;
};

TreeWalker.prototype.nextNode = function () {
    var testNode = this.currentNode;

    while (testNode) {
        if (testNode.childNodes.length !== 0) {
            testNode = testNode.firstChild;
        } else if (testNode.nextSibling) {
            testNode = testNode.nextSibling;
        } else {
            while (testNode) {
                if (testNode.parentNode && testNode.parentNode !== this.root) {
                    if (testNode.parentNode.nextSibling) {
                        testNode = testNode.parentNode.nextSibling;
                        break;
                    } else {
                        testNode = testNode.parentNode;
                    }
                }
                else return null;
            }
        }
        if (testNode && this._getFilteredStatus(testNode) === this.NodeFilter.FILTER_ACCEPT) {
            break;
        }
    }
    (testNode) && (this.currentNode = testNode);

    return testNode;
};

TreeWalker.prototype.previousNode = function () {
    var testNode = this.currentNode;

    while (testNode) {
        if (testNode.previousSibling) {
            testNode = testNode.previousSibling;
            while (testNode.lastChild) {
                testNode = testNode.lastChild;
            }
        }
        else {
            if (testNode.parentNode && testNode.parentNode !== this.root) {
                testNode = testNode.parentNode;
            }
            else testNode = null;
        }
        if (testNode && this._getFilteredStatus(testNode) === this.NodeFilter.FILTER_ACCEPT) {
            break;
        }
    }
    (testNode) && (this.currentNode = testNode);

    return testNode;
};

TreeWalker.prototype.nextSibling = function () {
    var testNode = this.currentNode;

    while(testNode) {
        (testNode.nextSibling) && (testNode = testNode.nextSibling);
        if(this._getFilteredStatus(testNode) === this.NodeFilter.FILTER_ACCEPT) {
            break;
        }
    }
    (testNode) && (this.currentNode = testNode);

    return testNode;
};

TreeWalker.prototype.previousSibling = function () {
    var testNode = this.currentNode;

    while(testNode) {
        (testNode.previousSibling) && (testNode = testNode.previousSibling);
        if(this._getFilteredStatus(testNode) == this.NodeFilter.FILTER_ACCEPT) {
            break;
        }
    }
    (testNode) && (this.currentNode = testNode);

    return testNode;
};

TreeWalker.prototype._getFilteredStatus = function (node) {
    var mask = ({
            /* ELEMENT_NODE */ 1: this.NodeFilter.SHOW_ELEMENT,
            /* ATTRIBUTE_NODE */ 2: this.NodeFilter.SHOW_ATTRIBUTE,
            /* TEXT_NODE */ 3: this.NodeFilter.SHOW_TEXT,
            /* CDATA_SECTION_NODE */ 4: this.NodeFilter.SHOW_CDATA_SECTION,
            /* ENTITY_REFERENCE_NODE */ 5: this.NodeFilter.SHOW_ENTITY_REFERENCE,
            /* ENTITY_NODE */ 6: this.NodeFilter.SHOW_PROCESSING_INSTRUCTION,
            /* PROCESSING_INSTRUCTION_NODE */ 7: this.NodeFilter.SHOW_PROCESSING_INSTRUCTION,
            /* COMMENT_NODE */ 8: this.NodeFilter.SHOW_COMMENT,
            /* DOCUMENT_NODE */ 9: this.NodeFilter.SHOW_DOCUMENT,
            /* DOCUMENT_TYPE_NODE */ 10: this.NodeFilter.SHOW_DOCUMENT_TYPE,
            /* DOCUMENT_FRAGMENT_NODE */ 11: this.NodeFilter.SHOW_DOCUMENT_FRAGMENT,
            /* NOTATION_NODE */ 12: this.NodeFilter.SHOW_NOTATION
        })[node.nodeType];

    return (
        (mask && (this.whatToShow & mask) == 0) ?
            this.NodeFilter.FILTER_REJECT :
            (this.filter && this.filter.acceptNode) ?
                this.filter.acceptNode(node) :
                this.NodeFilter.FILTER_ACCEPT
    );
};

if (!document.createTreeWalker) {
    document.createTreeWalker = function (root, whatToShow, filter, expandEntityReferences) {
        return new TreeWalker(root, whatToShow, filter, expandEntityReferences);
    };
}

     var logicGates = {
        nand: function (a, b) {
                return !(a && b);
        },
        not:  function (a)    {
                return this.nand(a, a);
        },
        and:  function (a, b) {
                return this.not(this.nand(a, b));
        },
        or:   function (a, b) {
                return this.nand(this.not(a), this.not(b));
        },
        nor:  function (a, b) {
                return this.not(this.or(a, b));
        },
        xor:  function (a, b) {
                return this.and(this.nand(a, b), this.or(a, b));
        },
        xnor: function (a, b) {
                return this.not(this.xor(a, b));
        }
    };

    [
        {a: false, b: false},
        {a: false, b: true},
        {a: true, b: false},
        {a: true, b: true},
    ].map(function (x) { return logicGates.nand(x.a, x.b); });

  // Pseudo Tail Call Optimization.
  // Try/Catch Trampoline.

  Function.prototype.tco = function () {
      var that = this;

      return function () {
          for (
              var caller = arguments.callee.caller;
                  caller;
                  caller = caller.caller
          ) {
              if (caller === arguments.callee) {
                  throw { args: arguments, self: this };
              }
          }

          var args = arguments,
              self = this;
              
          while (true) {
              try {
                  return that.apply(self, args);
              } catch (e) {
                  if (!e.args) { throw e; }
                  args = e.args; self = e.self;
              }
          }
      };
  };