padding: 4px 0; /* Vertical padding around content */

}

.CodeMirror pre {

  padding: 0 4px; /* Horizontal padding of content */

}

  background-color: white; /* The little square between H and V scrollbars */

}

/* GUTTER */

.CodeMirror-gutters {

  border-right: 1px solid #ddd;

  background-color: #f7f7f7;

}

.CodeMirror-linenumbers {}

.CodeMirror-linenumber {

  padding: 0 3px 0 5px;

  min-width: 20px;

  text-align: right;

  position: relative;

}

/* The fake, visible scrollbars. Used to force redraw during scrolling

   before actuall scrolling happens, thus preventing shaking and

   flickering artifacts. */

  position: absolute;

  z-index: 6;

  display: none;

}

.CodeMirror-vscrollbar {

  right: 0; top: 0;

  bottom: 0; left: 0;

  overflow-y: hidden;

  overflow-x: scroll;

}

.CodeMirror-scrollbar-filler {

  right: 0; bottom: 0;

}

.CodeMirror-gutters {

  position: absolute; left: 0; top: 0;

  padding-bottom: 30px;

  z-index: 3;

}

.CodeMirror-gutter {

  height: 100%;

  padding-bottom: 30px;

  margin-bottom: -32px;

  display: inline-block;

  /* Hack to make IE7 behave */

  *zoom:1;

  position: relative;

  z-index: 2;

  overflow: auto;

}

.CodeMirror-widget {

}

.CodeMirror-wrap .CodeMirror-scroll {

  overflow-x: hidden;

}

// CodeMirror is the only global var we claim

