trickster 0.0.4

data/js/lib/highlight-fc32801.min.js

@@ -0,0 +1,4601 @@
+var hljs = new function() {
+
+  /* Utility functions */
+
+  function escape(value) {
+    return value.replace(/&/gm, '&amp;').replace(/</gm, '&lt;');
+  }
+
+  function findCode(pre) {
+    for (var i = 0; i < pre.childNodes.length; i++) {
+      var node = pre.childNodes[i];
+      if (node.nodeName == 'CODE')
+        return node;
+      if (!(node.nodeType == 3 && node.nodeValue.match(/\s+/)))
+        break;
+    }
+  }
+
+  var is_old_IE = (typeof navigator !== 'undefined' && /MSIE [678]/.test(navigator.userAgent));
+
+  function blockText(block, ignoreNewLines) {
+    var result = '';
+    for (var i = 0; i < block.childNodes.length; i++)
+      if (block.childNodes[i].nodeType == 3) {
+        var chunk = block.childNodes[i].nodeValue;
+        if (ignoreNewLines)
+          chunk = chunk.replace(/\n/g, '');
+        result += chunk;
+      } else if (block.childNodes[i].nodeName == 'BR')
+        result += '\n';
+      else
+        result += blockText(block.childNodes[i]);
+    if (is_old_IE)
+      result = result.replace(/\r/g, '\n');
+    return result;
+  }
+
+  function blockLanguage(block) {
+    var classes = block.className.split(/\s+/);
+    classes = classes.concat(block.parentNode.className.split(/\s+/));
+    for (var i = 0; i < classes.length; i++) {
+      var class_ = classes[i].replace(/^language-/, '');
+      if (languages[class_] || class_ == 'no-highlight') {
+        return class_;
+      }
+    }
+  }
+
+  /* Stream merging */
+
+  function nodeStream(node) {
+    var result = [];
+    (function _nodeStream(node, offset) {
+      for (var i = 0; i < node.childNodes.length; i++) {
+        if (node.childNodes[i].nodeType == 3)
+          offset += node.childNodes[i].nodeValue.length;
+        else if (node.childNodes[i].nodeName == 'BR')
+          offset += 1;
+        else if (node.childNodes[i].nodeType == 1) {
+          result.push({
+            event: 'start',
+            offset: offset,
+            node: node.childNodes[i]
+          });
+          offset = _nodeStream(node.childNodes[i], offset);
+          result.push({
+            event: 'stop',
+            offset: offset,
+            node: node.childNodes[i]
+          });
+        }
+      }
+      return offset;
+    })(node, 0);
+    return result;
+  }
+
+  function mergeStreams(stream1, stream2, value) {
+    var processed = 0;
+    var result = '';
+    var nodeStack = [];
+
+    function selectStream() {
+      if (stream1.length && stream2.length) {
+        if (stream1[0].offset != stream2[0].offset)
+          return (stream1[0].offset < stream2[0].offset) ? stream1 : stream2;
+        else {
+          /*
+          To avoid starting the stream just before it should stop the order is
+          ensured that stream1 always starts first and closes last:
+
+          if (event1 == 'start' && event2 == 'start')
+            return stream1;
+          if (event1 == 'start' && event2 == 'stop')
+            return stream2;
+          if (event1 == 'stop' && event2 == 'start')
+            return stream1;
+          if (event1 == 'stop' && event2 == 'stop')
+            return stream2;
+
+          ... which is collapsed to:
+          */
+          return stream2[0].event == 'start' ? stream1 : stream2;
+        }
+      } else {
+        return stream1.length ? stream1 : stream2;
+      }
+    }
+
+    function open(node) {
+      var result = '<' + node.nodeName.toLowerCase();
+      for (var i = 0; i < node.attributes.length; i++) {
+        var attribute = node.attributes[i];
+        result += ' ' + attribute.nodeName.toLowerCase();
+        if (attribute.value !== undefined && attribute.value !== false && attribute.value !== null) {
+          result += '="' + escape(attribute.value) + '"';
+        }
+      }
+      return result + '>';
+    }
+
+    while (stream1.length || stream2.length) {
+      var current = selectStream().splice(0, 1)[0];
+      result += escape(value.substr(processed, current.offset - processed));
+      processed = current.offset;
+      if ( current.event == 'start') {
+        result += open(current.node);
+        nodeStack.push(current.node);
+      } else if (current.event == 'stop') {
+        var node, i = nodeStack.length;
+        do {
+          i--;
+          node = nodeStack[i];
+          result += ('</' + node.nodeName.toLowerCase() + '>');
+        } while (node != current.node);
+        nodeStack.splice(i, 1);
+        while (i < nodeStack.length) {
+          result += open(nodeStack[i]);
+          i++;
+        }
+      }
+    }
+    return result + escape(value.substr(processed));
+  }
+
+  /* Initialization */
+
+  function compileLanguage(language) {
+
+    function langRe(value, case_insensitive, global) {
+      return RegExp(
+        value,
+        'm' + (case_insensitive ? 'i' : '') + (global ? 'g' : '')
+      );
+    }
+
+    function compileMode(mode, parent) {
+      if (mode.compiled)
+        return;
+      mode.compiled = true;
+
+      var keywords = []; // used later with beginWithKeyword but filled as a side-effect of keywords compilation
+      if (mode.keywords) {
+        var compiled_keywords = {};
+
+        function flatten(className, str) {
+          var group = str.split(' ');
+          for (var i = 0; i < group.length; i++) {
+            var pair = group[i].split('|');
+            compiled_keywords[pair[0]] = [className, pair[1] ? Number(pair[1]) : 1];
+            keywords.push(pair[0]);
+          }
+        }
+
+        mode.lexemsRe = langRe(mode.lexems || hljs.IDENT_RE, language.case_insensitive, true);
+        if (typeof mode.keywords == 'string') { // string
+          flatten('keyword', mode.keywords)
+        } else {
+          for (var className in mode.keywords) {
+            if (!mode.keywords.hasOwnProperty(className))
+              continue;
+            flatten(className, mode.keywords[className]);
+          }
+        }
+        mode.keywords = compiled_keywords;
+      }
+      if (parent) {
+        if (mode.beginWithKeyword) {
+          mode.begin = '\\b(' + keywords.join('|') + ')\\s';
+        }
+        mode.beginRe = langRe(mode.begin ? mode.begin : '\\B|\\b', language.case_insensitive);
+        if (!mode.end && !mode.endsWithParent)
+          mode.end = '\\B|\\b';
+        if (mode.end)
+          mode.endRe = langRe(mode.end, language.case_insensitive);
+        mode.terminator_end = mode.end || '';
+        if (mode.endsWithParent && parent.terminator_end)
+          mode.terminator_end += (mode.end ? '|' : '') + parent.terminator_end;
+      }
+      if (mode.illegal)
+        mode.illegalRe = langRe(mode.illegal, language.case_insensitive);
+      if (mode.relevance === undefined)
+        mode.relevance = 1;
+      if (!mode.contains) {
+        mode.contains = [];
+      }
+      for (var i = 0; i < mode.contains.length; i++) {
+        if (mode.contains[i] == 'self') {
+          mode.contains[i] = mode;
+        }
+        compileMode(mode.contains[i], mode);
+      }
+      if (mode.starts) {
+        compileMode(mode.starts, parent);
+      }
+
+      var terminators = [];
+      for (var i = 0; i < mode.contains.length; i++) {
+        terminators.push(mode.contains[i].begin);
+      }
+      if (mode.terminator_end) {
+        terminators.push(mode.terminator_end);
+      }
+      if (mode.illegal) {
+        terminators.push(mode.illegal);
+      }
+      mode.terminators = terminators.length ? langRe(terminators.join('|'), language.case_insensitive, true) : null;
+    }
+
+    compileMode(language);
+  }
+
+  /*
+  Core highlighting function. Accepts a language name and a string with the
+  code to highlight. Returns an object with the following properties:
+
+  - relevance (int)
+  - keyword_count (int)
+  - value (an HTML string with highlighting markup)
+
+  */
+  function highlight(language_name, value) {
+
+    function subMode(lexem, mode) {
+      for (var i = 0; i < mode.contains.length; i++) {
+        var match = mode.contains[i].beginRe.exec(lexem);
+        if (match && match.index == 0) {
+          return mode.contains[i];
+        }
+      }
+    }
+
+    function endOfMode(mode_index, lexem) {
+      if (modes[mode_index].end && modes[mode_index].endRe.test(lexem))
+        return 1;
+      if (modes[mode_index].endsWithParent) {
+        var level = endOfMode(mode_index - 1, lexem);
+        return level ? level + 1 : 0;
+      }
+      return 0;
+    }
+
+    function isIllegal(lexem, mode) {
+      return mode.illegal && mode.illegalRe.test(lexem);
+    }
+
+    function eatModeChunk(value, index) {
+      var mode = modes[modes.length - 1];
+      var match;
+      if (mode.terminators) {
+        mode.terminators.lastIndex = index;
+        match = mode.terminators.exec(value);
+      }
+      return match ? [value.substr(index, match.index - index), match[0], false] : [value.substr(index), '', true];
+    }
+
+    function keywordMatch(mode, match) {
+      var match_str = language.case_insensitive ? match[0].toLowerCase() : match[0];
+      var value = mode.keywords[match_str];
+      if (value && value instanceof Array)
+          return value;
+      return false;
+    }
+
+    function processKeywords(buffer, mode) {
+      buffer = escape(buffer);
+      if (!mode.keywords)
+        return buffer;
+      var result = '';
+      var last_index = 0;
+      mode.lexemsRe.lastIndex = 0;
+      var match = mode.lexemsRe.exec(buffer);
+      while (match) {
+        result += buffer.substr(last_index, match.index - last_index);
+        var keyword_match = keywordMatch(mode, match);
+        if (keyword_match) {
+          keyword_count += keyword_match[1];
+          result += '<span class="'+ keyword_match[0] +'">' + match[0] + '</span>';
+        } else {
+          result += match[0];
+        }
+        last_index = mode.lexemsRe.lastIndex;
+        match = mode.lexemsRe.exec(buffer);
+      }
+      return result + buffer.substr(last_index);
+    }
+
+    function processSubLanguage(buffer, mode) {
+      var result;
+      if (mode.subLanguage == '') {
+        result = highlightAuto(buffer);
+      } else {
+        result = highlight(mode.subLanguage, buffer);
+      }
+      // Counting embedded language score towards the host language may be disabled
+      // with zeroing the containing mode relevance. Usecase in point is Markdown that
+      // allows XML everywhere and makes every XML snippet to have a much larger Markdown
+      // score.
+      if (mode.relevance > 0) {
+        keyword_count += result.keyword_count;
+        relevance += result.relevance;
+      }
+      return '<span class="' + result.language  + '">' + result.value + '</span>';
+    }
+
+    function processBuffer(buffer, mode) {
+      if (mode.subLanguage && languages[mode.subLanguage] || mode.subLanguage == '') {
+        return processSubLanguage(buffer, mode);
+      } else {
+        return processKeywords(buffer, mode);
+      }
+    }
+
+    function startNewMode(mode, lexem) {
+      var markup = mode.className? '<span class="' + mode.className + '">': '';
+      if (mode.returnBegin) {
+        result += markup;
+        mode.buffer = '';
+      } else if (mode.excludeBegin) {
+        result += escape(lexem) + markup;
+        mode.buffer = '';
+      } else {
+        result += markup;
+        mode.buffer = lexem;
+      }
+      modes.push(mode);
+      relevance += mode.relevance;
+    }
+
+    function processModeInfo(buffer, lexem, end) {
+      var current_mode = modes[modes.length - 1];
+      if (end) {
+        result += processBuffer(current_mode.buffer + buffer, current_mode);
+        return false;
+      }
+
+      var new_mode = subMode(lexem, current_mode);
+      if (new_mode) {
+        result += processBuffer(current_mode.buffer + buffer, current_mode);
+        startNewMode(new_mode, lexem);
+        return new_mode.returnBegin;
+      }
+
+      var end_level = endOfMode(modes.length - 1, lexem);
+      if (end_level) {
+        var markup = current_mode.className?'</span>':'';
+        if (current_mode.returnEnd) {
+          result += processBuffer(current_mode.buffer + buffer, current_mode) + markup;
+        } else if (current_mode.excludeEnd) {
+          result += processBuffer(current_mode.buffer + buffer, current_mode) + markup + escape(lexem);
+        } else {
+          result += processBuffer(current_mode.buffer + buffer + lexem, current_mode) + markup;
+        }
+        while (end_level > 1) {
+          markup = modes[modes.length - 2].className?'</span>':'';
+          result += markup;
+          end_level--;
+          modes.length--;
+        }
+        var last_ended_mode = modes[modes.length - 1];
+        modes.length--;
+        modes[modes.length - 1].buffer = '';
+        if (last_ended_mode.starts) {
+          startNewMode(last_ended_mode.starts, '');
+        }
+        return current_mode.returnEnd;
+      }
+
+      if (isIllegal(lexem, current_mode))
+        throw 'Illegal';
+    }
+
+    var language = languages[language_name];
+    compileLanguage(language);
+    var modes = [language];
+    language.buffer = '';
+    var relevance = 0;
+    var keyword_count = 0;
+    var result = '';
+    try {
+      var mode_info, index = 0;
+      do {
+        mode_info = eatModeChunk(value, index);
+        var return_lexem = processModeInfo(mode_info[0], mode_info[1], mode_info[2]);
+        index += mode_info[0].length;
+        if (!return_lexem) {
+          index += mode_info[1].length;
+        }
+      } while (!mode_info[2]);
+      return {
+        relevance: relevance,
+        keyword_count: keyword_count,
+        value: result,
+        language: language_name
+      };
+    } catch (e) {
+      if (e == 'Illegal') {
+        return {
+          relevance: 0,
+          keyword_count: 0,
+          value: escape(value)
+        };
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  /*
+  Highlighting with language detection. Accepts a string with the code to
+  highlight. Returns an object with the following properties:
+
+  - language (detected language)
+  - relevance (int)
+  - keyword_count (int)
+  - value (an HTML string with highlighting markup)
+  - second_best (object with the same structure for second-best heuristically
+    detected language, may be absent)
+
+  */
+  function highlightAuto(text) {
+    var result = {
+      keyword_count: 0,
+      relevance: 0,
+      value: escape(text)
+    };
+    var second_best = result;
+    for (var key in languages) {
+      if (!languages.hasOwnProperty(key))
+        continue;
+      var current = highlight(key, text);
+      current.language = key;
+      if (current.keyword_count + current.relevance > second_best.keyword_count + second_best.relevance) {
+        second_best = current;
+      }
+      if (current.keyword_count + current.relevance > result.keyword_count + result.relevance) {
+        second_best = result;
+        result = current;
+      }
+    }
+    if (second_best.language) {
+      result.second_best = second_best;
+    }
+    return result;
+  }
+
+  /*
+  Post-processing of the highlighted markup:
+
+  - replace TABs with something more useful
+  - replace real line-breaks with '<br>' for non-pre containers
+
+  */
+  function fixMarkup(value, tabReplace, useBR) {
+    if (tabReplace) {
+      value = value.replace(/^((<[^>]+>|\t)+)/gm, function(match, p1, offset, s) {
+        return p1.replace(/\t/g, tabReplace);
+      });
+    }
+    if (useBR) {
+      value = value.replace(/\n/g, '<br>');
+    }
+    return value;
+  }
+
+  function linesToCallout(block) {
+    if (block.attributes["data-callout-lines"]) {
+      var calloutLines = block.attributes["data-callout-lines"].value.split(",");
+      var adjustedCalloutLines = [];
+      for (var i in calloutLines) {
+        adjustedCalloutLines.push(parseInt(calloutLines[i]) - 1);
+      }
+      return adjustedCalloutLines;
+    }
+    else {
+      return [];
+    }
+  }
+
+  /** Wraps each line a <span> and also calls out lines if data-callout-lines was set on the code block */
+  function markupAndCalloutLines(result,block,text) {
+    var calloutLines = linesToCallout(block);
+    var resultPre = document.createElement('pre');
+    resultPre.innerHTML = result.value;
+    var linesPre = document.createElement('pre');
+    var eachLine = escape(text).split("\n");
+    var markedUpLines = "";
+    var previousLineCalledOut = false;
+    for (var i in eachLine) {
+      var calloutClass = '';
+      var startCalloutBlock = "";
+      var stopCalloutBlock = "";
+      if (calloutLines.indexOf(parseInt(i)) != -1) {
+        calloutClass = "line-callout";
+        if (!previousLineCalledOut) {
+          startCalloutBlock = "<div class='lines-callout'>";
+        }
+        previousLineCalledOut = true;
+      }
+      else {
+        if (previousLineCalledOut) {
+          stopCalloutBlock = "</div>";
+        }
+        previousLineCalledOut = false;
+      }
+      markedUpLines += stopCalloutBlock;
+      markedUpLines += startCalloutBlock;
+      markedUpLines += '<span class="line line-' + i + ' ' + calloutClass + ' ">'
+      markedUpLines += eachLine[i];
+      markedUpLines += '</span>' + "\n";
+    }
+    if (previousLineCalledOut) {
+      stopCalloutBlock = "</div>";
+    }
+    markedUpLines += stopCalloutBlock;
+    linesPre.innerHTML = markedUpLines;
+    return mergeStreams(nodeStream(linesPre), nodeStream(resultPre), text);
+  }
+
+  /*
+  Applies highlighting to a DOM node containing code. Accepts a DOM node and
+  two optional parameters for fixMarkup.
+  */
+  function highlightBlock(block, tabReplace, useBR, lineNodes) {
+    var text = blockText(block, useBR);
+    var language = blockLanguage(block);
+    var result, pre;
+    if (language == 'no-highlight')
+        return;
+    if (language) {
+      result = highlight(language, text);
+    } else {
+      result = highlightAuto(text);
+      language = result.language;
+    }
+    var original = nodeStream(block);
+    if (original.length) {
+      pre = document.createElement('pre');
+      pre.innerHTML = result.value;
+      result.value = mergeStreams(original, nodeStream(pre), text);
+    }
+    if (lineNodes) {
+      result.value = markupAndCalloutLines(result,block,text);
+    }
+    result.value = fixMarkup(result.value, tabReplace, useBR);
+
+    var class_name = block.className;
+    if (!class_name.match('(\\s|^)(language-)?' + language + '(\\s|$)')) {
+      class_name = class_name ? (class_name + ' ' + language) : language;
+    }
+    if (is_old_IE && block.tagName == 'CODE' && block.parentNode.tagName == 'PRE') {
+      // This is for backwards compatibility only. IE needs this strange
+      // hack becasue it cannot just cleanly replace <code> block contents.
+      pre = block.parentNode;
+      var container = document.createElement('div');
+      container.innerHTML = '<pre><code>' + result.value + '</code></pre>';
+      block = container.firstChild.firstChild;
+      container.firstChild.className = pre.className;
+      pre.parentNode.replaceChild(container.firstChild, pre);
+    } else {
+      block.innerHTML = result.value;
+    }
+    block.className = class_name;
+    block.result = {
+      language: language,
+      kw: result.keyword_count,
+      re: result.relevance
+    };
+    if (result.second_best) {
+      block.second_best = {
+        language: result.second_best.language,
+        kw: result.second_best.keyword_count,
+        re: result.second_best.relevance
+      };
+    }
+  }
+
+  /*
+  Applies highlighting to all <pre><code>..</code></pre> blocks on a page.
+  */
+  function initHighlighting() {
+    if (initHighlighting.called)
+      return;
+    initHighlighting.called = true;
+    var pres = document.getElementsByTagName('pre');
+    for (var i = 0; i < pres.length; i++) {
+      var code = findCode(pres[i]);
+      if (code)
+        highlightBlock(code, hljs.tabReplace, false, hljs.lineNodes);
+    }
+  }
+
+  /*
+  Attaches highlighting to the page load event.
+  */
+  function initHighlightingOnLoad() {
+    if (window.addEventListener) {
+      window.addEventListener('DOMContentLoaded', initHighlighting, false);
+      window.addEventListener('load', initHighlighting, false);
+    } else if (window.attachEvent)
+      window.attachEvent('onload', initHighlighting);
+    else
+      window.onload = initHighlighting;
+  }
+
+  var languages = {}; // a shortcut to avoid writing "this." everywhere
+
+  /* Interface definition */
+
+  this.LANGUAGES = languages;
+  this.highlight = highlight;
+  this.highlightAuto = highlightAuto;
+  this.fixMarkup = fixMarkup;
+  this.highlightBlock = highlightBlock;
+  this.initHighlighting = initHighlighting;
+  this.initHighlightingOnLoad = initHighlightingOnLoad;
+
+  // Common regexps
+  this.IDENT_RE = '[a-zA-Z][a-zA-Z0-9_]*';
+  this.UNDERSCORE_IDENT_RE = '[a-zA-Z_][a-zA-Z0-9_]*';
+  this.NUMBER_RE = '\\b\\d+(\\.\\d+)?';
+  this.C_NUMBER_RE = '(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)'; // 0x..., 0..., decimal, float
+  this.BINARY_NUMBER_RE = '\\b(0b[01]+)'; // 0b...
+  this.RE_STARTERS_RE = '!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|\\.|-|-=|/|/=|:|;|<|<<|<<=|<=|=|==|===|>|>=|>>|>>=|>>>|>>>=|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~';
+
+  // Common modes
+  this.BACKSLASH_ESCAPE = {
+    begin: '\\\\[\\s\\S]', relevance: 0
+  };
+  this.APOS_STRING_MODE = {
+    className: 'string',
+    begin: '\'', end: '\'',
+    illegal: '\\n',
+    contains: [this.BACKSLASH_ESCAPE],
+    relevance: 0
+  };
+  this.QUOTE_STRING_MODE = {
+    className: 'string',
+    begin: '"', end: '"',
+    illegal: '\\n',
+    contains: [this.BACKSLASH_ESCAPE],
+    relevance: 0
+  };
+  this.C_LINE_COMMENT_MODE = {
+    className: 'comment',
+    begin: '//', end: '$'
+  };
+  this.C_BLOCK_COMMENT_MODE = {
+    className: 'comment',
+    begin: '/\\*', end: '\\*/'
+  };
+  this.HASH_COMMENT_MODE = {
+    className: 'comment',
+    begin: '#', end: '$'
+  };
+  this.NUMBER_MODE = {
+    className: 'number',
+    begin: this.NUMBER_RE,
+    relevance: 0
+  };
+  this.C_NUMBER_MODE = {
+    className: 'number',
+    begin: this.C_NUMBER_RE,
+    relevance: 0
+  };
+  this.BINARY_NUMBER_MODE = {
+    className: 'number',
+    begin: this.BINARY_NUMBER_RE,
+    relevance: 0
+  };
+
+  // Utility functions
+  this.inherit = function(parent, obj) {
+    var result = {}
+    for (var key in parent)
+      result[key] = parent[key];
+    if (obj)
+      for (var key in obj)
+        result[key] = obj[key];
+    return result;
+  }
+}();
+hljs.LANGUAGES['1c'] = function(hljs){
+  var IDENT_RE_RU = '[a-zA-Zа-яА-Я][a-zA-Z0-9_а-яА-Я]*';
+  var OneS_KEYWORDS = 'возврат дата для если и или иначе иначеесли исключение конецесли ' +
+    'конецпопытки конецпроцедуры конецфункции конеццикла константа не перейти перем ' +
+    'перечисление по пока попытка прервать продолжить процедура строка тогда фс функция цикл ' +
+    'число экспорт';
+  var OneS_BUILT_IN = 'ansitooem oemtoansi ввестивидсубконто ввестидату ввестизначение ' +
+    'ввестиперечисление ввестипериод ввестиплансчетов ввестистроку ввестичисло вопрос ' +
+    'восстановитьзначение врег выбранныйплансчетов вызватьисключение датагод датамесяц ' +
+    'датачисло добавитьмесяц завершитьработусистемы заголовоксистемы записьжурналарегистрации ' +
+    'запуститьприложение зафиксироватьтранзакцию значениевстроку значениевстрокувнутр ' +
+    'значениевфайл значениеизстроки значениеизстрокивнутр значениеизфайла имякомпьютера ' +
+    'имяпользователя каталогвременныхфайлов каталогиб каталогпользователя каталогпрограммы ' +
+    'кодсимв командасистемы конгода конецпериодаби конецрассчитанногопериодаби ' +
+    'конецстандартногоинтервала конквартала конмесяца коннедели лев лог лог10 макс ' +
+    'максимальноеколичествосубконто мин монопольныйрежим названиеинтерфейса названиенабораправ ' +
+    'назначитьвид назначитьсчет найти найтипомеченныенаудаление найтиссылки началопериодаби ' +
+    'началостандартногоинтервала начатьтранзакцию начгода начквартала начмесяца начнедели ' +
+    'номерднягода номерднянедели номернеделигода нрег обработкаожидания окр описаниеошибки ' +
+    'основнойжурналрасчетов основнойплансчетов основнойязык открытьформу открытьформумодально ' +
+    'отменитьтранзакцию очиститьокносообщений периодстр полноеимяпользователя получитьвремята ' +
+    'получитьдатута получитьдокументта получитьзначенияотбора получитьпозициюта ' +
+    'получитьпустоезначение получитьта прав праводоступа предупреждение префиксавтонумерации ' +
+    'пустаястрока пустоезначение рабочаядаттьпустоезначение рабочаядата разделительстраниц ' +
+    'разделительстрок разм разобратьпозициюдокумента рассчитатьрегистрына ' +
+    'рассчитатьрегистрыпо сигнал симв символтабуляции создатьобъект сокрл сокрлп сокрп ' +
+    'сообщить состояние сохранитьзначение сред статусвозврата стрдлина стрзаменить ' +
+    'стрколичествострок стрполучитьстроку  стрчисловхождений сформироватьпозициюдокумента ' +
+    'счетпокоду текущаядата текущеевремя типзначения типзначениястр удалитьобъекты ' +
+    'установитьтана установитьтапо фиксшаблон формат цел шаблон';
+  var DQUOTE =  {className: 'dquote',  begin: '""'};
+  var STR_START = {
+      className: 'string',
+      begin: '"', end: '"|$',
+      contains: [DQUOTE],
+      relevance: 0
+    };
+  var STR_CONT = {
+    className: 'string',
+    begin: '\\|', end: '"|$',
+    contains: [DQUOTE]
+  };
+
+  return {
+    case_insensitive: true,
+    lexems: IDENT_RE_RU,
+    keywords: {keyword: OneS_KEYWORDS, built_in: OneS_BUILT_IN},
+    contains: [
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.NUMBER_MODE,
+      STR_START, STR_CONT,
+      {
+        className: 'function',
+        begin: '(процедура|функция)', end: '$',
+        lexems: IDENT_RE_RU,
+        keywords: 'процедура функция',
+        contains: [
+          {className: 'title', begin: IDENT_RE_RU},
+          {
+            className: 'tail',
+            endsWithParent: true,
+            contains: [
+              {
+                className: 'params',
+                begin: '\\(', end: '\\)',
+                lexems: IDENT_RE_RU,
+                keywords: 'знач',
+                contains: [STR_START, STR_CONT]
+              },
+              {
+                className: 'export',
+                begin: 'экспорт', endsWithParent: true,
+                lexems: IDENT_RE_RU,
+                keywords: 'экспорт',
+                contains: [hljs.C_LINE_COMMENT_MODE]
+              }
+            ]
+          },
+          hljs.C_LINE_COMMENT_MODE
+        ]
+      },
+      {className: 'preprocessor', begin: '#', end: '$'},
+      {className: 'date', begin: '\'\\d{2}\\.\\d{2}\\.(\\d{2}|\\d{4})\''}
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['actionscript'] = function(hljs) {
+  var IDENT_RE = '[a-zA-Z_$][a-zA-Z0-9_$]*';
+  var IDENT_FUNC_RETURN_TYPE_RE = '([*]|[a-zA-Z_$][a-zA-Z0-9_$]*)';
+
+  var AS3_REST_ARG_MODE = {
+    className: 'rest_arg',
+    begin: '[.]{3}', end: IDENT_RE,
+    relevance: 10
+  };
+  var TITLE_MODE = {className: 'title', begin: IDENT_RE};
+
+  return {
+    keywords: {
+      keyword: 'as break case catch class const continue default delete do dynamic each ' +
+        'else extends final finally for function get if implements import in include ' +
+        'instanceof interface internal is namespace native new override package private ' +
+        'protected public return set static super switch this throw try typeof use var void ' +
+        'while with',
+      literal: 'true false null undefined'
+    },
+    contains: [
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.C_NUMBER_MODE,
+      {
+        className: 'package',
+        beginWithKeyword: true, end: '{',
+        keywords: 'package',
+        contains: [TITLE_MODE]
+      },
+      {
+        className: 'class',
+        beginWithKeyword: true, end: '{',
+        keywords: 'class interface',
+        contains: [
+          {
+            beginWithKeyword: true,
+            keywords: 'extends implements'
+          },
+          TITLE_MODE
+        ]
+      },
+      {
+        className: 'preprocessor',
+        beginWithKeyword: true, end: ';',
+        keywords: 'import include'
+      },
+      {
+        className: 'function',
+        beginWithKeyword: true, end: '[{;]',
+        keywords: 'function',
+        illegal: '\\S',
+        contains: [
+          TITLE_MODE,
+          {
+            className: 'params',
+            begin: '\\(', end: '\\)',
+            contains: [
+              hljs.APOS_STRING_MODE,
+              hljs.QUOTE_STRING_MODE,
+              hljs.C_LINE_COMMENT_MODE,
+              hljs.C_BLOCK_COMMENT_MODE,
+              AS3_REST_ARG_MODE
+            ]
+          },
+          {
+            className: 'type',
+            begin: ':',
+            end: IDENT_FUNC_RETURN_TYPE_RE,
+            relevance: 10
+          }
+        ]
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['apache'] = function(hljs) {
+  var NUMBER = {className: 'number', begin: '[\\$%]\\d+'};
+  return {
+    case_insensitive: true,
+    keywords: {
+      keyword: 'acceptfilter acceptmutex acceptpathinfo accessfilename action addalt ' +
+        'addaltbyencoding addaltbytype addcharset adddefaultcharset adddescription ' +
+        'addencoding addhandler addicon addiconbyencoding addiconbytype addinputfilter ' +
+        'addlanguage addmoduleinfo addoutputfilter addoutputfilterbytype addtype alias ' +
+        'aliasmatch allow allowconnect allowencodedslashes allowoverride anonymous ' +
+        'anonymous_logemail anonymous_mustgiveemail anonymous_nouserid anonymous_verifyemail ' +
+        'authbasicauthoritative authbasicprovider authdbduserpwquery authdbduserrealmquery ' +
+        'authdbmgroupfile authdbmtype authdbmuserfile authdefaultauthoritative ' +
+        'authdigestalgorithm authdigestdomain authdigestnccheck authdigestnonceformat ' +
+        'authdigestnoncelifetime authdigestprovider authdigestqop authdigestshmemsize ' +
+        'authgroupfile authldapbinddn authldapbindpassword authldapcharsetconfig ' +
+        'authldapcomparednonserver authldapdereferencealiases authldapgroupattribute ' +
+        'authldapgroupattributeisdn authldapremoteuserattribute authldapremoteuserisdn ' +
+        'authldapurl authname authnprovideralias authtype authuserfile authzdbmauthoritative ' +
+        'authzdbmtype authzdefaultauthoritative authzgroupfileauthoritative ' +
+        'authzldapauthoritative authzownerauthoritative authzuserauthoritative ' +
+        'balancermember browsermatch browsermatchnocase bufferedlogs cachedefaultexpire ' +
+        'cachedirlength cachedirlevels cachedisable cacheenable cachefile ' +
+        'cacheignorecachecontrol cacheignoreheaders cacheignorenolastmod ' +
+        'cacheignorequerystring cachelastmodifiedfactor cachemaxexpire cachemaxfilesize ' +
+        'cacheminfilesize cachenegotiateddocs cacheroot cachestorenostore cachestoreprivate ' +
+        'cgimapextension charsetdefault charsetoptions charsetsourceenc checkcaseonly ' +
+        'checkspelling chrootdir contentdigest cookiedomain cookieexpires cookielog ' +
+        'cookiename cookiestyle cookietracking coredumpdirectory customlog dav ' +
+        'davdepthinfinity davgenericlockdb davlockdb davmintimeout dbdexptime dbdkeep ' +
+        'dbdmax dbdmin dbdparams dbdpersist dbdpreparesql dbdriver defaulticon ' +
+        'defaultlanguage defaulttype deflatebuffersize deflatecompressionlevel ' +
+        'deflatefilternote deflatememlevel deflatewindowsize deny directoryindex ' +
+        'directorymatch directoryslash documentroot dumpioinput dumpiologlevel dumpiooutput ' +
+        'enableexceptionhook enablemmap enablesendfile errordocument errorlog example ' +
+        'expiresactive expiresbytype expiresdefault extendedstatus extfilterdefine ' +
+        'extfilteroptions fileetag filterchain filterdeclare filterprotocol filterprovider ' +
+        'filtertrace forcelanguagepriority forcetype forensiclog gracefulshutdowntimeout ' +
+        'group header headername hostnamelookups identitycheck identitychecktimeout ' +
+        'imapbase imapdefault imapmenu include indexheadinsert indexignore indexoptions ' +
+        'indexorderdefault indexstylesheet isapiappendlogtoerrors isapiappendlogtoquery ' +
+        'isapicachefile isapifakeasync isapilognotsupported isapireadaheadbuffer keepalive ' +
+        'keepalivetimeout languagepriority ldapcacheentries ldapcachettl ' +
+        'ldapconnectiontimeout ldapopcacheentries ldapopcachettl ldapsharedcachefile ' +
+        'ldapsharedcachesize ldaptrustedclientcert ldaptrustedglobalcert ldaptrustedmode ' +
+        'ldapverifyservercert limitinternalrecursion limitrequestbody limitrequestfields ' +
+        'limitrequestfieldsize limitrequestline limitxmlrequestbody listen listenbacklog ' +
+        'loadfile loadmodule lockfile logformat loglevel maxclients maxkeepaliverequests ' +
+        'maxmemfree maxrequestsperchild maxrequestsperthread maxspareservers maxsparethreads ' +
+        'maxthreads mcachemaxobjectcount mcachemaxobjectsize mcachemaxstreamingbuffer ' +
+        'mcacheminobjectsize mcacheremovalalgorithm mcachesize metadir metafiles metasuffix ' +
+        'mimemagicfile minspareservers minsparethreads mmapfile mod_gzip_on ' +
+        'mod_gzip_add_header_count mod_gzip_keep_workfiles mod_gzip_dechunk ' +
+        'mod_gzip_min_http mod_gzip_minimum_file_size mod_gzip_maximum_file_size ' +
+        'mod_gzip_maximum_inmem_size mod_gzip_temp_dir mod_gzip_item_include ' +
+        'mod_gzip_item_exclude mod_gzip_command_version mod_gzip_can_negotiate ' +
+        'mod_gzip_handle_methods mod_gzip_static_suffix mod_gzip_send_vary ' +
+        'mod_gzip_update_static modmimeusepathinfo multiviewsmatch namevirtualhost noproxy ' +
+        'nwssltrustedcerts nwsslupgradeable options order passenv pidfile protocolecho ' +
+        'proxybadheader proxyblock proxydomain proxyerroroverride proxyftpdircharset ' +
+        'proxyiobuffersize proxymaxforwards proxypass proxypassinterpolateenv ' +
+        'proxypassmatch proxypassreverse proxypassreversecookiedomain ' +
+        'proxypassreversecookiepath proxypreservehost proxyreceivebuffersize proxyremote ' +
+        'proxyremotematch proxyrequests proxyset proxystatus proxytimeout proxyvia ' +
+        'readmename receivebuffersize redirect redirectmatch redirectpermanent ' +
+        'redirecttemp removecharset removeencoding removehandler removeinputfilter ' +
+        'removelanguage removeoutputfilter removetype requestheader require rewritebase ' +
+        'rewritecond rewriteengine rewritelock rewritelog rewriteloglevel rewritemap ' +
+        'rewriteoptions rewriterule rlimitcpu rlimitmem rlimitnproc satisfy scoreboardfile ' +
+        'script scriptalias scriptaliasmatch scriptinterpretersource scriptlog ' +
+        'scriptlogbuffer scriptloglength scriptsock securelisten seerequesttail ' +
+        'sendbuffersize serveradmin serveralias serverlimit servername serverpath ' +
+        'serverroot serversignature servertokens setenv setenvif setenvifnocase sethandler ' +
+        'setinputfilter setoutputfilter ssienableaccess ssiendtag ssierrormsg ssistarttag ' +
+        'ssitimeformat ssiundefinedecho sslcacertificatefile sslcacertificatepath ' +
+        'sslcadnrequestfile sslcadnrequestpath sslcarevocationfile sslcarevocationpath ' +
+        'sslcertificatechainfile sslcertificatefile sslcertificatekeyfile sslciphersuite ' +
+        'sslcryptodevice sslengine sslhonorciperorder sslmutex ssloptions ' +
+        'sslpassphrasedialog sslprotocol sslproxycacertificatefile ' +
+        'sslproxycacertificatepath sslproxycarevocationfile sslproxycarevocationpath ' +
+        'sslproxyciphersuite sslproxyengine sslproxymachinecertificatefile ' +
+        'sslproxymachinecertificatepath sslproxyprotocol sslproxyverify ' +
+        'sslproxyverifydepth sslrandomseed sslrequire sslrequiressl sslsessioncache ' +
+        'sslsessioncachetimeout sslusername sslverifyclient sslverifydepth startservers ' +
+        'startthreads substitute suexecusergroup threadlimit threadsperchild ' +
+        'threadstacksize timeout traceenable transferlog typesconfig unsetenv ' +
+        'usecanonicalname usecanonicalphysicalport user userdir virtualdocumentroot ' +
+        'virtualdocumentrootip virtualscriptalias virtualscriptaliasip ' +
+        'win32disableacceptex xbithack',
+      literal: 'on off'
+    },
+    contains: [
+      hljs.HASH_COMMENT_MODE,
+      {
+        className: 'sqbracket',
+        begin: '\\s\\[', end: '\\]$'
+      },
+      {
+        className: 'cbracket',
+        begin: '[\\$%]\\{', end: '\\}',
+        contains: ['self', NUMBER]
+      },
+      NUMBER,
+      {className: 'tag', begin: '</?', end: '>'},
+      hljs.QUOTE_STRING_MODE
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['avrasm'] = function(hljs) {
+  return {
+    case_insensitive: true,
+    keywords: {
+      keyword:
+        /* mnemonic */
+        'adc add adiw and andi asr bclr bld brbc brbs brcc brcs break breq brge brhc brhs ' +
+        'brid brie brlo brlt brmi brne brpl brsh brtc brts brvc brvs bset bst call cbi cbr ' +
+        'clc clh cli cln clr cls clt clv clz com cp cpc cpi cpse dec eicall eijmp elpm eor ' +
+        'fmul fmuls fmulsu icall ijmp in inc jmp ld ldd ldi lds lpm lsl lsr mov movw mul ' +
+        'muls mulsu neg nop or ori out pop push rcall ret reti rjmp rol ror sbc sbr sbrc sbrs ' +
+        'sec seh sbi sbci sbic sbis sbiw sei sen ser ses set sev sez sleep spm st std sts sub ' +
+        'subi swap tst wdr',
+      built_in:
+        /* general purpose registers */
+        'r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 r16 r17 r18 r19 r20 r21 r22 ' +
+        'r23 r24 r25 r26 r27 r28 r29 r30 r31 x|0 xh xl y|0 yh yl z|0 zh zl ' +
+        /* IO Registers (ATMega128) */
+        'ucsr1c udr1 ucsr1a ucsr1b ubrr1l ubrr1h ucsr0c ubrr0h tccr3c tccr3a tccr3b tcnt3h ' +
+        'tcnt3l ocr3ah ocr3al ocr3bh ocr3bl ocr3ch ocr3cl icr3h icr3l etimsk etifr tccr1c ' +
+        'ocr1ch ocr1cl twcr twdr twar twsr twbr osccal xmcra xmcrb eicra spmcsr spmcr portg ' +
+        'ddrg ping portf ddrf sreg sph spl xdiv rampz eicrb eimsk gimsk gicr eifr gifr timsk ' +
+        'tifr mcucr mcucsr tccr0 tcnt0 ocr0 assr tccr1a tccr1b tcnt1h tcnt1l ocr1ah ocr1al ' +
+        'ocr1bh ocr1bl icr1h icr1l tccr2 tcnt2 ocr2 ocdr wdtcr sfior eearh eearl eedr eecr ' +
+        'porta ddra pina portb ddrb pinb portc ddrc pinc portd ddrd pind spdr spsr spcr udr0 ' +
+        'ucsr0a ucsr0b ubrr0l acsr admux adcsr adch adcl porte ddre pine pinf'
+    },
+    contains: [
+      hljs.C_BLOCK_COMMENT_MODE,
+      {className: 'comment', begin: ';',  end: '$'},
+      hljs.C_NUMBER_MODE, // 0x..., decimal, float
+      hljs.BINARY_NUMBER_MODE, // 0b...
+      {
+        className: 'number',
+        begin: '\\b(\\$[a-zA-Z0-9]+|0o[0-7]+)' // $..., 0o...
+      },
+      hljs.QUOTE_STRING_MODE,
+      {
+        className: 'string',
+        begin: '\'', end: '[^\\\\]\'',
+        illegal: '[^\\\\][^\']'
+      },
+      {className: 'label',  begin: '^[A-Za-z0-9_.$]+:'},
+      {className: 'preprocessor', begin: '#', end: '$'},
+      {  // директивы «.include» «.macro» и т.д.
+        className: 'preprocessor',
+        begin: '\\.[a-zA-Z]+'
+      },
+      {  // подстановка в «.macro»
+        className: 'localvars',
+        begin: '@[0-9]+'
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['axapta'] = function(hljs) {
+  return {
+    keywords: 'false int abstract private char interface boolean static null if for true ' +
+      'while long throw finally protected extends final implements return void enum else ' +
+      'break new catch byte super class case short default double public try this switch ' +
+      'continue reverse firstfast firstonly forupdate nofetch sum avg minof maxof count ' +
+      'order group by asc desc index hint like dispaly edit client server ttsbegin ' +
+      'ttscommit str real date container anytype common div mod',
+    contains: [
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.C_NUMBER_MODE,
+      {
+        className: 'preprocessor',
+        begin: '#', end: '$'
+      },
+      {
+        className: 'class',
+        beginWithKeyword: true, end: '{',
+        illegal: ':',
+        keywords: 'class interface',
+        contains: [
+          {
+            className: 'inheritance',
+            beginWithKeyword: true,
+            keywords: 'extends implements',
+            relevance: 10
+          },
+          {
+            className: 'title',
+            begin: hljs.UNDERSCORE_IDENT_RE
+          }
+        ]
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['bash'] = function(hljs) {
+  var BASH_LITERAL = 'true false';
+  var VAR1 = {
+    className: 'variable', begin: '\\$[a-zA-Z0-9_]+\\b'
+  };
+  var VAR2 = {
+    className: 'variable', begin: '\\${([^}]|\\\\})+}'
+  };
+  var QUOTE_STRING = {
+    className: 'string',
+    begin: '"', end: '"',
+    illegal: '\\n',
+    contains: [hljs.BACKSLASH_ESCAPE, VAR1, VAR2],
+    relevance: 0
+  };
+  var APOS_STRING = {
+    className: 'string',
+    begin: '\'', end: '\'',
+    contains: [{begin: '\'\''}],
+    relevance: 0
+  };
+  var TEST_CONDITION = {
+    className: 'test_condition',
+    begin: '', end: '',
+    contains: [QUOTE_STRING, APOS_STRING, VAR1, VAR2],
+    keywords: {
+      literal: BASH_LITERAL
+    },
+    relevance: 0
+  };
+
+  return {
+    keywords: {
+      keyword: 'if then else fi for break continue while in do done echo exit return set declare',
+      literal: BASH_LITERAL
+    },
+    contains: [
+      {
+        className: 'shebang',
+        begin: '(#!\\/bin\\/bash)|(#!\\/bin\\/sh)',
+        relevance: 10
+      },
+      VAR1,
+      VAR2,
+      hljs.HASH_COMMENT_MODE,
+      QUOTE_STRING,
+      APOS_STRING,
+      hljs.inherit(TEST_CONDITION, {begin: '\\[ ', end: ' \\]', relevance: 0}),
+      hljs.inherit(TEST_CONDITION, {begin: '\\[\\[ ', end: ' \\]\\]'})
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['clojure'] = function(hljs) {
+  var keywords = {
+    built_in:
+      // Clojure keywords
+      'def cond apply if-not if-let if not not= = &lt; < > &lt;= <= >= == + / * - rem '+
+      'quot neg? pos? delay? symbol? keyword? true? false? integer? empty? coll? list? '+
+      'set? ifn? fn? associative? sequential? sorted? counted? reversible? number? decimal? '+
+      'class? distinct? isa? float? rational? reduced? ratio? odd? even? char? seq? vector? '+
+      'string? map? nil? contains? zero? instance? not-every? not-any? libspec? -> ->> .. . '+
+      'inc compare do dotimes mapcat take remove take-while drop letfn drop-last take-last '+
+      'drop-while while intern condp case reduced cycle split-at split-with repeat replicate '+
+      'iterate range merge zipmap declare line-seq sort comparator sort-by dorun doall nthnext '+
+      'nthrest partition eval doseq await await-for let agent atom send send-off release-pending-sends '+
+      'add-watch mapv filterv remove-watch agent-error restart-agent set-error-handler error-handler '+
+      'set-error-mode! error-mode shutdown-agents quote var fn loop recur throw try monitor-enter '+
+      'monitor-exit defmacro defn defn- macroexpand macroexpand-1 for doseq dosync dotimes and or '+
+      'when when-not when-let comp juxt partial sequence memoize constantly complement identity assert '+
+      'peek pop doto proxy defstruct first rest cons defprotocol cast coll deftype defrecord last butlast '+
+      'sigs reify second ffirst fnext nfirst nnext defmulti defmethod meta with-meta ns in-ns create-ns import '+
+      'intern refer keys select-keys vals key val rseq name namespace promise into transient persistent! conj! '+
+      'assoc! dissoc! pop! disj! import use class type num float double short byte boolean bigint biginteger '+
+      'bigdec print-method print-dup throw-if throw printf format load compile get-in update-in pr pr-on newline '+
+      'flush read slurp read-line subvec with-open memfn time ns assert re-find re-groups rand-int rand mod locking '+
+      'assert-valid-fdecl alias namespace resolve ref deref refset swap! reset! set-validator! compare-and-set! alter-meta! '+
+      'reset-meta! commute get-validator alter ref-set ref-history-count ref-min-history ref-max-history ensure sync io! '+
+      'new next conj set! memfn to-array future future-call into-array aset gen-class reduce merge map filter find empty '+
+      'hash-map hash-set sorted-map sorted-map-by sorted-set sorted-set-by vec vector seq flatten reverse assoc dissoc list '+
+      'disj get union difference intersection extend extend-type extend-protocol int nth delay count concat chunk chunk-buffer '+
+      'chunk-append chunk-first chunk-rest max min dec unchecked-inc-int unchecked-inc unchecked-dec-inc unchecked-dec unchecked-negate '+
+      'unchecked-add-int unchecked-add unchecked-subtract-int unchecked-subtract chunk-next chunk-cons chunked-seq? prn vary-meta '+
+      'lazy-seq spread list* str find-keyword keyword symbol gensym force rationalize'
+   };
+
+  var CLJ_IDENT_RE = '[a-zA-Z_0-9\\!\\.\\?\\-\\+\\*\\/\\<\\=\\>\\&\\#\\$\';]+';
+  var SIMPLE_NUMBER_RE = '[\\s:\\(\\{]+\\d+(\\.\\d+)?';
+
+  var NUMBER = {
+    className: 'number', begin: SIMPLE_NUMBER_RE,
+    relevance: 0
+  };
+  var STRING = {
+    className: 'string',
+    begin: '"', end: '"',
+    contains: [hljs.BACKSLASH_ESCAPE],
+    relevance: 0
+  };
+  var COMMENT = {
+    className: 'comment',
+    begin: ';', end: '$',
+    relevance: 0
+  };
+  var COLLECTION = {
+    className: 'collection',
+    begin: '[\\[\\{]', end: '[\\]\\}]'
+  };
+  var HINT = {
+    className: 'comment',
+    begin: '\\^' + CLJ_IDENT_RE
+  };
+  var HINT_COL = {
+    className: 'comment',
+    begin: '\\^\\{', end: '\\}'
+  };
+  var KEY = {
+    className: 'attribute',
+    begin: '[:]' + CLJ_IDENT_RE
+  };
+  var LIST = {
+    className: 'list',
+    begin: '\\(', end: '\\)',
+    relevance: 0
+  };
+  var BODY = {
+    endsWithParent: true, excludeEnd: true,
+    keywords: {literal: 'true false nil'},
+    relevance: 0
+  };
+  var TITLE = {
+    keywords: keywords,
+    lexems: CLJ_IDENT_RE,
+    className: 'title', begin: CLJ_IDENT_RE,
+    starts: BODY
+  };
+
+  LIST.contains = [{className: 'comment', begin: 'comment'}, TITLE];
+  BODY.contains = [LIST, STRING, HINT, HINT_COL, COMMENT, KEY, COLLECTION, NUMBER];
+  COLLECTION.contains = [LIST, STRING, HINT, COMMENT, KEY, COLLECTION, NUMBER];
+
+  return {
+    case_insensitive: true,
+    illegal: '\\S',
+    contains: [
+      COMMENT,
+      LIST
+    ]
+  }
+}(hljs);
+hljs.LANGUAGES['cmake'] = function(hljs) {
+  return {
+    case_insensitive: true,
+    keywords: 'add_custom_command add_custom_target add_definitions add_dependencies ' +
+      'add_executable add_library add_subdirectory add_test aux_source_directory ' +
+      'break build_command cmake_minimum_required cmake_policy configure_file ' +
+      'create_test_sourcelist define_property else elseif enable_language enable_testing ' +
+      'endforeach endfunction endif endmacro endwhile execute_process export find_file ' +
+      'find_library find_package find_path find_program fltk_wrap_ui foreach function ' +
+      'get_cmake_property get_directory_property get_filename_component get_property ' +
+      'get_source_file_property get_target_property get_test_property if include ' +
+      'include_directories include_external_msproject include_regular_expression install ' +
+      'link_directories load_cache load_command macro mark_as_advanced message option ' +
+      'output_required_files project qt_wrap_cpp qt_wrap_ui remove_definitions return ' +
+      'separate_arguments set set_directory_properties set_property ' +
+      'set_source_files_properties set_target_properties set_tests_properties site_name ' +
+      'source_group string target_link_libraries try_compile try_run unset variable_watch ' +
+      'while build_name exec_program export_library_dependencies install_files ' +
+      'install_programs install_targets link_libraries make_directory remove subdir_depends ' +
+      'subdirs use_mangled_mesa utility_source variable_requires write_file',
+    contains: [
+      {
+        className: 'envvar',
+        begin: '\\${', end: '}'
+      },
+      hljs.HASH_COMMENT_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.NUMBER_MODE
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['coffeescript'] = function(hljs) {
+  var keywords = {
+    keyword:
+      // JS keywords
+      'in if for while finally new do return else break catch instanceof throw try this ' +
+      'switch continue typeof delete debugger class extends super' +
+      // Coffee keywords
+      'then unless until loop of by when and or is isnt not',
+    literal:
+      // JS literals
+      'true false null undefined ' +
+      // Coffee literals
+      'yes no on off ',
+    reserved: 'case default function var void with const let enum export import native ' +
+      '__hasProp __extends __slice __bind __indexOf'
+  };
+
+  var JS_IDENT_RE = '[A-Za-z$_][0-9A-Za-z$_]*';
+
+  var COFFEE_QUOTE_STRING_SUBST_MODE = {
+    className: 'subst',
+    begin: '#\\{', end: '}',
+    keywords: keywords,
+    contains: [hljs.C_NUMBER_MODE, hljs.BINARY_NUMBER_MODE]
+  };
+
+  var COFFEE_QUOTE_STRING_MODE = {
+    className: 'string',
+    begin: '"', end: '"',
+    relevance: 0,
+    contains: [hljs.BACKSLASH_ESCAPE, COFFEE_QUOTE_STRING_SUBST_MODE]
+  };
+
+  var COFFEE_HEREDOC_MODE = {
+    className: 'string',
+    begin: '"""', end: '"""',
+    contains: [hljs.BACKSLASH_ESCAPE, COFFEE_QUOTE_STRING_SUBST_MODE]
+  };
+
+  var COFFEE_HERECOMMENT_MODE = {
+    className: 'comment',
+    begin: '###', end: '###'
+  };
+
+  var COFFEE_HEREGEX_MODE = {
+    className: 'regexp',
+    begin: '///', end: '///',
+    contains: [hljs.HASH_COMMENT_MODE]
+  };
+
+  var COFFEE_EMPTY_REGEX_MODE = {
+    className: 'regexp', begin: '//[gim]*'
+  };
+
+  var COFFEE_REGEX_MODE = {
+    className: 'regexp',
+    begin: '/\\S(\\\\.|[^\\n])*/[gim]*' // \S is required to parse x / 2 / 3 as two divisions
+  };
+
+  var COFFEE_FUNCTION_DECLARATION_MODE = {
+    className: 'function',
+    begin: JS_IDENT_RE + '\\s*=\\s*(\\(.+\\))?\\s*[-=]>',
+    returnBegin: true,
+    contains: [
+      {
+        className: 'title',
+        begin: JS_IDENT_RE
+      },
+      {
+        className: 'params',
+        begin: '\\(', end: '\\)'
+      }
+    ]
+  };
+
+  var COFFEE_EMBEDDED_JAVASCRIPT = {
+    begin: '`', end: '`',
+    excludeBegin: true, excludeEnd: true,
+    subLanguage: 'javascript'
+  };
+
+  return {
+    keywords: keywords,
+    contains: [
+      // Numbers
+      hljs.C_NUMBER_MODE,
+      hljs.BINARY_NUMBER_MODE,
+      // Strings
+      hljs.APOS_STRING_MODE,
+      COFFEE_HEREDOC_MODE, // Should be before COFFEE_QUOTE_STRING_MODE for greater priority
+      COFFEE_QUOTE_STRING_MODE,
+      // Comments
+      COFFEE_HERECOMMENT_MODE, // Should be before hljs.HASH_COMMENT_MODE for greater priority
+      hljs.HASH_COMMENT_MODE,
+      // CoffeeScript specific modes
+      COFFEE_HEREGEX_MODE,
+      COFFEE_EMPTY_REGEX_MODE,
+      COFFEE_REGEX_MODE,
+      COFFEE_EMBEDDED_JAVASCRIPT,
+      COFFEE_FUNCTION_DECLARATION_MODE
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['cpp'] = function(hljs) {
+  var CPP_KEYWORDS = {
+    keyword: 'false int float while private char catch export virtual operator sizeof ' +
+      'dynamic_cast|10 typedef const_cast|10 const struct for static_cast|10 union namespace ' +
+      'unsigned long throw volatile static protected bool template mutable if public friend ' +
+      'do return goto auto void enum else break new extern using true class asm case typeid ' +
+      'short reinterpret_cast|10 default double register explicit signed typename try this ' +
+      'switch continue wchar_t inline delete alignof char16_t char32_t constexpr decltype ' +
+      'noexcept nullptr static_assert thread_local restrict _Bool complex',
+    built_in: 'std string cin cout cerr clog stringstream istringstream ostringstream ' +
+      'auto_ptr deque list queue stack vector map set bitset multiset multimap unordered_set ' +
+      'unordered_map unordered_multiset unordered_multimap array shared_ptr'
+  };
+  return {
+    keywords: CPP_KEYWORDS,
+    illegal: '</',
+    contains: [
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.QUOTE_STRING_MODE,
+      {
+        className: 'string',
+        begin: '\'\\\\?.', end: '\'',
+        illegal: '.'
+      },
+      {
+        className: 'number',
+        begin: '\\b(\\d+(\\.\\d*)?|\\.\\d+)(u|U|l|L|ul|UL|f|F)'
+      },
+      hljs.C_NUMBER_MODE,
+      {
+        className: 'preprocessor',
+        begin: '#', end: '$'
+      },
+      {
+        className: 'stl_container',
+        begin: '\\b(deque|list|queue|stack|vector|map|set|bitset|multiset|multimap|unordered_map|unordered_set|unordered_multiset|unordered_multimap|array)\\s*<', end: '>',
+        keywords: CPP_KEYWORDS,
+        relevance: 10,
+        contains: ['self']
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['cs'] = function(hljs) {
+  return {
+    keywords:
+      // Normal keywords.
+      'abstract as base bool break byte case catch char checked class const continue decimal ' +
+      'default delegate do double else enum event explicit extern false finally fixed float ' +
+      'for foreach goto if implicit in int interface internal is lock long namespace new null ' +
+      'object operator out override params private protected public readonly ref return sbyte ' +
+      'sealed short sizeof stackalloc static string struct switch this throw true try typeof ' +
+      'uint ulong unchecked unsafe ushort using virtual volatile void while ' +
+      // Contextual keywords.
+      'ascending descending from get group into join let orderby partial select set value var '+
+      'where yield',
+    contains: [
+      {
+        className: 'comment',
+        begin: '///', end: '$', returnBegin: true,
+        contains: [
+          {
+            className: 'xmlDocTag',
+            begin: '///|<!--|-->'
+          },
+          {
+            className: 'xmlDocTag',
+            begin: '</?', end: '>'
+          }
+        ]
+      },
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      {
+        className: 'preprocessor',
+        begin: '#', end: '$',
+        keywords: 'if else elif endif define undef warning error line region endregion pragma checksum'
+      },
+      {
+        className: 'string',
+        begin: '@"', end: '"',
+        contains: [{begin: '""'}]
+      },
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.C_NUMBER_MODE
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['css'] = function(hljs) {
+  var FUNCTION = {
+    className: 'function',
+    begin: hljs.IDENT_RE + '\\(', end: '\\)',
+    contains: [hljs.NUMBER_MODE, hljs.APOS_STRING_MODE, hljs.QUOTE_STRING_MODE]
+  };
+  return {
+    case_insensitive: true,
+    illegal: '[=/|\']',
+    contains: [
+      hljs.C_BLOCK_COMMENT_MODE,
+      {
+        className: 'id', begin: '\\#[A-Za-z0-9_-]+'
+      },
+      {
+        className: 'class', begin: '\\.[A-Za-z0-9_-]+',
+        relevance: 0
+      },
+      {
+        className: 'attr_selector',
+        begin: '\\[', end: '\\]',
+        illegal: '$'
+      },
+      {
+        className: 'pseudo',
+        begin: ':(:)?[a-zA-Z0-9\\_\\-\\+\\(\\)\\"\\\']+'
+      },
+      {
+        className: 'at_rule',
+        begin: '@(font-face|page)',
+        lexems: '[a-z-]+',
+        keywords: 'font-face page'
+      },
+      {
+        className: 'at_rule',
+        begin: '@', end: '[{;]', // at_rule eating first "{" is a good thing
+                                 // because it doesn’t let it to be parsed as
+                                 // a rule set but instead drops parser into
+                                 // the default mode which is how it should be.
+        excludeEnd: true,
+        keywords: 'import page media charset',
+        contains: [
+          FUNCTION,
+          hljs.APOS_STRING_MODE, hljs.QUOTE_STRING_MODE,
+          hljs.NUMBER_MODE
+        ]
+      },
+      {
+        className: 'tag', begin: hljs.IDENT_RE,
+        relevance: 0
+      },
+      {
+        className: 'rules',
+        begin: '{', end: '}',
+        illegal: '[^\\s]',
+        relevance: 0,
+        contains: [
+          hljs.C_BLOCK_COMMENT_MODE,
+          {
+            className: 'rule',
+            begin: '[^\\s]', returnBegin: true, end: ';', endsWithParent: true,
+            contains: [
+              {
+                className: 'attribute',
+                begin: '[A-Z\\_\\.\\-]+', end: ':',
+                excludeEnd: true,
+                illegal: '[^\\s]',
+                starts: {
+                  className: 'value',
+                  endsWithParent: true, excludeEnd: true,
+                  contains: [
+                    FUNCTION,
+                    hljs.NUMBER_MODE,
+                    hljs.QUOTE_STRING_MODE,
+                    hljs.APOS_STRING_MODE,
+                    hljs.C_BLOCK_COMMENT_MODE,
+                    {
+                      className: 'hexcolor', begin: '\\#[0-9A-F]+'
+                    },
+                    {
+                      className: 'important', begin: '!important'
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['d'] = /**
+ * Known issues:
+ *
+ * - invalid hex string literals will be recognized as a double quoted strings
+ *   but 'x' at the beginning of string will not be matched
+ *
+ * - delimited string literals are not checked for matching end delimiter
+ *   (not possible to do with js regexp)
+ *
+ * - content of token string is colored as a string (i.e. no keyword coloring inside a token string)
+ *   also, content of token string is not validated to contain only valid D tokens
+ *
+ * - special token sequence rule is not strictly following D grammar (anything following #line
+ *   up to the end of line is matched as special token sequence)
+ */
+
+function(hljs) {
+
+	/**
+	 * Language keywords
+	 *
+	 * @type {Object}
+	 */
+	var D_KEYWORDS = {
+		keyword:
+			'abstract alias align asm assert auto body break byte case cast catch class ' +
+			'const continue debug default delete deprecated do else enum export extern final ' +
+			'finally for foreach foreach_reverse|10 goto if immutable import in inout int ' +
+			'interface invariant is lazy macro mixin module new nothrow out override package ' +
+			'pragma private protected public pure ref return scope shared static struct ' +
+			'super switch synchronized template this throw try typedef typeid typeof union ' +
+			'unittest version void volatile while with __FILE__ __LINE__ __gshared|10 ' +
+			'__thread __traits __DATE__ __EOF__ __TIME__ __TIMESTAMP__ __VENDOR__ __VERSION__',
+		built_in:
+			'bool cdouble cent cfloat char creal dchar delegate double dstring float function ' +
+			'idouble ifloat ireal long real short string ubyte ucent uint ulong ushort wchar ' +
+			'wstring',
+		literal:
+			'false null true'
+	};
+
+	/**
+	 * Number literal regexps
+	 *
+	 * @type {String}
+	 */
+	var decimal_integer_re = '(0|[1-9][\\d_]*)',
+		decimal_integer_nosus_re = '(0|[1-9][\\d_]*|\\d[\\d_]*|[\\d_]+?\\d)',
+		binary_integer_re = '0[bB][01_]+',
+		hexadecimal_digits_re = '([\\da-fA-F][\\da-fA-F_]*|_[\\da-fA-F][\\da-fA-F_]*)',
+		hexadecimal_integer_re = '0[xX]' + hexadecimal_digits_re,
+
+		decimal_exponent_re = '([eE][+-]?' + decimal_integer_nosus_re + ')',
+		decimal_float_re = '(' + decimal_integer_nosus_re + '(\\.\\d*|' + decimal_exponent_re + ')|' +
+								'\\d+\\.' + decimal_integer_nosus_re + decimal_integer_nosus_re + '|' +
+								'\\.' + decimal_integer_re + decimal_exponent_re + '?' +
+							')',
+		hexadecimal_float_re = '(0[xX](' +
+									hexadecimal_digits_re + '\\.' + hexadecimal_digits_re + '|'+
+									'\\.?' + hexadecimal_digits_re +
+							   ')[pP][+-]?' + decimal_integer_nosus_re + ')';
+
+		integer_re = '(' +
+			decimal_integer_re + '|' +
+			binary_integer_re  + '|' +
+		 	hexadecimal_integer_re   +
+		')',
+
+		float_re = '(' +
+			hexadecimal_float_re + '|' +
+			decimal_float_re  +
+		')';
+
+	/**
+	 * Escape sequence supported in D string and character literals
+	 *
+	 * @type {String}
+	 */
+	var escape_sequence_re = '\\\\(' +
+							'[\'"\\?\\\\abfnrtv]|' +	// common escapes
+							'u[\\dA-Fa-f]{4}|' + 		// four hex digit unicode codepoint
+							'[0-7]{1,3}|' + 			// one to three octal digit ascii char code
+							'x[\\dA-Fa-f]{2}|' +		// two hex digit ascii char code
+							'U[\\dA-Fa-f]{8}' +			// eight hex digit unicode codepoint
+						  ')|' +
+						  '&[a-zA-Z\\d]{2,};';			// named character entity
+
+
+	/**
+	 * D integer number literals
+	 *
+	 * @type {Object}
+	 */
+	var D_INTEGER_MODE = {
+		className: 'number',
+    	begin: '\\b' + integer_re + '(L|u|U|Lu|LU|uL|UL)?',
+    	relevance: 0
+	};
+
+	/**
+	 * [D_FLOAT_MODE description]
+	 * @type {Object}
+	 */
+	var D_FLOAT_MODE = {
+		className: 'number',
+		begin: '\\b(' +
+				float_re + '([fF]|L|i|[fF]i|Li)?|' +
+				integer_re + '(i|[fF]i|Li)' +
+			')',
+		relevance: 0
+	};
+
+	/**
+	 * D character literal
+	 *
+	 * @type {Object}
+	 */
+	var D_CHARACTER_MODE = {
+		className: 'string',
+		begin: '\'(' + escape_sequence_re + '|.)', end: '\'',
+		illegal: '.'
+	};
+
+	/**
+	 * D string escape sequence
+	 *
+	 * @type {Object}
+	 */
+	var D_ESCAPE_SEQUENCE = {
+		begin: escape_sequence_re,
+		relevance: 0
+	}
+
+	/**
+	 * D double quoted string literal
+	 *
+	 * @type {Object}
+	 */
+	var D_STRING_MODE = {
+		className: 'string',
+		begin: '"',
+		contains: [D_ESCAPE_SEQUENCE],
+		end: '"[cwd]?',
+		relevance: 0
+	};
+
+	/**
+	 * D wysiwyg and delimited string literals
+	 *
+	 * @type {Object}
+	 */
+	var D_WYSIWYG_DELIMITED_STRING_MODE = {
+		className: 'string',
+		begin: '[rq]"',
+		end: '"[cwd]?',
+		relevance: 5
+	};
+
+	/**
+	 * D alternate wysiwyg string literal
+	 *
+	 * @type {Object}
+	 */
+	var D_ALTERNATE_WYSIWYG_STRING_MODE = {
+		className: 'string',
+		begin: '`',
+		end: '`[cwd]?'
+	};
+
+	/**
+	 * D hexadecimal string literal
+	 *
+	 * @type {Object}
+	 */
+	var D_HEX_STRING_MODE = {
+		className: 'string',
+		begin: 'x"[\\da-fA-F\\s\\n\\r]*"[cwd]?',
+		relevance: 10
+	};
+
+	/**
+	 * D delimited string literal
+	 *
+	 * @type {Object}
+	 */
+	var D_TOKEN_STRING_MODE = {
+		className: 'string',
+		begin: 'q"\\{',
+		end: '\\}"'
+	};
+
+	/**
+	 * Hashbang support
+	 *
+	 * @type {Object}
+	 */
+	var D_HASHBANG_MODE = {
+		className: 'shebang',
+		begin: '^#!',
+		end: '$',
+		relevance: 5
+	};
+
+	/**
+	 * D special token sequence
+	 *
+	 * @type {Object}
+	 */
+	var D_SPECIAL_TOKEN_SEQUENCE_MODE = {
+		className: 'preprocessor',
+		begin: '#(line)',
+		end: '$',
+		relevance: 5
+	};
+
+	/**
+	 * D attributes
+	 *
+	 * @type {Object}
+	 */
+	var D_ATTRIBUTE_MODE = {
+		className: 'keyword',
+		begin: '@[a-zA-Z_][a-zA-Z_\\d]*'
+	};
+
+	/**
+	 * D nesting comment
+	 *
+	 * @type {Object}
+	 */
+	var D_NESTING_COMMENT_MODE = {
+		className: 'comment',
+		begin: '\\/\\+',
+		contains: ['self'],
+		end: '\\+\\/',
+		relevance: 10
+	}
+
+	return {
+		lexems: hljs.UNDERSCORE_IDENT_RE,
+		keywords: D_KEYWORDS,
+		contains: [
+			hljs.C_LINE_COMMENT_MODE,
+  			hljs.C_BLOCK_COMMENT_MODE,
+  			D_NESTING_COMMENT_MODE,
+  			D_HEX_STRING_MODE,
+  			D_STRING_MODE,
+  			D_WYSIWYG_DELIMITED_STRING_MODE,
+  			D_ALTERNATE_WYSIWYG_STRING_MODE,
+  			D_TOKEN_STRING_MODE,
+  			D_FLOAT_MODE,
+  			D_INTEGER_MODE,
+  			D_CHARACTER_MODE,
+  			D_HASHBANG_MODE,
+  			D_SPECIAL_TOKEN_SEQUENCE_MODE,
+  			D_ATTRIBUTE_MODE
+		]
+	};
+}(hljs);
+hljs.LANGUAGES['delphi'] = function(hljs) {
+  var DELPHI_KEYWORDS = 'and safecall cdecl then string exports library not pascal set ' +
+    'virtual file in array label packed end. index while const raise for to implementation ' +
+    'with except overload destructor downto finally program exit unit inherited override if ' +
+    'type until function do begin repeat goto nil far initialization object else var uses ' +
+    'external resourcestring interface end finalization class asm mod case on shr shl of ' +
+    'register xorwrite threadvar try record near stored constructor stdcall inline div out or ' +
+    'procedure';
+  var DELPHI_CLASS_KEYWORDS = 'safecall stdcall pascal stored const implementation ' +
+    'finalization except to finally program inherited override then exports string read not ' +
+    'mod shr try div shl set library message packed index for near overload label downto exit ' +
+    'public goto interface asm on of constructor or private array unit raise destructor var ' +
+    'type until function else external with case default record while protected property ' +
+    'procedure published and cdecl do threadvar file in if end virtual write far out begin ' +
+    'repeat nil initialization object uses resourcestring class register xorwrite inline static';
+  var CURLY_COMMENT =  {
+    className: 'comment',
+    begin: '{', end: '}',
+    relevance: 0
+  };
+  var PAREN_COMMENT = {
+    className: 'comment',
+    begin: '\\(\\*', end: '\\*\\)',
+    relevance: 10
+  };
+  var STRING = {
+    className: 'string',
+    begin: '\'', end: '\'',
+    contains: [{begin: '\'\''}],
+    relevance: 0
+  };
+  var CHAR_STRING = {
+    className: 'string', begin: '(#\\d+)+'
+  };
+  var FUNCTION = {
+    className: 'function',
+    beginWithKeyword: true, end: '[:;]',
+    keywords: 'function constructor|10 destructor|10 procedure|10',
+    contains: [
+      {
+        className: 'title', begin: hljs.IDENT_RE
+      },
+      {
+        className: 'params',
+        begin: '\\(', end: '\\)',
+        keywords: DELPHI_KEYWORDS,
+        contains: [STRING, CHAR_STRING]
+      },
+      CURLY_COMMENT, PAREN_COMMENT
+    ]
+  };
+  return {
+    case_insensitive: true,
+    keywords: DELPHI_KEYWORDS,
+    illegal: '("|\\$[G-Zg-z]|\\/\\*|</)',
+    contains: [
+      CURLY_COMMENT, PAREN_COMMENT, hljs.C_LINE_COMMENT_MODE,
+      STRING, CHAR_STRING,
+      hljs.NUMBER_MODE,
+      FUNCTION,
+      {
+        className: 'class',
+        begin: '=\\bclass\\b', end: 'end;',
+        keywords: DELPHI_CLASS_KEYWORDS,
+        contains: [
+          STRING, CHAR_STRING,
+          CURLY_COMMENT, PAREN_COMMENT, hljs.C_LINE_COMMENT_MODE,
+          FUNCTION
+        ]
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['diff'] = function(hljs) {
+  return {
+    case_insensitive: true,
+    contains: [
+      {
+        className: 'chunk',
+        begin: '^\\@\\@ +\\-\\d+,\\d+ +\\+\\d+,\\d+ +\\@\\@$',
+        relevance: 10
+      },
+      {
+        className: 'chunk',
+        begin: '^\\*\\*\\* +\\d+,\\d+ +\\*\\*\\*\\*$',
+        relevance: 10
+      },
+      {
+        className: 'chunk',
+        begin: '^\\-\\-\\- +\\d+,\\d+ +\\-\\-\\-\\-$',
+        relevance: 10
+      },
+      {
+        className: 'header',
+        begin: 'Index: ', end: '$'
+      },
+      {
+        className: 'header',
+        begin: '=====', end: '=====$'
+      },
+      {
+        className: 'header',
+        begin: '^\\-\\-\\-', end: '$'
+      },
+      {
+        className: 'header',
+        begin: '^\\*{3} ', end: '$'
+      },
+      {
+        className: 'header',
+        begin: '^\\+\\+\\+', end: '$'
+      },
+      {
+        className: 'header',
+        begin: '\\*{5}', end: '\\*{5}$'
+      },
+      {
+        className: 'addition',
+        begin: '^\\+', end: '$'
+      },
+      {
+        className: 'deletion',
+        begin: '^\\-', end: '$'
+      },
+      {
+        className: 'change',
+        begin: '^\\!', end: '$'
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['xml'] = function(hljs) {
+  var XML_IDENT_RE = '[A-Za-z0-9\\._:-]+';
+  var TAG_INTERNALS = {
+    endsWithParent: true,
+    contains: [
+      {
+        className: 'attribute',
+        begin: XML_IDENT_RE,
+        relevance: 0
+      },
+      {
+        begin: '="', returnBegin: true, end: '"',
+        contains: [{
+            className: 'value',
+            begin: '"', endsWithParent: true
+        }]
+      },
+      {
+        begin: '=\'', returnBegin: true, end: '\'',
+        contains: [{
+          className: 'value',
+          begin: '\'', endsWithParent: true
+        }]
+      },
+      {
+        begin: '=',
+        contains: [{
+          className: 'value',
+          begin: '[^\\s/>]+'
+        }]
+      }
+    ]
+  };
+  return {
+    case_insensitive: true,
+    contains: [
+      {
+        className: 'pi',
+        begin: '<\\?', end: '\\?>',
+        relevance: 10
+      },
+      {
+        className: 'doctype',
+        begin: '<!DOCTYPE', end: '>',
+        relevance: 10,
+        contains: [{begin: '\\[', end: '\\]'}]
+      },
+      {
+        className: 'comment',
+        begin: '<!--', end: '-->',
+        relevance: 10
+      },
+      {
+        className: 'cdata',
+        begin: '<\\!\\[CDATA\\[', end: '\\]\\]>',
+        relevance: 10
+      },
+      {
+        className: 'tag',
+        /*
+        The lookahead pattern (?=...) ensures that 'begin' only matches
+        '<style' as a single word, followed by a whitespace or an
+        ending braket. The '$' is needed for the lexem to be recognized
+        by hljs.subMode() that tests lexems outside the stream.
+        */
+        begin: '<style(?=\\s|>|$)', end: '>',
+        keywords: {title: 'style'},
+        contains: [TAG_INTERNALS],
+        starts: {
+          end: '</style>', returnEnd: true,
+          subLanguage: 'css'
+        }
+      },
+      {
+        className: 'tag',
+        // See the comment in the <style tag about the lookahead pattern
+        begin: '<script(?=\\s|>|$)', end: '>',
+        keywords: {title: 'script'},
+        contains: [TAG_INTERNALS],
+        starts: {
+          end: '</script>', returnEnd: true,
+          subLanguage: 'javascript'
+        }
+      },
+      {
+        begin: '<%', end: '%>',
+        subLanguage: 'vbscript'
+      },
+      {
+        className: 'tag',
+        begin: '</?', end: '/?>',
+        contains: [
+          {
+            className: 'title', begin: '[^ />]+'
+          },
+          TAG_INTERNALS
+        ]
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['django'] = function(hljs) {
+
+  function allowsDjangoSyntax(mode, parent) {
+    return (
+      parent == undefined || // default mode
+      (!mode.className && parent.className == 'tag') || // tag_internal
+      mode.className == 'value' // value
+    );
+  }
+
+  function copy(mode, parent) {
+    var result = {};
+    for (var key in mode) {
+      if (key != 'contains') {
+        result[key] = mode[key];
+      }
+      var contains = [];
+      for (var i = 0; mode.contains && i < mode.contains.length; i++) {
+        contains.push(copy(mode.contains[i], mode));
+      }
+      if (allowsDjangoSyntax(mode, parent)) {
+        contains = DJANGO_CONTAINS.concat(contains);
+      }
+      if (contains.length) {
+        result.contains = contains;
+      }
+    }
+    return result;
+  }
+
+  var FILTER = {
+    className: 'filter',
+    begin: '\\|[A-Za-z]+\\:?', excludeEnd: true,
+    keywords:
+      'truncatewords removetags linebreaksbr yesno get_digit timesince random striptags ' +
+      'filesizeformat escape linebreaks length_is ljust rjust cut urlize fix_ampersands ' +
+      'title floatformat capfirst pprint divisibleby add make_list unordered_list urlencode ' +
+      'timeuntil urlizetrunc wordcount stringformat linenumbers slice date dictsort ' +
+      'dictsortreversed default_if_none pluralize lower join center default ' +
+      'truncatewords_html upper length phone2numeric wordwrap time addslashes slugify first ' +
+      'escapejs force_escape iriencode last safe safeseq truncatechars localize unlocalize ' +
+      'localtime utc timezone',
+    contains: [
+      {className: 'argument', begin: '"', end: '"'}
+    ]
+  };
+
+  var DJANGO_CONTAINS = [
+    {
+      className: 'template_comment',
+      begin: '{%\\s*comment\\s*%}', end: '{%\\s*endcomment\\s*%}'
+    },
+    {
+      className: 'template_comment',
+      begin: '{#', end: '#}'
+    },
+    {
+      className: 'template_tag',
+      begin: '{%', end: '%}',
+      keywords:
+        'comment endcomment load templatetag ifchanged endifchanged if endif firstof for ' +
+        'endfor in ifnotequal endifnotequal widthratio extends include spaceless ' +
+        'endspaceless regroup by as ifequal endifequal ssi now with cycle url filter ' +
+        'endfilter debug block endblock else autoescape endautoescape csrf_token empty elif ' +
+        'endwith static trans blocktrans endblocktrans get_static_prefix get_media_prefix ' +
+        'plural get_current_language language get_available_languages ' +
+        'get_current_language_bidi get_language_info get_language_info_list localize ' +
+        'endlocalize localtime endlocaltime timezone endtimezone get_current_timezone',
+      contains: [FILTER]
+    },
+    {
+      className: 'variable',
+      begin: '{{', end: '}}',
+      contains: [FILTER]
+    }
+  ];
+
+  var result = copy(hljs.LANGUAGES.xml);
+  result.case_insensitive = true;
+  return result;
+}(hljs);
+hljs.LANGUAGES['dos'] = function(hljs) {
+  return {
+    case_insensitive: true,
+    keywords: {
+      flow: 'if else goto for in do call exit not exist errorlevel defined equ neq lss leq gtr geq',
+      keyword: 'shift cd dir echo setlocal endlocal set pause copy',
+      stream: 'prn nul lpt3 lpt2 lpt1 con com4 com3 com2 com1 aux',
+      winutils: 'ping net ipconfig taskkill xcopy ren del'
+    },
+    contains: [
+      {
+        className: 'envvar', begin: '%%[^ ]'
+      },
+      {
+        className: 'envvar', begin: '%[^ ]+?%'
+      },
+      {
+        className: 'envvar', begin: '![^ ]+?!'
+      },
+      {
+        className: 'number', begin: '\\b\\d+',
+        relevance: 0
+      },
+      {
+        className: 'comment',
+        begin: '@?rem', end: '$'
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['erlang-repl'] = function(hljs) {
+  return {
+    keywords: {
+      special_functions:
+        'spawn spawn_link self',
+      reserved:
+        'after and andalso|10 band begin bnot bor bsl bsr bxor case catch cond div end fun if ' +
+        'let not of or orelse|10 query receive rem try when xor'
+    },
+    contains: [
+      {
+        className: 'input_number', begin: '^[0-9]+> ',
+        relevance: 10
+      },
+      {
+        className: 'comment',
+        begin: '%', end: '$'
+      },
+      {
+        className: 'number',
+        begin: '\\b(\\d+#[a-fA-F0-9]+|\\d+(\\.\\d+)?([eE][-+]?\\d+)?)',
+        relevance: 0
+      },
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      {
+        className: 'constant', begin: '\\?(::)?([A-Z]\\w*(::)?)+'
+      },
+      {
+        className: 'arrow', begin: '->'
+      },
+      {
+        className: 'ok', begin: 'ok'
+      },
+      {
+        className: 'exclamation_mark', begin: '!'
+      },
+      {
+        className: 'function_or_atom',
+        begin: '(\\b[a-z\'][a-zA-Z0-9_\']*:[a-z\'][a-zA-Z0-9_\']*)|(\\b[a-z\'][a-zA-Z0-9_\']*)',
+        relevance: 0
+      },
+      {
+        className: 'variable',
+        begin: '[A-Z][a-zA-Z0-9_\']*',
+        relevance: 0
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['erlang'] = function(hljs) {
+  var BASIC_ATOM_RE = '[a-z\'][a-zA-Z0-9_\']*';
+  var FUNCTION_NAME_RE = '(' + BASIC_ATOM_RE + ':' + BASIC_ATOM_RE + '|' + BASIC_ATOM_RE + ')';
+  var ERLANG_RESERVED = {
+    keyword:
+      'after and andalso|10 band begin bnot bor bsl bzr bxor case catch cond div end fun let ' +
+      'not of orelse|10 query receive rem try when xor',
+    literal:
+      'false true'
+  };
+
+  var COMMENT = {
+    className: 'comment',
+    begin: '%', end: '$',
+    relevance: 0
+  };
+  var NUMBER = {
+    className: 'number',
+    begin: '\\b(\\d+#[a-fA-F0-9]+|\\d+(\\.\\d+)?([eE][-+]?\\d+)?)',
+    relevance: 0
+  };
+  var NAMED_FUN = {
+    begin: 'fun\\s+' + BASIC_ATOM_RE + '/\\d+'
+  };
+  var FUNCTION_CALL = {
+    begin: FUNCTION_NAME_RE + '\\(', end: '\\)',
+    returnBegin: true,
+    relevance: 0,
+    contains: [
+      {
+        className: 'function_name', begin: FUNCTION_NAME_RE,
+        relevance: 0
+      },
+      {
+        begin: '\\(', end: '\\)', endsWithParent: true,
+        returnEnd: true,
+        relevance: 0
+        // "contains" defined later
+      }
+    ]
+  };
+  var TUPLE = {
+    className: 'tuple',
+    begin: '{', end: '}',
+    relevance: 0
+    // "contains" defined later
+  };
+  var VAR1 = {
+    className: 'variable',
+    begin: '\\b_([A-Z][A-Za-z0-9_]*)?',
+    relevance: 0
+  };
+  var VAR2 = {
+    className: 'variable',
+    begin: '[A-Z][a-zA-Z0-9_]*',
+    relevance: 0
+  };
+  var RECORD_ACCESS = {
+    begin: '#', end: '}',
+    illegal: '.',
+    relevance: 0,
+    returnBegin: true,
+    contains: [
+      {
+        className: 'record_name',
+        begin: '#' + hljs.UNDERSCORE_IDENT_RE,
+        relevance: 0
+      },
+      {
+        begin: '{', endsWithParent: true,
+        relevance: 0
+        // "contains" defined later
+      }
+    ]
+  };
+
+  var BLOCK_STATEMENTS = {
+    keywords: ERLANG_RESERVED,
+    begin: '(fun|receive|if|try|case)', end: 'end'
+  };
+  BLOCK_STATEMENTS.contains = [
+    COMMENT,
+    NAMED_FUN,
+    hljs.inherit(hljs.APOS_STRING_MODE, {className: ''}),
+    BLOCK_STATEMENTS,
+    FUNCTION_CALL,
+    hljs.QUOTE_STRING_MODE,
+    NUMBER,
+    TUPLE,
+    VAR1, VAR2,
+    RECORD_ACCESS
+  ];
+
+  var BASIC_MODES = [
+    COMMENT,
+    NAMED_FUN,
+    BLOCK_STATEMENTS,
+    FUNCTION_CALL,
+    hljs.QUOTE_STRING_MODE,
+    NUMBER,
+    TUPLE,
+    VAR1, VAR2,
+    RECORD_ACCESS
+  ];
+  FUNCTION_CALL.contains[1].contains = BASIC_MODES;
+  TUPLE.contains = BASIC_MODES;
+  RECORD_ACCESS.contains[1].contains = BASIC_MODES;
+
+  var PARAMS = {
+    className: 'params',
+    begin: '\\(', end: '\\)',
+    contains: BASIC_MODES
+  };
+  return {
+    keywords: ERLANG_RESERVED,
+    illegal: '(</|\\*=|\\+=|-=|/=|/\\*|\\*/|\\(\\*|\\*\\))',
+    contains: [
+      {
+        className: 'function',
+        begin: '^' + BASIC_ATOM_RE + '\\s*\\(', end: '->',
+        returnBegin: true,
+        illegal: '\\(|#|//|/\\*|\\\\|:',
+        contains: [
+          PARAMS,
+          {
+            className: 'title', begin: BASIC_ATOM_RE
+          }
+        ],
+        starts: {
+          end: ';|\\.',
+          keywords: ERLANG_RESERVED,
+          contains: BASIC_MODES
+        }
+      },
+      COMMENT,
+      {
+        className: 'pp',
+        begin: '^-', end: '\\.',
+        relevance: 0,
+        excludeEnd: true,
+        returnBegin: true,
+        lexems: '-' + hljs.IDENT_RE,
+        keywords:
+          '-module -record -undef -export -ifdef -ifndef -author -copyright -doc -vsn ' +
+          '-import -include -include_lib -compile -define -else -endif -file -behaviour ' +
+          '-behavior',
+        contains: [PARAMS]
+      },
+      NUMBER,
+      hljs.QUOTE_STRING_MODE,
+      RECORD_ACCESS,
+      VAR1, VAR2,
+      TUPLE
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['glsl'] = function(hljs) {
+  return {
+    keywords: {
+      keyword:
+        'atomic_uint attribute bool break bvec2 bvec3 bvec4 case centroid coherent const continue default ' +
+        'discard dmat2 dmat2x2 dmat2x3 dmat2x4 dmat3 dmat3x2 dmat3x3 dmat3x4 dmat4 dmat4x2 dmat4x3 ' +
+        'dmat4x4 do double dvec2 dvec3 dvec4 else flat float for highp if iimage1D iimage1DArray ' +
+        'iimage2D iimage2DArray iimage2DMS iimage2DMSArray iimage2DRect iimage3D iimageBuffer iimageCube ' +
+        'iimageCubeArray image1D image1DArray image2D image2DArray image2DMS image2DMSArray image2DRect ' +
+        'image3D imageBuffer imageCube imageCubeArray in inout int invariant isampler1D isampler1DArray ' +
+        'isampler2D isampler2DArray isampler2DMS isampler2DMSArray isampler2DRect isampler3D isamplerBuffer ' +
+        'isamplerCube isamplerCubeArray ivec2 ivec3 ivec4 layout lowp mat2 mat2x2 mat2x3 mat2x4 mat3 mat3x2 ' +
+        'mat3x3 mat3x4 mat4 mat4x2 mat4x3 mat4x4 mediump noperspective out patch precision readonly restrict ' +
+        'return sample sampler1D sampler1DArray sampler1DArrayShadow sampler1DShadow sampler2D sampler2DArray ' +
+        'sampler2DArrayShadow sampler2DMS sampler2DMSArray sampler2DRect sampler2DRectShadow sampler2DShadow ' +
+        'sampler3D samplerBuffer samplerCube samplerCubeArray samplerCubeArrayShadow samplerCubeShadow smooth ' +
+        'struct subroutine switch uimage1D uimage1DArray uimage2D uimage2DArray uimage2DMS uimage2DMSArray ' +
+        'uimage2DRect uimage3D uimageBuffer uimageCube uimageCubeArray uint uniform usampler1D usampler1DArray ' +
+        'usampler2D usampler2DArray usampler2DMS usampler2DMSArray usampler2DRect usampler3D usamplerBuffer ' +
+        'usamplerCube usamplerCubeArray uvec2 uvec3 uvec4 varying vec2 vec3 vec4 void volatile while writeonly',
+      built_in:
+        'gl_BackColor gl_BackLightModelProduct gl_BackLightProduct gl_BackMaterial ' +
+        'gl_BackSecondaryColor gl_ClipDistance gl_ClipPlane gl_ClipVertex gl_Color ' +
+        'gl_DepthRange gl_EyePlaneQ gl_EyePlaneR gl_EyePlaneS gl_EyePlaneT gl_Fog gl_FogCoord ' +
+        'gl_FogFragCoord gl_FragColor gl_FragCoord gl_FragData gl_FragDepth gl_FrontColor ' +
+        'gl_FrontFacing gl_FrontLightModelProduct gl_FrontLightProduct gl_FrontMaterial ' +
+        'gl_FrontSecondaryColor gl_InstanceID gl_InvocationID gl_Layer gl_LightModel ' +
+        'gl_LightSource gl_MaxAtomicCounterBindings gl_MaxAtomicCounterBufferSize ' +
+        'gl_MaxClipDistances gl_MaxClipPlanes gl_MaxCombinedAtomicCounterBuffers ' +
+        'gl_MaxCombinedAtomicCounters gl_MaxCombinedImageUniforms gl_MaxCombinedImageUnitsAndFragmentOutputs ' +
+        'gl_MaxCombinedTextureImageUnits gl_MaxDrawBuffers gl_MaxFragmentAtomicCounterBuffers ' +
+        'gl_MaxFragmentAtomicCounters gl_MaxFragmentImageUniforms gl_MaxFragmentInputComponents ' +
+        'gl_MaxFragmentUniformComponents gl_MaxFragmentUniformVectors gl_MaxGeometryAtomicCounterBuffers ' +
+        'gl_MaxGeometryAtomicCounters gl_MaxGeometryImageUniforms gl_MaxGeometryInputComponents ' +
+        'gl_MaxGeometryOutputComponents gl_MaxGeometryOutputVertices gl_MaxGeometryTextureImageUnits ' +
+        'gl_MaxGeometryTotalOutputComponents gl_MaxGeometryUniformComponents gl_MaxGeometryVaryingComponents ' +
+        'gl_MaxImageSamples gl_MaxImageUnits gl_MaxLights gl_MaxPatchVertices gl_MaxProgramTexelOffset ' +
+        'gl_MaxTessControlAtomicCounterBuffers gl_MaxTessControlAtomicCounters gl_MaxTessControlImageUniforms ' +
+        'gl_MaxTessControlInputComponents gl_MaxTessControlOutputComponents gl_MaxTessControlTextureImageUnits ' +
+        'gl_MaxTessControlTotalOutputComponents gl_MaxTessControlUniformComponents ' +
+        'gl_MaxTessEvaluationAtomicCounterBuffers gl_MaxTessEvaluationAtomicCounters ' +
+        'gl_MaxTessEvaluationImageUniforms gl_MaxTessEvaluationInputComponents gl_MaxTessEvaluationOutputComponents ' +
+        'gl_MaxTessEvaluationTextureImageUnits gl_MaxTessEvaluationUniformComponents ' +
+        'gl_MaxTessGenLevel gl_MaxTessPatchComponents gl_MaxTextureCoords gl_MaxTextureImageUnits ' +
+        'gl_MaxTextureUnits gl_MaxVaryingComponents gl_MaxVaryingFloats gl_MaxVaryingVectors ' +
+        'gl_MaxVertexAtomicCounterBuffers gl_MaxVertexAtomicCounters gl_MaxVertexAttribs ' +
+        'gl_MaxVertexImageUniforms gl_MaxVertexOutputComponents gl_MaxVertexTextureImageUnits ' +
+        'gl_MaxVertexUniformComponents gl_MaxVertexUniformVectors gl_MaxViewports gl_MinProgramTexelOffset'+
+        'gl_ModelViewMatrix gl_ModelViewMatrixInverse gl_ModelViewMatrixInverseTranspose ' +
+        'gl_ModelViewMatrixTranspose gl_ModelViewProjectionMatrix gl_ModelViewProjectionMatrixInverse ' +
+        'gl_ModelViewProjectionMatrixInverseTranspose gl_ModelViewProjectionMatrixTranspose ' +
+        'gl_MultiTexCoord0 gl_MultiTexCoord1 gl_MultiTexCoord2 gl_MultiTexCoord3 gl_MultiTexCoord4 ' +
+        'gl_MultiTexCoord5 gl_MultiTexCoord6 gl_MultiTexCoord7 gl_Normal gl_NormalMatrix ' +
+        'gl_NormalScale gl_ObjectPlaneQ gl_ObjectPlaneR gl_ObjectPlaneS gl_ObjectPlaneT gl_PatchVerticesIn ' +
+        'gl_PerVertex gl_Point gl_PointCoord gl_PointSize gl_Position gl_PrimitiveID gl_PrimitiveIDIn ' +
+        'gl_ProjectionMatrix gl_ProjectionMatrixInverse gl_ProjectionMatrixInverseTranspose ' +
+        'gl_ProjectionMatrixTranspose gl_SampleID gl_SampleMask gl_SampleMaskIn gl_SamplePosition ' +
+        'gl_SecondaryColor gl_TessCoord gl_TessLevelInner gl_TessLevelOuter gl_TexCoord gl_TextureEnvColor ' +
+        'gl_TextureMatrixInverseTranspose gl_TextureMatrixTranspose gl_Vertex gl_VertexID ' +
+        'gl_ViewportIndex gl_in gl_out EmitStreamVertex EmitVertex EndPrimitive EndStreamPrimitive ' +
+        'abs acos acosh all any asin asinh atan atanh atomicCounter atomicCounterDecrement ' +
+        'atomicCounterIncrement barrier bitCount bitfieldExtract bitfieldInsert bitfieldReverse ' +
+        'ceil clamp cos cosh cross dFdx dFdy degrees determinant distance dot equal exp exp2 faceforward ' +
+        'findLSB findMSB floatBitsToInt floatBitsToUint floor fma fract frexp ftransform fwidth greaterThan ' +
+        'greaterThanEqual imageAtomicAdd imageAtomicAnd imageAtomicCompSwap imageAtomicExchange ' +
+        'imageAtomicMax imageAtomicMin imageAtomicOr imageAtomicXor imageLoad imageStore imulExtended ' +
+        'intBitsToFloat interpolateAtCentroid interpolateAtOffset interpolateAtSample inverse inversesqrt ' +
+        'isinf isnan ldexp length lessThan lessThanEqual log log2 matrixCompMult max memoryBarrier ' +
+        'min mix mod modf noise1 noise2 noise3 noise4 normalize not notEqual outerProduct packDouble2x32 ' +
+        'packHalf2x16 packSnorm2x16 packSnorm4x8 packUnorm2x16 packUnorm4x8 pow radians reflect refract ' +
+        'round roundEven shadow1D shadow1DLod shadow1DProj shadow1DProjLod shadow2D shadow2DLod shadow2DProj ' +
+        'shadow2DProjLod sign sin sinh smoothstep sqrt step tan tanh texelFetch texelFetchOffset texture ' +
+        'texture1D texture1DLod texture1DProj texture1DProjLod texture2D texture2DLod texture2DProj ' +
+        'texture2DProjLod texture3D texture3DLod texture3DProj texture3DProjLod textureCube textureCubeLod ' +
+        'textureGather textureGatherOffset textureGatherOffsets textureGrad textureGradOffset textureLod ' +
+        'textureLodOffset textureOffset textureProj textureProjGrad textureProjGradOffset textureProjLod ' +
+        'textureProjLodOffset textureProjOffset textureQueryLod textureSize transpose trunc uaddCarry ' +
+        'uintBitsToFloat umulExtended unpackDouble2x32 unpackHalf2x16 unpackSnorm2x16 unpackSnorm4x8 ' +
+        'unpackUnorm2x16 unpackUnorm4x8 usubBorrow gl_TextureMatrix gl_TextureMatrixInverse',
+      literal: 'true false'
+    },
+    illegal: '"',
+    contains: [
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.C_NUMBER_MODE,
+      {
+        className: 'preprocessor',
+        begin: '#', end: '$'
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['go'] = function(hljs) {
+  var GO_KEYWORDS = {
+    keyword:
+      'break default func interface select case map struct chan else goto package switch ' +
+      'const fallthrough if range type continue for import return var go defer',
+    constant:
+       'true false iota nil',
+    typename:
+      'bool byte complex64 complex128 float32 float64 int8 int16 int32 int64 string uint8 ' +
+      'uint16 uint32 uint64 int uint uintptr rune',
+    built_in:
+      'append cap close complex copy imag len make new panic print println real recover delete'
+  };
+  return {
+    keywords: GO_KEYWORDS,
+    illegal: '</',
+    contains: [
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.QUOTE_STRING_MODE,
+      {
+        className: 'string',
+        begin: '\'', end: '[^\\\\]\'',
+        relevance: 0
+      },
+      {
+        className: 'string',
+        begin: '`', end: '`'
+      },
+      {
+        className: 'number',
+        begin: '[^a-zA-Z_0-9](\\-|\\+)?\\d+(\\.\\d+|\\/\\d+)?((d|e|f|l|s)(\\+|\\-)?\\d+)?',
+        relevance: 0
+      },
+      hljs.C_NUMBER_MODE
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['haskell'] = function(hljs) {
+  var TYPE = {
+    className: 'type',
+    begin: '\\b[A-Z][\\w\']*',
+    relevance: 0
+  };
+  var CONTAINER = {
+    className: 'container',
+    begin: '\\(', end: '\\)',
+    contains: [
+      {className: 'type', begin: '\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?'},
+      {className: 'title', begin: '[_a-z][\\w\']*'}
+    ]
+  };
+  var CONTAINER2 = {
+    className: 'container',
+    begin: '{', end: '}',
+    contains: CONTAINER.contains
+  }
+
+  return {
+    keywords:
+      'let in if then else case of where do module import hiding qualified type data ' +
+      'newtype deriving class instance not as foreign ccall safe unsafe',
+    contains: [
+      {
+        className: 'comment',
+        begin: '--', end: '$'
+      },
+      {
+        className: 'preprocessor',
+        begin: '{-#', end: '#-}'
+      },
+      {
+        className: 'comment',
+        contains: ['self'],
+        begin: '{-', end: '-}'
+      },
+      {
+        className: 'string',
+        begin: '\\s+\'', end: '\'',
+        contains: [hljs.BACKSLASH_ESCAPE],
+        relevance: 0
+      },
+      hljs.QUOTE_STRING_MODE,
+      {
+        className: 'import',
+        begin: '\\bimport', end: '$',
+        keywords: 'import qualified as hiding',
+        contains: [CONTAINER],
+        illegal: '\\W\\.|;'
+      },
+      {
+        className: 'module',
+        begin: '\\bmodule', end: 'where',
+        keywords: 'module where',
+        contains: [CONTAINER],
+        illegal: '\\W\\.|;'
+      },
+      {
+        className: 'class',
+        begin: '\\b(class|instance)', end: 'where',
+        keywords: 'class where instance',
+        contains: [TYPE]
+      },
+      {
+        className: 'typedef',
+        begin: '\\b(data|(new)?type)', end: '$',
+        keywords: 'data type newtype deriving',
+        contains: [TYPE, CONTAINER, CONTAINER2]
+      },
+      hljs.C_NUMBER_MODE,
+      {
+        className: 'shebang',
+        begin: '#!\\/usr\\/bin\\/env\ runhaskell', end: '$'
+      },
+      TYPE,
+      {
+        className: 'title', begin: '^[_a-z][\\w\']*'
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['http'] = function(hljs) {
+  return {
+    illegal: '\\S',
+    contains: [
+      {
+        className: 'status',
+        begin: '^HTTP/[0-9\\.]+', end: '$',
+        contains: [{className: 'number', begin: '\\b\\d{3}\\b'}]
+      },
+      {
+        className: 'request',
+        begin: '^[A-Z]+ (.*?) HTTP/[0-9\\.]+$', returnBegin: true, end: '$',
+        contains: [
+          {
+            className: 'string',
+            begin: ' ', end: ' ',
+            excludeBegin: true, excludeEnd: true
+          }
+        ]
+      },
+      {
+        className: 'attribute',
+        begin: '^\\w', end: ': ', excludeEnd: true,
+        illegal: '\\n',
+        starts: {className: 'string', end: '$'}
+      },
+      {
+        begin: '\\n\\n',
+        starts: {subLanguage: '', endsWithParent: true}
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['ini'] = function(hljs) {
+  return {
+    case_insensitive: true,
+    illegal: '[^\\s]',
+    contains: [
+      {
+        className: 'comment',
+        begin: ';', end: '$'
+      },
+      {
+        className: 'title',
+        begin: '^\\[', end: '\\]'
+      },
+      {
+        className: 'setting',
+        begin: '^[a-z0-9\\[\\]_-]+[ \\t]*=[ \\t]*', end: '$',
+        contains: [
+          {
+            className: 'value',
+            endsWithParent: true,
+            keywords: 'on off true false yes no',
+            contains: [hljs.QUOTE_STRING_MODE, hljs.NUMBER_MODE]
+          }
+        ]
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['java'] = function(hljs) {
+  return {
+    keywords:
+      'false synchronized int abstract float private char boolean static null if const ' +
+      'for true while long throw strictfp finally protected import native final return void ' +
+      'enum else break transient new catch instanceof byte super volatile case assert short ' +
+      'package default double public try this switch continue throws',
+    contains: [
+      {
+        className: 'javadoc',
+        begin: '/\\*\\*', end: '\\*/',
+        contains: [{
+          className: 'javadoctag', begin: '@[A-Za-z]+'
+        }],
+        relevance: 10
+      },
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      {
+        className: 'class',
+        beginWithKeyword: true, end: '{',
+        keywords: 'class interface',
+        illegal: ':',
+        contains: [
+          {
+            beginWithKeyword: true,
+            keywords: 'extends implements',
+            relevance: 10
+          },
+          {
+            className: 'title',
+            begin: hljs.UNDERSCORE_IDENT_RE
+          }
+        ]
+      },
+      hljs.C_NUMBER_MODE,
+      {
+        className: 'annotation', begin: '@[A-Za-z]+'
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['javascript'] = function(hljs) {
+  return {
+    keywords: {
+      keyword:
+        'in if for while finally var new function do return void else break catch ' +
+        'instanceof with throw case default try this switch continue typeof delete ' +
+        'let yield',
+      literal:
+        'true false null undefined NaN Infinity'
+    },
+    contains: [
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.C_NUMBER_MODE,
+      { // regexp container
+        begin: '(' + hljs.RE_STARTERS_RE + '|\\b(case|return|throw)\\b)\\s*',
+        keywords: 'return throw case',
+        contains: [
+          hljs.C_LINE_COMMENT_MODE,
+          hljs.C_BLOCK_COMMENT_MODE,
+          {
+            className: 'regexp',
+            begin: '/', end: '/[gim]*',
+            contains: [{begin: '\\\\/'}]
+          }
+        ],
+        relevance: 0
+      },
+      {
+        className: 'function',
+        beginWithKeyword: true, end: '{',
+        keywords: 'function',
+        contains: [
+          {
+            className: 'title', begin: '[A-Za-z$_][0-9A-Za-z$_]*'
+          },
+          {
+            className: 'params',
+            begin: '\\(', end: '\\)',
+            contains: [
+              hljs.C_LINE_COMMENT_MODE,
+              hljs.C_BLOCK_COMMENT_MODE
+            ],
+            illegal: '["\'\\(]'
+          }
+        ],
+        illegal: '\\[|%'
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['json'] = function(hljs) {
+  var LITERALS = {literal: 'true false null'};
+  var TYPES = [
+    hljs.QUOTE_STRING_MODE,
+    hljs.C_NUMBER_MODE
+  ];
+  var VALUE_CONTAINER = {
+    className: 'value',
+    end: ',', endsWithParent: true, excludeEnd: true,
+    contains: TYPES,
+    keywords: LITERALS
+  };
+  var OBJECT = {
+    begin: '{', end: '}',
+    contains: [
+      {
+        className: 'attribute',
+        begin: '\\s*"', end: '"\\s*:\\s*', excludeBegin: true, excludeEnd: true,
+        contains: [hljs.BACKSLASH_ESCAPE],
+        illegal: '\\n',
+        starts: VALUE_CONTAINER
+      }
+    ],
+    illegal: '\\S'
+  };
+  var ARRAY = {
+    begin: '\\[', end: '\\]',
+    contains: [hljs.inherit(VALUE_CONTAINER, {className: null})], // inherit is also a workaround for a bug that makes shared modes with endsWithParent compile only the ending of one of the parents
+    illegal: '\\S'
+  };
+  TYPES.splice(TYPES.length, 0, OBJECT, ARRAY);
+  return {
+    contains: TYPES,
+    keywords: LITERALS,
+    illegal: '\\S'
+  };
+}(hljs);
+hljs.LANGUAGES['lisp'] = function(hljs) {
+  var LISP_IDENT_RE = '[a-zA-Z_\\-\\+\\*\\/\\<\\=\\>\\&\\#][a-zA-Z0-9_\\-\\+\\*\\/\\<\\=\\>\\&\\#]*';
+  var LISP_SIMPLE_NUMBER_RE = '(\\-|\\+)?\\d+(\\.\\d+|\\/\\d+)?((d|e|f|l|s)(\\+|\\-)?\\d+)?';
+  var LITERAL = {
+    className: 'literal',
+    begin: '\\b(t{1}|nil)\\b'
+  };
+  var NUMBERS = [
+    {
+      className: 'number', begin: LISP_SIMPLE_NUMBER_RE
+    },
+    {
+      className: 'number', begin: '#b[0-1]+(/[0-1]+)?'
+    },
+    {
+      className: 'number', begin: '#o[0-7]+(/[0-7]+)?'
+    },
+    {
+      className: 'number', begin: '#x[0-9a-f]+(/[0-9a-f]+)?'
+    },
+    {
+      className: 'number', begin: '#c\\(' + LISP_SIMPLE_NUMBER_RE + ' +' + LISP_SIMPLE_NUMBER_RE, end: '\\)'
+    }
+  ]
+  var STRING = {
+    className: 'string',
+    begin: '"', end: '"',
+    contains: [hljs.BACKSLASH_ESCAPE],
+    relevance: 0
+  };
+  var COMMENT = {
+    className: 'comment',
+    begin: ';', end: '$'
+  };
+  var VARIABLE = {
+    className: 'variable',
+    begin: '\\*', end: '\\*'
+  };
+  var KEYWORD = {
+    className: 'keyword',
+    begin: '[:&]' + LISP_IDENT_RE
+  };
+  var QUOTED_LIST = {
+    begin: '\\(', end: '\\)',
+    contains: ['self', LITERAL, STRING].concat(NUMBERS)
+  };
+  var QUOTED1 = {
+    className: 'quoted',
+    begin: '[\'`]\\(', end: '\\)',
+    contains: NUMBERS.concat([STRING, VARIABLE, KEYWORD, QUOTED_LIST])
+  };
+  var QUOTED2 = {
+    className: 'quoted',
+    begin: '\\(quote ', end: '\\)',
+    keywords: {title: 'quote'},
+    contains: NUMBERS.concat([STRING, VARIABLE, KEYWORD, QUOTED_LIST])
+  };
+  var LIST = {
+    className: 'list',
+    begin: '\\(', end: '\\)'
+  };
+  var BODY = {
+    className: 'body',
+    endsWithParent: true, excludeEnd: true
+  };
+  LIST.contains = [{className: 'title', begin: LISP_IDENT_RE}, BODY];
+  BODY.contains = [QUOTED1, QUOTED2, LIST, LITERAL].concat(NUMBERS).concat([STRING, COMMENT, VARIABLE, KEYWORD]);
+
+  return {
+    case_insensitive: true,
+    illegal: '[^\\s]',
+    contains: NUMBERS.concat([
+      LITERAL,
+      STRING,
+      COMMENT,
+      QUOTED1, QUOTED2,
+      LIST
+    ])
+  };
+}(hljs);
+hljs.LANGUAGES['lua'] = function(hljs) {
+  var OPENING_LONG_BRACKET = '\\[=*\\[';
+  var CLOSING_LONG_BRACKET = '\\]=*\\]';
+  var LONG_BRACKETS = {
+    begin: OPENING_LONG_BRACKET, end: CLOSING_LONG_BRACKET,
+    contains: ['self']
+  };
+  var COMMENTS = [
+    {
+      className: 'comment',
+      begin: '--(?!' + OPENING_LONG_BRACKET + ')', end: '$'
+    },
+    {
+      className: 'comment',
+      begin: '--' + OPENING_LONG_BRACKET, end: CLOSING_LONG_BRACKET,
+      contains: [LONG_BRACKETS],
+      relevance: 10
+    }
+  ]
+  return {
+    lexems: hljs.UNDERSCORE_IDENT_RE,
+    keywords: {
+      keyword:
+        'and break do else elseif end false for if in local nil not or repeat return then ' +
+        'true until while',
+      built_in:
+        '_G _VERSION assert collectgarbage dofile error getfenv getmetatable ipairs load ' +
+        'loadfile loadstring module next pairs pcall print rawequal rawget rawset require ' +
+        'select setfenv setmetatable tonumber tostring type unpack xpcall coroutine debug ' +
+        'io math os package string table'
+    },
+    contains: COMMENTS.concat([
+      {
+        className: 'function',
+        beginWithKeyword: true, end: '\\)',
+        keywords: 'function',
+        contains: [
+          {
+            className: 'title',
+            begin: '([_a-zA-Z]\\w*\\.)*([_a-zA-Z]\\w*:)?[_a-zA-Z]\\w*'
+          },
+          {
+            className: 'params',
+            begin: '\\(', endsWithParent: true,
+            contains: COMMENTS
+          }
+        ].concat(COMMENTS)
+      },
+      hljs.C_NUMBER_MODE,
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      {
+        className: 'string',
+        begin: OPENING_LONG_BRACKET, end: CLOSING_LONG_BRACKET,
+        contains: [LONG_BRACKETS],
+        relevance: 10
+      }
+    ])
+  };
+}(hljs);
+hljs.LANGUAGES['markdown'] = function(hljs) {
+  return {
+    case_insensitive: true,
+    contains: [
+      // highlight headers
+      {
+        className: 'header',
+        begin: '^#{1,3}', end: '$'
+      },
+      {
+        className: 'header',
+        begin: '^.+?\\n[=-]{2,}$'
+      },
+      // inline html
+      {
+        begin: '<', end: '>',
+        subLanguage: 'xml',
+        relevance: 0
+      },
+      // lists (indicators only)
+      {
+        className: 'bullet',
+        begin: '^([*+-]|(\\d+\\.))\\s+'
+      },
+      // strong segments
+      {
+        className: 'strong',
+        begin: '[*_]{2}.+?[*_]{2}'
+      },
+      // emphasis segments
+      {
+        className: 'emphasis',
+        begin: '\\*.+?\\*'
+      },
+      {
+        className: 'emphasis',
+        begin: '_.+?_',
+        relevance: 0
+      },
+      // blockquotes
+      {
+        className: 'blockquote',
+        begin: '^>\\s+', end: '$'
+      },
+      // code snippets
+      {
+        className: 'code',
+        begin: '`.+?`'
+      },
+      {
+        className: 'code',
+        begin: '^    ', end: '$',
+        relevance: 0
+      },
+      // horizontal rules
+      {
+        className: 'horizontal_rule',
+        begin: '^-{3,}', end: '$'
+      },
+      // using links - title and link
+      {
+        begin: '\\[.+?\\]\\(.+?\\)',
+        returnBegin: true,
+        contains: [
+          {
+            className: 'link_label',
+            begin: '\\[.+\\]'
+          },
+          {
+            className: 'link_url',
+            begin: '\\(', end: '\\)',
+            excludeBegin: true, excludeEnd: true
+          }
+        ]
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['matlab'] = function(hljs) {
+  return {
+    keywords: {
+      keyword:
+        'break case catch classdef continue else elseif end enumerated events for function ' +
+        'global if methods otherwise parfor persistent properties return spmd switch try while',
+      built_in:
+        'sin sind sinh asin asind asinh cos cosd cosh acos acosd acosh tan tand tanh atan ' +
+        'atand atan2 atanh sec secd sech asec asecd asech csc cscd csch acsc acscd acsch cot ' +
+        'cotd coth acot acotd acoth hypot exp expm1 log log1p log10 log2 pow2 realpow reallog ' +
+        'realsqrt sqrt nthroot nextpow2 abs angle complex conj imag real unwrap isreal ' +
+        'cplxpair fix floor ceil round mod rem sign airy besselj bessely besselh besseli ' +
+        'besselk beta betainc betaln ellipj ellipke erf erfc erfcx erfinv expint gamma ' +
+        'gammainc gammaln psi legendre cross dot factor isprime primes gcd lcm rat rats perms ' +
+        'nchoosek factorial cart2sph cart2pol pol2cart sph2cart hsv2rgb rgb2hsv zeros ones ' +
+        'eye repmat rand randn linspace logspace freqspace meshgrid accumarray size length ' +
+        'ndims numel disp isempty isequal isequalwithequalnans cat reshape diag blkdiag tril ' +
+        'triu fliplr flipud flipdim rot90 find sub2ind ind2sub bsxfun ndgrid permute ipermute ' +
+        'shiftdim circshift squeeze isscalar isvector ans eps realmax realmin pi i inf nan ' +
+        'isnan isinf isfinite j why compan gallery hadamard hankel hilb invhilb magic pascal ' +
+        'rosser toeplitz vander wilkinson'
+    },
+    illegal: '(//|"|#|/\\*|\\s+/\\w+)',
+    contains: [
+      {
+        className: 'function',
+        beginWithKeyword: true, end: '$',
+        keywords: 'function',
+        contains: [
+          {
+              className: 'title',
+              begin: hljs.UNDERSCORE_IDENT_RE
+          },
+          {
+              className: 'params',
+              begin: '\\(', end: '\\)'
+          },
+          {
+              className: 'params',
+              begin: '\\[', end: '\\]'
+          }
+        ]
+      },
+      {
+        className: 'string',
+        begin: '\'', end: '\'',
+        contains: [hljs.BACKSLASH_ESCAPE, {begin: '\'\''}],
+        relevance: 0
+      },
+      {
+        className: 'comment',
+        begin: '\\%', end: '$'
+      },
+      hljs.C_NUMBER_MODE
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['mel'] = function(hljs) {
+  return {
+    keywords:
+      'int float string vector matrix if else switch case default while do for in break ' +
+      'continue global proc return about abs addAttr addAttributeEditorNodeHelp addDynamic ' +
+      'addNewShelfTab addPP addPanelCategory addPrefixToName advanceToNextDrivenKey ' +
+      'affectedNet affects aimConstraint air alias aliasAttr align alignCtx alignCurve ' +
+      'alignSurface allViewFit ambientLight angle angleBetween animCone animCurveEditor ' +
+      'animDisplay animView annotate appendStringArray applicationName applyAttrPreset ' +
+      'applyTake arcLenDimContext arcLengthDimension arclen arrayMapper art3dPaintCtx ' +
+      'artAttrCtx artAttrPaintVertexCtx artAttrSkinPaintCtx artAttrTool artBuildPaintMenu ' +
+      'artFluidAttrCtx artPuttyCtx artSelectCtx artSetPaintCtx artUserPaintCtx assignCommand ' +
+      'assignInputDevice assignViewportFactories attachCurve attachDeviceAttr attachSurface ' +
+      'attrColorSliderGrp attrCompatibility attrControlGrp attrEnumOptionMenu ' +
+      'attrEnumOptionMenuGrp attrFieldGrp attrFieldSliderGrp attrNavigationControlGrp ' +
+      'attrPresetEditWin attributeExists attributeInfo attributeMenu attributeQuery ' +
+      'autoKeyframe autoPlace bakeClip bakeFluidShading bakePartialHistory bakeResults ' +
+      'bakeSimulation basename basenameEx batchRender bessel bevel bevelPlus binMembership ' +
+      'bindSkin blend2 blendShape blendShapeEditor blendShapePanel blendTwoAttr blindDataType ' +
+      'boneLattice boundary boxDollyCtx boxZoomCtx bufferCurve buildBookmarkMenu ' +
+      'buildKeyframeMenu button buttonManip CBG cacheFile cacheFileCombine cacheFileMerge ' +
+      'cacheFileTrack camera cameraView canCreateManip canvas capitalizeString catch ' +
+      'catchQuiet ceil changeSubdivComponentDisplayLevel changeSubdivRegion channelBox ' +
+      'character characterMap characterOutlineEditor characterize chdir checkBox checkBoxGrp ' +
+      'checkDefaultRenderGlobals choice circle circularFillet clamp clear clearCache clip ' +
+      'clipEditor clipEditorCurrentTimeCtx clipSchedule clipSchedulerOutliner clipTrimBefore ' +
+      'closeCurve closeSurface cluster cmdFileOutput cmdScrollFieldExecuter ' +
+      'cmdScrollFieldReporter cmdShell coarsenSubdivSelectionList collision color ' +
+      'colorAtPoint colorEditor colorIndex colorIndexSliderGrp colorSliderButtonGrp ' +
+      'colorSliderGrp columnLayout commandEcho commandLine commandPort compactHairSystem ' +
+      'componentEditor compositingInterop computePolysetVolume condition cone confirmDialog ' +
+      'connectAttr connectControl connectDynamic connectJoint connectionInfo constrain ' +
+      'constrainValue constructionHistory container containsMultibyte contextInfo control ' +
+      'convertFromOldLayers convertIffToPsd convertLightmap convertSolidTx convertTessellation ' +
+      'convertUnit copyArray copyFlexor copyKey copySkinWeights cos cpButton cpCache ' +
+      'cpClothSet cpCollision cpConstraint cpConvClothToMesh cpForces cpGetSolverAttr cpPanel ' +
+      'cpProperty cpRigidCollisionFilter cpSeam cpSetEdit cpSetSolverAttr cpSolver ' +
+      'cpSolverTypes cpTool cpUpdateClothUVs createDisplayLayer createDrawCtx createEditor ' +
+      'createLayeredPsdFile createMotionField createNewShelf createNode createRenderLayer ' +
+      'createSubdivRegion cross crossProduct ctxAbort ctxCompletion ctxEditMode ctxTraverse ' +
+      'currentCtx currentTime currentTimeCtx currentUnit currentUnit curve curveAddPtCtx ' +
+      'curveCVCtx curveEPCtx curveEditorCtx curveIntersect curveMoveEPCtx curveOnSurface ' +
+      'curveSketchCtx cutKey cycleCheck cylinder dagPose date defaultLightListCheckBox ' +
+      'defaultNavigation defineDataServer defineVirtualDevice deformer deg_to_rad delete ' +
+      'deleteAttr deleteShadingGroupsAndMaterials deleteShelfTab deleteUI deleteUnusedBrushes ' +
+      'delrandstr detachCurve detachDeviceAttr detachSurface deviceEditor devicePanel dgInfo ' +
+      'dgdirty dgeval dgtimer dimWhen directKeyCtx directionalLight dirmap dirname disable ' +
+      'disconnectAttr disconnectJoint diskCache displacementToPoly displayAffected ' +
+      'displayColor displayCull displayLevelOfDetail displayPref displayRGBColor ' +
+      'displaySmoothness displayStats displayString displaySurface distanceDimContext ' +
+      'distanceDimension doBlur dolly dollyCtx dopeSheetEditor dot dotProduct ' +
+      'doubleProfileBirailSurface drag dragAttrContext draggerContext dropoffLocator ' +
+      'duplicate duplicateCurve duplicateSurface dynCache dynControl dynExport dynExpression ' +
+      'dynGlobals dynPaintEditor dynParticleCtx dynPref dynRelEdPanel dynRelEditor ' +
+      'dynamicLoad editAttrLimits editDisplayLayerGlobals editDisplayLayerMembers ' +
+      'editRenderLayerAdjustment editRenderLayerGlobals editRenderLayerMembers editor ' +
+      'editorTemplate effector emit emitter enableDevice encodeString endString endsWith env ' +
+      'equivalent equivalentTol erf error eval eval evalDeferred evalEcho event ' +
+      'exactWorldBoundingBox exclusiveLightCheckBox exec executeForEachObject exists exp ' +
+      'expression expressionEditorListen extendCurve extendSurface extrude fcheck fclose feof ' +
+      'fflush fgetline fgetword file fileBrowserDialog fileDialog fileExtension fileInfo ' +
+      'filetest filletCurve filter filterCurve filterExpand filterStudioImport ' +
+      'findAllIntersections findAnimCurves findKeyframe findMenuItem findRelatedSkinCluster ' +
+      'finder firstParentOf fitBspline flexor floatEq floatField floatFieldGrp floatScrollBar ' +
+      'floatSlider floatSlider2 floatSliderButtonGrp floatSliderGrp floor flow fluidCacheInfo ' +
+      'fluidEmitter fluidVoxelInfo flushUndo fmod fontDialog fopen formLayout format fprint ' +
+      'frameLayout fread freeFormFillet frewind fromNativePath fwrite gamma gauss ' +
+      'geometryConstraint getApplicationVersionAsFloat getAttr getClassification ' +
+      'getDefaultBrush getFileList getFluidAttr getInputDeviceRange getMayaPanelTypes ' +
+      'getModifiers getPanel getParticleAttr getPluginResource getenv getpid glRender ' +
+      'glRenderEditor globalStitch gmatch goal gotoBindPose grabColor gradientControl ' +
+      'gradientControlNoAttr graphDollyCtx graphSelectContext graphTrackCtx gravity grid ' +
+      'gridLayout group groupObjectsByName HfAddAttractorToAS HfAssignAS HfBuildEqualMap ' +
+      'HfBuildFurFiles HfBuildFurImages HfCancelAFR HfConnectASToHF HfCreateAttractor ' +
+      'HfDeleteAS HfEditAS HfPerformCreateAS HfRemoveAttractorFromAS HfSelectAttached ' +
+      'HfSelectAttractors HfUnAssignAS hardenPointCurve hardware hardwareRenderPanel ' +
+      'headsUpDisplay headsUpMessage help helpLine hermite hide hilite hitTest hotBox hotkey ' +
+      'hotkeyCheck hsv_to_rgb hudButton hudSlider hudSliderButton hwReflectionMap hwRender ' +
+      'hwRenderLoad hyperGraph hyperPanel hyperShade hypot iconTextButton iconTextCheckBox ' +
+      'iconTextRadioButton iconTextRadioCollection iconTextScrollList iconTextStaticLabel ' +
+      'ikHandle ikHandleCtx ikHandleDisplayScale ikSolver ikSplineHandleCtx ikSystem ' +
+      'ikSystemInfo ikfkDisplayMethod illustratorCurves image imfPlugins inheritTransform ' +
+      'insertJoint insertJointCtx insertKeyCtx insertKnotCurve insertKnotSurface instance ' +
+      'instanceable instancer intField intFieldGrp intScrollBar intSlider intSliderGrp ' +
+      'interToUI internalVar intersect iprEngine isAnimCurve isConnected isDirty isParentOf ' +
+      'isSameObject isTrue isValidObjectName isValidString isValidUiName isolateSelect ' +
+      'itemFilter itemFilterAttr itemFilterRender itemFilterType joint jointCluster jointCtx ' +
+      'jointDisplayScale jointLattice keyTangent keyframe keyframeOutliner ' +
+      'keyframeRegionCurrentTimeCtx keyframeRegionDirectKeyCtx keyframeRegionDollyCtx ' +
+      'keyframeRegionInsertKeyCtx keyframeRegionMoveKeyCtx keyframeRegionScaleKeyCtx ' +
+      'keyframeRegionSelectKeyCtx keyframeRegionSetKeyCtx keyframeRegionTrackCtx ' +
+      'keyframeStats lassoContext lattice latticeDeformKeyCtx launch launchImageEditor ' +
+      'layerButton layeredShaderPort layeredTexturePort layout layoutDialog lightList ' +
+      'lightListEditor lightListPanel lightlink lineIntersection linearPrecision linstep ' +
+      'listAnimatable listAttr listCameras listConnections listDeviceAttachments listHistory ' +
+      'listInputDeviceAxes listInputDeviceButtons listInputDevices listMenuAnnotation ' +
+      'listNodeTypes listPanelCategories listRelatives listSets listTransforms ' +
+      'listUnselected listerEditor loadFluid loadNewShelf loadPlugin ' +
+      'loadPluginLanguageResources loadPrefObjects localizedPanelLabel lockNode loft log ' +
+      'longNameOf lookThru ls lsThroughFilter lsType lsUI Mayatomr mag makeIdentity makeLive ' +
+      'makePaintable makeRoll makeSingleSurface makeTubeOn makebot manipMoveContext ' +
+      'manipMoveLimitsCtx manipOptions manipRotateContext manipRotateLimitsCtx ' +
+      'manipScaleContext manipScaleLimitsCtx marker match max memory menu menuBarLayout ' +
+      'menuEditor menuItem menuItemToShelf menuSet menuSetPref messageLine min minimizeApp ' +
+      'mirrorJoint modelCurrentTimeCtx modelEditor modelPanel mouse movIn movOut move ' +
+      'moveIKtoFK moveKeyCtx moveVertexAlongDirection multiProfileBirailSurface mute ' +
+      'nParticle nameCommand nameField namespace namespaceInfo newPanelItems newton nodeCast ' +
+      'nodeIconButton nodeOutliner nodePreset nodeType noise nonLinear normalConstraint ' +
+      'normalize nurbsBoolean nurbsCopyUVSet nurbsCube nurbsEditUV nurbsPlane nurbsSelect ' +
+      'nurbsSquare nurbsToPoly nurbsToPolygonsPref nurbsToSubdiv nurbsToSubdivPref ' +
+      'nurbsUVSet nurbsViewDirectionVector objExists objectCenter objectLayer objectType ' +
+      'objectTypeUI obsoleteProc oceanNurbsPreviewPlane offsetCurve offsetCurveOnSurface ' +
+      'offsetSurface openGLExtension openMayaPref optionMenu optionMenuGrp optionVar orbit ' +
+      'orbitCtx orientConstraint outlinerEditor outlinerPanel overrideModifier ' +
+      'paintEffectsDisplay pairBlend palettePort paneLayout panel panelConfiguration ' +
+      'panelHistory paramDimContext paramDimension paramLocator parent parentConstraint ' +
+      'particle particleExists particleInstancer particleRenderInfo partition pasteKey ' +
+      'pathAnimation pause pclose percent performanceOptions pfxstrokes pickWalk picture ' +
+      'pixelMove planarSrf plane play playbackOptions playblast plugAttr plugNode pluginInfo ' +
+      'pluginResourceUtil pointConstraint pointCurveConstraint pointLight pointMatrixMult ' +
+      'pointOnCurve pointOnSurface pointPosition poleVectorConstraint polyAppend ' +
+      'polyAppendFacetCtx polyAppendVertex polyAutoProjection polyAverageNormal ' +
+      'polyAverageVertex polyBevel polyBlendColor polyBlindData polyBoolOp polyBridgeEdge ' +
+      'polyCacheMonitor polyCheck polyChipOff polyClipboard polyCloseBorder polyCollapseEdge ' +
+      'polyCollapseFacet polyColorBlindData polyColorDel polyColorPerVertex polyColorSet ' +
+      'polyCompare polyCone polyCopyUV polyCrease polyCreaseCtx polyCreateFacet ' +
+      'polyCreateFacetCtx polyCube polyCut polyCutCtx polyCylinder polyCylindricalProjection ' +
+      'polyDelEdge polyDelFacet polyDelVertex polyDuplicateAndConnect polyDuplicateEdge ' +
+      'polyEditUV polyEditUVShell polyEvaluate polyExtrudeEdge polyExtrudeFacet ' +
+      'polyExtrudeVertex polyFlipEdge polyFlipUV polyForceUV polyGeoSampler polyHelix ' +
+      'polyInfo polyInstallAction polyLayoutUV polyListComponentConversion polyMapCut ' +
+      'polyMapDel polyMapSew polyMapSewMove polyMergeEdge polyMergeEdgeCtx polyMergeFacet ' +
+      'polyMergeFacetCtx polyMergeUV polyMergeVertex polyMirrorFace polyMoveEdge ' +
+      'polyMoveFacet polyMoveFacetUV polyMoveUV polyMoveVertex polyNormal polyNormalPerVertex ' +
+      'polyNormalizeUV polyOptUvs polyOptions polyOutput polyPipe polyPlanarProjection ' +
+      'polyPlane polyPlatonicSolid polyPoke polyPrimitive polyPrism polyProjection ' +
+      'polyPyramid polyQuad polyQueryBlindData polyReduce polySelect polySelectConstraint ' +
+      'polySelectConstraintMonitor polySelectCtx polySelectEditCtx polySeparate ' +
+      'polySetToFaceNormal polySewEdge polyShortestPathCtx polySmooth polySoftEdge ' +
+      'polySphere polySphericalProjection polySplit polySplitCtx polySplitEdge polySplitRing ' +
+      'polySplitVertex polyStraightenUVBorder polySubdivideEdge polySubdivideFacet ' +
+      'polyToSubdiv polyTorus polyTransfer polyTriangulate polyUVSet polyUnite polyWedgeFace ' +
+      'popen popupMenu pose pow preloadRefEd print progressBar progressWindow projFileViewer ' +
+      'projectCurve projectTangent projectionContext projectionManip promptDialog propModCtx ' +
+      'propMove psdChannelOutliner psdEditTextureFile psdExport psdTextureFile putenv pwd ' +
+      'python querySubdiv quit rad_to_deg radial radioButton radioButtonGrp radioCollection ' +
+      'radioMenuItemCollection rampColorPort rand randomizeFollicles randstate rangeControl ' +
+      'readTake rebuildCurve rebuildSurface recordAttr recordDevice redo reference ' +
+      'referenceEdit referenceQuery refineSubdivSelectionList refresh refreshAE ' +
+      'registerPluginResource rehash reloadImage removeJoint removeMultiInstance ' +
+      'removePanelCategory rename renameAttr renameSelectionList renameUI render ' +
+      'renderGlobalsNode renderInfo renderLayerButton renderLayerParent ' +
+      'renderLayerPostProcess renderLayerUnparent renderManip renderPartition ' +
+      'renderQualityNode renderSettings renderThumbnailUpdate renderWindowEditor ' +
+      'renderWindowSelectContext renderer reorder reorderDeformers requires reroot ' +
+      'resampleFluid resetAE resetPfxToPolyCamera resetTool resolutionNode retarget ' +
+      'reverseCurve reverseSurface revolve rgb_to_hsv rigidBody rigidSolver roll rollCtx ' +
+      'rootOf rot rotate rotationInterpolation roundConstantRadius rowColumnLayout rowLayout ' +
+      'runTimeCommand runup sampleImage saveAllShelves saveAttrPreset saveFluid saveImage ' +
+      'saveInitialState saveMenu savePrefObjects savePrefs saveShelf saveToolSettings scale ' +
+      'scaleBrushBrightness scaleComponents scaleConstraint scaleKey scaleKeyCtx sceneEditor ' +
+      'sceneUIReplacement scmh scriptCtx scriptEditorInfo scriptJob scriptNode scriptTable ' +
+      'scriptToShelf scriptedPanel scriptedPanelType scrollField scrollLayout sculpt ' +
+      'searchPathArray seed selLoadSettings select selectContext selectCurveCV selectKey ' +
+      'selectKeyCtx selectKeyframeRegionCtx selectMode selectPref selectPriority selectType ' +
+      'selectedNodes selectionConnection separator setAttr setAttrEnumResource ' +
+      'setAttrMapping setAttrNiceNameResource setConstraintRestPosition ' +
+      'setDefaultShadingGroup setDrivenKeyframe setDynamic setEditCtx setEditor setFluidAttr ' +
+      'setFocus setInfinity setInputDeviceMapping setKeyCtx setKeyPath setKeyframe ' +
+      'setKeyframeBlendshapeTargetWts setMenuMode setNodeNiceNameResource setNodeTypeFlag ' +
+      'setParent setParticleAttr setPfxToPolyCamera setPluginResource setProject ' +
+      'setStampDensity setStartupMessage setState setToolTo setUITemplate setXformManip sets ' +
+      'shadingConnection shadingGeometryRelCtx shadingLightRelCtx shadingNetworkCompare ' +
+      'shadingNode shapeCompare shelfButton shelfLayout shelfTabLayout shellField ' +
+      'shortNameOf showHelp showHidden showManipCtx showSelectionInTitle ' +
+      'showShadingGroupAttrEditor showWindow sign simplify sin singleProfileBirailSurface ' +
+      'size sizeBytes skinCluster skinPercent smoothCurve smoothTangentSurface smoothstep ' +
+      'snap2to2 snapKey snapMode snapTogetherCtx snapshot soft softMod softModCtx sort sound ' +
+      'soundControl source spaceLocator sphere sphrand spotLight spotLightPreviewPort ' +
+      'spreadSheetEditor spring sqrt squareSurface srtContext stackTrace startString ' +
+      'startsWith stitchAndExplodeShell stitchSurface stitchSurfacePoints strcmp ' +
+      'stringArrayCatenate stringArrayContains stringArrayCount stringArrayInsertAtIndex ' +
+      'stringArrayIntersector stringArrayRemove stringArrayRemoveAtIndex ' +
+      'stringArrayRemoveDuplicates stringArrayRemoveExact stringArrayToString ' +
+      'stringToStringArray strip stripPrefixFromName stroke subdAutoProjection ' +
+      'subdCleanTopology subdCollapse subdDuplicateAndConnect subdEditUV ' +
+      'subdListComponentConversion subdMapCut subdMapSewMove subdMatchTopology subdMirror ' +
+      'subdToBlind subdToPoly subdTransferUVsToCache subdiv subdivCrease ' +
+      'subdivDisplaySmoothness substitute substituteAllString substituteGeometry substring ' +
+      'surface surfaceSampler surfaceShaderList swatchDisplayPort switchTable symbolButton ' +
+      'symbolCheckBox sysFile system tabLayout tan tangentConstraint texLatticeDeformContext ' +
+      'texManipContext texMoveContext texMoveUVShellContext texRotateContext texScaleContext ' +
+      'texSelectContext texSelectShortestPathCtx texSmudgeUVContext texWinToolCtx text ' +
+      'textCurves textField textFieldButtonGrp textFieldGrp textManip textScrollList ' +
+      'textToShelf textureDisplacePlane textureHairColor texturePlacementContext ' +
+      'textureWindow threadCount threePointArcCtx timeControl timePort timerX toNativePath ' +
+      'toggle toggleAxis toggleWindowVisibility tokenize tokenizeList tolerance tolower ' +
+      'toolButton toolCollection toolDropped toolHasOptions toolPropertyWindow torus toupper ' +
+      'trace track trackCtx transferAttributes transformCompare transformLimits translator ' +
+      'trim trunc truncateFluidCache truncateHairCache tumble tumbleCtx turbulence ' +
+      'twoPointArcCtx uiRes uiTemplate unassignInputDevice undo undoInfo ungroup uniform unit ' +
+      'unloadPlugin untangleUV untitledFileName untrim upAxis updateAE userCtx uvLink ' +
+      'uvSnapshot validateShelfName vectorize view2dToolCtx viewCamera viewClipPlane ' +
+      'viewFit viewHeadOn viewLookAt viewManip viewPlace viewSet visor volumeAxis vortex ' +
+      'waitCursor warning webBrowser webBrowserPrefs whatIs window windowPref wire ' +
+      'wireContext workspace wrinkle wrinkleContext writeTake xbmLangPathList xform',
+    illegal: '</',
+    contains: [
+      hljs.C_NUMBER_MODE,
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      {
+        className: 'string',
+        begin: '`', end: '`',
+        contains: [hljs.BACKSLASH_ESCAPE]
+      },
+      {
+        className: 'variable',
+        begin: '\\$\\d',
+        relevance: 5
+      },
+      {
+        className: 'variable',
+        begin: '[\\$\\%\\@\\*](\\^\\w\\b|#\\w+|[^\\s\\w{]|{\\w+}|\\w+)'
+      },
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['nginx'] = function(hljs) {
+  var VARS = [
+    {
+      className: 'variable', begin: '\\$\\d+'
+    },
+    {
+      className: 'variable', begin: '\\${', end: '}'
+    },
+    {
+      className: 'variable', begin: '[\\$\\@]' + hljs.UNDERSCORE_IDENT_RE
+    }
+  ];
+  var DEFAULT = {
+    endsWithParent: true,
+    lexems: '[a-z/_]+',
+    keywords: {
+      built_in:
+        'on off yes no true false none blocked debug info notice warn error crit ' +
+        'select break last permanent redirect kqueue rtsig epoll poll /dev/poll'
+    },
+    relevance: 0,
+    illegal: '=>',
+    contains: [
+      hljs.HASH_COMMENT_MODE,
+      {
+        className: 'string',
+        begin: '"', end: '"',
+        contains: [hljs.BACKSLASH_ESCAPE].concat(VARS),
+        relevance: 0
+      },
+      {
+        className: 'string',
+        begin: "'", end: "'",
+        contains: [hljs.BACKSLASH_ESCAPE].concat(VARS),
+        relevance: 0
+      },
+      {
+        className: 'url',
+        begin: '([a-z]+):/', end: '\\s', endsWithParent: true, excludeEnd: true
+      },
+      {
+        className: 'regexp',
+        begin: "\\s\\^", end: "\\s|{|;", returnEnd: true,
+        contains: [hljs.BACKSLASH_ESCAPE].concat(VARS)
+      },
+      // regexp locations (~, ~*)
+      {
+        className: 'regexp',
+        begin: "~\\*?\\s+", end: "\\s|{|;", returnEnd: true,
+        contains: [hljs.BACKSLASH_ESCAPE].concat(VARS)
+      },
+      // *.example.com
+      {
+        className: 'regexp',
+        begin: "\\*(\\.[a-z\\-]+)+",
+        contains: [hljs.BACKSLASH_ESCAPE].concat(VARS)
+      },
+      // sub.example.*
+      {
+        className: 'regexp',
+        begin: "([a-z\\-]+\\.)+\\*",
+        contains: [hljs.BACKSLASH_ESCAPE].concat(VARS)
+      },
+      // IP
+      {
+        className: 'number',
+        begin: '\\b\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}(:\\d{1,5})?\\b'
+      },
+      // units
+      {
+        className: 'number',
+        begin: '\\b\\d+[kKmMgGdshdwy]*\\b',
+        relevance: 0
+      }
+    ].concat(VARS)
+  };
+
+  return {
+    contains: [
+      hljs.HASH_COMMENT_MODE,
+      {
+        begin: hljs.UNDERSCORE_IDENT_RE + '\\s', end: ';|{', returnBegin: true,
+        contains: [
+          {
+            className: 'title',
+            begin: hljs.UNDERSCORE_IDENT_RE,
+            starts: DEFAULT
+          }
+        ]
+      }
+    ],
+    illegal: '[^\\s\\}]'
+  };
+}(hljs);
+hljs.LANGUAGES['objectivec'] = function(hljs) {
+  var OBJC_KEYWORDS = {
+    keyword:
+      'int float while private char catch export sizeof typedef const struct for union ' +
+      'unsigned long volatile static protected bool mutable if public do return goto void ' +
+      'enum else break extern class asm case short default double throw register explicit ' +
+      'signed typename try this switch continue wchar_t inline readonly assign property ' +
+      'protocol self synchronized end synthesize id optional required implementation ' +
+      'nonatomic interface super unichar finally dynamic IBOutlet IBAction selector strong ' +
+      'weak readonly',
+    literal:
+    	'false true FALSE TRUE nil YES NO NULL',
+    built_in:
+      'NSString NSDictionary CGRect CGPoint UIButton UILabel UITextView UIWebView MKMapView ' +
+      'UISegmentedControl NSObject UITableViewDelegate UITableViewDataSource NSThread ' +
+      'UIActivityIndicator UITabbar UIToolBar UIBarButtonItem UIImageView NSAutoreleasePool ' +
+      'UITableView BOOL NSInteger CGFloat NSException NSLog NSMutableString NSMutableArray ' +
+      'NSMutableDictionary NSURL NSIndexPath CGSize UITableViewCell UIView UIViewController ' +
+      'UINavigationBar UINavigationController UITabBarController UIPopoverController ' +
+      'UIPopoverControllerDelegate UIImage NSNumber UISearchBar NSFetchedResultsController ' +
+      'NSFetchedResultsChangeType UIScrollView UIScrollViewDelegate UIEdgeInsets UIColor ' +
+      'UIFont UIApplication NSNotFound NSNotificationCenter NSNotification ' +
+      'UILocalNotification NSBundle NSFileManager NSTimeInterval NSDate NSCalendar ' +
+      'NSUserDefaults UIWindow NSRange NSArray NSError NSURLRequest NSURLConnection class ' +
+      'UIInterfaceOrientation MPMoviePlayerController dispatch_once_t ' +
+      'dispatch_queue_t dispatch_sync dispatch_async dispatch_once'
+  };
+  return {
+    keywords: OBJC_KEYWORDS,
+    illegal: '</',
+    contains: [
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.C_NUMBER_MODE,
+      hljs.QUOTE_STRING_MODE,
+      {
+        className: 'string',
+        begin: '\'',
+        end: '[^\\\\]\'',
+        illegal: '[^\\\\][^\']'
+      },
+
+      {
+        className: 'preprocessor',
+        begin: '#import',
+        end: '$',
+        contains: [
+        {
+          className: 'title',
+          begin: '\"',
+          end: '\"'
+        },
+        {
+          className: 'title',
+          begin: '<',
+          end: '>'
+        }
+        ]
+      },
+      {
+        className: 'preprocessor',
+        begin: '#',
+        end: '$'
+      },
+      {
+        className: 'class',
+        beginWithKeyword: true,
+        end: '({|$)',
+        keywords: 'interface class protocol implementation',
+        contains: [{
+          className: 'id',
+          begin: hljs.UNDERSCORE_IDENT_RE
+        }
+        ]
+      },
+      {
+        className: 'variable',
+        begin: '\\.'+hljs.UNDERSCORE_IDENT_RE
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['parser3'] = function(hljs) {
+  return {
+    subLanguage: 'xml',
+    contains: [
+      {
+        className: 'comment',
+        begin: '^#', end: '$'
+      },
+      {
+        className: 'comment',
+        begin: '\\^rem{', end: '}',
+        relevance: 10,
+        contains: [
+          {
+            begin: '{', end: '}',
+            contains: ['self']
+          }
+        ]
+      },
+      {
+        className: 'preprocessor',
+        begin: '^@(?:BASE|USE|CLASS|OPTIONS)$',
+        relevance: 10
+      },
+      {
+        className: 'title',
+        begin: '@[\\w\\-]+\\[[\\w^;\\-]*\\](?:\\[[\\w^;\\-]*\\])?(?:.*)$'
+      },
+      {
+        className: 'variable',
+        begin: '\\$\\{?[\\w\\-\\.\\:]+\\}?'
+      },
+      {
+        className: 'keyword',
+        begin: '\\^[\\w\\-\\.\\:]+'
+      },
+      {
+        className: 'number',
+        begin: '\\^#[0-9a-fA-F]+'
+      },
+      hljs.C_NUMBER_MODE
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['perl'] = function(hljs) {
+  var PERL_KEYWORDS = 'getpwent getservent quotemeta msgrcv scalar kill dbmclose undef lc ' +
+    'ma syswrite tr send umask sysopen shmwrite vec qx utime local oct semctl localtime ' +
+    'readpipe do return format read sprintf dbmopen pop getpgrp not getpwnam rewinddir qq' +
+    'fileno qw endprotoent wait sethostent bless s|0 opendir continue each sleep endgrent ' +
+    'shutdown dump chomp connect getsockname die socketpair close flock exists index shmget' +
+    'sub for endpwent redo lstat msgctl setpgrp abs exit select print ref gethostbyaddr ' +
+    'unshift fcntl syscall goto getnetbyaddr join gmtime symlink semget splice x|0 ' +
+    'getpeername recv log setsockopt cos last reverse gethostbyname getgrnam study formline ' +
+    'endhostent times chop length gethostent getnetent pack getprotoent getservbyname rand ' +
+    'mkdir pos chmod y|0 substr endnetent printf next open msgsnd readdir use unlink ' +
+    'getsockopt getpriority rindex wantarray hex system getservbyport endservent int chr ' +
+    'untie rmdir prototype tell listen fork shmread ucfirst setprotoent else sysseek link ' +
+    'getgrgid shmctl waitpid unpack getnetbyname reset chdir grep split require caller ' +
+    'lcfirst until warn while values shift telldir getpwuid my getprotobynumber delete and ' +
+    'sort uc defined srand accept package seekdir getprotobyname semop our rename seek if q|0 ' +
+    'chroot sysread setpwent no crypt getc chown sqrt write setnetent setpriority foreach ' +
+    'tie sin msgget map stat getlogin unless elsif truncate exec keys glob tied closedir' +
+    'ioctl socket readlink eval xor readline binmode setservent eof ord bind alarm pipe ' +
+    'atan2 getgrent exp time push setgrent gt lt or ne m|0';
+  var SUBST = {
+    className: 'subst',
+    begin: '[$@]\\{', end: '\\}',
+    keywords: PERL_KEYWORDS,
+    relevance: 10
+  };
+  var VAR1 = {
+    className: 'variable',
+    begin: '\\$\\d'
+  };
+  var VAR2 = {
+    className: 'variable',
+    begin: '[\\$\\%\\@\\*](\\^\\w\\b|#\\w+(\\:\\:\\w+)*|[^\\s\\w{]|{\\w+}|\\w+(\\:\\:\\w*)*)'
+  };
+  var STRING_CONTAINS = [hljs.BACKSLASH_ESCAPE, SUBST, VAR1, VAR2];
+  var METHOD = {
+    begin: '->',
+    contains: [
+      {begin: hljs.IDENT_RE},
+      {begin: '{', end: '}'}
+    ]
+  };
+  var COMMENT = {
+    className: 'comment',
+    begin: '^(__END__|__DATA__)', end: '\\n$',
+    relevance: 5
+  }
+  var PERL_DEFAULT_CONTAINS = [
+    VAR1, VAR2,
+    hljs.HASH_COMMENT_MODE,
+    COMMENT,
+    {
+      className: 'comment',
+      begin: '^\\=\\w', end: '\\=cut', endsWithParent: true
+    },
+    METHOD,
+    {
+      className: 'string',
+      begin: 'q[qwxr]?\\s*\\(', end: '\\)',
+      contains: STRING_CONTAINS,
+      relevance: 5
+    },
+    {
+      className: 'string',
+      begin: 'q[qwxr]?\\s*\\[', end: '\\]',
+      contains: STRING_CONTAINS,
+      relevance: 5
+    },
+    {
+      className: 'string',
+      begin: 'q[qwxr]?\\s*\\{', end: '\\}',
+      contains: STRING_CONTAINS,
+      relevance: 5
+    },
+    {
+      className: 'string',
+      begin: 'q[qwxr]?\\s*\\|', end: '\\|',
+      contains: STRING_CONTAINS,
+      relevance: 5
+    },
+    {
+      className: 'string',
+      begin: 'q[qwxr]?\\s*\\<', end: '\\>',
+      contains: STRING_CONTAINS,
+      relevance: 5
+    },
+    {
+      className: 'string',
+      begin: 'qw\\s+q', end: 'q',
+      contains: STRING_CONTAINS,
+      relevance: 5
+    },
+    {
+      className: 'string',
+      begin: '\'', end: '\'',
+      contains: [hljs.BACKSLASH_ESCAPE],
+      relevance: 0
+    },
+    {
+      className: 'string',
+      begin: '"', end: '"',
+      contains: STRING_CONTAINS,
+      relevance: 0
+    },
+    {
+      className: 'string',
+      begin: '`', end: '`',
+      contains: [hljs.BACKSLASH_ESCAPE]
+    },
+    {
+      className: 'string',
+      begin: '{\\w+}',
+      relevance: 0
+    },
+    {
+      className: 'string',
+      begin: '\-?\\w+\\s*\\=\\>',
+      relevance: 0
+    },
+    {
+      className: 'number',
+      begin: '(\\b0[0-7_]+)|(\\b0x[0-9a-fA-F_]+)|(\\b[1-9][0-9_]*(\\.[0-9_]+)?)|[0_]\\b',
+      relevance: 0
+    },
+    { // regexp container
+      begin: '(' + hljs.RE_STARTERS_RE + '|\\b(split|return|print|reverse|grep)\\b)\\s*',
+      keywords: 'split return print reverse grep',
+      relevance: 0,
+      contains: [
+        hljs.HASH_COMMENT_MODE,
+        COMMENT,
+        {
+          className: 'regexp',
+          begin: '(s|tr|y)/(\\\\.|[^/])*/(\\\\.|[^/])*/[a-z]*',
+          relevance: 10
+        },
+        {
+          className: 'regexp',
+          begin: '(m|qr)?/', end: '/[a-z]*',
+          contains: [hljs.BACKSLASH_ESCAPE],
+          relevance: 0 // allows empty "//" which is a common comment delimiter in other languages
+        }
+      ]
+    },
+    {
+      className: 'sub',
+      beginWithKeyword: true, end: '(\\s*\\(.*?\\))?[;{]',
+      keywords: 'sub',
+      relevance: 5
+    },
+    {
+      className: 'operator',
+      begin: '-\\w\\b',
+      relevance: 0
+    }
+  ];
+  SUBST.contains = PERL_DEFAULT_CONTAINS;
+  METHOD.contains[1].contains = PERL_DEFAULT_CONTAINS;
+
+  return {
+    keywords: PERL_KEYWORDS,
+    contains: PERL_DEFAULT_CONTAINS
+  };
+}(hljs);
+hljs.LANGUAGES['php'] = function(hljs) {
+  var VARIABLE = {
+    className: 'variable', begin: '\\$+[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
+  };
+  var STRINGS = [
+    hljs.inherit(hljs.APOS_STRING_MODE, {illegal: null}),
+    hljs.inherit(hljs.QUOTE_STRING_MODE, {illegal: null}),
+    {
+      className: 'string',
+      begin: 'b"', end: '"',
+      contains: [hljs.BACKSLASH_ESCAPE]
+    },
+    {
+      className: 'string',
+      begin: 'b\'', end: '\'',
+      contains: [hljs.BACKSLASH_ESCAPE]
+    }
+  ];
+  var NUMBERS = [
+    hljs.C_NUMBER_MODE, // 0x..., 0..., decimal, float
+    hljs.BINARY_NUMBER_MODE // 0b...
+  ];
+  var TITLE = {
+    className: 'title', begin: hljs.UNDERSCORE_IDENT_RE
+  };
+  return {
+    case_insensitive: true,
+    keywords:
+      'and include_once list abstract global private echo interface as static endswitch ' +
+      'array null if endwhile or const for endforeach self var while isset public ' +
+      'protected exit foreach throw elseif include __FILE__ empty require_once do xor ' +
+      'return implements parent clone use __CLASS__ __LINE__ else break print eval new ' +
+      'catch __METHOD__ case exception php_user_filter default die require __FUNCTION__ ' +
+      'enddeclare final try this switch continue endfor endif declare unset true false ' +
+      'namespace trait goto instanceof insteadof __DIR__ __NAMESPACE__ __halt_compiler',
+    contains: [
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.HASH_COMMENT_MODE,
+      {
+        className: 'comment',
+        begin: '/\\*', end: '\\*/',
+        contains: [{
+            className: 'phpdoc',
+            begin: '\\s@[A-Za-z]+'
+        }]
+      },
+      {
+          className: 'comment',
+          excludeBegin: true,
+          begin: '__halt_compiler.+?;', endsWithParent: true
+      },
+      {
+        className: 'string',
+        begin: '<<<[\'"]?\\w+[\'"]?$', end: '^\\w+;',
+        contains: [hljs.BACKSLASH_ESCAPE]
+      },
+      {
+        className: 'preprocessor',
+        begin: '<\\?php',
+        relevance: 10
+      },
+      {
+        className: 'preprocessor',
+        begin: '\\?>'
+      },
+      VARIABLE,
+      {
+        className: 'function',
+        beginWithKeyword: true, end: '{',
+        keywords: 'function',
+        illegal: '\\$|\\[|%',
+        contains: [
+          TITLE,
+          {
+            className: 'params',
+            begin: '\\(', end: '\\)',
+            contains: [
+              'self',
+              VARIABLE,
+              hljs.C_BLOCK_COMMENT_MODE
+            ].concat(STRINGS).concat(NUMBERS)
+          }
+        ]
+      },
+      {
+        className: 'class',
+        beginWithKeyword: true, end: '{',
+        keywords: 'class',
+        illegal: '[:\\(\\$]',
+        contains: [
+          {
+            beginWithKeyword: true, endsWithParent: true,
+            keywords: 'extends',
+            contains: [TITLE]
+          },
+          TITLE
+        ]
+      },
+      {
+        begin: '=>' // No markup, just a relevance booster
+      }
+    ].concat(STRINGS).concat(NUMBERS)
+  };
+}(hljs);
+hljs.LANGUAGES['profile'] = function(hljs) {
+  return {
+    contains: [
+      hljs.C_NUMBER_MODE,
+      {
+        className: 'builtin',
+        begin: '{', end: '}$',
+        excludeBegin: true, excludeEnd: true,
+        contains: [hljs.APOS_STRING_MODE, hljs.QUOTE_STRING_MODE],
+        relevance: 0
+      },
+      {
+        className: 'filename',
+        begin: '[a-zA-Z_][\\da-zA-Z_]+\\.[\\da-zA-Z_]{1,3}', end: ':',
+        excludeEnd: true
+      },
+      {
+        className: 'header',
+        begin: '(ncalls|tottime|cumtime)', end: '$',
+        keywords: 'ncalls tottime|10 cumtime|10 filename',
+        relevance: 10
+      },
+      {
+        className: 'summary',
+        begin: 'function calls', end: '$',
+        contains: [hljs.C_NUMBER_MODE],
+        relevance: 10
+      },
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      {
+        className: 'function',
+        begin: '\\(', end: '\\)$',
+        contains: [{
+          className: 'title',
+          begin: hljs.UNDERSCORE_IDENT_RE,
+          relevance: 0
+        }],
+        relevance: 0
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['python'] = function(hljs) {
+  var STRINGS = [
+    {
+      className: 'string',
+      begin: '(u|b)?r?\'\'\'', end: '\'\'\'',
+      relevance: 10
+    },
+    {
+      className: 'string',
+      begin: '(u|b)?r?"""', end: '"""',
+      relevance: 10
+    },
+    {
+      className: 'string',
+      begin: '(u|r|ur)\'', end: '\'',
+      contains: [hljs.BACKSLASH_ESCAPE],
+      relevance: 10
+    },
+    {
+      className: 'string',
+      begin: '(u|r|ur)"', end: '"',
+      contains: [hljs.BACKSLASH_ESCAPE],
+      relevance: 10
+    },
+    {
+      className: 'string',
+      begin: '(b|br)\'', end: '\'',
+      contains: [hljs.BACKSLASH_ESCAPE]
+    },
+    {
+      className: 'string',
+      begin: '(b|br)"', end: '"',
+      contains: [hljs.BACKSLASH_ESCAPE]
+    }
+  ].concat([
+    hljs.APOS_STRING_MODE,
+    hljs.QUOTE_STRING_MODE
+  ]);
+  var TITLE = {
+    className: 'title', begin: hljs.UNDERSCORE_IDENT_RE
+  };
+  var PARAMS = {
+    className: 'params',
+    begin: '\\(', end: '\\)',
+    contains: ['self', hljs.C_NUMBER_MODE].concat(STRINGS)
+  };
+  var FUNC_CLASS_PROTO = {
+    beginWithKeyword: true, end: ':',
+    illegal: '[${=;\\n]',
+    contains: [TITLE, PARAMS],
+    relevance: 10
+  };
+
+  return {
+    keywords: {
+      keyword:
+        'and elif is global as in if from raise for except finally print import pass return ' +
+        'exec else break not with class assert yield try while continue del or def lambda ' +
+        'nonlocal|10',
+      built_in:
+        'None True False Ellipsis NotImplemented'
+    },
+    illegal: '(</|->|\\?)',
+    contains: STRINGS.concat([
+      hljs.HASH_COMMENT_MODE,
+      hljs.inherit(FUNC_CLASS_PROTO, {className: 'function', keywords: 'def'}),
+      hljs.inherit(FUNC_CLASS_PROTO, {className: 'class', keywords: 'class'}),
+      hljs.C_NUMBER_MODE,
+      {
+        className: 'decorator',
+        begin: '@', end: '$'
+      },
+      {
+        begin: '\\b(print|exec)\\(' // don’t highlight keywords-turned-functions in Python 3
+      }
+    ])
+  };
+}(hljs);
+hljs.LANGUAGES['r'] = function(hljs) {
+  var IDENT_RE = '([a-zA-Z]|\\.[a-zA-Z.])[a-zA-Z0-9._]*';
+
+  return {
+    contains: [
+      hljs.HASH_COMMENT_MODE,
+      {
+        begin: IDENT_RE,
+        lexems: IDENT_RE,
+        keywords: {
+          keyword:
+            'function if in break next repeat else for return switch while try tryCatch|10 ' +
+            'stop warning require library attach detach source setMethod setGeneric ' +
+            'setGroupGeneric setClass ...|10',
+          literal:
+            'NULL NA TRUE FALSE T F Inf NaN NA_integer_|10 NA_real_|10 NA_character_|10 ' +
+            'NA_complex_|10'
+        },
+        relevance: 0
+      },
+      {
+        // hex value
+        className: 'number',
+        begin: "0[xX][0-9a-fA-F]+[Li]?\\b",
+        relevance: 0
+      },
+      {
+        // explicit integer
+        className: 'number',
+        begin: "\\d+(?:[eE][+\\-]?\\d*)?L\\b",
+        relevance: 0
+      },
+      {
+        // number with trailing decimal
+        className: 'number',
+        begin: "\\d+\\.(?!\\d)(?:i\\b)?",
+        relevance: 0
+      },
+      {
+        // number
+        className: 'number',
+        begin: "\\d+(?:\\.\\d*)?(?:[eE][+\\-]?\\d*)?i?\\b",
+        relevance: 0
+      },
+      {
+        // number with leading decimal
+        className: 'number',
+        begin: "\\.\\d+(?:[eE][+\\-]?\\d*)?i?\\b",
+        relevance: 0
+      },
+
+      {
+        // escaped identifier
+        begin: '`',
+        end: '`',
+        relevance: 0
+      },
+
+      {
+        className: 'string',
+        begin: '"',
+        end: '"',
+        contains: [hljs.BACKSLASH_ESCAPE],
+        relevance: 0
+      },
+      {
+        className: 'string',
+        begin: "'",
+        end: "'",
+        contains: [hljs.BACKSLASH_ESCAPE],
+        relevance: 0
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['rib'] = function(hljs) {
+  return {
+    keywords:
+      'ArchiveRecord AreaLightSource Atmosphere Attribute AttributeBegin AttributeEnd Basis ' +
+      'Begin Blobby Bound Clipping ClippingPlane Color ColorSamples ConcatTransform Cone ' +
+      'CoordinateSystem CoordSysTransform CropWindow Curves Cylinder DepthOfField Detail ' +
+      'DetailRange Disk Displacement Display End ErrorHandler Exposure Exterior Format ' +
+      'FrameAspectRatio FrameBegin FrameEnd GeneralPolygon GeometricApproximation Geometry ' +
+      'Hider Hyperboloid Identity Illuminate Imager Interior LightSource ' +
+      'MakeCubeFaceEnvironment MakeLatLongEnvironment MakeShadow MakeTexture Matte ' +
+      'MotionBegin MotionEnd NuPatch ObjectBegin ObjectEnd ObjectInstance Opacity Option ' +
+      'Orientation Paraboloid Patch PatchMesh Perspective PixelFilter PixelSamples ' +
+      'PixelVariance Points PointsGeneralPolygons PointsPolygons Polygon Procedural Projection ' +
+      'Quantize ReadArchive RelativeDetail ReverseOrientation Rotate Scale ScreenWindow ' +
+      'ShadingInterpolation ShadingRate Shutter Sides Skew SolidBegin SolidEnd Sphere ' +
+      'SubdivisionMesh Surface TextureCoordinates Torus Transform TransformBegin TransformEnd ' +
+      'TransformPoints Translate TrimCurve WorldBegin WorldEnd',
+    illegal: '</',
+    contains: [
+      hljs.HASH_COMMENT_MODE,
+      hljs.C_NUMBER_MODE,
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['rsl'] = function(hljs) {
+  return {
+    keywords: {
+      keyword:
+        'float color point normal vector matrix while for if do return else break extern continue',
+      built_in:
+        'abs acos ambient area asin atan atmosphere attribute calculatenormal ceil cellnoise ' +
+        'clamp comp concat cos degrees depth Deriv diffuse distance Du Dv environment exp ' +
+        'faceforward filterstep floor format fresnel incident length lightsource log match ' +
+        'max min mod noise normalize ntransform opposite option phong pnoise pow printf ' +
+        'ptlined radians random reflect refract renderinfo round setcomp setxcomp setycomp ' +
+        'setzcomp shadow sign sin smoothstep specular specularbrdf spline sqrt step tan ' +
+        'texture textureinfo trace transform vtransform xcomp ycomp zcomp'
+    },
+    illegal: '</',
+    contains: [
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.APOS_STRING_MODE,
+      hljs.C_NUMBER_MODE,
+      {
+        className: 'preprocessor',
+        begin: '#', end: '$'
+      },
+      {
+        className: 'shader',
+        beginWithKeyword: true, end: '\\(',
+        keywords: 'surface displacement light volume imager'
+      },
+      {
+        className: 'shading',
+        beginWithKeyword: true, end: '\\(',
+        keywords: 'illuminate illuminance gather'
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['ruby'] = function(hljs) {
+  var RUBY_IDENT_RE = '[a-zA-Z_][a-zA-Z0-9_]*(\\!|\\?)?';
+  var RUBY_METHOD_RE = '[a-zA-Z_]\\w*[!?=]?|[-+~]\\@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?';
+  var RUBY_KEYWORDS = {
+    keyword:
+      'and false then defined module in return redo if BEGIN retry end for true self when ' +
+      'next until do begin unless END rescue nil else break undef not super class case ' +
+      'require yield alias while ensure elsif or include'
+  };
+  var YARDOCTAG = {
+    className: 'yardoctag',
+    begin: '@[A-Za-z]+'
+  };
+  var COMMENTS = [
+    {
+      className: 'comment',
+      begin: '#', end: '$',
+      contains: [YARDOCTAG]
+    },
+    {
+      className: 'comment',
+      begin: '^\\=begin', end: '^\\=end',
+      contains: [YARDOCTAG],
+      relevance: 10
+    },
+    {
+      className: 'comment',
+      begin: '^__END__', end: '\\n$'
+    }
+  ];
+  var SUBST = {
+    className: 'subst',
+    begin: '#\\{', end: '}',
+    lexems: RUBY_IDENT_RE,
+    keywords: RUBY_KEYWORDS
+  };
+  var STR_CONTAINS = [hljs.BACKSLASH_ESCAPE, SUBST];
+  var STRINGS = [
+    {
+      className: 'string',
+      begin: '\'', end: '\'',
+      contains: STR_CONTAINS,
+      relevance: 0
+    },
+    {
+      className: 'string',
+      begin: '"', end: '"',
+      contains: STR_CONTAINS,
+      relevance: 0
+    },
+    {
+      className: 'string',
+      begin: '%[qw]?\\(', end: '\\)',
+      contains: STR_CONTAINS
+    },
+    {
+      className: 'string',
+      begin: '%[qw]?\\[', end: '\\]',
+      contains: STR_CONTAINS
+    },
+    {
+      className: 'string',
+      begin: '%[qw]?{', end: '}',
+      contains: STR_CONTAINS
+    },
+    {
+      className: 'string',
+      begin: '%[qw]?<', end: '>',
+      contains: STR_CONTAINS,
+      relevance: 10
+    },
+    {
+      className: 'string',
+      begin: '%[qw]?/', end: '/',
+      contains: STR_CONTAINS,
+      relevance: 10
+    },
+    {
+      className: 'string',
+      begin: '%[qw]?%', end: '%',
+      contains: STR_CONTAINS,
+      relevance: 10
+    },
+    {
+      className: 'string',
+      begin: '%[qw]?-', end: '-',
+      contains: STR_CONTAINS,
+      relevance: 10
+    },
+    {
+      className: 'string',
+      begin: '%[qw]?\\|', end: '\\|',
+      contains: STR_CONTAINS,
+      relevance: 10
+    }
+  ];
+  var FUNCTION = {
+    className: 'function',
+    beginWithKeyword: true, end: ' |$|;',
+    keywords: 'def',
+    contains: [
+      {
+        className: 'title',
+        begin: RUBY_METHOD_RE,
+        lexems: RUBY_IDENT_RE,
+        keywords: RUBY_KEYWORDS
+      },
+      {
+        className: 'params',
+        begin: '\\(', end: '\\)',
+        lexems: RUBY_IDENT_RE,
+        keywords: RUBY_KEYWORDS
+      }
+    ].concat(COMMENTS)
+  };
+
+  var RUBY_DEFAULT_CONTAINS = COMMENTS.concat(STRINGS.concat([
+    {
+      className: 'class',
+      beginWithKeyword: true, end: '$|;',
+      keywords: 'class module',
+      contains: [
+        {
+          className: 'title',
+          begin: '[A-Za-z_]\\w*(::\\w+)*(\\?|\\!)?',
+          relevance: 0
+        },
+        {
+          className: 'inheritance',
+          begin: '<\\s*',
+          contains: [{
+            className: 'parent',
+            begin: '(' + hljs.IDENT_RE + '::)?' + hljs.IDENT_RE
+          }]
+        }
+      ].concat(COMMENTS)
+    },
+    FUNCTION,
+    {
+      className: 'constant',
+      begin: '(::)?(\\b[A-Z]\\w*(::)?)+',
+      relevance: 0
+    },
+    {
+      className: 'symbol',
+      begin: ':',
+      contains: STRINGS.concat([{begin: RUBY_IDENT_RE}]),
+      relevance: 0
+    },
+    {
+      className: 'number',
+      begin: '(\\b0[0-7_]+)|(\\b0x[0-9a-fA-F_]+)|(\\b[1-9][0-9_]*(\\.[0-9_]+)?)|[0_]\\b',
+      relevance: 0
+    },
+    {
+      className: 'number',
+      begin: '\\?\\w'
+    },
+    {
+      className: 'variable',
+      begin: '(\\$\\W)|((\\$|\\@\\@?)(\\w+))'
+    },
+    { // regexp container
+      begin: '(' + hljs.RE_STARTERS_RE + ')\\s*',
+      contains: COMMENTS.concat([
+        {
+          className: 'regexp',
+          begin: '/', end: '/[a-z]*',
+          illegal: '\\n',
+          contains: [hljs.BACKSLASH_ESCAPE]
+        }
+      ]),
+      relevance: 0
+    }
+  ]));
+  SUBST.contains = RUBY_DEFAULT_CONTAINS;
+  FUNCTION.contains[1].contains = RUBY_DEFAULT_CONTAINS;
+
+  return {
+    lexems: RUBY_IDENT_RE,
+    keywords: RUBY_KEYWORDS,
+    contains: RUBY_DEFAULT_CONTAINS
+  };
+}(hljs);
+hljs.LANGUAGES['rust'] = function(hljs) {
+  var TITLE = {
+    className: 'title',
+    begin: hljs.UNDERSCORE_IDENT_RE
+  };
+  var QUOTE_STRING = {
+    className: 'string',
+    begin: '"', end: '"',
+    contains: [hljs.BACKSLASH_ESCAPE],
+    relevance: 0
+  };
+  var NUMBER = {
+    className: 'number',
+    begin: '\\b(0[xb][A-Za-z0-9_]+|[0-9_]+(\\.[0-9_]+)?([uif](8|16|32|64)?)?)',
+    relevance: 0
+  };
+  var KEYWORDS =
+    'alt any as assert be bind block bool break char check claim const cont dir do else enum ' +
+    'export f32 f64 fail false float fn for i16 i32 i64 i8 if iface impl import in int let ' +
+    'log mod mutable native note of prove pure resource ret self str syntax true type u16 u32 ' +
+    'u64 u8 uint unchecked unsafe use vec while';
+  return {
+    keywords: KEYWORDS,
+    illegal: '</',
+    contains: [
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      QUOTE_STRING,
+      hljs.APOS_STRING_MODE,
+      NUMBER,
+      {
+        className: 'function',
+        beginWithKeyword: true, end: '(\\(|<)',
+        keywords: 'fn',
+        contains: [TITLE]
+      },
+      {
+        className: 'preprocessor',
+        begin: '#\\[', end: '\\]'
+      },
+      {
+        beginWithKeyword: true, end: '(=|<)',
+        keywords: 'type',
+        contains: [TITLE],
+        illegal: '\\S'
+      },
+      {
+        beginWithKeyword: true, end: '({|<)',
+        keywords: 'iface enum',
+        contains: [TITLE],
+        illegal: '\\S'
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['scala'] = function(hljs) {
+  var ANNOTATION = {
+    className: 'annotation', begin: '@[A-Za-z]+'
+  };
+  var STRING = {
+    className: 'string',
+    begin: 'u?r?"""', end: '"""',
+    relevance: 10
+  };
+  return {
+    keywords:
+      'type yield lazy override def with val var false true sealed abstract private trait ' +
+      'object null if for while throw finally protected extends import final return else ' +
+      'break new catch super class case package default try this match continue throws',
+    contains: [
+      {
+        className: 'javadoc',
+        begin: '/\\*\\*', end: '\\*/',
+        contains: [{
+          className: 'javadoctag',
+          begin: '@[A-Za-z]+'
+        }],
+        relevance: 10
+      },
+      hljs.C_LINE_COMMENT_MODE, hljs.C_BLOCK_COMMENT_MODE,
+      hljs.APOS_STRING_MODE, hljs.QUOTE_STRING_MODE, STRING,
+      {
+        className: 'class',
+        begin: '((case )?class |object |trait )', end: '({|$)', // beginWithKeyword won't work because a single "case" shouldn't start this mode
+        illegal: ':',
+        keywords: 'case class trait object',
+        contains: [
+          {
+            beginWithKeyword: true,
+            keywords: 'extends with',
+            relevance: 10
+          },
+          {
+            className: 'title',
+            begin: hljs.UNDERSCORE_IDENT_RE
+          },
+          {
+            className: 'params',
+            begin: '\\(', end: '\\)',
+            contains: [
+              hljs.APOS_STRING_MODE, hljs.QUOTE_STRING_MODE, STRING,
+              ANNOTATION
+            ]
+          }
+        ]
+      },
+      hljs.C_NUMBER_MODE,
+      ANNOTATION
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['smalltalk'] = function(hljs) {
+  var VAR_IDENT_RE = '[a-z][a-zA-Z0-9_]*';
+  var CHAR = {
+    className: 'char',
+    begin: '\\$.{1}'
+  };
+  var SYMBOL = {
+    className: 'symbol',
+    begin: '#' + hljs.UNDERSCORE_IDENT_RE
+  };
+  return {
+    keywords: 'self super nil true false thisContext', // only 6
+    contains: [
+      {
+        className: 'comment',
+        begin: '"', end: '"',
+        relevance: 0
+      },
+      hljs.APOS_STRING_MODE,
+      {
+        className: 'class',
+        begin: '\\b[A-Z][A-Za-z0-9_]*',
+        relevance: 0
+      },
+      {
+        className: 'method',
+        begin: VAR_IDENT_RE + ':'
+      },
+      hljs.C_NUMBER_MODE,
+      SYMBOL,
+      CHAR,
+      {
+        className: 'localvars',
+        begin: '\\|\\s*((' + VAR_IDENT_RE + ')\\s*)+\\|'
+      },
+      {
+        className: 'array',
+        begin: '\\#\\(', end: '\\)',
+        contains: [
+          hljs.APOS_STRING_MODE,
+          CHAR,
+          hljs.C_NUMBER_MODE,
+          SYMBOL
+        ]
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['sql'] = function(hljs) {
+  return {
+    case_insensitive: true,
+    illegal: '[^\\s]',
+    contains: [
+      {
+        className: 'operator',
+        begin: '(begin|start|commit|rollback|savepoint|lock|alter|create|drop|rename|call|delete|do|handler|insert|load|replace|select|truncate|update|set|show|pragma|grant)\\b', end: ';', endsWithParent: true,
+        keywords: {
+          keyword: 'all partial global month current_timestamp using go revoke smallint ' +
+            'indicator end-exec disconnect zone with character assertion to add current_user ' +
+            'usage input local alter match collate real then rollback get read timestamp ' +
+            'session_user not integer bit unique day minute desc insert execute like ilike|2 ' +
+            'level decimal drop continue isolation found where constraints domain right ' +
+            'national some module transaction relative second connect escape close system_user ' +
+            'for deferred section cast current sqlstate allocate intersect deallocate numeric ' +
+            'public preserve full goto initially asc no key output collation group by union ' +
+            'session both last language constraint column of space foreign deferrable prior ' +
+            'connection unknown action commit view or first into float year primary cascaded ' +
+            'except restrict set references names table outer open select size are rows from ' +
+            'prepare distinct leading create only next inner authorization schema ' +
+            'corresponding option declare precision immediate else timezone_minute external ' +
+            'varying translation true case exception join hour default double scroll value ' +
+            'cursor descriptor values dec fetch procedure delete and false int is describe ' +
+            'char as at in varchar null trailing any absolute current_time end grant ' +
+            'privileges when cross check write current_date pad begin temporary exec time ' +
+            'update catalog user sql date on identity timezone_hour natural whenever interval ' +
+            'work order cascade diagnostics nchar having left call do handler load replace ' +
+            'truncate start lock show pragma',
+          aggregate: 'count sum min max avg'
+        },
+        contains: [
+          {
+            className: 'string',
+            begin: '\'', end: '\'',
+            contains: [hljs.BACKSLASH_ESCAPE, {begin: '\'\''}],
+            relevance: 0
+          },
+          {
+            className: 'string',
+            begin: '"', end: '"',
+            contains: [hljs.BACKSLASH_ESCAPE, {begin: '""'}],
+            relevance: 0
+          },
+          {
+            className: 'string',
+            begin: '`', end: '`',
+            contains: [hljs.BACKSLASH_ESCAPE]
+          },
+          hljs.C_NUMBER_MODE
+        ]
+      },
+      hljs.C_BLOCK_COMMENT_MODE,
+      {
+        className: 'comment',
+        begin: '--', end: '$'
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['tex'] = function(hljs) {
+  var COMMAND1 = {
+    className: 'command',
+    begin: '\\\\[a-zA-Zа-яА-я]+[\\*]?'
+  };
+  var COMMAND2 = {
+    className: 'command',
+    begin: '\\\\[^a-zA-Zа-яА-я0-9]'
+  };
+  var SPECIAL = {
+    className: 'special',
+    begin: '[{}\\[\\]\\&#~]',
+    relevance: 0
+  };
+
+  return {
+    contains: [
+      { // parameter
+        begin: '\\\\[a-zA-Zа-яА-я]+[\\*]? *= *-?\\d*\\.?\\d+(pt|pc|mm|cm|in|dd|cc|ex|em)?',
+        returnBegin: true,
+        contains: [
+          COMMAND1, COMMAND2,
+          {
+            className: 'number',
+            begin: ' *=', end: '-?\\d*\\.?\\d+(pt|pc|mm|cm|in|dd|cc|ex|em)?',
+            excludeBegin: true
+          }
+        ],
+        relevance: 10
+      },
+      COMMAND1, COMMAND2,
+      SPECIAL,
+      {
+        className: 'formula',
+        begin: '\\$\\$', end: '\\$\\$',
+        contains: [COMMAND1, COMMAND2, SPECIAL],
+        relevance: 0
+      },
+      {
+        className: 'formula',
+        begin: '\\$', end: '\\$',
+        contains: [COMMAND1, COMMAND2, SPECIAL],
+        relevance: 0
+      },
+      {
+        className: 'comment',
+        begin: '%', end: '$',
+        relevance: 0
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['vala'] = function(hljs) {
+  return {
+    keywords: {
+      keyword:
+        // Value types
+        'char uchar unichar int uint long ulong short ushort int8 int16 int32 int64 uint8 ' +
+        'uint16 uint32 uint64 float double bool struct enum string void ' +
+        // Reference types
+        'weak unowned owned ' +
+        // Modifiers
+        'async signal static abstract interface override ' +
+        // Control Structures
+        'while do for foreach else switch case break default return try catch ' +
+        // Visibility
+        'public private protected internal ' +
+        // Other
+        'using new this get set const stdout stdin stderr var',
+      built_in:
+        'DBus GLib CCode Gee Object',
+      literal:
+        'false true null'
+    },
+    contains: [
+      {
+        className: 'class',
+        beginWithKeyword: true, end: '{',
+        keywords: 'class interface delegate namespace',
+        contains: [
+          {
+            beginWithKeyword: true,
+            keywords: 'extends implements'
+          },
+          {
+            className: 'title',
+            begin: hljs.UNDERSCORE_IDENT_RE
+          }
+        ]
+      },
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      {
+        className: 'string',
+        begin: '"""', end: '"""',
+        relevance: 5
+      },
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.C_NUMBER_MODE,
+      {
+        className: 'preprocessor',
+        begin: '^#', end: '$',
+        relevance: 2
+      },
+      {
+        className: 'constant',
+        begin: ' [A-Z_]+ ',
+        relevance: 0
+      }
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['vbscript'] = function(hljs) {
+  return {
+    case_insensitive: true,
+    keywords: {
+      keyword:
+        'call class const dim do loop erase execute executeglobal exit for each next function ' +
+        'if then else on error option explicit new private property let get public randomize ' +
+        'redim rem select case set stop sub while wend with end to elseif is or xor and not ' +
+        'class_initialize class_terminate default preserve in me byval byref step resume goto',
+      built_in:
+        'lcase month vartype instrrev ubound setlocale getobject rgb getref string ' +
+        'weekdayname rnd dateadd monthname now day minute isarray cbool round formatcurrency ' +
+        'conversions csng timevalue second year space abs clng timeserial fixs len asc ' +
+        'isempty maths dateserial atn timer isobject filter weekday datevalue ccur isdate ' +
+        'instr datediff formatdatetime replace isnull right sgn array snumeric log cdbl hex ' +
+        'chr lbound msgbox ucase getlocale cos cdate cbyte rtrim join hour oct typename trim ' +
+        'strcomp int createobject loadpicture tan formatnumber mid scriptenginebuildversion ' +
+        'scriptengine split scriptengineminorversion cint sin datepart ltrim sqr ' +
+        'scriptenginemajorversion time derived eval date formatpercent exp inputbox left ascw ' +
+        'chrw regexp server response request cstr err',
+      literal:
+        'true false null nothing empty'
+    },
+    illegal: '//',
+    contains: [
+      { // can’t use standard QUOTE_STRING_MODE since it’s compiled with its own escape and doesn’t use the local one
+        className: 'string',
+        begin: '"', end: '"',
+        illegal: '\\n',
+        contains: [{begin: '""'}],
+        relevance: 0
+      },
+      {
+        className: 'comment',
+        begin: '\'', end: '$'
+      },
+      hljs.C_NUMBER_MODE
+    ]
+  };
+}(hljs);
+hljs.LANGUAGES['vhdl'] = function(hljs) {
+  return {
+    case_insensitive: true,
+    keywords: {
+      keyword:
+        'abs access after alias all and architecture array assert attribute begin block ' +
+        'body buffer bus case component configuration constant context cover disconnect ' +
+        'downto default else elsif end entity exit fairness file for force function generate ' +
+        'generic group guarded if impure in inertial inout is label library linkage literal ' +
+        'loop map mod nand new next nor not null of on open or others out package port ' +
+        'postponed procedure process property protected pure range record register reject ' +
+        'release rem report restrict restrict_guarantee return rol ror select sequence ' +
+        'severity shared signal sla sll sra srl strong subtype then to transport type ' +
+        'unaffected units until use variable vmode vprop vunit wait when while with xnor xor',
+      typename:
+        'boolean bit character severity_level integer time delay_length natural positive ' +
+        'string bit_vector file_open_kind file_open_status std_ulogic std_ulogic_vector ' +
+        'std_logic std_logic_vector unsigned signed boolean_vector integer_vector ' +
+        'real_vector time_vector'
+    },
+    illegal: '{',
+    contains: [
+      hljs.C_BLOCK_COMMENT_MODE,        // VHDL-2008 block commenting.
+      {
+        className: 'comment',
+        begin: '--', end: '$'
+      },
+      hljs.QUOTE_STRING_MODE,
+      hljs.C_NUMBER_MODE,
+      {
+        className: 'literal',
+        begin: '\'(U|X|0|1|Z|W|L|H|-)\'',
+        contains: [hljs.BACKSLASH_ESCAPE]
+      },
+      {
+        className: 'attribute',
+        begin: '\'[A-Za-z](_?[A-Za-z0-9])*',
+        contains: [hljs.BACKSLASH_ESCAPE]
+      }
+    ]
+  }; // return
+}(hljs);