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

}

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

}

.CodeMirror-gutters {

  border-right: 1px solid #ddd;

  background-color: #f7f7f7;

}

.CodeMirror-linenumbers {}

.CodeMirror-linenumber {

/* 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-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;

}

.CodeMirror-widget {

}

.CodeMirror-wrap .CodeMirror-scroll {

// CodeMirror is the only global var we claim

window.CodeMirror = (function() {

  "use strict";

    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;");

    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");

    // 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);

    estimateLineHeights(cm);

    regChange(cm);

    clearCaches(cm);

  }

  function estimateHeight(cm) {

  }

  function keyMapChanged(cm) {

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

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

  }

  function themeChanged(cm) {

  function guttersChanged(cm) {

    updateGutters(cm);

    regChange(cm);

  }

  function updateGutters(cm) {

  // 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.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";

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

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

    for (;;) {

        updated = true;

      updateSelection(cm);

      // Clip forced viewport to actual scrollable area

      if (viewPort)

      changes = [];

    }

    return updated;

  }

      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 (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");

              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

    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 (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);

                               "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 {

      } else {

    }

    removeChildrenAndAdd(display.selectionDiv, fragment);

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

    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) {

    return e.offsetLeft;

  }

    var dir = -1;

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

      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) {

      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

      // Failing that, recompute and store result in cache

      var cache = cm.display.measureLineCache;

      var memo = {text: line.text, width: cm.display.scroller.clientWidth,

                  markedSpans: line.markedSpans, measure: measure,

                  classes: line.textClass + "|" + line.bgClass + "|" + line.wrapClass};

      if (cache.length == 16) cache[++cm.display.measureLineCachePos % 16] = memo;

      else cache.push(memo);

    return measure;

  }

    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;

            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;

  }

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

    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) {

    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;

  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;

  }

  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 found = coordsCharInner(cm, lineObj, lineNo, x, y);

      var merged = collapsedSpanAtEnd(lineObj);

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

        lineNo = mergedPos.to.line;

      else

        return found;

    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;

  // 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) {

      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;

    cm.curOp.updateInput = updateInput;

    if (text.length > 1000 || text.indexOf("\n") > -1) input.value = cm.display.prevInput = "";

    else cm.display.prevInput = text;

    if (withOp) endOperation(cm);

    on(d.scroller, "mousedown", operation(cm, onMouseDown));

    if (ie)

      on(d.scroller, "dblclick", operation(cm, function(e) {

        var pos = posFromMouse(cm, e);

        if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) return;

        e_preventDefault(e);

        extendSelection(cm.doc, word.from, word.to);

      }));

    else

    on(d.lineSpace, "selectstart", function(e) {

      if (!eventInWidget(d, e)) e_preventDefault(e);

    });

    // Prevent wrapper from ever scrolling

    on(d.wrapper, "scroll", function() { d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; });

    function onResize() {

      // Might be a text scaling operation, clear size caches.

      clearCaches(cm);

      runInOp(cm, bind(regChange, cm));

    }

    on(window, "resize", onResize);

    // Above handler holds on to the editor and its data structures.

    setTimeout(unregister, 5000);

    on(d.input, "keyup", operation(cm, function(e) {

      if (e.keyCode == 16) cm.doc.sel.shift = false;

    }));

    on(d.input, "input", bind(fastPoll, cm));

    on(d.input, "blur", bind(onBlur, cm));

    function drag_(e) {

      e_stop(e);

    }

    if (cm.options.dragDrop) {

  function eventInWidget(display, e) {

    for (var n = e_target(e); n != display.wrapper; n = n.parentNode) {

    }

  }

      var target = e_target(e);

      if (target == display.scrollbarH || target == display.scrollbarH.firstChild ||

          target == display.scrollbarV || target == display.scrollbarV.firstChild ||

    }

    var x, y, space = getRect(display.lineSpace);

    // Fails unpredictably on IE[67] when mouse is dragged around quickly.

  var lastClick, lastDoubleClick;

  function onMouseDown(e) {

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

    sel.shift = e.shiftKey;

    function done(e) {

      counter = Infinity;

      e_preventDefault(e);

      focusInput(cm);

      off(document, "mousemove", move);

    on(document, "mouseup", up);

  }

  function onDrop(e) {

    var cm = this;

      return;

    e_preventDefault(e);

    var pos = posFromMouse(cm, e, true), files = e.dataTransfer.files;

    if (!pos || isReadOnly(cm)) return;

    if (files && files.length && window.FileReader && window.File) {

    }

  }

  function onDragStart(cm, e) {