window.CodeMirror = (function() {

  "use strict";

  // BROWSER SNIFFING

    var input = d.input = elt("textarea", null, null, "position: absolute; padding: 0; width: 1px; height: 1em; outline: none; font-size: 4px;");

    if (webkit) input.style.width = "1000px";

    else input.setAttribute("wrap", "off");

    // if border: 0; -- iOS fails to open keyboard (issue #1287)

    if (ios) input.style.border = "1px solid black";

    // Wraps and hides input textarea

    d.inputDiv = elt("div", [input], null, "overflow: hidden; position: relative; width: 3px; height: 0px;");

    // The actual fake scrollbars.

    d.scrollbarH = elt("div", [elt("div", null, null, "height: 1px")], "CodeMirror-hscrollbar");

    d.scrollbarV = elt("div", [elt("div", null, null, "width: 1px")], "CodeMirror-vscrollbar");

    d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler");

    // DIVs containing the selection and the actual code

    d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1");

    // Blinky cursor, and element used to ensure cursor fits at the end of a line

    d.cursor = elt("div", "\u00a0", "CodeMirror-cursor");

    // Secondary cursor, shown when on a 'jump' in bi-directional text

    d.otherCursor = elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor");

    // Used to measure text size

    d.sizer = elt("div", [d.mover], "CodeMirror-sizer");

    // D is needed because behavior of elts with overflow: auto and padding is inconsistent across browsers

    d.heightForcer = elt("div", null, null, "position: absolute; height: " + scrollerCutOff + "px; width: 1px;");

    // Will contain the gutters, if any

    d.gutters = elt("div", null, "CodeMirror-gutters");

    d.lineGutter = null;

    // Provides scrolling

    d.scroller.setAttribute("tabIndex", "-1");

    // The element in which the editor lives.

    d.wrapper = elt("div", [d.inputDiv, d.scrollbarH, d.scrollbarV,

    // Work around IE7 z-index bug

    if (ie_lt8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0; }

    if (place.appendChild) place.appendChild(d.wrapper); else place(d.wrapper);

    // Needed to hide big blue blinking cursor on Mobile Safari

    if (ios) input.style.width = "0px";

      cm.display.wrapper.className = cm.display.wrapper.className.replace(" CodeMirror-wrap", "");

      computeMaxLength(cm);

    }

    estimateLineHeights(cm);

    regChange(cm);

    clearCaches(cm);

  }

  function estimateHeight(cm) {

    var th = textHeight(cm.display), wrapping = cm.options.lineWrapping;

    var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3);

    return function(line) {

      var estHeight = est(line);

      if (estHeight != line.height) updateLineHeight(line, estHeight);

    });

  }

  function keyMapChanged(cm) {

    cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-keymap-\S+/g, "") +

      (style ? " cm-keymap-" + style : "");

  }

  function themeChanged(cm) {

    cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") +

      cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-");

    clearCaches(cm);

  }

  function guttersChanged(cm) {

    updateGutters(cm);

    regChange(cm);

  }

  function updateGutters(cm) {

    var gutters = cm.display.gutters, specs = cm.options.gutters;

    removeChildren(gutters);

    for (var i = 0; i < specs.length; ++i) {

  }

  // SCROLLBARS

  // Re-synchronize the fake scrollbars with the actual size of the

  // content. Optionally force a scrollTop.

    var totalHeight = docHeight + paddingVert(d);

    d.sizer.style.minHeight = d.heightForcer.style.top = totalHeight + "px";

    var scrollHeight = Math.max(totalHeight, d.scroller.scrollHeight);

    if (needsV) {

      d.scrollbarV.style.display = "block";

      d.scrollbarV.style.bottom = needsH ? scrollbarWidth(d.measure) + "px" : "0";

      d.scrollbarV.firstChild.style.height =

        (scrollHeight - d.scroller.clientHeight + d.scrollbarV.clientHeight) + "px";

    } else d.scrollbarV.style.display = "";

        (d.scroller.scrollWidth - d.scroller.clientWidth + d.scrollbarH.clientWidth) + "px";

    } else d.scrollbarH.style.display = "";

    if (needsH && needsV) {

      d.scrollbarFiller.style.display = "block";

      d.scrollbarFiller.style.height = d.scrollbarFiller.style.width = scrollbarWidth(d.measure) + "px";

    } else d.scrollbarFiller.style.display = "";

    if (mac_geLion && scrollbarWidth(d.measure) === 0)

      d.scrollbarV.style.minWidth = d.scrollbarH.style.minHeight = mac_geMountainLion ? "18px" : "12px";

  }

  function visibleLines(display, doc, viewPort) {

  // DISPLAY DRAWING

  function updateDisplay(cm, changes, viewPort) {

    var oldFrom = cm.display.showingFrom, oldTo = cm.display.showingTo, updated;

    var visible = visibleLines(cm.display, cm.doc, viewPort);

    for (;;) {

      updateSelection(cm);

      // Clip forced viewport to actual scrollable area

      if (viewPort)

        viewPort = Math.min(cm.display.scroller.scrollHeight - cm.display.scroller.clientHeight,

                            typeof viewPort == "number" ? viewPort : viewPort.top);

      visible = visibleLines(cm.display, cm.doc, viewPort);

      if (visible.from >= cm.display.showingFrom && visible.to <= cm.display.showingTo)

        break;

      changes = [];

    }

    return updated;

  }

  // Uses a set of changes plus the current scroll position to

  // determine which DOM updates have to be made, and makes the

  // updates.

    if (focused && document.activeElement != focused && focused.offsetHeight) focused.focus();

    var different = from != display.showingFrom || to != display.showingTo ||

      display.lastSizeC != display.wrapper.clientHeight;

    // This is just a bogus formula that detects when the editor is

    // resized or the font size changes.

    display.showingFrom = from; display.showingTo = to;

    var prevBottom = display.lineDiv.offsetTop;

    for (var node = display.lineDiv.firstChild, height; node; node = node.nextSibling) if (node.lineObj) {

      if (ie_lt8) {

        var bot = node.offsetTop + node.offsetHeight;

        height = bot - prevBottom;

    var nextIntact = intact.shift(), lineN = from;

    cm.doc.iter(from, to, function(line) {

      if (nextIntact && nextIntact.to == lineN) nextIntact = intact.shift();

      if (lineIsHidden(cm.doc, line)) {

        if (line.height != 0) updateLineHeight(line, 0);

            var prev = cur.previousSibling;

            if (/pre/i.test(prev.nodeName)) {

              var wrap = elt("div", null, null, "position: relative");

              prev.parentNode.replaceChild(wrap, prev);

              wrap.appendChild(prev);

              prev = wrap;

            }

          }

      } else if (nextIntact && nextIntact.from <= lineN && nextIntact.to > lineN) {

        // This line is intact. Skip to the actual node. Update its

        // line number if needed.

        while (cur.lineObj != line) cur = rm(cur);

        if (lineNumbers && updateNumbersFrom <= lineN && cur.lineNumber)

          setTextContent(cur.lineNumber, lineNumberFor(cm.options, lineN));

    // Lines with gutter elements, widgets or a background class need

    // to be wrapped again, and have the extra elements added to the

    // wrapper div

    if (reuse) {

      reuse.alignable = null;

      for (var n = reuse.firstChild, next; n; n = next) {

        next = n.nextSibling;

        if (!/\bCodeMirror-linewidget\b/.test(n.className)) {

          reuse.removeChild(n);

        } else {

          for (var i = 0, first = true; i < line.widgets.length; ++i) {

            if (widget.node == n.firstChild) {

              positionLineWidget(widget, n, reuse, dims);

              ++widgetsSeen;

              break;

            }

          }

          if (i == line.widgets.length) { isOk = false; break; }

        }

      }

      if (isOk && widgetsSeen == line.widgets.length) {

        wrap = reuse;

        reuse.className = line.wrapClass || "";

      }

    }

    if (!wrap) {

                                       dims.gutterLeft[id] + "px; width: " + dims.gutterWidth[id] + "px"));

        }

    }

    if (ie_lt8) wrap.style.zIndex = 2;

    if (line.widgets && wrap != reuse) for (var i = 0, ws = line.widgets; i < ws.length; ++i) {

      var widget = ws[i], node = elt("div", [widget.node], "CodeMirror-linewidget");

      positionLineWidget(widget, node, wrap, dims);

      if (widget.above)

        wrap.insertBefore(node, cm.options.lineNumbers && line.height != 0 ? gutterWrap : lineElement);

      else

        wrap.appendChild(node);

      signalLater(widget, "redraw");

      if (top < 0) top = 0;

      fragment.appendChild(elt("div", null, "CodeMirror-selected", "position: absolute; left: " + left +

                               "px; top: " + top + "px; width: " + (width == null ? clientWidth - left : width) +

                               "px; height: " + (bottom - top) + "px"));

    }

      var lineObj = getLine(doc, line);

      }

      iterateBidiSections(getOrder(lineObj), fromArg || 0, toArg == null ? lineLen : toArg, function(from, to, dir) {

        if (from == to) {

          rightPos = leftPos;

          left = right = leftPos.left;

        } else {

          if (dir == "rtl") { var tmp = leftPos; leftPos = rightPos; rightPos = tmp; }

          left = leftPos.left;

          right = rightPos.right;

        }

        if (rightPos.top - leftPos.top > 3) { // Different lines, draw top part

          add(left, leftPos.top, null, leftPos.bottom);

          left = pl;

          if (leftPos.bottom < rightPos.top) add(left, leftPos.bottom, null, rightPos.top);

        }

        if (toArg == null && to == lineLen) right = clientWidth;

        if (left < pl + 1) left = pl;

        add(left, rightPos.top, right - left, rightPos.bottom);

      });

    }

    if (sel.from.line == sel.to.line) {

      drawForLine(sel.from.line, sel.from.ch, sel.to.ch);

    } else {

        }

      }

    }

    removeChildrenAndAdd(display.selectionDiv, fragment);

    display.selectionDiv.style.display = "";

  }

  // Finds the line to start with when starting a parse. Tries to

  // find a line with a stateAfter, so that it can start with a

  // valid state. If that fails, it returns the line with the

  // smallest indentation, which tends to need the least context to

  // parse correctly.

    var minindent, minline, doc = cm.doc;

    for (var search = n, lim = n - 100; search > lim; --search) {

      if (search <= doc.first) return doc.first;

      var line = getLine(doc, search - 1);

      var indented = countColumn(line.text, null, cm.options.tabSize);

      if (minline == null || minindent > indented) {

        minline = search - 1;

        minindent = indented;

      }

    }

    return minline;

  }

    var doc = cm.doc, display = cm.display;

      if (!doc.mode.startState) return true;

    if (!state) state = startState(doc.mode);

    else state = copyState(doc.mode, state);

    doc.iter(pos, n, function(line) {

      processLine(cm, line, state);

      var save = pos == n - 1 || pos % 5 == 0 || pos >= display.showingFrom && pos < display.showingTo;

      line.stateAfter = save ? copyState(doc.mode, state) : null;

  function paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight;}

  function paddingLeft(display) {

    var e = removeChildrenAndAdd(display.measure, elt("pre", null, null, "text-align: left")).appendChild(elt("span", "x"));

    return e.offsetLeft;

  }

    var dir = -1;

    data = data || measureLine(cm, line);

    for (var pos = ch;; pos += dir) {

      var r = data[pos];

      if (r) break;

      if (dir < 0 && pos == 0) dir = 1;

    }

    return {left: pos < ch ? r.right : r.left,

            right: pos > ch ? r.left : r.right,

  }

  function findCachedMeasurement(cm, line) {

    var cache = cm.display.measureLineCache;

    for (var i = 0; i < cache.length; ++i) {

      var memo = cache[i];

      if (memo.text == line.text && memo.markedSpans == line.markedSpans &&

          cm.display.scroller.clientWidth == memo.width &&

          memo.classes == line.textClass + "|" + line.bgClass + "|" + line.wrapClass)

  }

  function measureLine(cm, line) {

    // First look in the cache

    return measure;

  }

  function measureLineInner(cm, line) {

    var display = cm.display, measure = emptyArray(line.text.length);

    var pre = lineContent(cm, line, measure);

    var vranges = [], data = emptyArray(line.text.length), maxBot = pre.offsetHeight;

    // Work around an IE7/8 bug where it will sometimes have randomly

    // replaced our pre with a clone at this point.

    if (ie_lt9 && display.measure.first != pre)

      removeChildrenAndAdd(display.measure, pre);

      for (var j = 0; j < vranges.length; j += 2) {

        var rtop = vranges[j], rbot = vranges[j+1];

        if (rtop > bot || rbot < top) continue;

        if (rtop <= top && rbot >= bot ||

            top <= rtop && bot >= rbot ||

            Math.min(bot, rbot) - Math.max(top, rtop) >= (bot - top) >> 1) {

          vranges[j] = Math.min(top, rtop);

          vranges[j+1] = Math.max(bot, rbot);

        }

      }

      var right = size.right;

      if (cur.measureRight) right = getRect(cur.measureRight).left;

    }

    for (var i = 0, cur; i < data.length; ++i) if (cur = data[i]) {

      cur.top = vranges[vr]; cur.bottom = vranges[vr+1];

    return data;

  }

  function measureLineWidth(cm, line) {

    var hasBadSpan = false;

    if (line.markedSpans) for (var i = 0; i < line.markedSpans; ++i) {

      var sp = line.markedSpans[i];

      if (sp.collapsed && (sp.to == null || sp.to == line.text.length)) hasBadSpan = true;

    }

    var cached = !hasBadSpan && findCachedMeasurement(cm, line);

    var pre = lineContent(cm, line);

    var end = pre.appendChild(zeroWidthElement(cm.display.measure));

    removeChildrenAndAdd(cm.display.measure, pre);

    return getRect(end).right - getRect(cm.display.lineDiv).left;

  }

    cm.display.measureLineCache.length = cm.display.measureLineCachePos = 0;

    cm.display.cachedCharWidth = cm.display.cachedTextHeight = null;

    if (!cm.options.lineWrapping) cm.display.maxLineChanged = true;

    cm.display.lineNumChars = null;

  }

  // Context is one of "line", "div" (display.lineDiv), "local"/null (editor), or "page"

  function intoCoordSystem(cm, lineObj, rect, context) {

    if (lineObj.widgets) for (var i = 0; i < lineObj.widgets.length; ++i) if (lineObj.widgets[i].above) {

      var size = widgetHeight(lineObj.widgets[i]);

      rect.top += size; rect.bottom += size;

    }

    if (context == "line") return rect;

    if (!context) context = "local";

    var yOff = heightAtLine(cm, lineObj);

      var lOff = getRect(cm.display.lineSpace);

      rect.left += xOff; rect.right += xOff;

    }

    rect.top += yOff; rect.bottom += yOff;

    return rect;

  }

  // Context may be "window", "page", "div", or "local"/null

  // Result is in "div" coords

  function fromCoordSystem(cm, coords, context) {

    if (context == "div") return coords;

    var left = coords.left, top = coords.top;

    if (context == "page") {

    var lineSpaceBox = getRect(cm.display.lineSpace);

    if (!lineObj) lineObj = getLine(cm.doc, pos.line);

  }

  function cursorCoords(cm, pos, context, lineObj, measurement) {

    lineObj = lineObj || getLine(cm.doc, pos.line);

    if (!measurement) measurement = measureLine(cm, lineObj);

    function get(ch, right) {

      if (right) m.left = m.right; else m.right = m.left;

      return intoCoordSystem(cm, lineObj, m, context);

    }

    var order = getOrder(lineObj), ch = pos.ch;

    if (!order) return get(ch);

    var pos = new Pos(line, ch);

    if (outside) pos.outside = true;

    return pos;

  }

  // Coords must be lineSpace-local

  function coordsChar(cm, x, y) {

    var doc = cm.doc;

    y += cm.display.viewOffset;

    var lineNo = lineAtHeight(doc, y), last = doc.first + doc.size - 1;

    if (lineNo > last)

    if (x < 0) x = 0;

    for (;;) {

      var lineObj = getLine(doc, lineNo);

      var found = coordsCharInner(cm, lineObj, lineNo, x, y);

      var merged = collapsedSpanAtEnd(lineObj);

      var mergedPos = merged && merged.find();

        lineNo = mergedPos.to.line;

      else

        return found;

    }

  }

    }

    var bidi = getOrder(lineObj), dist = lineObj.text.length;

    var from = lineLeft(lineObj), to = lineRight(lineObj);

    var fromX = getX(from), fromOutside = wrongLine, toX = getX(to), toOutside = wrongLine;

    // Do a binary search between these bounds.

    for (;;) {

      if (bidi ? to == from || to == moveVisually(lineObj, from, 1) : to - from <= 1) {

        while (isExtendingChar.test(lineObj.text.charAt(ch))) ++ch;

        return pos;

      }

      var step = Math.ceil(dist / 2), middle = from + step;

      if (bidi) {

        middle = from;

        for (var i = 0; i < step; ++i) middle = moveVisually(lineObj, middle, 1);

  // on every change, that breaks IME. So we look for changes

  // compared to the previous content instead. (Modern browsers have

  // events that indicate IME taking place, but these are not widely

  // supported or compatible enough yet to rely on.)

  function readInput(cm) {

    var input = cm.display.input, prevInput = cm.display.prevInput, doc = cm.doc, sel = doc.sel;

    var text = input.value;

    if (text == prevInput && posEq(sel.from, sel.to)) return false;

    if (ie && !ie_lt9 && cm.display.inputHasSelection === text) {

      resetInput(cm, true);

      return false;

    }

    while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) ++same;

    var from = sel.from, to = sel.to;

    if (same < prevInput.length)

      from = Pos(from.line, from.ch - (prevInput.length - same));

    else if (cm.state.overwrite && posEq(from, to) && !cm.state.pasteIncoming)

      to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + (text.length - same)));

    var updateInput = cm.curOp.updateInput;