window.CodeMirror = (function (){ 
"use strict"; 
var gecko = /gecko\/\d/i.test(navigator.userAgent); 
var ie = /MSIE \d/.test(navigator.userAgent); 
var ie_lt8 = ie && (document.documentMode == null  || document.documentMode < 8); 
var ie_lt9 = ie && (document.documentMode == null  || document.documentMode < 9); 
var ie_gt10 = /Trident\/([7-9]|\d{2,})\./.test(navigator.userAgent); 
var webkit = /WebKit\//.test(navigator.userAgent); 
var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(navigator.userAgent); 
var chrome = /Chrome\//.test(navigator.userAgent); 
var opera = /Opera\//.test(navigator.userAgent); 
var safari = /Apple Computer/.test(navigator.vendor); 
var khtml = /KHTML\//.test(navigator.userAgent); 
var mac_geLion = /Mac OS X 1\d\D([7-9]|\d\d)\D/.test(navigator.userAgent); 
var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(navigator.userAgent); 
var phantom = /PhantomJS/.test(navigator.userAgent); 
var ios = /AppleWebKit/.test(navigator.userAgent) && /Mobile\/\w+/.test(navigator.userAgent); 
var mobile = ios || /Android|webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(navigator.userAgent); 
var mac = ios || /Mac/.test(navigator.platform); 
var windows = /win/i.test(navigator.platform); 
var opera_version = opera && navigator.userAgent.match(/Version\/(\d*\.\d*)/); 
if (opera_version) opera_version = Number(opera_version[1]); 
if (opera_version && opera_version >= 15) { 
opera = false ; 
webkit = true ; 
} 
var flipCtrlCmd = mac && (qtwebkit || opera && (opera_version == null  || opera_version < 12.11)); 
var captureMiddleClick = gecko || (ie && !ie_lt9); 
var sawReadOnlySpans = false , sawCollapsedSpans = false ; 
function CodeMirror(place, options){ 
if (!(this instanceof CodeMirror)) return new CodeMirror(place, options); 
this.options = options = options || { 
}
; 
for (var opt in defaults)if (!options.hasOwnProperty(opt) && defaults.hasOwnProperty(opt)) options[opt] = defaults[opt]; 
setGuttersForLineNumbers(options); 
var docStart = typeof options.value == "string"? 0: options.value.first; 
var display = this.display = makeDisplay(place, docStart); 
display.wrapper.CodeMirror = this; 
updateGutters(this); 
if (options.autofocus && !mobile) focusInput(this); 
this.state = { 
keyMaps: [] ,
overlays: [] ,
modeGen: 0,
overwrite: false ,
focused: false ,
suppressEdits: false ,
pasteIncoming: false ,
draggingText: false ,
highlight: new Delayed()}
; 
themeChanged(this); 
if (options.lineWrapping) this.display.wrapper.className += " CodeMirror-wrap"; 
var doc = options.value; 
if (typeof doc == "string") doc = new Doc(options.value, options.mode); 
operation(this, attachDoc)(this, doc); 
if (ie) _AN_Call_settimeout("setTimeout", window, bind(resetInput, this, true ), 20); 
registerEventHandlers(this); 
var hasFocus; 
try { 
hasFocus = (document.activeElement == display.input); 
} 
catch (e) { 
} 
if (hasFocus || (options.autofocus && !mobile)) _AN_Call_settimeout("setTimeout", window, bind(onFocus, this), 20); 
 else onBlur(this); 
operation(this, function (){ 
for (var opt in optionHandlers)if (optionHandlers.propertyIsEnumerable(opt)) optionHandlers[opt](this, options[opt], Init); 
for (var i = 0; 
i < _AN_Read_length("length", initHooks); ++i)initHooks[i](this); 
} 
)(); 
} 
function makeDisplay(place, docStart){ 
var d = { 
}
; 
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 _AN_Call_setattribute("setAttribute", input, "wrap", "off"); 
if (ios) input.style.border = "1px solid black"; 
_AN_Call_setattribute("setAttribute", input, "autocorrect", "off"); 
_AN_Call_setattribute("setAttribute", input, "autocapitalize", "off"); 
_AN_Call_setattribute("setAttribute", input, "spellcheck", "false"); 
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"); 
d.gutterFiller = elt("div", null , "CodeMirror-gutter-filler"); 
d.lineDiv = elt("div", null , "CodeMirror-code"); 
d.selectionDiv = elt("div", null , null , "position: relative; z-index: 1"); 
_AN_Write_cursor("cursor", d, false , elt("div", "\u00a0", "CodeMirror-cursor")); 
d.otherCursor = elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor"); 
d.measure = elt("div", null , "CodeMirror-measure"); 
d.lineSpace = elt("div", [d.measure, d.selectionDiv, d.lineDiv, d.cursor, d.otherCursor] , null , "position: relative; outline: none"); 
d.mover = elt("div", [elt("div", [d.lineSpace] , "CodeMirror-lines")] , null , "position: relative"); 
d.sizer = elt("div", [d.mover] , "CodeMirror-sizer"); 
d.heightForcer = elt("div", null , null , "position: absolute; height: " + scrollerCutOff + "px; width: 1px;"); 
d.gutters = elt("div", null , "CodeMirror-gutters"); 
d.lineGutter = null ; 
d.scroller = elt("div", [d.sizer, d.heightForcer, d.gutters] , "CodeMirror-scroll"); 
_AN_Call_setattribute("setAttribute", d.scroller, "tabIndex", "-1"); 
d.wrapper = elt("div", [d.inputDiv, d.scrollbarH, d.scrollbarV, d.scrollbarFiller, d.gutterFiller, d.scroller] , "CodeMirror"); 
if (ie_lt8) { 
d.gutters.style.zIndex = -1; 
d.scroller.style.paddingRight = 0; 
} 
if (place.appendChild) _AN_Call_appendchild("appendChild", place, d.wrapper); 
 else place(d.wrapper); 
if (ios) input.style.width = "0px"; 
if (!webkit) d.scroller.draggable = true ; 
if (khtml) { 
d.inputDiv.style.height = "1px"; 
d.inputDiv.style.position = "absolute"; 
} 
 else if (ie_lt8) d.scrollbarH.style.minWidth = d.scrollbarV.style.minWidth = "18px"; 
d.viewOffset = d.lastSizeC = 0; 
d.showingFrom = d.showingTo = docStart; 
d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null ; 
d.prevInput = ""; 
d.alignWidgets = false ; 
d.pollingFast = false ; 
d.poll = new Delayed(); 
d.cachedCharWidth = d.cachedTextHeight = null ; 
d.measureLineCache = [] ; 
d.measureLineCachePos = 0; 
d.inaccurateSelection = false ; 
d.maxLine = null ; 
d.maxLineLength = 0; 
d.maxLineChanged = false ; 
d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null ; 
return d; 
} 
function loadMode(cm){ 
cm.doc.mode = CodeMirror.getMode(cm.options, cm.doc.modeOption); 
cm.doc.iter(function (line){ 
if (line.stateAfter) line.stateAfter = null ; 
if (line.styles) line.styles = null ; 
} 
); 
cm.doc.frontier = cm.doc.first; 
startWorker(cm, 100); 
cm.state.modeGen++ ; 
if (cm.curOp) regChange(cm); 
} 
function wrappingChanged(cm){ 
if (cm.options.lineWrapping) { 
cm.display.wrapper.className += " CodeMirror-wrap"; 
cm.display.sizer.style.minWidth = ""; 
} 
 else { 
cm.display.wrapper.className = _AN_Call_replace("replace", cm.display.wrapper.className, " CodeMirror-wrap", ""); 
computeMaxLength(cm); 
} 
estimateLineHeights(cm); 
regChange(cm); 
clearCaches(cm); 
_AN_Call_settimeout("setTimeout", window, function (){ 
updateScrollbars(cm); 
} 
, 100); 
} 
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){ 
if (lineIsHidden(cm.doc, line)) return 0; 
 else if (wrapping) return (Math.ceil(_AN_Read_length("length", line.text) / perLine) || 1) * th; 
 else return th; 
} 
; 
} 
function estimateLineHeights(cm){ 
var doc = cm.doc, est = estimateHeight(cm); 
doc.iter(function (line){ 
var estHeight = est(line); 
if (estHeight != line.height) updateLineHeight(line, estHeight); 
} 
); 
} 
function keyMapChanged(cm){ 
var map = keyMap[cm.options.keyMap], style = map.style; 
cm.display.wrapper.className = _AN_Call_replace("replace", cm.display.wrapper.className, /\s*cm-keymap-\S+/g, "") + (style? " cm-keymap-" + style: ""); 
if (cm.state.disableInput && !map.disableInput) resetInput(cm, true ); 
cm.state.disableInput = map.disableInput; 
} 
function themeChanged(cm){ 
cm.display.wrapper.className = _AN_Call_replace("replace", cm.display.wrapper.className, /\s*cm-s-\S+/g, "") + _AN_Call_replace("replace", cm.options.theme, /(^|\s)\s*/g, " cm-s-"); 
clearCaches(cm); 
} 
function guttersChanged(cm){ 
updateGutters(cm); 
regChange(cm); 
_AN_Call_settimeout("setTimeout", window, function (){ 
alignHorizontally(cm); 
} 
, 20); 
} 
function updateGutters(cm){ 
var gutters = cm.display.gutters, specs = cm.options.gutters; 
removeChildren(gutters); 
for (var i = 0; 
i < _AN_Read_length("length", specs); ++i){ 
var gutterClass = specs[i]; 
var gElt = _AN_Call_appendchild("appendChild", gutters, elt("div", null , "CodeMirror-gutter " + gutterClass)); 
if (gutterClass == "CodeMirror-linenumbers") { 
cm.display.lineGutter = gElt; 
gElt.style.width = (cm.display.lineNumWidth || 1) + "px"; 
} 
} 
gutters.style.display = i? "": "none"; 
} 
function lineLength(doc, line){ 
if (line.height == 0) return 0; 
var len = _AN_Read_length("length", line.text), merged, cur = line; 
while (merged = collapsedSpanAtStart(cur)){ 
var found = merged.find(); 
cur = getLine(doc, found.from.line); 
len += found.from.ch - found.to.ch; 
} 
cur = line; 
while (merged = collapsedSpanAtEnd(cur)){ 
var found = merged.find(); 
len -= _AN_Read_length("length", cur.text) - found.from.ch; 
cur = getLine(doc, found.to.line); 
len += _AN_Read_length("length", cur.text) - found.to.ch; 
} 
return len; 
} 
function computeMaxLength(cm){ 
var d = cm.display, doc = cm.doc; 
d.maxLine = getLine(doc, doc.first); 
d.maxLineLength = lineLength(doc, d.maxLine); 
d.maxLineChanged = true ; 
doc.iter(function (line){ 
var len = lineLength(doc, line); 
if (len > d.maxLineLength) { 
d.maxLineLength = len; 
d.maxLine = line; 
} 
} 
); 
} 
function setGuttersForLineNumbers(options){ 
var found = indexOf(options.gutters, "CodeMirror-linenumbers"); 
if (found == -1 && options.lineNumbers) { 
options.gutters = options.gutters.concat(["CodeMirror-linenumbers"] ); 
} 
 else if (found > -1 && !options.lineNumbers) { 
options.gutters = options.gutters.slice(0); 
options.gutters.splice(found, 1); 
} 
} 
function updateScrollbars(cm){ 
var d = cm.display, docHeight = cm.doc.height; 
var totalHeight = docHeight + paddingVert(d); 
d.sizer.style.minHeight = d.heightForcer.style.top = totalHeight + "px"; 
d.gutters.style.height = Math.max(totalHeight, d.scroller.clientHeight - scrollerCutOff) + "px"; 
var scrollHeight = Math.max(totalHeight, d.scroller.scrollHeight); 
var needsH = d.scroller.scrollWidth > (d.scroller.clientWidth + 1); 
var needsV = scrollHeight > (d.scroller.clientHeight + 1); 
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.scrollbarV.firstChild.style.height = "0"; 
} 
if (needsH) { 
d.scrollbarH.style.display = "block"; 
d.scrollbarH.style.right = needsV? scrollbarWidth(d.measure) + "px": "0"; 
d.scrollbarH.firstChild.style.width = (d.scroller.scrollWidth - d.scroller.clientWidth + d.scrollbarH.clientWidth) + "px"; 
} 
 else { 
d.scrollbarH.style.display = ""; 
d.scrollbarH.firstChild.style.width = "0"; 
} 
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 (needsH && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) { 
d.gutterFiller.style.display = "block"; 
d.gutterFiller.style.height = scrollbarWidth(d.measure) + "px"; 
d.gutterFiller.style.width = d.gutters.offsetWidth + "px"; 
} 
 else d.gutterFiller.style.display = ""; 
if (mac_geLion && scrollbarWidth(d.measure) === 0) { 
d.scrollbarV.style.minWidth = d.scrollbarH.style.minHeight = mac_geMountainLion? "18px": "12px"; 
d.scrollbarV.style.pointerEvents = d.scrollbarH.style.pointerEvents = "none"; 
} 
} 
function visibleLines(display, doc, viewPort){ 
var top = display.scroller.scrollTop, height = display.wrapper.clientHeight; 
if (typeof viewPort == "number") top = viewPort; 
 else if (viewPort) { 
top = viewPort.top; 
height = viewPort.bottom - viewPort.top; 
} 
top = Math.floor(top - paddingTop(display)); 
var bottom = Math.ceil(top + height); 
return { 
from: lineAtHeight(doc, top),
to: lineAtHeight(doc, bottom)}
; 
} 
function alignHorizontally(cm){ 
var display = cm.display; 
if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) return ; 
var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft; 
var gutterW = display.gutters.offsetWidth, l = comp + "px"; 
for (var n = display.lineDiv.firstChild; 
n; n = n.nextSibling)if (n.alignable) { 
for (var i = 0, a = n.alignable; 
i < _AN_Read_length("length", a); ++i)a[i].style.left = l; 
} 
if (cm.options.fixedGutter) display.gutters.style.left = (comp + gutterW) + "px"; 
} 
function maybeUpdateLineNumberWidth(cm){ 
if (!cm.options.lineNumbers) return false ; 
var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display; 
if (_AN_Read_length("length", last) != display.lineNumChars) { 
var test = _AN_Call_appendchild("appendChild", display.measure, elt("div", [elt("div", last)] , "CodeMirror-linenumber CodeMirror-gutter-elt")); 
var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW; 
display.lineGutter.style.width = ""; 
display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding); 
display.lineNumWidth = display.lineNumInnerWidth + padding; 
display.lineNumChars = display.lineNumInnerWidth? _AN_Read_length("length", last): -1; 
display.lineGutter.style.width = display.lineNumWidth + "px"; 
return true ; 
} 
return false ; 
} 
function lineNumberFor(options, i){ 
return String(options.lineNumberFormatter(i + options.firstLineNumber)); 
} 
function compensateForHScroll(display){ 
return getRect(display.scroller).left - getRect(display.sizer).left; 
} 
function updateDisplay(cm, changes, viewPort, forced){ 
var oldFrom = cm.display.showingFrom, oldTo = cm.display.showingTo, updated; 
var visible = visibleLines(cm.display, cm.doc, viewPort); 
for (var first = true ; 
; first = false ){ 
var oldWidth = cm.display.scroller.clientWidth; 
if (!updateDisplayInner(cm, changes, visible, forced)) break ; 
updated = true ; 
changes = [] ; 
updateSelection(cm); 
updateScrollbars(cm); 
if (first && cm.options.lineWrapping && oldWidth != cm.display.scroller.clientWidth) { 
forced = true ; 
continue ; 
} 
forced = false ; 
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 ; 
} 
if (updated) { 
signalLater(cm, "update", cm); 
if (cm.display.showingFrom != oldFrom || cm.display.showingTo != oldTo) signalLater(cm, "viewportChange", cm, cm.display.showingFrom, cm.display.showingTo); 
} 
return updated; 
} 
function updateDisplayInner(cm, changes, visible, forced){ 
var display = cm.display, doc = cm.doc; 
if (!display.wrapper.offsetWidth) { 
display.showingFrom = display.showingTo = doc.first; 
display.viewOffset = 0; 
return ; 
} 
if (!forced && _AN_Read_length("length", changes) == 0 && visible.from > display.showingFrom && visible.to < display.showingTo) return ; 
if (maybeUpdateLineNumberWidth(cm)) changes = [{ 
from: doc.first,
to: doc.first + doc.size}
] ; 
var gutterW = display.sizer.style.marginLeft = display.gutters.offsetWidth + "px"; 
display.scrollbarH.style.left = cm.options.fixedGutter? gutterW: "0"; 
var positionsChangedFrom = Infinity; 
if (cm.options.lineNumbers) for (var i = 0; 
i < _AN_Read_length("length", changes); ++i)if (changes[i].diff && changes[i].from < positionsChangedFrom) { 
positionsChangedFrom = changes[i].from; 
} 
var end = doc.first + doc.size; 
var from = Math.max(visible.from - cm.options.viewportMargin, doc.first); 
var to = Math.min(end, visible.to + cm.options.viewportMargin); 
if (display.showingFrom < from && from - display.showingFrom < 20) from = Math.max(doc.first, display.showingFrom); 
if (display.showingTo > to && display.showingTo - to < 20) to = Math.min(end, display.showingTo); 
if (sawCollapsedSpans) { 
from = lineNo(visualLine(doc, getLine(doc, from))); 
while (to < end && lineIsHidden(doc, getLine(doc, to)))++to; 
} 
var intact = [{ 
from: Math.max(display.showingFrom, doc.first),
to: Math.min(display.showingTo, end)}
] ; 
if (intact[0].from >= intact[0].to) intact = [] ; 
 else intact = computeIntact(intact, changes); 
if (sawCollapsedSpans) for (var i = 0; 
i < _AN_Read_length("length", intact); ++i){ 
var range = intact[i], merged; 
while (merged = collapsedSpanAtEnd(getLine(doc, range.to - 1))){ 
var newTo = merged.find().from.line; 
if (newTo > range.from) range.to = newTo; 
 else { 
intact.splice(i-- , 1); 
break ; 
} 
} 
} 
var intactLines = 0; 
for (var i = 0; 
i < _AN_Read_length("length", intact); ++i){ 
var range = intact[i]; 
if (range.from < from) range.from = from; 
if (range.to > to) range.to = to; 
if (range.from >= range.to) intact.splice(i-- , 1); 
 else intactLines += range.to - range.from; 
} 
if (!forced && intactLines == to - from && from == display.showingFrom && to == display.showingTo) { 
updateViewOffset(cm); 
return ; 
} 
intact.sort(function (a, b){ 
return a.from - b.from; 
} 
); 
try { 
var focused = document.activeElement; 
} 
catch (e) { 
} 
if (intactLines < (to - from) * 0.7) display.lineDiv.style.display = "none"; 
patchDisplay(cm, from, to, intact, positionsChangedFrom); 
display.lineDiv.style.display = ""; 
if (focused && document.activeElement != focused && focused.offsetHeight) focused.focus(); 
var different = from != display.showingFrom || to != display.showingTo || display.lastSizeC != display.wrapper.clientHeight; 
if (different) { 
display.lastSizeC = display.wrapper.clientHeight; 
startWorker(cm, 400); 
} 
display.showingFrom = from; 
display.showingTo = to; 
display.gutters.style.height = ""; 
updateHeightsInViewport(cm); 
updateViewOffset(cm); 
return true ; 
} 
function updateHeightsInViewport(cm){ 
var display = cm.display; 
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; 
prevBottom = bot; 
} 
 else { 
var box = getRect(node); 
height = box.bottom - box.top; 
} 
var diff = node.lineObj.height - height; 
if (height < 2) height = textHeight(display); 
if (diff > 0.001 || diff < -0.001) { 
updateLineHeight(node.lineObj, height); 
var widgets = node.lineObj.widgets; 
if (widgets) for (var i = 0; 
i < _AN_Read_length("length", widgets); ++i)widgets[i].height = widgets[i].node.offsetHeight; 
} 
} 
} 
function updateViewOffset(cm){ 
var off = cm.display.viewOffset = heightAtLine(cm, getLine(cm.doc, cm.display.showingFrom)); 
cm.display.mover.style.top = off + "px"; 
} 
function computeIntact(intact, changes){ 
for (var i = 0, l = _AN_Read_length("length", changes) || 0; 
i < l; ++i){ 
var change = changes[i], intact2 = [] , diff = change.diff || 0; 
for (var j = 0, l2 = _AN_Read_length("length", intact); 
j < l2; ++j){ 
var range = intact[j]; 
if (change.to <= range.from && change.diff) { 
intact2.push({ 
from: range.from + diff,
to: range.to + diff}
); 
} 
 else if (change.to <= range.from || change.from >= range.to) { 
intact2.push(range); 
} 
 else { 
if (change.from > range.from) intact2.push({ 
from: range.from,
to: change.from}
); 
if (change.to < range.to) intact2.push({ 
from: change.to + diff,
to: range.to + diff}
); 
} 
} 
intact = intact2; 
} 
return intact; 
} 
function getDimensions(cm){ 
var d = cm.display, left = { 
}
, width = { 
}
; 
for (var n = d.gutters.firstChild, i = 0; 
n; n = n.nextSibling, ++i){ 
left[cm.options.gutters[i]] = n.offsetLeft; 
width[cm.options.gutters[i]] = n.offsetWidth; 
} 
return { 
fixedPos: compensateForHScroll(d),
gutterTotalWidth: d.gutters.offsetWidth,
gutterLeft: left,
gutterWidth: width,
wrapperWidth: d.wrapper.clientWidth}
; 
} 
function patchDisplay(cm, from, to, intact, updateNumbersFrom){ 
var dims = getDimensions(cm); 
var display = cm.display, lineNumbers = cm.options.lineNumbers; 
if (!_AN_Read_length("length", intact) && (!webkit || !cm.display.currentWheelTarget)) removeChildren(display.lineDiv); 
var container = display.lineDiv, cur = container.firstChild; 
function rm(node){ 
var next = node.nextSibling; 
if (webkit && mac && cm.display.currentWheelTarget == node) { 
node.style.display = "none"; 
node.lineObj = null ; 
} 
 else { 
node.parentNode.removeChild(node); 
} 
return next; 
} 
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); 
if (line.widgets && cur && cur.previousSibling) for (var i = 0; 
i < _AN_Read_length("length", line.widgets); ++i){ 
var w = line.widgets[i]; 
if (w.showIfHidden) { 
var prev = cur.previousSibling; 
if (/pre/i.test(prev.nodeName)) { 
var wrap = elt("div", null , null , "position: relative"); 
prev.parentNode.replaceChild(wrap, prev); 
_AN_Call_appendchild("appendChild", wrap, prev); 
prev = wrap; 
} 
var wnode = _AN_Call_appendchild("appendChild", prev, elt("div", [w.node] , "CodeMirror-linewidget")); 
if (!w.handleMouseEvents) wnode.ignoreEvents = true ; 
positionLineWidget(w, wnode, prev, dims); 
} 
} 
} 
 else if (nextIntact && nextIntact.from <= lineN && nextIntact.to > lineN) { 
while (cur.lineObj != line)cur = rm(cur); 
if (lineNumbers && updateNumbersFrom <= lineN && cur.lineNumber) setTextContent(cur.lineNumber, lineNumberFor(cm.options, lineN)); 
cur = cur.nextSibling; 
} 
 else { 
if (line.widgets) for (var j = 0, search = cur, reuse; 
search && j < 20; ++j, search = search.nextSibling)if (search.lineObj == line && /div/i.test(search.nodeName)) { 
reuse = search; 
break ; 
} 
var lineNode = buildLineElement(cm, line, lineN, dims, reuse); 
if (lineNode != reuse) { 
container.insertBefore(lineNode, cur); 
} 
 else { 
while (cur != reuse)cur = rm(cur); 
cur = cur.nextSibling; 
} 
lineNode.lineObj = line; 
} 
++lineN; 
} 
); 
while (cur)cur = rm(cur); 
} 
function buildLineElement(cm, line, lineNo, dims, reuse){ 
var built = buildLineContent(cm, line), lineElement = built.pre; 
var markers = line.gutterMarkers, display = cm.display, wrap; 
var bgClass = built.bgClass? built.bgClass + " " + (line.bgClass || ""): line.bgClass; 
if (!cm.options.lineNumbers && !markers && !bgClass && !line.wrapClass && !line.widgets) return lineElement; 
if (reuse) { 
reuse.alignable = null ; 
var isOk = true , widgetsSeen = 0, insertBefore = 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; 
i < _AN_Read_length("length", line.widgets); ++i){ 
var widget = line.widgets[i]; 
if (widget.node == n.firstChild) { 
if (!widget.above && !insertBefore) insertBefore = n; 
positionLineWidget(widget, n, reuse, dims); 
++widgetsSeen; 
break ; 
} 
} 
if (i == _AN_Read_length("length", line.widgets)) { 
isOk = false ; 
break ; 
} 
} 
} 
reuse.insertBefore(lineElement, insertBefore); 
if (isOk && widgetsSeen == _AN_Read_length("length", line.widgets)) { 
wrap = reuse; 
reuse.className = line.wrapClass || ""; 
} 
} 
if (!wrap) { 
wrap = elt("div", null , line.wrapClass, "position: relative"); 
_AN_Call_appendchild("appendChild", wrap, lineElement); 
} 
if (bgClass) wrap.insertBefore(elt("div", null , bgClass + " CodeMirror-linebackground"), wrap.firstChild); 
if (cm.options.lineNumbers || markers) { 
var gutterWrap = wrap.insertBefore(elt("div", null , "CodeMirror-gutter-wrapper", "position: absolute; left: " + (cm.options.fixedGutter? dims.fixedPos: - dims.gutterTotalWidth) + "px"), lineElement); 
if (cm.options.fixedGutter) (wrap.alignable || (wrap.alignable = [] )).push(gutterWrap); 
if (cm.options.lineNumbers && (!markers || !markers["CodeMirror-linenumbers"] )) wrap.lineNumber = _AN_Call_appendchild("appendChild", gutterWrap, elt("div", lineNumberFor(cm.options, lineNo), "CodeMirror-linenumber CodeMirror-gutter-elt", "left: " + dims.gutterLeft["CodeMirror-linenumbers"]  + "px; width: " + display.lineNumInnerWidth + "px")); 
if (markers) for (var k = 0; 
k < _AN_Read_length("length", cm.options.gutters); ++k){ 
var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id]; 
if (found) _AN_Call_appendchild("appendChild", gutterWrap, elt("div", [found] , "CodeMirror-gutter-elt", "left: " + 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 < _AN_Read_length("length", ws); ++i){ 
var widget = ws[i], node = elt("div", [widget.node] , "CodeMirror-linewidget"); 
if (!widget.handleMouseEvents) node.ignoreEvents = true ; 
positionLineWidget(widget, node, wrap, dims); 
if (widget.above) wrap.insertBefore(node, cm.options.lineNumbers && line.height != 0? gutterWrap: lineElement); 
 else _AN_Call_appendchild("appendChild", wrap, node); 
signalLater(widget, "redraw"); 
} 
return wrap; 
} 
function positionLineWidget(widget, node, wrap, dims){ 
if (widget.noHScroll) { 
(wrap.alignable || (wrap.alignable = [] )).push(node); 
var width = dims.wrapperWidth; 
node.style.left = dims.fixedPos + "px"; 
if (!widget.coverGutter) { 
width -= dims.gutterTotalWidth; 
node.style.paddingLeft = dims.gutterTotalWidth + "px"; 
} 
node.style.width = width + "px"; 
} 
if (widget.coverGutter) { 
node.style.zIndex = 5; 
node.style.position = "relative"; 
if (!widget.noHScroll) node.style.marginLeft = - dims.gutterTotalWidth + "px"; 
} 
} 
function updateSelection(cm){ 
var display = cm.display; 
var collapsed = posEq(cm.doc.sel.from, cm.doc.sel.to); 
if (collapsed || cm.options.showCursorWhenSelecting) updateSelectionCursor(cm); 
 else display.cursor.style.display = display.otherCursor.style.display = "none"; 
if (!collapsed) updateSelectionRange(cm); 
 else display.selectionDiv.style.display = "none"; 
if (cm.options.moveInputWithCursor) { 
var headPos = cursorCoords(cm, cm.doc.sel.head, "div"); 
var wrapOff = getRect(display.wrapper), lineOff = getRect(display.lineDiv); 
display.inputDiv.style.top = Math.max(0, Math.min(display.wrapper.clientHeight - 10, headPos.top + lineOff.top - wrapOff.top)) + "px"; 
display.inputDiv.style.left = Math.max(0, Math.min(display.wrapper.clientWidth - 10, headPos.left + lineOff.left - wrapOff.left)) + "px"; 
} 
} 
function updateSelectionCursor(cm){ 
var display = cm.display, pos = cursorCoords(cm, cm.doc.sel.head, "div"); 
display.cursor.style.left = pos.left + "px"; 
display.cursor.style.top = pos.top + "px"; 
display.cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px"; 
display.cursor.style.display = ""; 
if (pos.other) { 
display.otherCursor.style.display = ""; 
display.otherCursor.style.left = pos.other.left + "px"; 
display.otherCursor.style.top = pos.other.top + "px"; 
display.otherCursor.style.height = (pos.other.bottom - pos.other.top) * 0.85 + "px"; 
} 
 else { 
display.otherCursor.style.display = "none"; 
} 
} 
function updateSelectionRange(cm){ 
var display = cm.display, doc = cm.doc, sel = cm.doc.sel; 
var fragment = document.createDocumentFragment(); 
var clientWidth = display.lineSpace.offsetWidth, pl = paddingLeft(cm.display); 
function add(left, top, width, bottom){ 
if (top < 0) top = 0; 
_AN_Call_appendchild("appendChild", fragment, elt("div", null , "CodeMirror-selected", "position: absolute; left: " + left + "px; top: " + top + "px; width: " + (width == null ? clientWidth - left: width) + "px; height: " + (bottom - top) + "px")); 
} 
function drawForLine(line, fromArg, toArg){ 
var lineObj = getLine(doc, line); 
var lineLen = _AN_Read_length("length", lineObj.text); 
var start, end; 
function coords(ch, bias){ 
return charCoords(cm, Pos(line, ch), "div", lineObj, bias); 
} 
iterateBidiSections(getOrder(lineObj), fromArg || 0, toArg == null ? lineLen: toArg, function (from, to, dir){ 
var leftPos = coords(from, "left"), rightPos, left, right; 
if (from == to) { 
rightPos = leftPos; 
left = right = leftPos.left; 
} 
 else { 
rightPos = coords(to - 1, "right"); 
if (dir == "rtl") { 
var tmp = leftPos; 
leftPos = rightPos; 
rightPos = tmp; 
} 
left = leftPos.left; 
right = rightPos.right; 
} 
if (fromArg == null  && from == 0) left = pl; 
if (rightPos.top - leftPos.top > 3) { 
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 (!start || leftPos.top < start.top || leftPos.top == start.top && leftPos.left < start.left) start = leftPos; 
if (!end || rightPos.bottom > end.bottom || rightPos.bottom == end.bottom && rightPos.right > end.right) end = rightPos; 
if (left < pl + 1) left = pl; 
add(left, rightPos.top, right - left, rightPos.bottom); 
} 
); 
return { 
start: start,
end: end}
; 
} 
if (sel.from.line == sel.to.line) { 
drawForLine(sel.from.line, sel.from.ch, sel.to.ch); 
} 
 else { 
var fromLine = getLine(doc, sel.from.line), toLine = getLine(doc, sel.to.line); 
var singleVLine = visualLine(doc, fromLine) == visualLine(doc, toLine); 
var leftEnd = drawForLine(sel.from.line, sel.from.ch, singleVLine? _AN_Read_length("length", fromLine.text): null ).end; 
var rightStart = drawForLine(sel.to.line, singleVLine? 0: null , sel.to.ch).start; 
if (singleVLine) { 
if (leftEnd.top < rightStart.top - 2) { 
add(leftEnd.right, leftEnd.top, null , leftEnd.bottom); 
add(pl, rightStart.top, rightStart.left, rightStart.bottom); 
} 
 else { 
add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom); 
} 
} 
if (leftEnd.bottom < rightStart.top) add(pl, leftEnd.bottom, null , rightStart.top); 
} 
removeChildrenAndAdd(display.selectionDiv, fragment); 
display.selectionDiv.style.display = ""; 
} 
function restartBlink(cm){ 
if (!cm.state.focused) return ; 
var display = cm.display; 
clearInterval(display.blinker); 
var on = true ; 
display.cursor.style.visibility = display.otherCursor.style.visibility = ""; 
if (cm.options.cursorBlinkRate > 0) display.blinker = _AN_Call_setinterval("setInterval", window, function (){ 
display.cursor.style.visibility = display.otherCursor.style.visibility = (on = !on)? "": "hidden"; 
} 
, cm.options.cursorBlinkRate); 
} 
function startWorker(cm, time){ 
if (cm.doc.mode.startState && cm.doc.frontier < cm.display.showingTo) cm.state.highlight.set(time, bind(highlightWorker, cm)); 
} 
function highlightWorker(cm){ 
var doc = cm.doc; 
if (doc.frontier < doc.first) doc.frontier = doc.first; 
if (doc.frontier >= cm.display.showingTo) return ; 
var end = + new Date() + cm.options.workTime; 
var state = copyState(doc.mode, getStateBefore(cm, doc.frontier)); 
var changed = [] , prevChange; 
doc.iter(doc.frontier, Math.min(doc.first + doc.size, cm.display.showingTo + 500), function (line){ 
if (doc.frontier >= cm.display.showingFrom) { 
var oldStyles = line.styles; 
line.styles = highlightLine(cm, line, state, true ); 
var ischange = !oldStyles || _AN_Read_length("length", oldStyles) != _AN_Read_length("length", line.styles); 
for (var i = 0; 
!ischange && i < _AN_Read_length("length", oldStyles); ++i)ischange = oldStyles[i] != line.styles[i]; 
if (ischange) { 
if (prevChange && prevChange.end == doc.frontier) prevChange.end++ ; 
 else changed.push(prevChange = { 
start: doc.frontier,
end: doc.frontier + 1}
); 
} 
line.stateAfter = copyState(doc.mode, state); 
} 
 else { 
processLine(cm, line.text, state); 
line.stateAfter = doc.frontier % 5 == 0? copyState(doc.mode, state): null ; 
} 
++doc.frontier; 
if (+ new Date() > end) { 
startWorker(cm, cm.options.workDelay); 
return true ; 
} 
} 
); 
if (changed.length) operation(cm, function (){ 
for (var i = 0; 
i < _AN_Read_length("length", changed); ++i)regChange(this, changed[i].start, changed[i].end); 
} 
)(); 
} 
function findStartLine(cm, n, precise){ 
var minindent, minline, doc = cm.doc; 
var lim = precise? -1: n - (cm.doc.mode.innerMode? 1000: 100); 
for (var search = n; 
search > lim; --search){ 
if (search <= doc.first) return doc.first; 
var line = getLine(doc, search - 1); 
if (line.stateAfter && (!precise || search <= doc.frontier)) return search; 
var indented = countColumn(line.text, null , cm.options.tabSize); 
if (minline == null  || minindent > indented) { 
minline = search - 1; 
minindent = indented; 
} 
} 
return minline; 
} 
function getStateBefore(cm, n, precise){ 
var doc = cm.doc, display = cm.display; 
if (!doc.mode.startState) return true ; 
var pos = findStartLine(cm, n, precise), state = pos > doc.first && getLine(doc, pos - 1).stateAfter; 
if (!state) state = startState(doc.mode); 
 else state = copyState(doc.mode, state); 
doc.iter(pos, n, function (line){ 
processLine(cm, line.text, state); 
var save = pos == n - 1 || pos % 5 == 0 || pos >= display.showingFrom && pos < display.showingTo; 
line.stateAfter = save? copyState(doc.mode, state): null ; 
++pos; 
} 
); 
if (precise) doc.frontier = pos; 
return state; 
} 
function paddingTop(display){ 
return display.lineSpace.offsetTop; 
} 
function paddingVert(display){ 
return display.mover.offsetHeight - display.lineSpace.offsetHeight; 
} 
function paddingLeft(display){ 
var e = _AN_Call_appendchild("appendChild", removeChildrenAndAdd(display.measure, elt("pre", null , null , "text-align: left")), elt("span", "x")); 
return e.offsetLeft; 
} 
function measureChar(cm, line, ch, data, bias){ 
var dir = -1; 
data = data || measureLine(cm, line); 
if (data.crude) { 
var left = data.left + ch * data.width; 
return { 
left: left,
right: left + data.width,
top: data.top,
bottom: data.bottom}
; 
} 
for (var pos = ch; 
; pos += dir){ 
var r = data[pos]; 
if (r) break ; 
if (dir < 0 && pos == 0) dir = 1; 
} 
bias = pos > ch? "left": pos < ch? "right": bias; 
if (bias == "left" && r.leftSide) r = r.leftSide; 
 else if (bias == "right" && r.rightSide) r = r.rightSide; 
return { 
left: pos < ch? r.right: r.left,
right: pos > ch? r.left: r.right,
top: r.top,
bottom: r.bottom}
; 
} 
function findCachedMeasurement(cm, line){ 
var cache = cm.display.measureLineCache; 
for (var i = 0; 
i < _AN_Read_length("length", cache); ++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.wrapClass) return memo; 
} 
} 
function clearCachedMeasurement(cm, line){ 
var exists = findCachedMeasurement(cm, line); 
if (exists) _AN_Write_text("text", exists, false , exists.measure = exists.markedSpans = null ); 
} 
function measureLine(cm, line){ 
var cached = findCachedMeasurement(cm, line); 
if (cached) return cached.measure; 
var measure = measureLineInner(cm, line); 
var cache = cm.display.measureLineCache; 
var memo = { 
text: line.text,
width: cm.display.scroller.clientWidth,
markedSpans: line.markedSpans,
measure: measure,
classes: line.textClass + "|" + line.wrapClass}
; 
if (_AN_Read_length("length", cache) == 16) cache[++cm.display.measureLineCachePos % 16] = memo; 
 else cache.push(memo); 
return measure; 
} 
function measureLineInner(cm, line){ 
if (!cm.options.lineWrapping && _AN_Read_length("length", line.text) >= cm.options.crudeMeasuringFrom) return crudelyMeasureLine(cm, line); 
var display = cm.display, measure = emptyArray(_AN_Read_length("length", line.text)); 
var pre = buildLineContent(cm, line, measure, true ).pre; 
if (ie && !ie_lt8 && !cm.options.lineWrapping && _AN_Read_length("length", pre.childNodes) > 100) { 
var fragment = document.createDocumentFragment(); 
var chunk = 10, n = _AN_Read_length("length", pre.childNodes); 
for (var i = 0, chunks = Math.ceil(n / chunk); 
i < chunks; ++i){ 
var wrap = elt("div", null , null , "display: inline-block"); 
for (var j = 0; 
j < chunk && n; ++j){ 
_AN_Call_appendchild("appendChild", wrap, pre.firstChild); 
--n; 
} 
_AN_Call_appendchild("appendChild", fragment, wrap); 
} 
_AN_Call_appendchild("appendChild", pre, fragment); 
} 
removeChildrenAndAdd(display.measure, pre); 
var outer = getRect(display.lineDiv); 
var vranges = [] , data = emptyArray(_AN_Read_length("length", line.text)), maxBot = pre.offsetHeight; 
if (ie_lt9 && display.measure.first != pre) removeChildrenAndAdd(display.measure, pre); 
function measureRect(rect){ 
var top = rect.top - outer.top, bot = rect.bottom - outer.top; 
if (bot > maxBot) bot = maxBot; 
if (top < 0) top = 0; 
for (var i = _AN_Read_length("length", vranges) - 2; 
i >= 0; i -= 2){ 
var rtop = vranges[i], rbot = vranges[i + 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[i] = Math.min(top, rtop); 
vranges[i + 1] = Math.max(bot, rbot); 
break ; 
} 
} 
if (i < 0) { 
i = _AN_Read_length("length", vranges); 
vranges.push(top, bot); 
} 
return { 
left: rect.left - outer.left,
right: rect.right - outer.left,
top: i,
bottom: null }
; 
} 
function finishRect(rect){ 
rect.bottom = vranges[rect.top + 1]; 
rect.top = vranges[rect.top]; 
} 
for (var i = 0, cur; 
i < _AN_Read_length("length", measure); ++i)if (cur = measure[i]) { 
var node = cur, rect = null ; 
if (/\bCodeMirror-widget\b/.test(cur.className) && cur.getClientRects) { 
if (cur.firstChild.nodeType == 1) node = cur.firstChild; 
var rects = node.getClientRects(); 
if (_AN_Read_length("length", rects) > 1) { 
rect = data[i] = measureRect(rects[0]); 
rect.rightSide = measureRect(rects[_AN_Read_length("length", rects) - 1]); 
} 
} 
if (!rect) rect = data[i] = measureRect(getRect(node)); 
if (cur.measureRight) rect.right = getRect(cur.measureRight).left - outer.left; 
if (cur.leftSide) rect.leftSide = measureRect(getRect(cur.leftSide)); 
} 
removeChildren(cm.display.measure); 
for (var i = 0, cur; 
i < _AN_Read_length("length", data); ++i)if (cur = data[i]) { 
finishRect(cur); 
if (cur.leftSide) finishRect(cur.leftSide); 
if (cur.rightSide) finishRect(cur.rightSide); 
} 
return data; 
} 
function crudelyMeasureLine(cm, line){ 
var copy = new Line(line.text.slice(0, 100), null ); 
if (line.textClass) copy.textClass = line.textClass; 
var measure = measureLineInner(cm, copy); 
var left = measureChar(cm, copy, 0, measure, "left"); 
var right = measureChar(cm, copy, 99, measure, "right"); 
return { 
crude: true ,
top: left.top,
left: left.left,
bottom: left.bottom,
width: (right.right - left.left) / 100}
; 
} 
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 == _AN_Read_length("length", line.text))) hasBadSpan = true ; 
} 
var cached = !hasBadSpan && findCachedMeasurement(cm, line); 
if (cached || _AN_Read_length("length", line.text) >= cm.options.crudeMeasuringFrom) return measureChar(cm, line, _AN_Read_length("length", line.text), cached && cached.measure, "right").right; 
var pre = buildLineContent(cm, line, null , true ).pre; 
var end = _AN_Call_appendchild("appendChild", pre, zeroWidthElement(cm.display.measure)); 
removeChildrenAndAdd(cm.display.measure, pre); 
return getRect(end).right - getRect(cm.display.lineDiv).left; 
} 
function clearCaches(cm){ 
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 ; 
} 
function pageScrollX(){ 
return window.pageXOffset || (document.documentElement || document.body).scrollLeft; 
} 
function pageScrollY(){ 
return window.pageYOffset || (document.documentElement || document.body).scrollTop; 
} 
function intoCoordSystem(cm, lineObj, rect, context){ 
if (lineObj.widgets) for (var i = 0; 
i < _AN_Read_length("length", lineObj.widgets); ++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); 
if (context == "local") yOff += paddingTop(cm.display); 
 else yOff -= cm.display.viewOffset; 
if (context == "page" || context == "window") { 
var lOff = getRect(cm.display.lineSpace); 
yOff += lOff.top + (context == "window"? 0: pageScrollY()); 
var xOff = lOff.left + (context == "window"? 0: pageScrollX()); 
rect.left += xOff; 
rect.right += xOff; 
} 
rect.top += yOff; 
rect.bottom += yOff; 
return rect; 
} 
function fromCoordSystem(cm, coords, context){ 
if (context == "div") return coords; 
var left = coords.left, top = coords.top; 
if (context == "page") { 
left -= pageScrollX(); 
top -= pageScrollY(); 
} 
 else if (context == "local" || !context) { 
var localBox = getRect(cm.display.sizer); 
left += localBox.left; 
top += localBox.top; 
} 
var lineSpaceBox = getRect(cm.display.lineSpace); 
return { 
left: left - lineSpaceBox.left,
top: top - lineSpaceBox.top}
; 
} 
function charCoords(cm, pos, context, lineObj, bias){ 
if (!lineObj) lineObj = getLine(cm.doc, pos.line); 
return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, null , bias), context); 
} 
function cursorCoords(cm, pos, context, lineObj, measurement){ 
lineObj = lineObj || getLine(cm.doc, pos.line); 
if (!measurement) measurement = measureLine(cm, lineObj); 
function get(ch, right){ 
var m = measureChar(cm, lineObj, ch, measurement, right? "right": "left"); 
if (right) m.left = m.right; 
 else m.right = m.left; 
return intoCoordSystem(cm, lineObj, m, context); 
} 
function getBidi(ch, partPos){ 
var part = order[partPos], right = part.level % 2; 
if (ch == bidiLeft(part) && partPos && part.level < order[partPos - 1].level) { 
part = order[--partPos]; 
ch = bidiRight(part) - (part.level % 2? 0: 1); 
right = true ; 
} 
 else if (ch == bidiRight(part) && partPos < _AN_Read_length("length", order) - 1 && part.level < order[partPos + 1].level) { 
part = order[++partPos]; 
ch = bidiLeft(part) - part.level % 2; 
right = false ; 
} 
if (right && ch == part.to && ch > part.from) return get(ch - 1); 
return get(ch, right); 
} 
var order = getOrder(lineObj), ch = pos.ch; 
if (!order) return get(ch); 
var partPos = getBidiPartAt(order, ch); 
var val = getBidi(ch, partPos); 
if (bidiOther != null ) val.other = getBidi(ch, bidiOther); 
return val; 
} 
function PosWithInfo(line, ch, outside, xRel){ 
var pos = new Pos(line, ch); 
pos.xRel = xRel; 
if (outside) pos.outside = true ; 
return pos; 
} 
function coordsChar(cm, x, y){ 
var doc = cm.doc; 
y += cm.display.viewOffset; 
if (y < 0) return PosWithInfo(doc.first, 0, true , -1); 
var lineNo = lineAtHeight(doc, y), last = doc.first + doc.size - 1; 
if (lineNo > last) return PosWithInfo(doc.first + doc.size - 1, _AN_Read_length("length", getLine(doc, last).text), true , 1); 
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(); 
if (merged && (found.ch > mergedPos.from.ch || found.ch == mergedPos.from.ch && found.xRel > 0)) lineNo = mergedPos.to.line; 
 else return found; 
} 
} 
function coordsCharInner(cm, lineObj, lineNo, x, y){ 
var innerOff = y - heightAtLine(cm, lineObj); 
var wrongLine = false , adjust = 2 * cm.display.wrapper.clientWidth; 
var measurement = measureLine(cm, lineObj); 
function getX(ch){ 
var sp = cursorCoords(cm, Pos(lineNo, ch), "line", lineObj, measurement); 
wrongLine = true ; 
if (innerOff > sp.bottom) return sp.left - adjust; 
 else if (innerOff < sp.top) return sp.left + adjust; 
 else wrongLine = false ; 
return sp.left; 
} 
var bidi = getOrder(lineObj), dist = _AN_Read_length("length", lineObj.text); 
var from = lineLeft(lineObj), to = lineRight(lineObj); 
var fromX = getX(from), fromOutside = wrongLine, toX = getX(to), toOutside = wrongLine; 
if (x > toX) return PosWithInfo(lineNo, to, toOutside, 1); 
for (; ; ){ 
if (bidi? to == from || to == moveVisually(lineObj, from, 1): to - from <= 1) { 
var ch = x < fromX || x - fromX <= toX - x? from: to; 
var xDiff = x - (ch == from? fromX: toX); 
while (isExtendingChar.test(lineObj.text.charAt(ch)))++ch; 
var pos = PosWithInfo(lineNo, ch, ch == from? fromOutside: toOutside, xDiff < 0? -1: xDiff? 1: 0); 
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); 
} 
var middleX = getX(middle); 
if (middleX > x) { 
to = middle; 
toX = middleX; 
if (toOutside = wrongLine) toX += 1000; 
dist = step; 
} 
 else { 
from = middle; 
fromX = middleX; 
fromOutside = wrongLine; 
dist -= step; 
} 
} 
} 
var measureText; 
function textHeight(display){ 
if (display.cachedTextHeight != null ) return display.cachedTextHeight; 
if (measureText == null ) { 
measureText = elt("pre"); 
for (var i = 0; 
i < 49; ++i){ 
_AN_Call_appendchild("appendChild", measureText, document.createTextNode("x")); 
_AN_Call_appendchild("appendChild", measureText, elt("br")); 
} 
_AN_Call_appendchild("appendChild", measureText, document.createTextNode("x")); 
} 
removeChildrenAndAdd(display.measure, measureText); 
var height = measureText.offsetHeight / 50; 
if (height > 3) display.cachedTextHeight = height; 
removeChildren(display.measure); 
return height || 1; 
} 
function charWidth(display){ 
if (display.cachedCharWidth != null ) return display.cachedCharWidth; 
var anchor = elt("span", "x"); 
var pre = elt("pre", [anchor] ); 
removeChildrenAndAdd(display.measure, pre); 
var width = anchor.offsetWidth; 
if (width > 2) display.cachedCharWidth = width; 
return width || 10; 
} 
var nextOpId = 0; 
function startOperation(cm){ 
cm.curOp = { 
changes: [] ,
forceUpdate: false ,
updateInput: null ,
userSelChange: null ,
textChanged: null ,
selectionChanged: false ,
cursorActivity: false ,
updateMaxLine: false ,
updateScrollPos: false ,
id: ++nextOpId}
; 
if (!delayedCallbackDepth++ ) delayedCallbacks = [] ; 
} 
function endOperation(cm){ 
var op = cm.curOp, doc = cm.doc, display = cm.display; 
cm.curOp = null ; 
if (op.updateMaxLine) computeMaxLength(cm); 
if (display.maxLineChanged && !cm.options.lineWrapping && display.maxLine) { 
var width = measureLineWidth(cm, display.maxLine); 
display.sizer.style.minWidth = Math.max(0, width + 3 + scrollerCutOff) + "px"; 
display.maxLineChanged = false ; 
var maxScrollLeft = Math.max(0, display.sizer.offsetLeft + display.sizer.offsetWidth - display.scroller.clientWidth); 
if (maxScrollLeft < doc.scrollLeft && !op.updateScrollPos) setScrollLeft(cm, Math.min(display.scroller.scrollLeft, maxScrollLeft), true ); 
} 
var newScrollPos, updated; 
if (op.updateScrollPos) { 
newScrollPos = op.updateScrollPos; 
} 
 else if (op.selectionChanged && display.scroller.clientHeight) { 
var coords = cursorCoords(cm, doc.sel.head); 
newScrollPos = calculateScrollPos(cm, coords.left, coords.top, coords.left, coords.bottom); 
} 
if (_AN_Read_length("length", op.changes) || op.forceUpdate || newScrollPos && newScrollPos.scrollTop != null ) { 
updated = updateDisplay(cm, op.changes, newScrollPos && newScrollPos.scrollTop, op.forceUpdate); 
if (cm.display.scroller.offsetHeight) cm.doc.scrollTop = cm.display.scroller.scrollTop; 
} 
if (!updated && op.selectionChanged) updateSelection(cm); 
if (op.updateScrollPos) { 
var top = Math.max(0, Math.min(display.scroller.scrollHeight - display.scroller.clientHeight, newScrollPos.scrollTop)); 
var left = Math.max(0, Math.min(display.scroller.scrollWidth - display.scroller.clientWidth, newScrollPos.scrollLeft)); 
display.scroller.scrollTop = display.scrollbarV.scrollTop = doc.scrollTop = top; 
display.scroller.scrollLeft = display.scrollbarH.scrollLeft = doc.scrollLeft = left; 
alignHorizontally(cm); 
if (op.scrollToPos) scrollPosIntoView(cm, clipPos(cm.doc, op.scrollToPos.from), clipPos(cm.doc, op.scrollToPos.to), op.scrollToPos.margin); 
} 
 else if (newScrollPos) { 
scrollCursorIntoView(cm); 
} 
if (op.selectionChanged) restartBlink(cm); 
if (cm.state.focused && op.updateInput) resetInput(cm, op.userSelChange); 
var hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers; 
if (hidden) for (var i = 0; 
i < _AN_Read_length("length", hidden); ++i)if (!_AN_Read_length("length", hidden[i].lines)) signal(hidden[i], "hide"); 
if (unhidden) for (var i = 0; 
i < _AN_Read_length("length", unhidden); ++i)if (unhidden[i].lines.length) signal(unhidden[i], "unhide"); 
var delayed; 
if (!--delayedCallbackDepth) { 
delayed = delayedCallbacks; 
delayedCallbacks = null ; 
} 
if (op.textChanged) signal(cm, "change", cm, op.textChanged); 
if (op.cursorActivity) signal(cm, "cursorActivity", cm); 
if (delayed) for (var i = 0; 
i < _AN_Read_length("length", delayed); ++i)delayed[i](); 
} 
function operation(cm1, f){ 
return function (){ 
var cm = cm1 || this, withOp = !cm.curOp; 
if (withOp) startOperation(cm); 
try { 
var result = f.apply(cm, arguments); 
} 
finally{ 
if (withOp) endOperation(cm); 
} 
return result; 
} 
; 
} 
function docOperation(f){ 
return function (){ 
var withOp = this.cm && !this.cm.curOp, result; 
if (withOp) startOperation(this.cm); 
try { 
result = f.apply(this, arguments); 
} 
finally{ 
if (withOp) endOperation(this.cm); 
} 
return result; 
} 
; 
} 
function runInOp(cm, f){ 
var withOp = !cm.curOp, result; 
if (withOp) startOperation(cm); 
try { 
result = f(); 
} 
finally{ 
if (withOp) endOperation(cm); 
} 
return result; 
} 
function regChange(cm, from, to, lendiff){ 
if (from == null ) from = cm.doc.first; 
if (to == null ) to = cm.doc.first + cm.doc.size; 
cm.curOp.changes.push({ 
from: from,
to: to,
diff: lendiff}
); 
} 
function slowPoll(cm){ 
if (cm.display.pollingFast) return ; 
cm.display.poll.set(cm.options.pollInterval, function (){ 
readInput(cm); 
if (cm.state.focused) slowPoll(cm); 
} 
); 
} 
function fastPoll(cm){ 
var missed = false ; 
cm.display.pollingFast = true ; 
function p(){ 
var changed = readInput(cm); 
if (!changed && !missed) { 
missed = true ; 
cm.display.poll.set(60, p); 
} 
 else { 
cm.display.pollingFast = false ; 
slowPoll(cm); 
} 
} 
cm.display.poll.set(20, p); 
} 
function readInput(cm){ 
var input = cm.display.input, prevInput = cm.display.prevInput, doc = cm.doc, sel = doc.sel; 
if (!cm.state.focused || hasSelection(input) || isReadOnly(cm) || cm.state.disableInput) return false ; 
if (cm.state.pasteIncoming && cm.state.fakedLastChar) { 
input.value = input.value.substring(0, _AN_Read_length("length", input.value) - 1); 
cm.state.fakedLastChar = false ; 
} 
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 ; 
} 
var withOp = !cm.curOp; 
if (withOp) startOperation(cm); 
sel.shift = false ; 
var same = 0, l = Math.min(_AN_Read_length("length", prevInput), _AN_Read_length("length", text)); 
while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same))++same; 
var from = sel.from, to = sel.to; 
var inserted = text.slice(same); 
if (same < _AN_Read_length("length", prevInput)) from = Pos(from.line, from.ch - (_AN_Read_length("length", prevInput) - same)); 
 else if (cm.state.overwrite && posEq(from, to) && !cm.state.pasteIncoming) to = Pos(to.line, Math.min(_AN_Read_length("length", getLine(doc, to.line).text), to.ch + _AN_Read_length("length", inserted))); 
var updateInput = cm.curOp.updateInput; 
var changeEvent = { 
from: from,
to: to,
text: splitLines(inserted),
origin: cm.state.pasteIncoming? "paste": "+input"}
; 
makeChange(cm.doc, changeEvent, "end"); 
cm.curOp.updateInput = updateInput; 
signalLater(cm, "inputRead", cm, changeEvent); 
if (!cm.state.pasteIncoming && cm.options.electricChars && cm.options.smartIndent && sel.head.ch < 100) { 
var electric = cm.getModeAt(sel.head).electricChars; 
if (electric) for (var i = 0; 
i < _AN_Read_length("length", electric); i++ )if (inserted.indexOf(electric.charAt(i)) > -1) { 
indentLine(cm, sel.head.line, "smart"); 
break ; 
} 
} 
if (_AN_Read_length("length", text) > 1000 || text.indexOf("\n") > -1) input.value = cm.display.prevInput = ""; 
 else cm.display.prevInput = text; 
if (withOp) endOperation(cm); 
cm.state.pasteIncoming = false ; 
return true ; 
} 
function resetInput(cm, user){ 
var minimal, selected, doc = cm.doc; 
if (!posEq(doc.sel.from, doc.sel.to)) { 
cm.display.prevInput = ""; 
minimal = hasCopyEvent && (doc.sel.to.line - doc.sel.from.line > 100 || _AN_Read_length("length", (selected = cm.getSelection())) > 1000); 
var content = minimal? "-": selected || cm.getSelection(); 
cm.display.input.value = content; 
if (cm.state.focused) selectInput(cm.display.input); 
if (ie && !ie_lt9) cm.display.inputHasSelection = content; 
} 
 else if (user) { 
cm.display.prevInput = cm.display.input.value = ""; 
if (ie && !ie_lt9) cm.display.inputHasSelection = null ; 
} 
cm.display.inaccurateSelection = minimal; 
} 
function focusInput(cm){ 
if (cm.options.readOnly != "nocursor" && (!mobile || document.activeElement != cm.display.input)) cm.display.input.focus(); 
} 
function isReadOnly(cm){ 
return cm.options.readOnly || cm.doc.cantEdit; 
} 
function registerEventHandlers(cm){ 
var d = cm.display; 
on(d.scroller, "mousedown", operation(cm, onMouseDown)); 
if (ie) on(d.scroller, "dblclick", operation(cm, function (e){ 
if (signalDOMEvent(cm, e)) return ; 
var pos = posFromMouse(cm, e); 
if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) return ; 
e_preventDefault(e); 
var word = findWordAt(getLine(cm.doc, pos.line).text, pos); 
extendSelection(cm.doc, word.from, word.to); 
} 
)); 
 else on(d.scroller, "dblclick", function (e){ 
signalDOMEvent(cm, e) || e_preventDefault(e); 
} 
); 
on(d.lineSpace, "selectstart", function (e){ 
if (!eventInWidget(d, e)) e_preventDefault(e); 
} 
); 
if (!captureMiddleClick) on(d.scroller, "contextmenu", function (e){ 
onContextMenu(cm, e); 
} 
); 
on(d.scroller, "scroll", function (){ 
if (d.scroller.clientHeight) { 
setScrollTop(cm, d.scroller.scrollTop); 
setScrollLeft(cm, d.scroller.scrollLeft, true ); 
signal(cm, "scroll", cm); 
} 
} 
); 
on(d.scrollbarV, "scroll", function (){ 
if (d.scroller.clientHeight) setScrollTop(cm, d.scrollbarV.scrollTop); 
} 
); 
on(d.scrollbarH, "scroll", function (){ 
if (d.scroller.clientHeight) setScrollLeft(cm, d.scrollbarH.scrollLeft); 
} 
); 
on(d.scroller, "mousewheel", function (e){ 
onScrollWheel(cm, e); 
} 
); 
on(d.scroller, "DOMMouseScroll", function (e){ 
onScrollWheel(cm, e); 
} 
); 
function reFocus(){ 
if (cm.state.focused) _AN_Call_settimeout("setTimeout", window, bind(focusInput, cm), 0); 
} 
on(d.scrollbarH, "mousedown", reFocus); 
on(d.scrollbarV, "mousedown", reFocus); 
on(d.wrapper, "scroll", function (){ 
d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; 
} 
); 
var resizeTimer; 
function onResize(){ 
if (resizeTimer == null ) resizeTimer = _AN_Call_settimeout("setTimeout", window, function (){ 
resizeTimer = null ; 
d.cachedCharWidth = d.cachedTextHeight = knownScrollbarWidth = null ; 
clearCaches(cm); 
runInOp(cm, bind(regChange, cm)); 
} 
, 100); 
} 
on(window, "resize", onResize); 
function unregister(){ 
for (var p = d.wrapper.parentNode; 
p && p != document.body; p = p.parentNode){ 
} 
if (p) _AN_Call_settimeout("setTimeout", window, unregister, 5000); 
 else off(window, "resize", onResize); 
} 
_AN_Call_settimeout("setTimeout", window, unregister, 5000); 
on(d.input, "keyup", operation(cm, function (e){ 
if (signalDOMEvent(cm, e) || cm.options.onKeyEvent && cm.options.onKeyEvent(cm, addStop(e))) return ; 
if (e.keyCode == 16) cm.doc.sel.shift = false ; 
} 
)); 
on(d.input, "input", function (){ 
if (ie && !ie_lt9 && cm.display.inputHasSelection) cm.display.inputHasSelection = null ; 
fastPoll(cm); 
} 
); 
on(d.input, "keydown", operation(cm, onKeyDown)); 
on(d.input, "keypress", operation(cm, onKeyPress)); 
on(d.input, "focus", bind(onFocus, cm)); 
on(d.input, "blur", bind(onBlur, cm)); 
function drag_(e){ 
if (signalDOMEvent(cm, e) || cm.options.onDragEvent && cm.options.onDragEvent(cm, addStop(e))) return ; 
e_stop(e); 
} 
if (cm.options.dragDrop) { 
on(d.scroller, "dragstart", function (e){ 
onDragStart(cm, e); 
} 
); 
on(d.scroller, "dragenter", drag_); 
on(d.scroller, "dragover", drag_); 
on(d.scroller, "drop", operation(cm, onDrop)); 
} 
on(d.scroller, "paste", function (e){ 
if (eventInWidget(d, e)) return ; 
focusInput(cm); 
fastPoll(cm); 
} 
); 
on(d.input, "paste", function (){ 
if (webkit && !cm.state.fakedLastChar && !(new Date() - cm.state.lastMiddleDown < 200)) { 
var start = d.input.selectionStart, end = d.input.selectionEnd; 
d.input.value += "$"; 
d.input.selectionStart = start; 
d.input.selectionEnd = end; 
cm.state.fakedLastChar = true ; 
} 
cm.state.pasteIncoming = true ; 
fastPoll(cm); 
} 
); 
function prepareCopy(){ 
if (d.inaccurateSelection) { 
d.prevInput = ""; 
d.inaccurateSelection = false ; 
d.input.value = cm.getSelection(); 
selectInput(d.input); 
} 
} 
on(d.input, "cut", prepareCopy); 
on(d.input, "copy", prepareCopy); 
if (khtml) on(d.sizer, "mouseup", function (){ 
if (document.activeElement == d.input) d.input.blur(); 
focusInput(cm); 
} 
); 
} 
function eventInWidget(display, e){ 
for (var n = e_target(e); 
n != display.wrapper; n = n.parentNode){ 
if (!n || n.ignoreEvents || n.parentNode == display.sizer && n != display.mover) return true ; 
} 
} 
function posFromMouse(cm, e, liberal){ 
var display = cm.display; 
if (!liberal) { 
var target = e_target(e); 
if (target == display.scrollbarH || target == display.scrollbarH.firstChild || target == display.scrollbarV || target == display.scrollbarV.firstChild || target == display.scrollbarFiller || target == display.gutterFiller) return null ; 
} 
var x, y, space = getRect(display.lineSpace); 
try { 
x = e.clientX; 
y = e.clientY; 
} 
catch (e) { 
return null ; 
} 
return coordsChar(cm, x - space.left, y - space.top); 
} 
var lastClick, lastDoubleClick; 
function onMouseDown(e){ 
if (signalDOMEvent(this, e)) return ; 
var cm = this, display = cm.display, doc = cm.doc, sel = doc.sel; 
sel.shift = e.shiftKey; 
if (eventInWidget(display, e)) { 
if (!webkit) { 
display.scroller.draggable = false ; 
_AN_Call_settimeout("setTimeout", window, function (){ 
display.scroller.draggable = true ; 
} 
, 100); 
} 
return ; 
} 
if (clickInGutter(cm, e)) return ; 
var start = posFromMouse(cm, e); 
switch (e_button(e)){ 
case 3: if (captureMiddleClick) onContextMenu.call(cm, cm, e); 
return ; 
case 2: if (webkit) cm.state.lastMiddleDown = + new Date(); 
if (start) extendSelection(cm.doc, start); 
_AN_Call_settimeout("setTimeout", window, bind(focusInput, cm), 20); 
e_preventDefault(e); 
return ; 
} 
if (!start) { 
if (e_target(e) == display.scroller) e_preventDefault(e); 
return ; 
} 
if (!cm.state.focused) onFocus(cm); 
var now = + new Date(), type = "single"; 
if (lastDoubleClick && lastDoubleClick.time > now - 400 && posEq(lastDoubleClick.pos, start)) { 
type = "triple"; 
e_preventDefault(e); 
_AN_Call_settimeout("setTimeout", window, bind(focusInput, cm), 20); 
selectLine(cm, start.line); 
} 
 else if (lastClick && lastClick.time > now - 400 && posEq(lastClick.pos, start)) { 
type = "double"; 
lastDoubleClick = { 
time: now,
pos: start}
; 
e_preventDefault(e); 
var word = findWordAt(getLine(doc, start.line).text, start); 
extendSelection(cm.doc, word.from, word.to); 
} 
 else { 
lastClick = { 
time: now,
pos: start}
; 
} 
var last = start; 
if (cm.options.dragDrop && dragAndDrop && !isReadOnly(cm) && !posEq(sel.from, sel.to) && !posLess(start, sel.from) && !posLess(sel.to, start) && type == "single") { 
var dragEnd = operation(cm, function (e2){ 
if (webkit) display.scroller.draggable = false ; 
cm.state.draggingText = false ; 
off(document, "mouseup", dragEnd); 
off(display.scroller, "drop", dragEnd); 
if (Math.abs(e.clientX - e2.clientX) + Math.abs(e.clientY - e2.clientY) < 10) { 
e_preventDefault(e2); 
extendSelection(cm.doc, start); 
focusInput(cm); 
} 
} 
); 
if (webkit) display.scroller.draggable = true ; 
cm.state.draggingText = dragEnd; 
if (display.scroller.dragDrop) display.scroller.dragDrop(); 
on(document, "mouseup", dragEnd); 
on(display.scroller, "drop", dragEnd); 
return ; 
} 
e_preventDefault(e); 
if (type == "single") extendSelection(cm.doc, clipPos(doc, start)); 
var startstart = sel.from, startend = sel.to, lastPos = start; 
function doSelect(cur){ 
if (posEq(lastPos, cur)) return ; 
lastPos = cur; 
if (type == "single") { 
extendSelection(cm.doc, clipPos(doc, start), cur); 
return ; 
} 
startstart = clipPos(doc, startstart); 
startend = clipPos(doc, startend); 
if (type == "double") { 
var word = findWordAt(getLine(doc, cur.line).text, cur); 
if (posLess(cur, startstart)) extendSelection(cm.doc, word.from, startend); 
 else extendSelection(cm.doc, startstart, word.to); 
} 
 else if (type == "triple") { 
if (posLess(cur, startstart)) extendSelection(cm.doc, startend, clipPos(doc, Pos(cur.line, 0))); 
 else extendSelection(cm.doc, startstart, clipPos(doc, Pos(cur.line + 1, 0))); 
} 
} 
var editorSize = getRect(display.wrapper); 
var counter = 0; 
function extend(e){ 
var curCount = ++counter; 
var cur = posFromMouse(cm, e, true ); 
if (!cur) return ; 
if (!posEq(cur, last)) { 
if (!cm.state.focused) onFocus(cm); 
last = cur; 
doSelect(cur); 
var visible = visibleLines(display, doc); 
if (cur.line >= visible.to || cur.line < visible.from) _AN_Call_settimeout("setTimeout", window, operation(cm, function (){ 
if (counter == curCount) extend(e); 
} 
), 150); 
} 
 else { 
var outside = e.clientY < editorSize.top? -20: e.clientY > editorSize.bottom? 20: 0; 
if (outside) _AN_Call_settimeout("setTimeout", window, operation(cm, function (){ 
if (counter != curCount) return ; 
display.scroller.scrollTop += outside; 
extend(e); 
} 
), 50); 
} 
} 
function done(e){ 
counter = Infinity; 
e_preventDefault(e); 
focusInput(cm); 
off(document, "mousemove", move); 
off(document, "mouseup", up); 
} 
var move = operation(cm, function (e){ 
if (!ie && !e_button(e)) done(e); 
 else extend(e); 
} 
); 
var up = operation(cm, done); 
on(document, "mousemove", move); 
on(document, "mouseup", up); 
} 
function gutterEvent(cm, e, type, prevent, signalfn){ 
try { 
var mX = e.clientX, mY = e.clientY; 
} 
catch (e) { 
return false ; 
} 
if (mX >= Math.floor(getRect(cm.display.gutters).right)) return false ; 
if (prevent) e_preventDefault(e); 
var display = cm.display; 
var lineBox = getRect(display.lineDiv); 
if (mY > lineBox.bottom || !hasHandler(cm, type)) return e_defaultPrevented(e); 
mY -= lineBox.top - display.viewOffset; 
for (var i = 0; 
i < _AN_Read_length("length", cm.options.gutters); ++i){ 
var g = display.gutters.childNodes[i]; 
if (g && getRect(g).right >= mX) { 
var line = lineAtHeight(cm.doc, mY); 
var gutter = cm.options.gutters[i]; 
signalfn(cm, type, cm, line, gutter, e); 
return e_defaultPrevented(e); 
} 
} 
} 
function contextMenuInGutter(cm, e){ 
if (!hasHandler(cm, "gutterContextMenu")) return false ; 
return gutterEvent(cm, e, "gutterContextMenu", false , signal); 
} 
function clickInGutter(cm, e){ 
return gutterEvent(cm, e, "gutterClick", true , signalLater); 
} 
var lastDrop = 0; 
function onDrop(e){ 
var cm = this; 
if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e) || (cm.options.onDragEvent && cm.options.onDragEvent(cm, addStop(e)))) return ; 
e_preventDefault(e); 
if (ie) lastDrop = + new Date(); 
var pos = posFromMouse(cm, e, true ), files = e.dataTransfer.files; 
if (!pos || isReadOnly(cm)) return ; 
if (files && _AN_Read_length("length", files) && window.FileReader && window.File) { 
var n = _AN_Read_length("length", files), text = Array(n), read = 0; 
var loadFile = function (file, i){ 
var reader = new FileReader(); 
reader.onload = function (){ 
text[i] = reader.result; 
if (++read == n) { 
pos = clipPos(cm.doc, pos); 
makeChange(cm.doc, { 
from: pos,
to: pos,
text: splitLines(text.join("\n")),
origin: "paste"}
, "around"); 
} 
} 
; 
reader.readAsText(file); 
} 
; 
for (var i = 0; 
i < n; ++i)loadFile(files[i], i); 
} 
 else { 
if (cm.state.draggingText && !(posLess(pos, cm.doc.sel.from) || posLess(cm.doc.sel.to, pos))) { 
cm.state.draggingText(e); 
_AN_Call_settimeout("setTimeout", window, bind(focusInput, cm), 20); 
return ; 
} 
try { 
var text = e.dataTransfer.getData("Text"); 
if (text) { 
var curFrom = cm.doc.sel.from, curTo = cm.doc.sel.to; 
setSelection(cm.doc, pos, pos); 
if (cm.state.draggingText) replaceRange(cm.doc, "", curFrom, curTo, "paste"); 
cm.replaceSelection(text, null , "paste"); 
focusInput(cm); 
} 
} 
catch (e) { 
} 
} 
} 
function onDragStart(cm, e){ 
if (ie && (!cm.state.draggingText || + new Date() - lastDrop < 100)) { 
e_stop(e); 
return ; 
} 
if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) return ; 
var txt = cm.getSelection(); 
e.dataTransfer.setData("Text", txt); 
if (e.dataTransfer.setDragImage && !safari) { 
var img = elt("img", null , null , "position: fixed; left: 0; top: 0;"); 
_AN_Write_src("src", img, false , "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="); 
if (opera) { 
img.width = img.height = 1; 
_AN_Call_appendchild("appendChild", cm.display.wrapper, img); 
img._top = img.offsetTop; 
} 
e.dataTransfer.setDragImage(img, 0, 0); 
if (opera) img.parentNode.removeChild(img); 
} 
} 
function setScrollTop(cm, val){ 
if (Math.abs(cm.doc.scrollTop - val) < 2) return ; 
cm.doc.scrollTop = val; 
if (!gecko) updateDisplay(cm, [] , val); 
if (cm.display.scroller.scrollTop != val) cm.display.scroller.scrollTop = val; 
if (cm.display.scrollbarV.scrollTop != val) cm.display.scrollbarV.scrollTop = val; 
if (gecko) updateDisplay(cm, [] ); 
startWorker(cm, 100); 
} 
function setScrollLeft(cm, val, isScroller){ 
if (isScroller? val == cm.doc.scrollLeft: Math.abs(cm.doc.scrollLeft - val) < 2) return ; 
val = Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth); 
cm.doc.scrollLeft = val; 
alignHorizontally(cm); 
if (cm.display.scroller.scrollLeft != val) cm.display.scroller.scrollLeft = val; 
if (cm.display.scrollbarH.scrollLeft != val) cm.display.scrollbarH.scrollLeft = val; 
} 
var wheelSamples = 0, wheelPixelsPerUnit = null ; 
if (ie) wheelPixelsPerUnit = -0.53; 
 else if (gecko) wheelPixelsPerUnit = 15; 
 else if (chrome) wheelPixelsPerUnit = -0.7; 
 else if (safari) wheelPixelsPerUnit = -1 / 3; 
function onScrollWheel(cm, e){ 
var dx = e.wheelDeltaX, dy = e.wheelDeltaY; 
if (dx == null  && e.detail && e.axis == e.HORIZONTAL_AXIS) dx = e.detail; 
if (dy == null  && e.detail && e.axis == e.VERTICAL_AXIS) dy = e.detail; 
 else if (dy == null ) dy = e.wheelDelta; 
var display = cm.display, scroll = display.scroller; 
if (!(dx && scroll.scrollWidth > scroll.clientWidth || dy && scroll.scrollHeight > scroll.clientHeight)) return ; 
if (dy && mac && webkit) { 
for (var cur = _AN_Read_target("target", e); 
cur != scroll; cur = cur.parentNode){ 
if (cur.lineObj) { 
cm.display.currentWheelTarget = cur; 
break ; 
} 
} 
} 
if (dx && !gecko && !opera && wheelPixelsPerUnit != null ) { 
if (dy) setScrollTop(cm, Math.max(0, Math.min(scroll.scrollTop + dy * wheelPixelsPerUnit, scroll.scrollHeight - scroll.clientHeight))); 
setScrollLeft(cm, Math.max(0, Math.min(scroll.scrollLeft + dx * wheelPixelsPerUnit, scroll.scrollWidth - scroll.clientWidth))); 
e_preventDefault(e); 
display.wheelStartX = null ; 
return ; 
} 
if (dy && wheelPixelsPerUnit != null ) { 
var pixels = dy * wheelPixelsPerUnit; 
var top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight; 
if (pixels < 0) top = Math.max(0, top + pixels - 50); 
 else bot = Math.min(cm.doc.height, bot + pixels + 50); 
updateDisplay(cm, [] , { 
top: top,
bottom: bot}
); 
} 
if (wheelSamples < 20) { 
if (display.wheelStartX == null ) { 
display.wheelStartX = scroll.scrollLeft; 
display.wheelStartY = scroll.scrollTop; 
display.wheelDX = dx; 
display.wheelDY = dy; 
_AN_Call_settimeout("setTimeout", window, function (){ 
if (display.wheelStartX == null ) return ; 
var movedX = scroll.scrollLeft - display.wheelStartX; 
var movedY = scroll.scrollTop - display.wheelStartY; 
var sample = (movedY && display.wheelDY && movedY / display.wheelDY) || (movedX && display.wheelDX && movedX / display.wheelDX); 
display.wheelStartX = display.wheelStartY = null ; 
if (!sample) return ; 
wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1); 
++wheelSamples; 
} 
, 200); 
} 
 else { 
display.wheelDX += dx; 
display.wheelDY += dy; 
} 
} 
} 
function doHandleBinding(cm, bound, dropShift){ 
if (typeof bound == "string") { 
bound = commands[bound]; 
if (!bound) return false ; 
} 
if (cm.display.pollingFast && readInput(cm)) cm.display.pollingFast = false ; 
var doc = cm.doc, prevShift = doc.sel.shift, done = false ; 
try { 
if (isReadOnly(cm)) cm.state.suppressEdits = true ; 
if (dropShift) doc.sel.shift = false ; 
done = bound(cm) != Pass; 
} 
finally{ 
doc.sel.shift = prevShift; 
cm.state.suppressEdits = false ; 
} 
return done; 
} 
function allKeyMaps(cm){ 
var maps = cm.state.keyMaps.slice(0); 
if (cm.options.extraKeys) maps.push(cm.options.extraKeys); 
maps.push(cm.options.keyMap); 
return maps; 
} 
var maybeTransition; 
function handleKeyBinding(cm, e){ 
var startMap = getKeyMap(cm.options.keyMap), next = startMap.auto; 
clearTimeout(maybeTransition); 
if (next && !isModifierKey(e)) maybeTransition = _AN_Call_settimeout("setTimeout", window, function (){ 
if (getKeyMap(cm.options.keyMap) == startMap) { 
cm.options.keyMap = (next.call? next.call(null , cm): next); 
keyMapChanged(cm); 
} 
} 
, 50); 
var name = keyName(e, true ), handled = false ; 
if (!name) return false ; 
var keymaps = allKeyMaps(cm); 
if (e.shiftKey) { 
handled = lookupKey("Shift-" + name, keymaps, function (b){ 
return doHandleBinding(cm, b, true ); 
} 
) || lookupKey(name, keymaps, function (b){ 
if (typeof b == "string"? /^go[A-Z]/.test(b): b.motion) return doHandleBinding(cm, b); 
} 
); 
} 
 else { 
handled = lookupKey(name, keymaps, function (b){ 
return doHandleBinding(cm, b); 
} 
); 
} 
if (handled) { 
e_preventDefault(e); 
restartBlink(cm); 
if (ie_lt9) { 
e.oldKeyCode = e.keyCode; 
e.keyCode = 0; 
} 
signalLater(cm, "keyHandled", cm, name, e); 
} 
return handled; 
} 
function handleCharBinding(cm, e, ch){ 
var handled = lookupKey("'" + ch + "'", allKeyMaps(cm), function (b){ 
return doHandleBinding(cm, b, true ); 
} 
); 
if (handled) { 
e_preventDefault(e); 
restartBlink(cm); 
signalLater(cm, "keyHandled", cm, "'" + ch + "'", e); 
} 
return handled; 
} 
var lastStoppedKey = null ; 
function onKeyDown(e){ 
var cm = this; 
if (!cm.state.focused) onFocus(cm); 
if (signalDOMEvent(cm, e) || cm.options.onKeyEvent && cm.options.onKeyEvent(cm, addStop(e))) return ; 
if (ie && e.keyCode == 27) e.returnValue = false ; 
var code = e.keyCode; 
cm.doc.sel.shift = code == 16 || e.shiftKey; 
var handled = handleKeyBinding(cm, e); 
if (opera) { 
lastStoppedKey = handled? code: null ; 
if (!handled && code == 88 && !hasCopyEvent && (mac? e.metaKey: e.ctrlKey)) cm.replaceSelection(""); 
} 
} 
function onKeyPress(e){ 
var cm = this; 
if (signalDOMEvent(cm, e) || cm.options.onKeyEvent && cm.options.onKeyEvent(cm, addStop(e))) return ; 
var keyCode = e.keyCode, charCode = e.charCode; 
if (opera && keyCode == lastStoppedKey) { 
lastStoppedKey = null ; 
e_preventDefault(e); 
return ; 
} 
if (((opera && (!e.which || e.which < 10)) || khtml) && handleKeyBinding(cm, e)) return ; 
var ch = String.fromCharCode(charCode == null ? keyCode: charCode); 
if (handleCharBinding(cm, e, ch)) return ; 
if (ie && !ie_lt9) cm.display.inputHasSelection = null ; 
fastPoll(cm); 
} 
function onFocus(cm){ 
if (cm.options.readOnly == "nocursor") return ; 
if (!cm.state.focused) { 
signal(cm, "focus", cm); 
cm.state.focused = true ; 
if (cm.display.wrapper.className.search(/\bCodeMirror-focused\b/) == -1) cm.display.wrapper.className += " CodeMirror-focused"; 
if (!cm.curOp) { 
resetInput(cm, true ); 
if (webkit) _AN_Call_settimeout("setTimeout", window, bind(resetInput, cm, true ), 0); 
} 
} 
slowPoll(cm); 
restartBlink(cm); 
} 
function onBlur(cm){ 
if (cm.state.focused) { 
signal(cm, "blur", cm); 
cm.state.focused = false ; 
cm.display.wrapper.className = _AN_Call_replace("replace", cm.display.wrapper.className, " CodeMirror-focused", ""); 
} 
clearInterval(cm.display.blinker); 
_AN_Call_settimeout("setTimeout", window, function (){ 
if (!cm.state.focused) cm.doc.sel.shift = false ; 
} 
, 150); 
} 
var detectingSelectAll; 
function onContextMenu(cm, e){ 
if (signalDOMEvent(cm, e, "contextmenu")) return ; 
var display = cm.display, sel = cm.doc.sel; 
if (eventInWidget(display, e) || contextMenuInGutter(cm, e)) return ; 
var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop; 
if (!pos || opera) return ; 
var reset = cm.options.resetSelectionOnContextMenu; 
if (reset && (posEq(sel.from, sel.to) || posLess(pos, sel.from) || !posLess(pos, sel.to))) operation(cm, setSelection)(cm.doc, pos, pos); 
var oldCSS = _AN_Read_csstext("cssText", display.input.style); 
display.inputDiv.style.position = "absolute"; 
_AN_Write_csstext("cssText", display.input.style, false , "position: fixed; width: 30px; height: 30px; top: " + (e.clientY - 5) + "px; left: " + (e.clientX - 5) + "px; z-index: 1000; background: transparent; outline: none;" + "border-width: 0; outline: none; overflow: hidden; opacity: .05; -ms-opacity: .05; filter: alpha(opacity=5);"); 
focusInput(cm); 
resetInput(cm, true ); 
if (posEq(sel.from, sel.to)) display.input.value = display.prevInput = " "; 
function prepareSelectAllHack(){ 
if (display.input.selectionStart != null ) { 
var extval = display.input.value = "\u200b" + (posEq(sel.from, sel.to)? "": display.input.value); 
display.prevInput = "\u200b"; 
display.input.selectionStart = 1; 
display.input.selectionEnd = _AN_Read_length("length", extval); 
} 
} 
function rehide(){ 
display.inputDiv.style.position = "relative"; 
_AN_Write_csstext("cssText", display.input.style, false , oldCSS); 
if (ie_lt9) display.scrollbarV.scrollTop = display.scroller.scrollTop = scrollPos; 
slowPoll(cm); 
if (display.input.selectionStart != null ) { 
if (!ie || ie_lt9) prepareSelectAllHack(); 
clearTimeout(detectingSelectAll); 
var i = 0, poll = function (){ 
if (display.prevInput == "\u200b" && display.input.selectionStart == 0) operation(cm, commands.selectAll)(cm); 
 else if (i++  < 10) detectingSelectAll = _AN_Call_settimeout("setTimeout", window, poll, 500); 
 else resetInput(cm); 
} 
; 
detectingSelectAll = _AN_Call_settimeout("setTimeout", window, poll, 200); 
} 
} 
if (ie && !ie_lt9) prepareSelectAllHack(); 
if (captureMiddleClick) { 
e_stop(e); 
var mouseup = function (){ 
off(window, "mouseup", mouseup); 
_AN_Call_settimeout("setTimeout", window, rehide, 20); 
} 
; 
on(window, "mouseup", mouseup); 
} 
 else { 
_AN_Call_settimeout("setTimeout", window, rehide, 50); 
} 
} 
var changeEnd = CodeMirror.changeEnd = function (change){ 
if (!change.text) return change.to; 
return Pos(change.from.line + _AN_Read_length("length", change.text) - 1, _AN_Read_length("length", lst(change.text)) + (_AN_Read_length("length", change.text) == 1? change.from.ch: 0)); 
} 
; 
function clipPostChange(doc, change, pos){ 
if (!posLess(change.from, pos)) return clipPos(doc, pos); 
var diff = (_AN_Read_length("length", change.text) - 1) - (change.to.line - change.from.line); 
if (pos.line > change.to.line + diff) { 
var preLine = pos.line - diff, lastLine = doc.first + doc.size - 1; 
if (preLine > lastLine) return Pos(lastLine, _AN_Read_length("length", getLine(doc, lastLine).text)); 
return clipToLen(pos, _AN_Read_length("length", getLine(doc, preLine).text)); 
} 
if (pos.line == change.to.line + diff) return clipToLen(pos, _AN_Read_length("length", lst(change.text)) + (_AN_Read_length("length", change.text) == 1? change.from.ch: 0) + _AN_Read_length("length", getLine(doc, change.to.line).text) - change.to.ch); 
var inside = pos.line - change.from.line; 
return clipToLen(pos, _AN_Read_length("length", change.text[inside]) + (inside? 0: change.from.ch)); 
} 
function computeSelAfterChange(doc, change, hint){ 
if (hint && typeof hint == "object") return { 
anchor: clipPostChange(doc, change, hint.anchor),
head: clipPostChange(doc, change, hint.head)}
; 
if (hint == "start") return { 
anchor: change.from,
head: change.from}
; 
var end = changeEnd(change); 
if (hint == "around") return { 
anchor: change.from,
head: end}
; 
if (hint == "end") return { 
anchor: end,
head: end}
; 
var adjustPos = function (pos){ 
if (posLess(pos, change.from)) return pos; 
if (!posLess(change.to, pos)) return end; 
var line = pos.line + _AN_Read_length("length", change.text) - (change.to.line - change.from.line) - 1, ch = pos.ch; 
if (pos.line == change.to.line) ch += end.ch - change.to.ch; 
return Pos(line, ch); 
} 
; 
return { 
anchor: adjustPos(doc.sel.anchor),
head: adjustPos(doc.sel.head)}
; 
} 
function filterChange(doc, change, update){ 
var obj = { 
canceled: false ,
from: change.from,
to: change.to,
text: change.text,
origin: change.origin,
cancel: function (){ 
this.canceled = true ; 
} 
}
; 
if (update) obj.update = function (from, to, text, origin){ 
if (from) this.from = clipPos(doc, from); 
if (to) this.to = clipPos(doc, to); 
if (text) _AN_Write_text("text", this, false , text); 
if (origin !== undefined) this.origin = origin; 
} 
; 
signal(doc, "beforeChange", doc, obj); 
if (doc.cm) signal(doc.cm, "beforeChange", doc.cm, obj); 
if (obj.canceled) return null ; 
return { 
from: obj.from,
to: obj.to,
text: obj.text,
origin: obj.origin}
; 
} 
function makeChange(doc, change, selUpdate, ignoreReadOnly){ 
if (doc.cm) { 
if (!doc.cm.curOp) return operation(doc.cm, makeChange)(doc, change, selUpdate, ignoreReadOnly); 
if (doc.cm.state.suppressEdits) return ; 
} 
if (hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")) { 
change = filterChange(doc, change, true ); 
if (!change) return ; 
} 
var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to); 
if (split) { 
for (var i = _AN_Read_length("length", split) - 1; 
i >= 1; --i)makeChangeNoReadonly(doc, { 
from: split[i].from,
to: split[i].to,
text: [""] }
); 
if (split.length) makeChangeNoReadonly(doc, { 
from: split[0].from,
to: split[0].to,
text: change.text}
, selUpdate); 
} 
 else { 
makeChangeNoReadonly(doc, change, selUpdate); 
} 
} 
function makeChangeNoReadonly(doc, change, selUpdate){ 
if (_AN_Read_length("length", change.text) == 1 && change.text[0] == "" && posEq(change.from, change.to)) return ; 
var selAfter = computeSelAfterChange(doc, change, selUpdate); 
addToHistory(doc, change, selAfter, doc.cm? doc.cm.curOp.id: NaN); 
makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change)); 
var rebased = [] ; 
linkedDocs(doc, function (doc, sharedHist){ 
if (!sharedHist && indexOf(rebased, doc.history) == -1) { 
rebaseHist(doc.history, change); 
rebased.push(doc.history); 
} 
makeChangeSingleDoc(doc, change, null , stretchSpansOverChange(doc, change)); 
} 
); 
} 
function makeChangeFromHistory(doc, type){ 
if (doc.cm && doc.cm.state.suppressEdits) return ; 
var hist = doc.history; 
var event = (type == "undo"? hist.done: hist.undone).pop(); 
if (!event) return ; 
var anti = { 
changes: [] ,
anchorBefore: event.anchorAfter,
headBefore: event.headAfter,
anchorAfter: event.anchorBefore,
headAfter: event.headBefore,
generation: hist.generation}
; 
(type == "undo"? hist.undone: hist.done).push(anti); 
hist.generation = event.generation || ++hist.maxGeneration; 
var filter = hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange"); 
for (var i = _AN_Read_length("length", event.changes) - 1; 
i >= 0; --i){ 
var change = event.changes[i]; 
change.origin = type; 
if (filter && !filterChange(doc, change, false )) { 
(type == "undo"? hist.done: hist.undone).length = 0; 
return ; 
} 
anti.changes.push(historyChangeFromChange(doc, change)); 
var after = i? computeSelAfterChange(doc, change, null ): { 
anchor: event.anchorBefore,
head: event.headBefore}
; 
makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change)); 
var rebased = [] ; 
linkedDocs(doc, function (doc, sharedHist){ 
if (!sharedHist && indexOf(rebased, doc.history) == -1) { 
rebaseHist(doc.history, change); 
rebased.push(doc.history); 
} 
makeChangeSingleDoc(doc, change, null , mergeOldSpans(doc, change)); 
} 
); 
} 
} 
function shiftDoc(doc, distance){ 
function shiftPos(pos){ 
return Pos(pos.line + distance, pos.ch); 
} 
doc.first += distance; 
if (doc.cm) regChange(doc.cm, doc.first, doc.first, distance); 
doc.sel.head = shiftPos(doc.sel.head); 
doc.sel.anchor = shiftPos(doc.sel.anchor); 
doc.sel.from = shiftPos(doc.sel.from); 
doc.sel.to = shiftPos(doc.sel.to); 
} 
function makeChangeSingleDoc(doc, change, selAfter, spans){ 
if (doc.cm && !doc.cm.curOp) return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans); 
if (change.to.line < doc.first) { 
shiftDoc(doc, _AN_Read_length("length", change.text) - 1 - (change.to.line - change.from.line)); 
return ; 
} 
if (change.from.line > doc.lastLine()) return ; 
if (change.from.line < doc.first) { 
var shift = _AN_Read_length("length", change.text) - 1 - (doc.first - change.from.line); 
shiftDoc(doc, shift); 
change = { 
from: Pos(doc.first, 0),
to: Pos(change.to.line + shift, change.to.ch),
text: [lst(change.text)] ,
origin: change.origin}
; 
} 
var last = doc.lastLine(); 
if (change.to.line > last) { 
change = { 
from: change.from,
to: Pos(last, _AN_Read_length("length", getLine(doc, last).text)),
text: [change.text[0]] ,
origin: change.origin}
; 
} 
change.removed = getBetween(doc, change.from, change.to); 
if (!selAfter) selAfter = computeSelAfterChange(doc, change, null ); 
if (doc.cm) makeChangeSingleDocInEditor(doc.cm, change, spans, selAfter); 
 else updateDoc(doc, change, spans, selAfter); 
} 
function makeChangeSingleDocInEditor(cm, change, spans, selAfter){ 
var doc = cm.doc, display = cm.display, from = change.from, to = change.to; 
var recomputeMaxLength = false , checkWidthStart = from.line; 
if (!cm.options.lineWrapping) { 
checkWidthStart = lineNo(visualLine(doc, getLine(doc, from.line))); 
doc.iter(checkWidthStart, to.line + 1, function (line){ 
if (line == display.maxLine) { 
recomputeMaxLength = true ; 
return true ; 
} 
} 
); 
} 
if (!posLess(doc.sel.head, change.from) && !posLess(change.to, doc.sel.head)) cm.curOp.cursorActivity = true ; 
updateDoc(doc, change, spans, selAfter, estimateHeight(cm)); 
if (!cm.options.lineWrapping) { 
doc.iter(checkWidthStart, from.line + _AN_Read_length("length", change.text), function (line){ 
var len = lineLength(doc, line); 
if (len > display.maxLineLength) { 
display.maxLine = line; 
display.maxLineLength = len; 
display.maxLineChanged = true ; 
recomputeMaxLength = false ; 
} 
} 
); 
if (recomputeMaxLength) cm.curOp.updateMaxLine = true ; 
} 
doc.frontier = Math.min(doc.frontier, from.line); 
startWorker(cm, 400); 
var lendiff = _AN_Read_length("length", change.text) - (to.line - from.line) - 1; 
regChange(cm, from.line, to.line + 1, lendiff); 
if (hasHandler(cm, "change")) { 
var changeObj = { 
from: from,
to: to,
text: change.text,
removed: change.removed,
origin: change.origin}
; 
if (cm.curOp.textChanged) { 
for (var cur = cm.curOp.textChanged; 
cur.next; cur = cur.next){ 
} 
cur.next = changeObj; 
} 
 else cm.curOp.textChanged = changeObj; 
} 
} 
function replaceRange(doc, code, from, to, origin){ 
if (!to) to = from; 
if (posLess(to, from)) { 
var tmp = to; 
to = from; 
from = tmp; 
} 
if (typeof code == "string") code = splitLines(code); 
makeChange(doc, { 
from: from,
to: to,
text: code,
origin: origin}
, null ); 
} 
function Pos(line, ch){ 
if (!(this instanceof Pos)) return new Pos(line, ch); 
this.line = line; 
this.ch = ch; 
} 
CodeMirror.Pos = Pos; 
function posEq(a, b){ 
return a.line == b.line && a.ch == b.ch; 
} 
function posLess(a, b){ 
return a.line < b.line || (a.line == b.line && a.ch < b.ch); 
} 
function cmp(a, b){ 
return a.line - b.line || a.ch - b.ch; 
} 
function copyPos(x){ 
return Pos(x.line, x.ch); 
} 
function clipLine(doc, n){ 
return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1)); 
} 
function clipPos(doc, pos){ 
if (pos.line < doc.first) return Pos(doc.first, 0); 
var last = doc.first + doc.size - 1; 
if (pos.line > last) return Pos(last, _AN_Read_length("length", getLine(doc, last).text)); 
return clipToLen(pos, _AN_Read_length("length", getLine(doc, pos.line).text)); 
} 
function clipToLen(pos, linelen){ 
var ch = pos.ch; 
if (ch == null  || ch > linelen) return Pos(pos.line, linelen); 
 else if (ch < 0) return Pos(pos.line, 0); 
 else return pos; 
} 
function isLine(doc, l){ 
return l >= doc.first && l < doc.first + doc.size; 
} 
function extendSelection(doc, pos, other, bias){ 
if (doc.sel.shift || doc.sel.extend) { 
var anchor = doc.sel.anchor; 
if (other) { 
var posBefore = posLess(pos, anchor); 
if (posBefore != posLess(other, anchor)) { 
anchor = pos; 
pos = other; 
} 
 else if (posBefore != posLess(pos, other)) { 
pos = other; 
} 
} 
setSelection(doc, anchor, pos, bias); 
} 
 else { 
setSelection(doc, pos, other || pos, bias); 
} 
if (doc.cm) doc.cm.curOp.userSelChange = true ; 
} 
function filterSelectionChange(doc, anchor, head){ 
var obj = { 
anchor: anchor,
head: head}
; 
signal(doc, "beforeSelectionChange", doc, obj); 
if (doc.cm) signal(doc.cm, "beforeSelectionChange", doc.cm, obj); 
obj.anchor = clipPos(doc, obj.anchor); 
obj.head = clipPos(doc, obj.head); 
return obj; 
} 
function setSelection(doc, anchor, head, bias, checkAtomic){ 
if (!checkAtomic && hasHandler(doc, "beforeSelectionChange") || doc.cm && hasHandler(doc.cm, "beforeSelectionChange")) { 
var filtered = filterSelectionChange(doc, anchor, head); 
head = filtered.head; 
anchor = filtered.anchor; 
} 
var sel = doc.sel; 
sel.goalColumn = null ; 
if (bias == null ) bias = posLess(head, sel.head)? -1: 1; 
if (checkAtomic || !posEq(anchor, sel.anchor)) anchor = skipAtomic(doc, anchor, bias, checkAtomic != "push"); 
if (checkAtomic || !posEq(head, sel.head)) head = skipAtomic(doc, head, bias, checkAtomic != "push"); 
if (posEq(sel.anchor, anchor) && posEq(sel.head, head)) return ; 
sel.anchor = anchor; 
sel.head = head; 
var inv = posLess(head, anchor); 
sel.from = inv? head: anchor; 
sel.to = inv? anchor: head; 
if (doc.cm) doc.cm.curOp.updateInput = doc.cm.curOp.selectionChanged = doc.cm.curOp.cursorActivity = true ; 
signalLater(doc, "cursorActivity", doc); 
} 
function reCheckSelection(cm){ 
setSelection(cm.doc, cm.doc.sel.from, cm.doc.sel.to, null , "push"); 
} 
function skipAtomic(doc, pos, bias, mayClear){ 
var flipped = false , curPos = pos; 
var dir = bias || 1; 
doc.cantEdit = false ; 
search: for (; ; ){ 
var line = getLine(doc, curPos.line); 
if (line.markedSpans) { 
for (var i = 0; 
i < _AN_Read_length("length", line.markedSpans); ++i){ 
var sp = line.markedSpans[i], m = sp.marker; 
if ((sp.from == null  || (m.inclusiveLeft? sp.from <= curPos.ch: sp.from < curPos.ch)) && (sp.to == null  || (m.inclusiveRight? sp.to >= curPos.ch: sp.to > curPos.ch))) { 
if (mayClear) { 
signal(m, "beforeCursorEnter"); 
if (m.explicitlyCleared) { 
if (!line.markedSpans) break ; 
 else { 
--i; 
continue ; 
} 
} 
} 
if (!m.atomic) continue ; 
var newPos = m.find()[dir < 0? "from": "to"]; 
if (posEq(newPos, curPos)) { 
newPos.ch += dir; 
if (newPos.ch < 0) { 
if (newPos.line > doc.first) newPos = clipPos(doc, Pos(newPos.line - 1)); 
 else newPos = null ; 
} 
 else if (newPos.ch > _AN_Read_length("length", line.text)) { 
if (newPos.line < doc.first + doc.size - 1) newPos = Pos(newPos.line + 1, 0); 
 else newPos = null ; 
} 
if (!newPos) { 
if (flipped) { 
if (!mayClear) return skipAtomic(doc, pos, bias, true ); 
doc.cantEdit = true ; 
return Pos(doc.first, 0); 
} 
flipped = true ; 
newPos = pos; 
dir = - dir; 
} 
} 
curPos = newPos; 
continue search; 
} 
} 
} 
return curPos; 
} 
} 
function scrollCursorIntoView(cm){ 
var coords = scrollPosIntoView(cm, cm.doc.sel.head, null , cm.options.cursorScrollMargin); 
if (!cm.state.focused) return ; 
var display = cm.display, box = getRect(display.sizer), doScroll = null ; 
if (coords.top + box.top < 0) doScroll = true ; 
 else if (coords.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) doScroll = false ; 
if (doScroll != null  && !phantom) { 
var scrollNode = elt("div", "\u200b", null , "position: absolute; top: " + (coords.top - display.viewOffset) + "px; height: " + (coords.bottom - coords.top + scrollerCutOff) + "px; left: " + coords.left + "px; width: 2px;"); 
_AN_Call_appendchild("appendChild", cm.display.lineSpace, scrollNode); 
scrollNode.scrollIntoView(doScroll); 
cm.display.lineSpace.removeChild(scrollNode); 
} 
} 
function scrollPosIntoView(cm, pos, end, margin){ 
if (margin == null ) margin = 0; 
for (; ; ){ 
var changed = false , coords = cursorCoords(cm, pos); 
var endCoords = !end || end == pos? coords: cursorCoords(cm, end); 
var scrollPos = calculateScrollPos(cm, Math.min(coords.left, endCoords.left), Math.min(coords.top, endCoords.top) - margin, Math.max(coords.left, endCoords.left), Math.max(coords.bottom, endCoords.bottom) + margin); 
var startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft; 
if (scrollPos.scrollTop != null ) { 
setScrollTop(cm, scrollPos.scrollTop); 
if (Math.abs(cm.doc.scrollTop - startTop) > 1) changed = true ; 
} 
if (scrollPos.scrollLeft != null ) { 
setScrollLeft(cm, scrollPos.scrollLeft); 
if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) changed = true ; 
} 
if (!changed) return coords; 
} 
} 
function scrollIntoView(cm, x1, y1, x2, y2){ 
var scrollPos = calculateScrollPos(cm, x1, y1, x2, y2); 
if (scrollPos.scrollTop != null ) setScrollTop(cm, scrollPos.scrollTop); 
if (scrollPos.scrollLeft != null ) setScrollLeft(cm, scrollPos.scrollLeft); 
} 
function calculateScrollPos(cm, x1, y1, x2, y2){ 
var display = cm.display, snapMargin = textHeight(cm.display); 
if (y1 < 0) y1 = 0; 
var screen = display.scroller.clientHeight - scrollerCutOff, screentop = display.scroller.scrollTop, result = { 
}
; 
var docBottom = cm.doc.height + paddingVert(display); 
var atTop = y1 < snapMargin, atBottom = y2 > docBottom - snapMargin; 
if (y1 < screentop) { 
result.scrollTop = atTop? 0: y1; 
} 
 else if (y2 > screentop + screen) { 
var newTop = Math.min(y1, (atBottom? docBottom: y2) - screen); 
if (newTop != screentop) result.scrollTop = newTop; 
} 
var screenw = display.scroller.clientWidth - scrollerCutOff, screenleft = display.scroller.scrollLeft; 
x1 += display.gutters.offsetWidth; 
x2 += display.gutters.offsetWidth; 
var gutterw = display.gutters.offsetWidth; 
var atLeft = x1 < gutterw + 10; 
if (x1 < screenleft + gutterw || atLeft) { 
if (atLeft) x1 = 0; 
result.scrollLeft = Math.max(0, x1 - 10 - gutterw); 
} 
 else if (x2 > screenw + screenleft - 3) { 
result.scrollLeft = x2 + 10 - screenw; 
} 
return result; 
} 
function updateScrollPos(cm, left, top){ 
cm.curOp.updateScrollPos = { 
scrollLeft: left == null ? cm.doc.scrollLeft: left,
scrollTop: top == null ? cm.doc.scrollTop: top}
; 
} 
function addToScrollPos(cm, left, top){ 
var pos = cm.curOp.updateScrollPos || (cm.curOp.updateScrollPos = { 
scrollLeft: cm.doc.scrollLeft,
scrollTop: cm.doc.scrollTop}
); 
var scroll = cm.display.scroller; 
pos.scrollTop = Math.max(0, Math.min(scroll.scrollHeight - scroll.clientHeight, pos.scrollTop + top)); 
pos.scrollLeft = Math.max(0, Math.min(scroll.scrollWidth - scroll.clientWidth, pos.scrollLeft + left)); 
} 
function indentLine(cm, n, how, aggressive){ 
var doc = cm.doc; 
if (how == null ) how = "add"; 
if (how == "smart") { 
if (!cm.doc.mode.indent) how = "prev"; 
 else var state = getStateBefore(cm, n); 
} 
var tabSize = cm.options.tabSize; 
var line = getLine(doc, n), curSpace = countColumn(line.text, null , tabSize); 
var curSpaceString = line.text.match(/^\s*/)[0], indentation; 
if (!aggressive && !/\S/.test(line.text)) { 
indentation = 0; 
how = "not"; 
} 
 else if (how == "smart") { 
indentation = cm.doc.mode.indent(state, line.text.slice(_AN_Read_length("length", curSpaceString)), line.text); 
if (indentation == Pass) { 
if (!aggressive) return ; 
how = "prev"; 
} 
} 
if (how == "prev") { 
if (n > doc.first) indentation = countColumn(getLine(doc, n - 1).text, null , tabSize); 
 else indentation = 0; 
} 
 else if (how == "add") { 
indentation = curSpace + cm.options.indentUnit; 
} 
 else if (how == "subtract") { 
indentation = curSpace - cm.options.indentUnit; 
} 
 else if (typeof how == "number") { 
indentation = curSpace + how; 
} 
indentation = Math.max(0, indentation); 
var indentString = "", pos = 0; 
if (cm.options.indentWithTabs) for (var i = Math.floor(indentation / tabSize); 
i; --i){ 
pos += tabSize; 
indentString += "\t"; 
} 
if (pos < indentation) indentString += spaceStr(indentation - pos); 
if (indentString != curSpaceString) replaceRange(cm.doc, indentString, Pos(n, 0), Pos(n, _AN_Read_length("length", curSpaceString)), "+input"); 
 else if (doc.sel.head.line == n && doc.sel.head.ch < _AN_Read_length("length", curSpaceString)) setSelection(doc, Pos(n, _AN_Read_length("length", curSpaceString)), Pos(n, _AN_Read_length("length", curSpaceString)), 1); 
line.stateAfter = null ; 
} 
function changeLine(cm, handle, op){ 
var no = handle, line = handle, doc = cm.doc; 
if (typeof handle == "number") line = getLine(doc, clipLine(doc, handle)); 
 else no = lineNo(handle); 
if (no == null ) return null ; 
if (op(line, no)) regChange(cm, no, no + 1); 
 else return null ; 
return line; 
} 
function findPosH(doc, pos, dir, unit, visually){ 
var line = pos.line, ch = pos.ch, origDir = dir; 
var lineObj = getLine(doc, line); 
var possible = true ; 
function findNextLine(){ 
var l = line + dir; 
if (l < doc.first || l >= doc.first + doc.size) return (possible = false ); 
line = l; 
return lineObj = getLine(doc, l); 
} 
function moveOnce(boundToLine){ 
var next = (visually? moveVisually: moveLogically)(lineObj, ch, dir, true ); 
if (next == null ) { 
if (!boundToLine && findNextLine()) { 
if (visually) ch = (dir < 0? lineRight: lineLeft)(lineObj); 
 else ch = dir < 0? _AN_Read_length("length", lineObj.text): 0; 
} 
 else return (possible = false ); 
} 
 else ch = next; 
return true ; 
} 
if (unit == "char") moveOnce(); 
 else if (unit == "column") moveOnce(true ); 
 else if (unit == "word" || unit == "group") { 
var sawType = null , group = unit == "group"; 
for (var first = true ; 
; first = false ){ 
if (dir < 0 && !moveOnce(!first)) break ; 
var cur = lineObj.text.charAt(ch) || "\n"; 
var type = isWordChar(cur)? "w": !group? null : /\s/.test(cur)? null : "p"; 
if (sawType && sawType != type) { 
if (dir < 0) { 
dir = 1; 
moveOnce(); 
} 
break ; 
} 
if (type) sawType = type; 
if (dir > 0 && !moveOnce(!first)) break ; 
} 
} 
var result = skipAtomic(doc, Pos(line, ch), origDir, true ); 
if (!possible) result.hitSide = true ; 
return result; 
} 
function findPosV(cm, pos, dir, unit){ 
var doc = cm.doc, x = pos.left, y; 
if (unit == "page") { 
var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight); 
y = pos.top + dir * (pageSize - (dir < 0? 1.5: 0.5) * textHeight(cm.display)); 
} 
 else if (unit == "line") { 
y = dir > 0? pos.bottom + 3: pos.top - 3; 
} 
for (; ; ){ 
var target = coordsChar(cm, x, y); 
if (!target.outside) break ; 
if (dir < 0? y <= 0: y >= doc.height) { 
target.hitSide = true ; 
break ; 
} 
y += dir * 5; 
} 
return target; 
} 
function findWordAt(line, pos){ 
var start = pos.ch, end = pos.ch; 
if (line) { 
if ((pos.xRel < 0 || end == _AN_Read_length("length", line)) && start) --start; 
 else ++end; 
var startChar = line.charAt(start); 
var check = isWordChar(startChar)? isWordChar: /\s/.test(startChar)? function (ch){ 
return /\s/.test(ch); 
} 
: function (ch){ 
return !/\s/.test(ch) && !isWordChar(ch); 
} 
; 
while (start > 0 && check(line.charAt(start - 1)))--start; 
while (end < _AN_Read_length("length", line) && check(line.charAt(end)))++end; 
} 
return { 
from: Pos(pos.line, start),
to: Pos(pos.line, end)}
; 
} 
function selectLine(cm, line){ 
extendSelection(cm.doc, Pos(line, 0), clipPos(cm.doc, Pos(line + 1, 0))); 
} 
CodeMirror.prototype = { 
constructor: CodeMirror,
focus: function (){ 
window.focus(); 
focusInput(this); 
fastPoll(this); 
} 
,
setOption: function (option, value){ 
var options = this.options, old = options[option]; 
if (options[option] == value && option != "mode") return ; 
options[option] = value; 
if (optionHandlers.hasOwnProperty(option)) operation(this, optionHandlers[option])(this, value, old); 
} 
,
getOption: function (option){ 
return this.options[option]; 
} 
,
getDoc: function (){ 
return this.doc; 
} 
,
addKeyMap: function (map, bottom){ 
this.state.keyMaps[bottom? "push": "unshift"](map); 
} 
,
removeKeyMap: function (map){ 
var maps = this.state.keyMaps; 
for (var i = 0; 
i < _AN_Read_length("length", maps); ++i)if (maps[i] == map || (typeof maps[i] != "string" && maps[i].name == map)) { 
maps.splice(i, 1); 
return true ; 
} 
} 
,
addOverlay: operation(null , function (spec, options){ 
var mode = spec.token? spec: CodeMirror.getMode(this.options, spec); 
if (mode.startState) throw new Error("Overlays may not be stateful.")
this.state.overlays.push({ 
mode: mode,
modeSpec: spec,
opaque: options && options.opaque}
); 
this.state.modeGen++ ; 
regChange(this); 
} 
),
removeOverlay: operation(null , function (spec){ 
var overlays = this.state.overlays; 
for (var i = 0; 
i < _AN_Read_length("length", overlays); ++i){ 
var cur = overlays[i].modeSpec; 
if (cur == spec || typeof spec == "string" && cur.name == spec) { 
overlays.splice(i, 1); 
this.state.modeGen++ ; 
regChange(this); 
return ; 
} 
} 
} 
),
indentLine: operation(null , function (n, dir, aggressive){ 
if (typeof dir != "string" && typeof dir != "number") { 
if (dir == null ) dir = this.options.smartIndent? "smart": "prev"; 
 else dir = dir? "add": "subtract"; 
} 
if (isLine(this.doc, n)) indentLine(this, n, dir, aggressive); 
} 
),
indentSelection: operation(null , function (how){ 
var sel = this.doc.sel; 
if (posEq(sel.from, sel.to)) return indentLine(this, sel.from.line, how, true ); 
var e = sel.to.line - (sel.to.ch? 0: 1); 
for (var i = sel.from.line; 
i <= e; ++i)indentLine(this, i, how); 
} 
),
getTokenAt: function (pos, precise){ 
var doc = this.doc; 
pos = clipPos(doc, pos); 
var state = getStateBefore(this, pos.line, precise), mode = this.doc.mode; 
var line = getLine(doc, pos.line); 
var stream = new StringStream(line.text, this.options.tabSize); 
while (stream.pos < pos.ch && !stream.eol()){ 
stream.start = stream.pos; 
var style = mode.token(stream, state); 
} 
return { 
start: stream.start,
end: stream.pos,
string: stream.current(),
className: style || null ,
type: style || null ,
state: state}
; 
} 
,
getTokenTypeAt: function (pos){ 
pos = clipPos(this.doc, pos); 
var styles = getLineStyles(this, getLine(this.doc, pos.line)); 
var before = 0, after = (_AN_Read_length("length", styles) - 1) / 2, ch = pos.ch; 
if (ch == 0) return styles[2]; 
for (; ; ){ 
var mid = (before + after) >> 1; 
if ((mid? styles[mid * 2 - 1]: 0) >= ch) after = mid; 
 else if (styles[mid * 2 + 1] < ch) before = mid + 1; 
 else return styles[mid * 2 + 2]; 
} 
} 
,
getModeAt: function (pos){ 
var mode = this.doc.mode; 
if (!mode.innerMode) return mode; 
return CodeMirror.innerMode(mode, this.getTokenAt(pos).state).mode; 
} 
,
getHelper: function (pos, type){ 
return this.getHelpers(pos, type)[0]; 
} 
,
getHelpers: function (pos, type){ 
var found = [] ; 
if (!helpers.hasOwnProperty(type)) return helpers; 
var help = helpers[type], mode = this.getModeAt(pos); 
if (typeof mode[type] == "string") { 
if (help[mode[type]]) found.push(help[mode[type]]); 
} 
 else if (mode[type]) { 
for (var i = 0; 
i < _AN_Read_length("length", mode[type]); i++ ){ 
var val = help[mode[type][i]]; 
if (val) found.push(val); 
} 
} 
 else if (mode.helperType && help[mode.helperType]) { 
found.push(help[mode.helperType]); 
} 
 else if (help[mode.name]) { 
found.push(help[mode.name]); 
} 
for (var i = 0; 
i < _AN_Read_length("length", help._global); i++ ){ 
var cur = help._global[i]; 
if (cur.pred(mode, this) && indexOf(found, cur.val) == -1) found.push(cur.val); 
} 
return found; 
} 
,
getStateAfter: function (line, precise){ 
var doc = this.doc; 
line = clipLine(doc, line == null ? doc.first + doc.size - 1: line); 
return getStateBefore(this, line + 1, precise); 
} 
,
cursorCoords: function (start, mode){ 
var pos, sel = this.doc.sel; 
if (start == null ) pos = sel.head; 
 else if (typeof start == "object") pos = clipPos(this.doc, start); 
 else pos = start? sel.from: sel.to; 
return cursorCoords(this, pos, mode || "page"); 
} 
,
charCoords: function (pos, mode){ 
return charCoords(this, clipPos(this.doc, pos), mode || "page"); 
} 
,
coordsChar: function (coords, mode){ 
coords = fromCoordSystem(this, coords, mode || "page"); 
return coordsChar(this, coords.left, coords.top); 
} 
,
lineAtHeight: function (height, mode){ 
height = fromCoordSystem(this, { 
top: height,
left: 0}
, mode || "page").top; 
return lineAtHeight(this.doc, height + this.display.viewOffset); 
} 
,
heightAtLine: function (line, mode){ 
var end = false , last = this.doc.first + this.doc.size - 1; 
if (line < this.doc.first) line = this.doc.first; 
 else if (line > last) { 
line = last; 
end = true ; 
} 
var lineObj = getLine(this.doc, line); 
return intoCoordSystem(this, getLine(this.doc, line), { 
top: 0,
left: 0}
, mode || "page").top + (end? lineObj.height: 0); 
} 
,
defaultTextHeight: function (){ 
return textHeight(this.display); 
} 
,
defaultCharWidth: function (){ 
return charWidth(this.display); 
} 
,
setGutterMarker: operation(null , function (line, gutterID, value){ 
return changeLine(this, line, function (line){ 
var markers = line.gutterMarkers || (line.gutterMarkers = { 
}
); 
markers[gutterID] = value; 
if (!value && isEmpty(markers)) line.gutterMarkers = null ; 
return true ; 
} 
); 
} 
),
clearGutter: operation(null , function (gutterID){ 
var cm = this, doc = cm.doc, i = doc.first; 
doc.iter(function (line){ 
if (line.gutterMarkers && line.gutterMarkers[gutterID]) { 
line.gutterMarkers[gutterID] = null ; 
regChange(cm, i, i + 1); 
if (isEmpty(line.gutterMarkers)) line.gutterMarkers = null ; 
} 
++i; 
} 
); 
} 
),
addLineClass: operation(null , function (handle, where, cls){ 
return changeLine(this, handle, function (line){ 
var prop = where == "text"? "textClass": where == "background"? "bgClass": "wrapClass"; 
if (!line[prop]) line[prop] = cls; 
 else if (new RegExp("(?:^|\\s)" + cls + "(?:$|\\s)").test(line[prop])) return false ; 
 else line[prop] += " " + cls; 
return true ; 
} 
); 
} 
),
removeLineClass: operation(null , function (handle, where, cls){ 
return changeLine(this, handle, function (line){ 
var prop = where == "text"? "textClass": where == "background"? "bgClass": "wrapClass"; 
var cur = line[prop]; 
if (!cur) return false ; 
 else if (cls == null ) line[prop] = null ; 
 else { 
var found = cur.match(new RegExp("(?:^|\\s+)" + cls + "(?:$|\\s+)")); 
if (!found) return false ; 
var end = found.index + _AN_Read_length("length", found[0]); 
line[prop] = cur.slice(0, found.index) + (!found.index || end == _AN_Read_length("length", cur)? "": " ") + cur.slice(end) || null ; 
} 
return true ; 
} 
); 
} 
),
addLineWidget: operation(null , function (handle, node, options){ 
return addLineWidget(this, handle, node, options); 
} 
),
removeLineWidget: function (widget){ 
_AN_Call_clear("clear", widget); 
} 
,
lineInfo: function (line){ 
if (typeof line == "number") { 
if (!isLine(this.doc, line)) return null ; 
var n = line; 
line = getLine(this.doc, line); 
if (!line) return null ; 
} 
 else { 
var n = lineNo(line); 
if (n == null ) return null ; 
} 
return { 
line: n,
handle: line,
text: line.text,
gutterMarkers: line.gutterMarkers,
textClass: line.textClass,
bgClass: line.bgClass,
wrapClass: line.wrapClass,
widgets: line.widgets}
; 
} 
,
getViewport: function (){ 
return { 
from: this.display.showingFrom,
to: this.display.showingTo}
; 
} 
,
addWidget: function (pos, node, scroll, vert, horiz){ 
var display = this.display; 
pos = cursorCoords(this, clipPos(this.doc, pos)); 
var top = pos.bottom, left = pos.left; 
node.style.position = "absolute"; 
_AN_Call_appendchild("appendChild", display.sizer, node); 
if (vert == "over") { 
top = pos.top; 
} 
 else if (vert == "above" || vert == "near") { 
var vspace = Math.max(display.wrapper.clientHeight, this.doc.height), hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth); 
if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight) top = pos.top - node.offsetHeight; 
 else if (pos.bottom + node.offsetHeight <= vspace) top = pos.bottom; 
if (left + node.offsetWidth > hspace) left = hspace - node.offsetWidth; 
} 
node.style.top = top + "px"; 
node.style.left = node.style.right = ""; 
if (horiz == "right") { 
left = display.sizer.clientWidth - node.offsetWidth; 
node.style.right = "0px"; 
} 
 else { 
if (horiz == "left") left = 0; 
 else if (horiz == "middle") left = (display.sizer.clientWidth - node.offsetWidth) / 2; 
node.style.left = left + "px"; 
} 
if (scroll) scrollIntoView(this, left, top, left + node.offsetWidth, top + node.offsetHeight); 
} 
,
triggerOnKeyDown: operation(null , onKeyDown),
execCommand: function (cmd){ 
return commands[cmd](this); 
} 
,
findPosH: function (from, amount, unit, visually){ 
var dir = 1; 
if (amount < 0) { 
dir = -1; 
amount = - amount; 
} 
for (var i = 0, cur = clipPos(this.doc, from); 
i < amount; ++i){ 
cur = findPosH(this.doc, cur, dir, unit, visually); 
if (cur.hitSide) break ; 
} 
return cur; 
} 
,
moveH: operation(null , function (dir, unit){ 
var sel = this.doc.sel, pos; 
if (sel.shift || sel.extend || posEq(sel.from, sel.to)) pos = findPosH(this.doc, sel.head, dir, unit, this.options.rtlMoveVisually); 
 else pos = dir < 0? sel.from: sel.to; 
extendSelection(this.doc, pos, pos, dir); 
} 
),
deleteH: operation(null , function (dir, unit){ 
var sel = this.doc.sel; 
if (!posEq(sel.from, sel.to)) replaceRange(this.doc, "", sel.from, sel.to, "+delete"); 
 else replaceRange(this.doc, "", sel.from, findPosH(this.doc, sel.head, dir, unit, false ), "+delete"); 
this.curOp.userSelChange = true ; 
} 
),
findPosV: function (from, amount, unit, goalColumn){ 
var dir = 1, x = goalColumn; 
if (amount < 0) { 
dir = -1; 
amount = - amount; 
} 
for (var i = 0, cur = clipPos(this.doc, from); 
i < amount; ++i){ 
var coords = cursorCoords(this, cur, "div"); 
if (x == null ) x = coords.left; 
 else coords.left = x; 
cur = findPosV(this, coords, dir, unit); 
if (cur.hitSide) break ; 
} 
return cur; 
} 
,
moveV: operation(null , function (dir, unit){ 
var sel = this.doc.sel, target, goal; 
if (sel.shift || sel.extend || posEq(sel.from, sel.to)) { 
var pos = cursorCoords(this, sel.head, "div"); 
if (sel.goalColumn != null ) pos.left = sel.goalColumn; 
target = findPosV(this, pos, dir, unit); 
if (unit == "page") addToScrollPos(this, 0, charCoords(this, target, "div").top - pos.top); 
goal = pos.left; 
} 
 else { 
target = dir < 0? sel.from: sel.to; 
} 
extendSelection(this.doc, target, target, dir); 
if (goal != null ) sel.goalColumn = goal; 
} 
),
toggleOverwrite: function (value){ 
if (value != null  && value == this.state.overwrite) return ; 
if (this.state.overwrite = !this.state.overwrite) this.display.cursor.className += " CodeMirror-overwrite"; 
 else this.display.cursor.className = _AN_Call_replace("replace", this.display.cursor.className, " CodeMirror-overwrite", ""); 
} 
,
hasFocus: function (){ 
return this.state.focused; 
} 
,
scrollTo: operation(null , function (x, y){ 
updateScrollPos(this, x, y); 
} 
),
getScrollInfo: function (){ 
var scroller = this.display.scroller, co = scrollerCutOff; 
return { 
left: scroller.scrollLeft,
top: scroller.scrollTop,
height: scroller.scrollHeight - co,
width: scroller.scrollWidth - co,
clientHeight: scroller.clientHeight - co,
clientWidth: scroller.clientWidth - co}
; 
} 
,
scrollIntoView: operation(null , function (range, margin){ 
if (range == null ) range = { 
from: this.doc.sel.head,
to: null }
; 
 else if (typeof range == "number") range = { 
from: Pos(range, 0),
to: null }
; 
 else if (range.from == null ) range = { 
from: range,
to: null }
; 
if (!range.to) range.to = range.from; 
if (!margin) margin = 0; 
var coords = range; 
if (range.from.line != null ) { 
this.curOp.scrollToPos = { 
from: range.from,
to: range.to,
margin: margin}
; 
coords = { 
from: cursorCoords(this, range.from),
to: cursorCoords(this, range.to)}
; 
} 
var sPos = calculateScrollPos(this, Math.min(coords.from.left, coords.to.left), Math.min(coords.from.top, coords.to.top) - margin, Math.max(coords.from.right, coords.to.right), Math.max(coords.from.bottom, coords.to.bottom) + margin); 
updateScrollPos(this, sPos.scrollLeft, sPos.scrollTop); 
} 
),
setSize: operation(null , function (width, height){ 
function interpret(val){ 
return typeof val == "number" || /^\d+$/.test(String(val))? val + "px": val; 
} 
if (width != null ) this.display.wrapper.style.width = interpret(width); 
if (height != null ) this.display.wrapper.style.height = interpret(height); 
if (this.options.lineWrapping) this.display.measureLineCache.length = this.display.measureLineCachePos = 0; 
this.curOp.forceUpdate = true ; 
} 
),
operation: function (f){ 
return runInOp(this, f); 
} 
,
refresh: operation(null , function (){ 
var badHeight = this.display.cachedTextHeight == null ; 
clearCaches(this); 
updateScrollPos(this, this.doc.scrollLeft, this.doc.scrollTop); 
regChange(this); 
if (badHeight) estimateLineHeights(this); 
} 
),
swapDoc: operation(null , function (doc){ 
var old = this.doc; 
old.cm = null ; 
attachDoc(this, doc); 
clearCaches(this); 
resetInput(this, true ); 
updateScrollPos(this, doc.scrollLeft, doc.scrollTop); 
signalLater(this, "swapDoc", this, old); 
return old; 
} 
),
getInputField: function (){ 
return this.display.input; 
} 
,
getWrapperElement: function (){ 
return this.display.wrapper; 
} 
,
getScrollerElement: function (){ 
return this.display.scroller; 
} 
,
getGutterElement: function (){ 
return this.display.gutters; 
} 
}
; 
eventMixin(CodeMirror); 
var optionHandlers = CodeMirror.optionHandlers = { 
}
; 
var defaults = CodeMirror.defaults = { 
}
; 
function option(name, deflt, handle, notOnInit){ 
CodeMirror.defaults[name] = deflt; 
if (handle) optionHandlers[name] = notOnInit? function (cm, val, old){ 
if (old != Init) handle(cm, val, old); 
} 
: handle; 
} 
var Init = CodeMirror.Init = { 
toString: function (){ 
return "CodeMirror.Init"; 
} 
}
; 
option("value", "", function (cm, val){ 
cm.setValue(val); 
} 
, true ); 
option("mode", null , function (cm, val){ 
cm.doc.modeOption = val; 
loadMode(cm); 
} 
, true ); 
option("indentUnit", 2, loadMode, true ); 
option("indentWithTabs", false ); 
option("smartIndent", true ); 
option("tabSize", 4, function (cm){ 
loadMode(cm); 
clearCaches(cm); 
regChange(cm); 
} 
, true ); 
option("specialChars", /[\t\u0000-\u0019\u00ad\u200b\u2028\u2029\ufeff]/g, function (cm, val){ 
cm.options.specialChars = new RegExp(val.source + (val.test("\t")? "": "|\t"), "g"); 
_AN_Call_refresh("refresh", cm); 
} 
, true ); 
option("specialCharPlaceholder", defaultSpecialCharPlaceholder, function (cm){ 
_AN_Call_refresh("refresh", cm); 
} 
, true ); 
option("electricChars", true ); 
option("rtlMoveVisually", !windows); 
option("wholeLineUpdateBefore", true ); 
option("theme", "default", function (cm){ 
themeChanged(cm); 
guttersChanged(cm); 
} 
, true ); 
option("keyMap", "default", keyMapChanged); 
option("extraKeys", null ); 
option("onKeyEvent", null ); 
option("onDragEvent", null ); 
option("lineWrapping", false , wrappingChanged, true ); 
option("gutters", [] , function (cm){ 
setGuttersForLineNumbers(cm.options); 
guttersChanged(cm); 
} 
, true ); 
option("fixedGutter", true , function (cm, val){ 
cm.display.gutters.style.left = val? compensateForHScroll(cm.display) + "px": "0"; 
_AN_Call_refresh("refresh", cm); 
} 
, true ); 
option("coverGutterNextToScrollbar", false , updateScrollbars, true ); 
option("lineNumbers", false , function (cm){ 
setGuttersForLineNumbers(cm.options); 
guttersChanged(cm); 
} 
, true ); 
option("firstLineNumber", 1, guttersChanged, true ); 
option("lineNumberFormatter", function (integer){ 
return integer; 
} 
, guttersChanged, true ); 
option("showCursorWhenSelecting", false , updateSelection, true ); 
option("resetSelectionOnContextMenu", true ); 
option("readOnly", false , function (cm, val){ 
if (val == "nocursor") { 
onBlur(cm); 
cm.display.input.blur(); 
cm.display.disabled = true ; 
} 
 else { 
cm.display.disabled = false ; 
if (!val) resetInput(cm, true ); 
} 
} 
); 
option("dragDrop", true ); 
option("cursorBlinkRate", 530); 
option("cursorScrollMargin", 0); 
option("cursorHeight", 1); 
option("workTime", 100); 
option("workDelay", 100); 
option("flattenSpans", true ); 
option("pollInterval", 100); 
option("undoDepth", 40, function (cm, val){ 
cm.doc.history.undoDepth = val; 
} 
); 
option("historyEventDelay", 500); 
option("viewportMargin", 10, function (cm){ 
_AN_Call_refresh("refresh", cm); 
} 
, true ); 
option("maxHighlightLength", 10000, function (cm){ 
loadMode(cm); 
_AN_Call_refresh("refresh", cm); 
} 
, true ); 
option("crudeMeasuringFrom", 10000); 
option("moveInputWithCursor", true , function (cm, val){ 
if (!val) cm.display.inputDiv.style.top = cm.display.inputDiv.style.left = 0; 
} 
); 
option("tabindex", null , function (cm, val){ 
cm.display.input.tabIndex = val || ""; 
} 
); 
option("autofocus", null ); 
var modes = CodeMirror.modes = { 
}
, mimeModes = CodeMirror.mimeModes = { 
}
; 
CodeMirror.defineMode = function (name, mode){ 
if (!CodeMirror.defaults.mode && name != "null") CodeMirror.defaults.mode = name; 
if (_AN_Read_length("length", arguments) > 2) { 
mode.dependencies = [] ; 
for (var i = 2; 
i < _AN_Read_length("length", arguments); ++i)mode.dependencies.push(arguments[i]); 
} 
modes[name] = mode; 
} 
; 
CodeMirror.defineMIME = function (mime, spec){ 
mimeModes[mime] = spec; 
} 
; 
CodeMirror.resolveMode = function (spec){ 
if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) { 
spec = mimeModes[spec]; 
} 
 else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) { 
var found = mimeModes[spec.name]; 
spec = createObj(found, spec); 
spec.name = found.name; 
} 
 else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) { 
return CodeMirror.resolveMode("application/xml"); 
} 
if (typeof spec == "string") return { 
name: spec}
; 
 else return spec || { 
name: "null"}
; 
} 
; 
CodeMirror.getMode = function (options, spec){ 
var spec = CodeMirror.resolveMode(spec); 
var mfactory = modes[spec.name]; 
if (!mfactory) return CodeMirror.getMode(options, "text/plain"); 
var modeObj = mfactory(options, spec); 
if (modeExtensions.hasOwnProperty(spec.name)) { 
var exts = modeExtensions[spec.name]; 
for (var prop in exts){ 
if (!exts.hasOwnProperty(prop)) continue ; 
if (modeObj.hasOwnProperty(prop)) modeObj["_" + prop] = modeObj[prop]; 
modeObj[prop] = exts[prop]; 
} 
} 
modeObj.name = spec.name; 
if (spec.helperType) modeObj.helperType = spec.helperType; 
if (spec.modeProps) for (var prop in spec.modeProps)modeObj[prop] = spec.modeProps[prop]; 
return modeObj; 
} 
; 
CodeMirror.defineMode("null", function (){ 
return { 
token: function (stream){ 
stream.skipToEnd(); 
} 
}
; 
} 
); 
CodeMirror.defineMIME("text/plain", "null"); 
var modeExtensions = CodeMirror.modeExtensions = { 
}
; 
CodeMirror.extendMode = function (mode, properties){ 
var exts = modeExtensions.hasOwnProperty(mode)? modeExtensions[mode]: (modeExtensions[mode] = { 
}
); 
copyObj(properties, exts); 
} 
; 
CodeMirror.defineExtension = function (name, func){ 
CodeMirror.prototype[name] = func; 
} 
; 
CodeMirror.defineDocExtension = function (name, func){ 
Doc.prototype[name] = func; 
} 
; 
CodeMirror.defineOption = option; 
var initHooks = [] ; 
CodeMirror.defineInitHook = function (f){ 
initHooks.push(f); 
} 
; 
var helpers = CodeMirror.helpers = { 
}
; 
CodeMirror.registerHelper = function (type, name, value){ 
if (!helpers.hasOwnProperty(type)) helpers[type] = CodeMirror[type] = { 
_global: [] }
; 
helpers[type][name] = value; 
} 
; 
CodeMirror.registerGlobalHelper = function (type, name, predicate, value){ 
CodeMirror.registerHelper(type, name, value); 
helpers[type]._global.push({ 
pred: predicate,
val: value}
); 
} 
; 
CodeMirror.isWordChar = isWordChar; 
function copyState(mode, state){ 
if (state === true ) return state; 
if (mode.copyState) return mode.copyState(state); 
var nstate = { 
}
; 
for (var n in state){ 
var val = state[n]; 
if (val instanceof Array) val = val.concat([] ); 
nstate[n] = val; 
} 
return nstate; 
} 
CodeMirror.copyState = copyState; 
function startState(mode, a1, a2){ 
return mode.startState? mode.startState(a1, a2): true ; 
} 
CodeMirror.startState = startState; 
CodeMirror.innerMode = function (mode, state){ 
while (mode.innerMode){ 
var info = mode.innerMode(state); 
if (!info || info.mode == mode) break ; 
state = info.state; 
mode = info.mode; 
} 
return info || { 
mode: mode,
state: state}
; 
} 
; 
var commands = CodeMirror.commands = { 
selectAll: function (cm){ 
cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine())); 
} 
,
killLine: function (cm){ 
var from = cm.getCursor(true ), to = cm.getCursor(false ), sel = !posEq(from, to); 
if (!sel && _AN_Read_length("length", cm.getLine(from.line)) == from.ch) cm.replaceRange("", from, Pos(from.line + 1, 0), "+delete"); 
 else cm.replaceRange("", from, sel? to: Pos(from.line), "+delete"); 
} 
,
deleteLine: function (cm){ 
var l = cm.getCursor().line; 
cm.replaceRange("", Pos(l, 0), Pos(l), "+delete"); 
} 
,
delLineLeft: function (cm){ 
var cur = cm.getCursor(); 
cm.replaceRange("", Pos(cur.line, 0), cur, "+delete"); 
} 
,
undo: function (cm){ 
cm.undo(); 
} 
,
redo: function (cm){ 
cm.redo(); 
} 
,
goDocStart: function (cm){ 
cm.extendSelection(Pos(cm.firstLine(), 0)); 
} 
,
goDocEnd: function (cm){ 
cm.extendSelection(Pos(cm.lastLine())); 
} 
,
goLineStart: function (cm){ 
cm.extendSelection(lineStart(cm, cm.getCursor().line)); 
} 
,
goLineStartSmart: function (cm){ 
var cur = cm.getCursor(), start = lineStart(cm, cur.line); 
var line = cm.getLineHandle(start.line); 
var order = getOrder(line); 
if (!order || order[0].level == 0) { 
var firstNonWS = Math.max(0, line.text.search(/\S/)); 
var inWS = cur.line == start.line && cur.ch <= firstNonWS && cur.ch; 
cm.extendSelection(Pos(start.line, inWS? 0: firstNonWS)); 
} 
 else cm.extendSelection(start); 
} 
,
goLineEnd: function (cm){ 
cm.extendSelection(lineEnd(cm, cm.getCursor().line)); 
} 
,
goLineRight: function (cm){ 
var top = cm.charCoords(cm.getCursor(), "div").top + 5; 
cm.extendSelection(cm.coordsChar({ 
left: cm.display.lineDiv.offsetWidth + 100,
top: top}
, "div")); 
} 
,
goLineLeft: function (cm){ 
var top = cm.charCoords(cm.getCursor(), "div").top + 5; 
cm.extendSelection(cm.coordsChar({ 
left: 0,
top: top}
, "div")); 
} 
,
goLineUp: function (cm){ 
cm.moveV(-1, "line"); 
} 
,
goLineDown: function (cm){ 
cm.moveV(1, "line"); 
} 
,
goPageUp: function (cm){ 
cm.moveV(-1, "page"); 
} 
,
goPageDown: function (cm){ 
cm.moveV(1, "page"); 
} 
,
goCharLeft: function (cm){ 
cm.moveH(-1, "char"); 
} 
,
goCharRight: function (cm){ 
cm.moveH(1, "char"); 
} 
,
goColumnLeft: function (cm){ 
cm.moveH(-1, "column"); 
} 
,
goColumnRight: function (cm){ 
cm.moveH(1, "column"); 
} 
,
goWordLeft: function (cm){ 
cm.moveH(-1, "word"); 
} 
,
goGroupRight: function (cm){ 
cm.moveH(1, "group"); 
} 
,
goGroupLeft: function (cm){ 
cm.moveH(-1, "group"); 
} 
,
goWordRight: function (cm){ 
cm.moveH(1, "word"); 
} 
,
delCharBefore: function (cm){ 
cm.deleteH(-1, "char"); 
} 
,
delCharAfter: function (cm){ 
cm.deleteH(1, "char"); 
} 
,
delWordBefore: function (cm){ 
cm.deleteH(-1, "word"); 
} 
,
delWordAfter: function (cm){ 
cm.deleteH(1, "word"); 
} 
,
delGroupBefore: function (cm){ 
cm.deleteH(-1, "group"); 
} 
,
delGroupAfter: function (cm){ 
cm.deleteH(1, "group"); 
} 
,
indentAuto: function (cm){ 
cm.indentSelection("smart"); 
} 
,
indentMore: function (cm){ 
cm.indentSelection("add"); 
} 
,
indentLess: function (cm){ 
cm.indentSelection("subtract"); 
} 
,
insertTab: function (cm){ 
cm.replaceSelection("\t", "end", "+input"); 
} 
,
defaultTab: function (cm){ 
if (cm.somethingSelected()) cm.indentSelection("add"); 
 else cm.replaceSelection("\t", "end", "+input"); 
} 
,
transposeChars: function (cm){ 
var cur = cm.getCursor(), line = cm.getLine(cur.line); 
if (cur.ch > 0 && cur.ch < _AN_Read_length("length", line) - 1) cm.replaceRange(line.charAt(cur.ch) + line.charAt(cur.ch - 1), Pos(cur.line, cur.ch - 1), Pos(cur.line, cur.ch + 1)); 
} 
,
newlineAndIndent: function (cm){ 
operation(cm, function (){ 
cm.replaceSelection("\n", "end", "+input"); 
cm.indentLine(cm.getCursor().line, null , true ); 
} 
)(); 
} 
,
toggleOverwrite: function (cm){ 
cm.toggleOverwrite(); 
} 
}
; 
var keyMap = CodeMirror.keyMap = { 
}
; 
keyMap.basic = { 
"Left": "goCharLeft",
"Right": "goCharRight",
"Up": "goLineUp",
"Down": "goLineDown",
"End": "goLineEnd",
"Home": "goLineStartSmart",
"PageUp": "goPageUp",
"PageDown": "goPageDown",
"Delete": "delCharAfter",
"Backspace": "delCharBefore",
"Shift-Backspace": "delCharBefore",
"Tab": "defaultTab",
"Shift-Tab": "indentAuto",
"Enter": "newlineAndIndent",
"Insert": "toggleOverwrite"}
; 
keyMap.pcDefault = { 
"Ctrl-A": "selectAll",
"Ctrl-D": "deleteLine",
"Ctrl-Z": "undo",
"Shift-Ctrl-Z": "redo",
"Ctrl-Y": "redo",
"Ctrl-Home": "goDocStart",
"Alt-Up": "goDocStart",
"Ctrl-End": "goDocEnd",
"Ctrl-Down": "goDocEnd",
"Ctrl-Left": "goGroupLeft",
"Ctrl-Right": "goGroupRight",
"Alt-Left": "goLineStart",
"Alt-Right": "goLineEnd",
"Ctrl-Backspace": "delGroupBefore",
"Ctrl-Delete": "delGroupAfter",
"Ctrl-S": "save",
"Ctrl-F": "find",
"Ctrl-G": "findNext",
"Shift-Ctrl-G": "findPrev",
"Shift-Ctrl-F": "replace",
"Shift-Ctrl-R": "replaceAll",
"Ctrl-[": "indentLess",
"Ctrl-]": "indentMore",
fallthrough: "basic"}
; 
keyMap.macDefault = { 
"Cmd-A": "selectAll",
"Cmd-D": "deleteLine",
"Cmd-Z": "undo",
"Shift-Cmd-Z": "redo",
"Cmd-Y": "redo",
"Cmd-Up": "goDocStart",
"Cmd-End": "goDocEnd",
"Cmd-Down": "goDocEnd",
"Alt-Left": "goGroupLeft",
"Alt-Right": "goGroupRight",
"Cmd-Left": "goLineStart",
"Cmd-Right": "goLineEnd",
"Alt-Backspace": "delGroupBefore",
"Ctrl-Alt-Backspace": "delGroupAfter",
"Alt-Delete": "delGroupAfter",
"Cmd-S": "save",
"Cmd-F": "find",
"Cmd-G": "findNext",
"Shift-Cmd-G": "findPrev",
"Cmd-Alt-F": "replace",
"Shift-Cmd-Alt-F": "replaceAll",
"Cmd-[": "indentLess",
"Cmd-]": "indentMore",
"Cmd-Backspace": "delLineLeft",
fallthrough: ["basic", "emacsy"] }
; 
keyMap["default"]  = mac? keyMap.macDefault: keyMap.pcDefault; 
keyMap.emacsy = { 
"Ctrl-F": "goCharRight",
"Ctrl-B": "goCharLeft",
"Ctrl-P": "goLineUp",
"Ctrl-N": "goLineDown",
"Alt-F": "goWordRight",
"Alt-B": "goWordLeft",
"Ctrl-A": "goLineStart",
"Ctrl-E": "goLineEnd",
"Ctrl-V": "goPageDown",
"Shift-Ctrl-V": "goPageUp",
"Ctrl-D": "delCharAfter",
"Ctrl-H": "delCharBefore",
"Alt-D": "delWordAfter",
"Alt-Backspace": "delWordBefore",
"Ctrl-K": "killLine",
"Ctrl-T": "transposeChars"}
; 
function getKeyMap(val){ 
if (typeof val == "string") return keyMap[val]; 
 else return val; 
} 
function lookupKey(name, maps, handle){ 
function lookup(map){ 
map = getKeyMap(map); 
var found = map[name]; 
if (found === false ) return "stop"; 
if (found != null  && handle(found)) return true ; 
if (map.nofallthrough) return "stop"; 
var fallthrough = map.fallthrough; 
if (fallthrough == null ) return false ; 
if (Object.prototype.toString.call(fallthrough) != "[object Array]") return lookup(fallthrough); 
for (var i = 0, e = _AN_Read_length("length", fallthrough); 
i < e; ++i){ 
var done = lookup(fallthrough[i]); 
if (done) return done; 
} 
return false ; 
} 
for (var i = 0; 
i < _AN_Read_length("length", maps); ++i){ 
var done = lookup(maps[i]); 
if (done) return done != "stop"; 
} 
} 
function isModifierKey(event){ 
var name = keyNames[event.keyCode]; 
return name == "Ctrl" || name == "Alt" || name == "Shift" || name == "Mod"; 
} 
function keyName(event, noShift){ 
if (opera && event.keyCode == 34 && event["char"] ) return false ; 
var name = keyNames[event.keyCode]; 
if (name == null  || event.altGraphKey) return false ; 
if (event.altKey) name = "Alt-" + name; 
if (flipCtrlCmd? event.metaKey: event.ctrlKey) name = "Ctrl-" + name; 
if (flipCtrlCmd? event.ctrlKey: event.metaKey) name = "Cmd-" + name; 
if (!noShift && event.shiftKey) name = "Shift-" + name; 
return name; 
} 
CodeMirror.lookupKey = lookupKey; 
CodeMirror.isModifierKey = isModifierKey; 
CodeMirror.keyName = keyName; 
CodeMirror.fromTextArea = function (textarea, options){ 
if (!options) options = { 
}
; 
options.value = textarea.value; 
if (!options.tabindex && textarea.tabindex) options.tabindex = textarea.tabindex; 
if (!options.placeholder && textarea.placeholder) options.placeholder = textarea.placeholder; 
if (options.autofocus == null ) { 
var hasFocus = document.body; 
try { 
hasFocus = document.activeElement; 
} 
catch (e) { 
} 
options.autofocus = hasFocus == textarea || _AN_Call_getattribute("getAttribute", textarea, "autofocus") != null  && hasFocus == document.body; 
} 
function save(){ 
textarea.value = cm.getValue(); 
} 
if (textarea.form) { 
on(textarea.form, "submit", save); 
if (!options.leaveSubmitMethodAlone) { 
var form = textarea.form, realSubmit = form.submit; 
try { 
var wrappedSubmit = form.submit = function (){ 
save(); 
form.submit = realSubmit; 
form.submit(); 
form.submit = wrappedSubmit; 
} 
; 
} 
catch (e) { 
} 
} 
} 
textarea.style.display = "none"; 
var cm = CodeMirror(function (node){ 
textarea.parentNode.insertBefore(node, textarea.nextSibling); 
} 
, options); 
cm.save = save; 
cm.getTextArea = function (){ 
return textarea; 
} 
; 
cm.toTextArea = function (){ 
save(); 
textarea.parentNode.removeChild(cm.getWrapperElement()); 
textarea.style.display = ""; 
if (textarea.form) { 
off(textarea.form, "submit", save); 
if (typeof textarea.form.submit == "function") textarea.form.submit = realSubmit; 
} 
} 
; 
return cm; 
} 
; 
function StringStream(string, tabSize){ 
this.pos = this.start = 0; 
this.string = string; 
this.tabSize = tabSize || 8; 
this.lastColumnPos = this.lastColumnValue = 0; 
this.lineStart = 0; 
} 
StringStream.prototype = { 
eol: function (){ 
return this.pos >= _AN_Read_length("length", this.string); 
} 
,
sol: function (){ 
return this.pos == this.lineStart; 
} 
,
peek: function (){ 
return this.string.charAt(this.pos) || undefined; 
} 
,
next: function (){ 
if (this.pos < _AN_Read_length("length", this.string)) return this.string.charAt(this.pos++ ); 
} 
,
eat: function (match){ 
var ch = this.string.charAt(this.pos); 
if (typeof match == "string") var ok = ch == match; 
 else var ok = ch && (match.test? match.test(ch): match(ch)); 
if (ok) { 
++this.pos; 
return ch; 
} 
} 
,
eatWhile: function (match){ 
var start = this.pos; 
while (this.eat(match)){ 
} 
return this.pos > start; 
} 
,
eatSpace: function (){ 
var start = this.pos; 
while (/[\s\u00a0]/.test(this.string.charAt(this.pos)))++this.pos; 
return this.pos > start; 
} 
,
skipToEnd: function (){ 
this.pos = _AN_Read_length("length", this.string); 
} 
,
skipTo: function (ch){ 
var found = this.string.indexOf(ch, this.pos); 
if (found > -1) { 
this.pos = found; 
return true ; 
} 
} 
,
backUp: function (n){ 
this.pos -= n; 
} 
,
column: function (){ 
if (this.lastColumnPos < this.start) { 
this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue); 
this.lastColumnPos = this.start; 
} 
return this.lastColumnValue - (this.lineStart? countColumn(this.string, this.lineStart, this.tabSize): 0); 
} 
,
indentation: function (){ 
return countColumn(this.string, null , this.tabSize) - (this.lineStart? countColumn(this.string, this.lineStart, this.tabSize): 0); 
} 
,
match: function (pattern, consume, caseInsensitive){ 
if (typeof pattern == "string") { 
var cased = function (str){ 
return caseInsensitive? str.toLowerCase(): str; 
} 
; 
var substr = this.string.substr(this.pos, _AN_Read_length("length", pattern)); 
if (cased(substr) == cased(pattern)) { 
if (consume !== false ) this.pos += _AN_Read_length("length", pattern); 
return true ; 
} 
} 
 else { 
var match = this.string.slice(this.pos).match(pattern); 
if (match && match.index > 0) return null ; 
if (match && consume !== false ) this.pos += _AN_Read_length("length", match[0]); 
return match; 
} 
} 
,
current: function (){ 
return this.string.slice(this.start, this.pos); 
} 
,
hideFirstChars: function (n, inner){ 
this.lineStart += n; 
try { 
return inner(); 
} 
finally{ 
this.lineStart -= n; 
} 
} 
}
; 
CodeMirror.StringStream = StringStream; 
function TextMarker(doc, type){ 
this.lines = [] ; 
this.type = type; 
this.doc = doc; 
} 
CodeMirror.TextMarker = TextMarker; 
eventMixin(TextMarker); 
TextMarker.prototype.clear = function (){ 
if (this.explicitlyCleared) return ; 
var cm = this.doc.cm, withOp = cm && !cm.curOp; 
if (withOp) startOperation(cm); 
if (hasHandler(this, "clear")) { 
var found = this.find(); 
if (found) signalLater(this, "clear", found.from, found.to); 
} 
var min = null , max = null ; 
for (var i = 0; 
i < _AN_Read_length("length", this.lines); ++i){ 
var line = this.lines[i]; 
var span = getMarkedSpanFor(line.markedSpans, this); 
if (span.to != null ) max = lineNo(line); 
line.markedSpans = removeMarkedSpan(line.markedSpans, span); 
if (span.from != null ) min = lineNo(line); 
 else if (this.collapsed && !lineIsHidden(this.doc, line) && cm) updateLineHeight(line, textHeight(cm.display)); 
} 
if (cm && this.collapsed && !cm.options.lineWrapping) for (var i = 0; 
i < _AN_Read_length("length", this.lines); ++i){ 
var visual = visualLine(cm.doc, this.lines[i]), len = lineLength(cm.doc, visual); 
if (len > cm.display.maxLineLength) { 
cm.display.maxLine = visual; 
cm.display.maxLineLength = len; 
cm.display.maxLineChanged = true ; 
} 
} 
if (min != null  && cm) regChange(cm, min, max + 1); 
this.lines.length = 0; 
this.explicitlyCleared = true ; 
if (this.atomic && this.doc.cantEdit) { 
this.doc.cantEdit = false ; 
if (cm) reCheckSelection(cm); 
} 
if (withOp) endOperation(cm); 
} 
; 
TextMarker.prototype.find = function (bothSides){ 
var from, to; 
for (var i = 0; 
i < _AN_Read_length("length", this.lines); ++i){ 
var line = this.lines[i]; 
var span = getMarkedSpanFor(line.markedSpans, this); 
if (span.from != null  || span.to != null ) { 
var found = lineNo(line); 
if (span.from != null ) from = Pos(found, span.from); 
if (span.to != null ) to = Pos(found, span.to); 
} 
} 
if (this.type == "bookmark" && !bothSides) return from; 
return from && { 
from: from,
to: to}
; 
} 
; 
TextMarker.prototype.changed = function (){ 
var pos = this.find(), cm = this.doc.cm; 
if (!pos || !cm) return ; 
if (this.type != "bookmark") pos = pos.from; 
var line = getLine(this.doc, pos.line); 
clearCachedMeasurement(cm, line); 
if (pos.line >= cm.display.showingFrom && pos.line < cm.display.showingTo) { 
for (var node = cm.display.lineDiv.firstChild; 
node; node = node.nextSibling)if (node.lineObj == line) { 
if (node.offsetHeight != line.height) updateLineHeight(line, node.offsetHeight); 
break ; 
} 
runInOp(cm, function (){ 
cm.curOp.selectionChanged = cm.curOp.forceUpdate = cm.curOp.updateMaxLine = true ; 
} 
); 
} 
} 
; 
TextMarker.prototype.attachLine = function (line){ 
if (!_AN_Read_length("length", this.lines) && this.doc.cm) { 
var op = this.doc.cm.curOp; 
if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1) (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [] )).push(this); 
} 
this.lines.push(line); 
} 
; 
TextMarker.prototype.detachLine = function (line){ 
this.lines.splice(indexOf(this.lines, line), 1); 
if (!_AN_Read_length("length", this.lines) && this.doc.cm) { 
var op = this.doc.cm.curOp; 
(op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [] )).push(this); 
} 
} 
; 
var nextMarkerId = 0; 
function markText(doc, from, to, options, type){ 
if (options && options.shared) return markTextShared(doc, from, to, options, type); 
if (doc.cm && !doc.cm.curOp) return operation(doc.cm, markText)(doc, from, to, options, type); 
var marker = new TextMarker(doc, type); 
if (options) copyObj(options, marker); 
if (posLess(to, from) || posEq(from, to) && marker.clearWhenEmpty !== false ) return marker; 
if (marker.replacedWith) { 
marker.collapsed = true ; 
marker.replacedWith = elt("span", [marker.replacedWith] , "CodeMirror-widget"); 
if (!options.handleMouseEvents) marker.replacedWith.ignoreEvents = true ; 
} 
if (marker.collapsed) { 
if (conflictingCollapsedRange(doc, from.line, from, to, marker) || from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker)) throw new Error("Inserting collapsed marker partially overlapping an existing one")
sawCollapsedSpans = true ; 
} 
if (marker.addToHistory) addToHistory(doc, { 
from: from,
to: to,
origin: "markText"}
, { 
head: doc.sel.head,
anchor: doc.sel.anchor}
, NaN); 
var curLine = from.line, cm = doc.cm, updateMaxLine; 
doc.iter(curLine, to.line + 1, function (line){ 
if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(doc, line) == cm.display.maxLine) updateMaxLine = true ; 
var span = { 
from: null ,
to: null ,
marker: marker}
; 
if (curLine == from.line) span.from = from.ch; 
if (curLine == to.line) span.to = to.ch; 
if (marker.collapsed && curLine != from.line) updateLineHeight(line, 0); 
addMarkedSpan(line, span); 
++curLine; 
} 
); 
if (marker.collapsed) doc.iter(from.line, to.line + 1, function (line){ 
if (lineIsHidden(doc, line)) updateLineHeight(line, 0); 
} 
); 
if (marker.clearOnEnter) on(marker, "beforeCursorEnter", function (){ 
_AN_Call_clear("clear", marker); 
} 
); 
if (marker.readOnly) { 
sawReadOnlySpans = true ; 
if (_AN_Read_length("length", doc.history.done) || _AN_Read_length("length", doc.history.undone)) doc.clearHistory(); 
} 
if (marker.collapsed) { 
marker.id = ++nextMarkerId; 
marker.atomic = true ; 
} 
if (cm) { 
if (updateMaxLine) cm.curOp.updateMaxLine = true ; 
if (marker.className || marker.title || marker.startStyle || marker.endStyle || marker.collapsed) regChange(cm, from.line, to.line + 1); 
if (marker.atomic) reCheckSelection(cm); 
} 
return marker; 
} 
function SharedTextMarker(markers, primary){ 
this.markers = markers; 
this.primary = primary; 
for (var i = 0, me = this; 
i < _AN_Read_length("length", markers); ++i){ 
markers[i].parent = this; 
on(markers[i], "clear", function (){ 
_AN_Call_clear("clear", me); 
} 
); 
} 
} 
CodeMirror.SharedTextMarker = SharedTextMarker; 
eventMixin(SharedTextMarker); 
SharedTextMarker.prototype.clear = function (){ 
if (this.explicitlyCleared) return ; 
this.explicitlyCleared = true ; 
for (var i = 0; 
i < _AN_Read_length("length", this.markers); ++i)_AN_Call_clear("clear", this.markers[i]); 
signalLater(this, "clear"); 
} 
; 
SharedTextMarker.prototype.find = function (){ 
return this.primary.find(); 
} 
; 
function markTextShared(doc, from, to, options, type){ 
options = copyObj(options); 
options.shared = false ; 
var markers = [markText(doc, from, to, options, type)] , primary = markers[0]; 
var widget = options.replacedWith; 
linkedDocs(doc, function (doc){ 
if (widget) options.replacedWith = widget.cloneNode(true ); 
markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type)); 
for (var i = 0; 
i < _AN_Read_length("length", doc.linked); ++i)if (doc.linked[i].isParent) return ; 
primary = lst(markers); 
} 
); 
return new SharedTextMarker(markers, primary); 
} 
function getMarkedSpanFor(spans, marker){ 
if (spans) for (var i = 0; 
i < _AN_Read_length("length", spans); ++i){ 
var span = spans[i]; 
if (span.marker == marker) return span; 
} 
} 
function removeMarkedSpan(spans, span){ 
for (var r, i = 0; 
i < _AN_Read_length("length", spans); ++i)if (spans[i] != span) (r || (r = [] )).push(spans[i]); 
return r; 
} 
function addMarkedSpan(line, span){ 
line.markedSpans = line.markedSpans? line.markedSpans.concat([span] ): [span] ; 
span.marker.attachLine(line); 
} 
function markedSpansBefore(old, startCh, isInsert){ 
if (old) for (var i = 0, nw; 
i < _AN_Read_length("length", old); ++i){ 
var span = old[i], marker = span.marker; 
var startsBefore = span.from == null  || (marker.inclusiveLeft? span.from <= startCh: span.from < startCh); 
if (startsBefore || span.from == startCh && marker.type == "bookmark" && (!isInsert || !span.marker.insertLeft)) { 
var endsAfter = span.to == null  || (marker.inclusiveRight? span.to >= startCh: span.to > startCh); 
(nw || (nw = [] )).push({ 
from: span.from,
to: endsAfter? null : span.to,
marker: marker}
); 
} 
} 
return nw; 
} 
function markedSpansAfter(old, endCh, isInsert){ 
if (old) for (var i = 0, nw; 
i < _AN_Read_length("length", old); ++i){ 
var span = old[i], marker = span.marker; 
var endsAfter = span.to == null  || (marker.inclusiveRight? span.to >= endCh: span.to > endCh); 
if (endsAfter || span.from == endCh && marker.type == "bookmark" && (!isInsert || span.marker.insertLeft)) { 
var startsBefore = span.from == null  || (marker.inclusiveLeft? span.from <= endCh: span.from < endCh); 
(nw || (nw = [] )).push({ 
from: startsBefore? null : span.from - endCh,
to: span.to == null ? null : span.to - endCh,
marker: marker}
); 
} 
} 
return nw; 
} 
function stretchSpansOverChange(doc, change){ 
var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans; 
var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans; 
if (!oldFirst && !oldLast) return null ; 
var startCh = change.from.ch, endCh = change.to.ch, isInsert = posEq(change.from, change.to); 
var first = markedSpansBefore(oldFirst, startCh, isInsert); 
var last = markedSpansAfter(oldLast, endCh, isInsert); 
var sameLine = _AN_Read_length("length", change.text) == 1, offset = _AN_Read_length("length", lst(change.text)) + (sameLine? startCh: 0); 
if (first) { 
for (var i = 0; 
i < _AN_Read_length("length", first); ++i){ 
var span = first[i]; 
if (span.to == null ) { 
var found = getMarkedSpanFor(last, span.marker); 
if (!found) span.to = startCh; 
 else if (sameLine) span.to = found.to == null ? null : found.to + offset; 
} 
} 
} 
if (last) { 
for (var i = 0; 
i < _AN_Read_length("length", last); ++i){ 
var span = last[i]; 
if (span.to != null ) span.to += offset; 
if (span.from == null ) { 
var found = getMarkedSpanFor(first, span.marker); 
if (!found) { 
span.from = offset; 
if (sameLine) (first || (first = [] )).push(span); 
} 
} 
 else { 
span.from += offset; 
if (sameLine) (first || (first = [] )).push(span); 
} 
} 
} 
if (first) first = clearEmptySpans(first); 
if (last && last != first) last = clearEmptySpans(last); 
var newMarkers = [first] ; 
if (!sameLine) { 
var gap = _AN_Read_length("length", change.text) - 2, gapMarkers; 
if (gap > 0 && first) for (var i = 0; 
i < _AN_Read_length("length", first); ++i)if (first[i].to == null ) (gapMarkers || (gapMarkers = [] )).push({ 
from: null ,
to: null ,
marker: first[i].marker}
); 
for (var i = 0; 
i < gap; ++i)newMarkers.push(gapMarkers); 
newMarkers.push(last); 
} 
return newMarkers; 
} 
function clearEmptySpans(spans){ 
for (var i = 0; 
i < _AN_Read_length("length", spans); ++i){ 
var span = spans[i]; 
if (span.from != null  && span.from == span.to && span.marker.clearWhenEmpty !== false ) spans.splice(i-- , 1); 
} 
if (!_AN_Read_length("length", spans)) return null ; 
return spans; 
} 
function mergeOldSpans(doc, change){ 
var old = getOldSpans(doc, change); 
var stretched = stretchSpansOverChange(doc, change); 
if (!old) return stretched; 
if (!stretched) return old; 
for (var i = 0; 
i < _AN_Read_length("length", old); ++i){ 
var oldCur = old[i], stretchCur = stretched[i]; 
if (oldCur && stretchCur) { 
spans: for (var j = 0; 
j < _AN_Read_length("length", stretchCur); ++j){ 
var span = stretchCur[j]; 
for (var k = 0; 
k < _AN_Read_length("length", oldCur); ++k)if (oldCur[k].marker == span.marker) continue spans; 
oldCur.push(span); 
} 
} 
 else if (stretchCur) { 
old[i] = stretchCur; 
} 
} 
return old; 
} 
function removeReadOnlyRanges(doc, from, to){ 
var markers = null ; 
doc.iter(from.line, to.line + 1, function (line){ 
if (line.markedSpans) for (var i = 0; 
i < _AN_Read_length("length", line.markedSpans); ++i){ 
var mark = line.markedSpans[i].marker; 
if (mark.readOnly && (!markers || indexOf(markers, mark) == -1)) (markers || (markers = [] )).push(mark); 
} 
} 
); 
if (!markers) return null ; 
var parts = [{ 
from: from,
to: to}
] ; 
for (var i = 0; 
i < _AN_Read_length("length", markers); ++i){ 
var mk = markers[i], m = mk.find(); 
for (var j = 0; 
j < _AN_Read_length("length", parts); ++j){ 
var p = parts[j]; 
if (posLess(p.to, m.from) || posLess(m.to, p.from)) continue ; 
var newParts = [j, 1] ; 
if (posLess(p.from, m.from) || !mk.inclusiveLeft && posEq(p.from, m.from)) newParts.push({ 
from: p.from,
to: m.from}
); 
if (posLess(m.to, p.to) || !mk.inclusiveRight && posEq(p.to, m.to)) newParts.push({ 
from: m.to,
to: p.to}
); 
parts.splice.apply(parts, newParts); 
j += _AN_Read_length("length", newParts) - 1; 
} 
} 
return parts; 
} 
function extraLeft(marker){ 
return marker.inclusiveLeft? -1: 0; 
} 
function extraRight(marker){ 
return marker.inclusiveRight? 1: 0; 
} 
function compareCollapsedMarkers(a, b){ 
var lenDiff = _AN_Read_length("length", a.lines) - _AN_Read_length("length", b.lines); 
if (lenDiff != 0) return lenDiff; 
var aPos = a.find(), bPos = b.find(); 
var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b); 
if (fromCmp) return - fromCmp; 
var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b); 
if (toCmp) return toCmp; 
return b.id - a.id; 
} 
function collapsedSpanAtSide(line, start){ 
var sps = sawCollapsedSpans && line.markedSpans, found; 
if (sps) for (var sp, i = 0; 
i < _AN_Read_length("length", sps); ++i){ 
sp = sps[i]; 
if (sp.marker.collapsed && (start? sp.from: sp.to) == null  && (!found || compareCollapsedMarkers(found, sp.marker) < 0)) found = sp.marker; 
} 
return found; 
} 
function collapsedSpanAtStart(line){ 
return collapsedSpanAtSide(line, true ); 
} 
function collapsedSpanAtEnd(line){ 
return collapsedSpanAtSide(line, false ); 
} 
function conflictingCollapsedRange(doc, lineNo, from, to, marker){ 
var line = getLine(doc, lineNo); 
var sps = sawCollapsedSpans && line.markedSpans; 
if (sps) for (var i = 0; 
i < _AN_Read_length("length", sps); ++i){ 
var sp = sps[i]; 
if (!sp.marker.collapsed) continue ; 
var found = sp.marker.find(true ); 
var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker); 
var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker); 
if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) continue ; 
if (fromCmp <= 0 && (cmp(found.to, from) || extraRight(sp.marker) - extraLeft(marker)) > 0 || fromCmp >= 0 && (cmp(found.from, to) || extraLeft(sp.marker) - extraRight(marker)) < 0) return true ; 
} 
} 
function visualLine(doc, line){ 
var merged; 
while (merged = collapsedSpanAtStart(line))line = getLine(doc, merged.find().from.line); 
return line; 
} 
function lineIsHidden(doc, line){ 
var sps = sawCollapsedSpans && line.markedSpans; 
if (sps) for (var sp, i = 0; 
i < _AN_Read_length("length", sps); ++i){ 
sp = sps[i]; 
if (!sp.marker.collapsed) continue ; 
if (sp.from == null ) return true ; 
if (sp.marker.replacedWith) continue ; 
if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp)) return true ; 
} 
} 
function lineIsHiddenInner(doc, line, span){ 
if (span.to == null ) { 
var end = span.marker.find().to, endLine = getLine(doc, end.line); 
return lineIsHiddenInner(doc, endLine, getMarkedSpanFor(endLine.markedSpans, span.marker)); 
} 
if (span.marker.inclusiveRight && span.to == _AN_Read_length("length", line.text)) return true ; 
for (var sp, i = 0; 
i < _AN_Read_length("length", line.markedSpans); ++i){ 
sp = line.markedSpans[i]; 
if (sp.marker.collapsed && !sp.marker.replacedWith && sp.from == span.to && (sp.to == null  || sp.to != span.from) && (sp.marker.inclusiveLeft || span.marker.inclusiveRight) && lineIsHiddenInner(doc, line, sp)) return true ; 
} 
} 
function detachMarkedSpans(line){ 
var spans = line.markedSpans; 
if (!spans) return ; 
for (var i = 0; 
i < _AN_Read_length("length", spans); ++i)spans[i].marker.detachLine(line); 
line.markedSpans = null ; 
} 
function attachMarkedSpans(line, spans){ 
if (!spans) return ; 
for (var i = 0; 
i < _AN_Read_length("length", spans); ++i)spans[i].marker.attachLine(line); 
line.markedSpans = spans; 
} 
var LineWidget = CodeMirror.LineWidget = function (cm, node, options){ 
if (options) for (var opt in options)if (options.hasOwnProperty(opt)) this[opt] = options[opt]; 
this.cm = cm; 
this.node = node; 
} 
; 
eventMixin(LineWidget); 
function widgetOperation(f){ 
return function (){ 
var withOp = !this.cm.curOp; 
if (withOp) startOperation(this.cm); 
try { 
var result = f.apply(this, arguments); 
} 
finally{ 
if (withOp) endOperation(this.cm); 
} 
return result; 
} 
; 
} 
LineWidget.prototype.clear = widgetOperation(function (){ 
var ws = this.line.widgets, no = lineNo(this.line); 
if (no == null  || !ws) return ; 
for (var i = 0; 
i < _AN_Read_length("length", ws); ++i)if (ws[i] == this) ws.splice(i-- , 1); 
if (!_AN_Read_length("length", ws)) this.line.widgets = null ; 
var aboveVisible = heightAtLine(this.cm, this.line) < this.cm.doc.scrollTop; 
updateLineHeight(this.line, Math.max(0, this.line.height - widgetHeight(this))); 
if (aboveVisible) addToScrollPos(this.cm, 0, - this.height); 
regChange(this.cm, no, no + 1); 
} 
); 
LineWidget.prototype.changed = widgetOperation(function (){ 
var oldH = this.height; 
this.height = null ; 
var diff = widgetHeight(this) - oldH; 
if (!diff) return ; 
updateLineHeight(this.line, this.line.height + diff); 
var no = lineNo(this.line); 
regChange(this.cm, no, no + 1); 
} 
); 
function widgetHeight(widget){ 
if (widget.height != null ) return widget.height; 
if (!widget.node.parentNode || widget.node.parentNode.nodeType != 1) removeChildrenAndAdd(widget.cm.display.measure, elt("div", [widget.node] , null , "position: relative")); 
return widget.height = widget.node.offsetHeight; 
} 
function addLineWidget(cm, handle, node, options){ 
var widget = new LineWidget(cm, node, options); 
if (widget.noHScroll) cm.display.alignWidgets = true ; 
changeLine(cm, handle, function (line){ 
var widgets = line.widgets || (line.widgets = [] ); 
if (widget.insertAt == null ) widgets.push(widget); 
 else widgets.splice(Math.min(_AN_Read_length("length", widgets) - 1, Math.max(0, widget.insertAt)), 0, widget); 
widget.line = line; 
if (!lineIsHidden(cm.doc, line) || widget.showIfHidden) { 
var aboveVisible = heightAtLine(cm, line) < cm.doc.scrollTop; 
updateLineHeight(line, line.height + widgetHeight(widget)); 
if (aboveVisible) addToScrollPos(cm, 0, widget.height); 
} 
return true ; 
} 
); 
return widget; 
} 
var Line = CodeMirror.Line = function (text, markedSpans, estimateHeight){ 
_AN_Write_text("text", this, false , text); 
attachMarkedSpans(this, markedSpans); 
this.height = estimateHeight? estimateHeight(this): 1; 
} 
; 
eventMixin(Line); 
Line.prototype.lineNo = function (){ 
return lineNo(this); 
} 
; 
function updateLine(line, text, markedSpans, estimateHeight){ 
_AN_Write_text("text", line, false , text); 
if (line.stateAfter) line.stateAfter = null ; 
if (line.styles) line.styles = null ; 
if (line.order != null ) line.order = null ; 
detachMarkedSpans(line); 
attachMarkedSpans(line, markedSpans); 
var estHeight = estimateHeight? estimateHeight(line): 1; 
if (estHeight != line.height) updateLineHeight(line, estHeight); 
} 
function cleanUpLine(line){ 
line.parent = null ; 
detachMarkedSpans(line); 
} 
function runMode(cm, text, mode, state, f, forceToEnd){ 
var flattenSpans = mode.flattenSpans; 
if (flattenSpans == null ) flattenSpans = cm.options.flattenSpans; 
var curStart = 0, curStyle = null ; 
var stream = new StringStream(text, cm.options.tabSize), style; 
if (text == "" && mode.blankLine) mode.blankLine(state); 
while (!stream.eol()){ 
if (stream.pos > cm.options.maxHighlightLength) { 
flattenSpans = false ; 
if (forceToEnd) processLine(cm, text, state, stream.pos); 
stream.pos = _AN_Read_length("length", text); 
style = null ; 
} 
 else { 
style = mode.token(stream, state); 
} 
if (!flattenSpans || curStyle != style) { 
if (curStart < stream.start) f(stream.start, curStyle); 
curStart = stream.start; 
curStyle = style; 
} 
stream.start = stream.pos; 
} 
while (curStart < stream.pos){ 
var pos = Math.min(stream.pos, curStart + 50000); 
f(pos, curStyle); 
curStart = pos; 
} 
} 
function highlightLine(cm, line, state, forceToEnd){ 
var st = [cm.state.modeGen] ; 
runMode(cm, line.text, cm.doc.mode, state, function (end, style){ 
st.push(end, style); 
} 
, forceToEnd); 
for (var o = 0; 
o < _AN_Read_length("length", cm.state.overlays); ++o){ 
var overlay = cm.state.overlays[o], i = 1, at = 0; 
runMode(cm, line.text, overlay.mode, true , function (end, style){ 
var start = i; 
while (at < end){ 
var i_end = st[i]; 
if (i_end > end) st.splice(i, 1, end, st[i + 1], i_end); 
i += 2; 
at = Math.min(end, i_end); 
} 
if (!style) return ; 
if (overlay.opaque) { 
st.splice(start, i - start, end, style); 
i = start + 2; 
} 
 else { 
for (; start < i; start += 2){ 
var cur = st[start + 1]; 
st[start + 1] = cur? cur + " " + style: style; 
} 
} 
} 
); 
} 
return st; 
} 
function getLineStyles(cm, line){ 
if (!line.styles || line.styles[0] != cm.state.modeGen) line.styles = highlightLine(cm, line, line.stateAfter = getStateBefore(cm, lineNo(line))); 
return line.styles; 
} 
function processLine(cm, text, state, startAt){ 
var mode = cm.doc.mode; 
var stream = new StringStream(text, cm.options.tabSize); 
stream.start = stream.pos = startAt || 0; 
if (text == "" && mode.blankLine) mode.blankLine(state); 
while (!stream.eol() && stream.pos <= cm.options.maxHighlightLength){ 
mode.token(stream, state); 
stream.start = stream.pos; 
} 
} 
var styleToClassCache = { 
}
; 
function interpretTokenStyle(style, builder){ 
if (!style) return null ; 
for (; ; ){ 
var lineClass = style.match(/(?:^|\s)line-(background-)?(\S+)/); 
if (!lineClass) break ; 
style = style.slice(0, lineClass.index) + style.slice(lineClass.index + _AN_Read_length("length", lineClass[0])); 
var prop = lineClass[1]? "bgClass": "textClass"; 
if (builder[prop] == null ) builder[prop] = lineClass[2]; 
 else if (!(new RegExp("(?:^|s)" + lineClass[2] + "(?:$|s)")).test(builder[prop])) builder[prop] += " " + lineClass[2]; 
} 
return styleToClassCache[style] || (styleToClassCache[style] = "cm-" + _AN_Call_replace("replace", style, / +/g, " cm-")); 
} 
function buildLineContent(cm, realLine, measure, copyWidgets){ 
var merged, line = realLine, empty = true ; 
while (merged = collapsedSpanAtStart(line))line = getLine(cm.doc, merged.find().from.line); 
var builder = { 
pre: elt("pre"),
col: 0,
pos: 0,
measure: null ,
measuredSomething: false ,
cm: cm,
copyWidgets: copyWidgets}
; 
do { 
if (line.text) empty = false ; 
builder.measure = line == realLine && measure; 
builder.pos = 0; 
builder.addToken = builder.measure? buildTokenMeasure: buildToken; 
if ((ie || webkit) && cm.getOption("lineWrapping")) builder.addToken = buildTokenSplitSpaces(builder.addToken); 
var next = insertLineContent(line, builder, getLineStyles(cm, line)); 
if (measure && line == realLine && !builder.measuredSomething) { 
measure[0] = _AN_Call_appendchild("appendChild", builder.pre, zeroWidthElement(cm.display.measure)); 
builder.measuredSomething = true ; 
} 
if (next) line = getLine(cm.doc, next.to.line); 
} 
while(next)if (measure && !builder.measuredSomething && !measure[0]) measure[0] = _AN_Call_appendchild("appendChild", builder.pre, empty? elt("span", "\u00a0"): zeroWidthElement(cm.display.measure)); 
if (!builder.pre.firstChild && !lineIsHidden(cm.doc, realLine)) _AN_Call_appendchild("appendChild", builder.pre, document.createTextNode("\u00a0")); 
var order; 
if (measure && (ie || ie_gt10) && (order = getOrder(line))) { 
var l = _AN_Read_length("length", order) - 1; 
if (order[l].from == order[l].to) --l; 
var last = order[l], prev = order[l - 1]; 
if (last.from + 1 == last.to && prev && last.level < prev.level) { 
var span = measure[builder.pos - 1]; 
if (span) span.parentNode.insertBefore(span.measureRight = zeroWidthElement(cm.display.measure), span.nextSibling); 
} 
} 
var textClass = builder.textClass? builder.textClass + " " + (realLine.textClass || ""): realLine.textClass; 
if (textClass) builder.pre.className = textClass; 
signal(cm, "renderLine", cm, realLine, builder.pre); 
return builder; 
} 
function defaultSpecialCharPlaceholder(ch){ 
var token = elt("span", "\u2022", "cm-invalidchar"); 
token.title = "\\u" + ch.charCodeAt(0).toString(16); 
return token; 
} 
function buildToken(builder, text, style, startStyle, endStyle, title){ 
if (!text) return ; 
var special = builder.cm.options.specialChars; 
if (!special.test(text)) { 
builder.col += _AN_Read_length("length", text); 
var content = document.createTextNode(text); 
} 
 else { 
var content = document.createDocumentFragment(), pos = 0; 
while (true ){ 
special.lastIndex = pos; 
var m = special.exec(text); 
var skipped = m? m.index - pos: _AN_Read_length("length", text) - pos; 
if (skipped) { 
_AN_Call_appendchild("appendChild", content, document.createTextNode(text.slice(pos, pos + skipped))); 
builder.col += skipped; 
} 
if (!m) break ; 
pos += skipped + 1; 
if (m[0] == "\t") { 
var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize; 
_AN_Call_appendchild("appendChild", content, elt("span", spaceStr(tabWidth), "cm-tab")); 
builder.col += tabWidth; 
} 
 else { 
var token = builder.cm.options.specialCharPlaceholder(m[0]); 
_AN_Call_appendchild("appendChild", content, token); 
builder.col += 1; 
} 
} 
} 
if (style || startStyle || endStyle || builder.measure) { 
var fullStyle = style || ""; 
if (startStyle) fullStyle += startStyle; 
if (endStyle) fullStyle += endStyle; 
var token = elt("span", [content] , fullStyle); 
if (title) token.title = title; 
return _AN_Call_appendchild("appendChild", builder.pre, token); 
} 
_AN_Call_appendchild("appendChild", builder.pre, content); 
} 
function buildTokenMeasure(builder, text, style, startStyle, endStyle){ 
var wrapping = builder.cm.options.lineWrapping; 
for (var i = 0; 
i < _AN_Read_length("length", text); ++i){ 
var ch = text.charAt(i), start = i == 0; 
if (ch >= "\ud800" && ch < "\udbff" && i < _AN_Read_length("length", text) - 1) { 
ch = text.slice(i, i + 2); 
++i; 
} 
 else if (i && wrapping && spanAffectsWrapping(text, i)) { 
_AN_Call_appendchild("appendChild", builder.pre, elt("wbr")); 
} 
var old = builder.measure[builder.pos]; 
var span = builder.measure[builder.pos] = buildToken(builder, ch, style, start && startStyle, i == _AN_Read_length("length", text) - 1 && endStyle); 
if (old) span.leftSide = old.leftSide || old; 
if (ie && wrapping && ch == " " && i && !/\s/.test(text.charAt(i - 1)) && i < _AN_Read_length("length", text) - 1 && !/\s/.test(text.charAt(i + 1))) span.style.whiteSpace = "normal"; 
builder.pos += _AN_Read_length("length", ch); 
} 
if (text.length) builder.measuredSomething = true ; 
} 
function buildTokenSplitSpaces(inner){ 
function split(old){ 
var out = " "; 
for (var i = 0; 
i < _AN_Read_length("length", old) - 2; ++i)out += i % 2? " ": "\u00a0"; 
out += " "; 
return out; 
} 
return function (builder, text, style, startStyle, endStyle, title){ 
return inner(builder, _AN_Call_replace("replace", text, / {3,}/g, split), style, startStyle, endStyle, title); 
} 
; 
} 
function buildCollapsedSpan(builder, size, marker, ignoreWidget){ 
var widget = !ignoreWidget && marker.replacedWith; 
if (widget) { 
if (builder.copyWidgets) widget = widget.cloneNode(true ); 
_AN_Call_appendchild("appendChild", builder.pre, widget); 
if (builder.measure) { 
if (size) { 
builder.measure[builder.pos] = widget; 
} 
 else { 
var elt = zeroWidthElement(builder.cm.display.measure); 
if (marker.type == "bookmark" && !marker.insertLeft) builder.measure[builder.pos] = _AN_Call_appendchild("appendChild", builder.pre, elt); 
 else if (builder.measure[builder.pos]) return ; 
 else builder.measure[builder.pos] = builder.pre.insertBefore(elt, widget); 
} 
builder.measuredSomething = true ; 
} 
} 
builder.pos += size; 
} 
function insertLineContent(line, builder, styles){ 
var spans = line.markedSpans, allText = line.text, at = 0; 
if (!spans) { 
for (var i = 1; 
i < _AN_Read_length("length", styles); i += 2)builder.addToken(builder, allText.slice(at, at = styles[i]), interpretTokenStyle(styles[i + 1], builder)); 
return ; 
} 
var len = _AN_Read_length("length", allText), pos = 0, i = 1, text = "", style; 
var nextChange = 0, spanStyle, spanEndStyle, spanStartStyle, title, collapsed; 
for (; ; ){ 
if (nextChange == pos) { 
spanStyle = spanEndStyle = spanStartStyle = title = ""; 
collapsed = null ; 
nextChange = Infinity; 
var foundBookmarks = [] ; 
for (var j = 0; 
j < _AN_Read_length("length", spans); ++j){ 
var sp = spans[j], m = sp.marker; 
if (sp.from <= pos && (sp.to == null  || sp.to > pos)) { 
if (sp.to != null  && nextChange > sp.to) { 
nextChange = sp.to; 
spanEndStyle = ""; 
} 
if (m.className) spanStyle += " " + m.className; 
if (m.startStyle && sp.from == pos) spanStartStyle += " " + m.startStyle; 
if (m.endStyle && sp.to == nextChange) spanEndStyle += " " + m.endStyle; 
if (m.title && !title) title = m.title; 
if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0)) collapsed = sp; 
} 
 else if (sp.from > pos && nextChange > sp.from) { 
nextChange = sp.from; 
} 
if (m.type == "bookmark" && sp.from == pos && m.replacedWith) foundBookmarks.push(m); 
} 
if (collapsed && (collapsed.from || 0) == pos) { 
buildCollapsedSpan(builder, (collapsed.to == null ? len: collapsed.to) - pos, collapsed.marker, collapsed.from == null ); 
if (collapsed.to == null ) return collapsed.marker.find(); 
} 
if (!collapsed && _AN_Read_length("length", foundBookmarks)) for (var j = 0; 
j < _AN_Read_length("length", foundBookmarks); ++j)buildCollapsedSpan(builder, 0, foundBookmarks[j]); 
} 
if (pos >= len) break ; 
var upto = Math.min(len, nextChange); 
while (true ){ 
if (text) { 
var end = pos + _AN_Read_length("length", text); 
if (!collapsed) { 
var tokenText = end > upto? text.slice(0, upto - pos): text; 
builder.addToken(builder, tokenText, style? style + spanStyle: spanStyle, spanStartStyle, pos + _AN_Read_length("length", tokenText) == nextChange? spanEndStyle: "", title); 
} 
if (end >= upto) { 
text = text.slice(upto - pos); 
pos = upto; 
break ; 
} 
pos = end; 
spanStartStyle = ""; 
} 
text = allText.slice(at, at = styles[i++ ]); 
style = interpretTokenStyle(styles[i++ ], builder); 
} 
} 
} 
function updateDoc(doc, change, markedSpans, selAfter, estimateHeight){ 
function spansFor(n){ 
return markedSpans? markedSpans[n]: null ; 
} 
function update(line, text, spans){ 
updateLine(line, text, spans, estimateHeight); 
signalLater(line, "change", line, change); 
} 
var from = change.from, to = change.to, text = change.text; 
var firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line); 
var lastText = lst(text), lastSpans = spansFor(_AN_Read_length("length", text) - 1), nlines = to.line - from.line; 
if (from.ch == 0 && to.ch == 0 && lastText == "" && (!doc.cm || doc.cm.options.wholeLineUpdateBefore)) { 
for (var i = 0, e = _AN_Read_length("length", text) - 1, added = [] ; 
i < e; ++i)added.push(new Line(text[i], spansFor(i), estimateHeight)); 
update(lastLine, lastLine.text, lastSpans); 
if (nlines) doc.remove(from.line, nlines); 
if (added.length) doc.insert(from.line, added); 
} 
 else if (firstLine == lastLine) { 
if (_AN_Read_length("length", text) == 1) { 
update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans); 
} 
 else { 
for (var added = [] , i = 1, e = _AN_Read_length("length", text) - 1; 
i < e; ++i)added.push(new Line(text[i], spansFor(i), estimateHeight)); 
added.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight)); 
update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0)); 
doc.insert(from.line + 1, added); 
} 
} 
 else if (_AN_Read_length("length", text) == 1) { 
update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0)); 
doc.remove(from.line + 1, nlines); 
} 
 else { 
update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0)); 
update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans); 
for (var i = 1, e = _AN_Read_length("length", text) - 1, added = [] ; 
i < e; ++i)added.push(new Line(text[i], spansFor(i), estimateHeight)); 
if (nlines > 1) doc.remove(from.line + 1, nlines - 1); 
doc.insert(from.line + 1, added); 
} 
signalLater(doc, "change", doc, change); 
setSelection(doc, selAfter.anchor, selAfter.head, null , true ); 
} 
function LeafChunk(lines){ 
this.lines = lines; 
this.parent = null ; 
for (var i = 0, e = _AN_Read_length("length", lines), height = 0; 
i < e; ++i){ 
lines[i].parent = this; 
height += lines[i].height; 
} 
this.height = height; 
} 
LeafChunk.prototype = { 
chunkSize: function (){ 
return _AN_Read_length("length", this.lines); 
} 
,
removeInner: function (at, n){ 
for (var i = at, e = at + n; 
i < e; ++i){ 
var line = this.lines[i]; 
this.height -= line.height; 
cleanUpLine(line); 
signalLater(line, "delete"); 
} 
this.lines.splice(at, n); 
} 
,
collapse: function (lines){ 
lines.splice.apply(lines, [_AN_Read_length("length", lines), 0] .concat(this.lines)); 
} 
,
insertInner: function (at, lines, height){ 
this.height += height; 
this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at)); 
for (var i = 0, e = _AN_Read_length("length", lines); 
i < e; ++i)lines[i].parent = this; 
} 
,
iterN: function (at, n, op){ 
for (var e = at + n; 
at < e; ++at)if (op(this.lines[at])) return true ; 
} 
}
; 
function BranchChunk(children){ 
this.children = children; 
var size = 0, height = 0; 
for (var i = 0, e = _AN_Read_length("length", children); 
i < e; ++i){ 
var ch = children[i]; 
size += ch.chunkSize(); 
height += ch.height; 
ch.parent = this; 
} 
this.size = size; 
this.height = height; 
this.parent = null ; 
} 
BranchChunk.prototype = { 
chunkSize: function (){ 
return this.size; 
} 
,
removeInner: function (at, n){ 
this.size -= n; 
for (var i = 0; 
i < _AN_Read_length("length", this.children); ++i){ 
var child = this.children[i], sz = child.chunkSize(); 
if (at < sz) { 
var rm = Math.min(n, sz - at), oldHeight = child.height; 
child.removeInner(at, rm); 
this.height -= oldHeight - child.height; 
if (sz == rm) { 
this.children.splice(i-- , 1); 
child.parent = null ; 
} 
if ((n -= rm) == 0) break ; 
at = 0; 
} 
 else at -= sz; 
} 
if (this.size - n < 25) { 
var lines = [] ; 
this.collapse(lines); 
this.children = [new LeafChunk(lines)] ; 
this.children[0].parent = this; 
} 
} 
,
collapse: function (lines){ 
for (var i = 0, e = _AN_Read_length("length", this.children); 
i < e; ++i)this.children[i].collapse(lines); 
} 
,
insertInner: function (at, lines, height){ 
this.size += _AN_Read_length("length", lines); 
this.height += height; 
for (var i = 0, e = _AN_Read_length("length", this.children); 
i < e; ++i){ 
var child = this.children[i], sz = child.chunkSize(); 
if (at <= sz) { 
child.insertInner(at, lines, height); 
if (child.lines && _AN_Read_length("length", child.lines) > 50) { 
while (_AN_Read_length("length", child.lines) > 50){ 
var spilled = child.lines.splice(_AN_Read_length("length", child.lines) - 25, 25); 
var newleaf = new LeafChunk(spilled); 
child.height -= newleaf.height; 
this.children.splice(i + 1, 0, newleaf); 
newleaf.parent = this; 
} 
this.maybeSpill(); 
} 
break ; 
} 
at -= sz; 
} 
} 
,
maybeSpill: function (){ 
if (_AN_Read_length("length", this.children) <= 10) return ; 
var me = this; 
do { 
var spilled = me.children.splice(_AN_Read_length("length", me.children) - 5, 5); 
var sibling = new BranchChunk(spilled); 
if (!me.parent) { 
var copy = new BranchChunk(me.children); 
copy.parent = me; 
me.children = [copy, sibling] ; 
me = copy; 
} 
 else { 
me.size -= sibling.size; 
me.height -= sibling.height; 
var myIndex = indexOf(me.parent.children, me); 
me.parent.children.splice(myIndex + 1, 0, sibling); 
} 
sibling.parent = me.parent; 
} 
while(_AN_Read_length("length", me.children) > 10)me.parent.maybeSpill(); 
} 
,
iterN: function (at, n, op){ 
for (var i = 0, e = _AN_Read_length("length", this.children); 
i < e; ++i){ 
var child = this.children[i], sz = child.chunkSize(); 
if (at < sz) { 
var used = Math.min(n, sz - at); 
if (child.iterN(at, used, op)) return true ; 
if ((n -= used) == 0) break ; 
at = 0; 
} 
 else at -= sz; 
} 
} 
}
; 
var nextDocId = 0; 
var Doc = CodeMirror.Doc = function (text, mode, firstLine){ 
if (!(this instanceof Doc)) return new Doc(text, mode, firstLine); 
if (firstLine == null ) firstLine = 0; 
BranchChunk.call(this, [new LeafChunk([new Line("", null )] )] ); 
this.first = firstLine; 
this.scrollTop = this.scrollLeft = 0; 
this.cantEdit = false ; 
this.history = makeHistory(); 
this.cleanGeneration = 1; 
this.frontier = firstLine; 
var start = Pos(firstLine, 0); 
this.sel = { 
from: start,
to: start,
head: start,
anchor: start,
shift: false ,
extend: false ,
goalColumn: null }
; 
this.id = ++nextDocId; 
this.modeOption = mode; 
if (typeof text == "string") text = splitLines(text); 
updateDoc(this, { 
from: start,
to: start,
text: text}
, null , { 
head: start,
anchor: start}
); 
} 
; 
Doc.prototype = createObj(BranchChunk.prototype, { 
constructor: Doc,
iter: function (from, to, op){ 
if (op) this.iterN(from - this.first, to - from, op); 
 else this.iterN(this.first, this.first + this.size, from); 
} 
,
insert: function (at, lines){ 
var height = 0; 
for (var i = 0, e = _AN_Read_length("length", lines); 
i < e; ++i)height += lines[i].height; 
this.insertInner(at - this.first, lines, height); 
} 
,
remove: function (at, n){ 
this.removeInner(at - this.first, n); 
} 
,
getValue: function (lineSep){ 
var lines = getLines(this, this.first, this.first + this.size); 
if (lineSep === false ) return lines; 
return lines.join(lineSep || "\n"); 
} 
,
setValue: function (code){ 
var top = Pos(this.first, 0), last = this.first + this.size - 1; 
makeChange(this, { 
from: top,
to: Pos(last, _AN_Read_length("length", getLine(this, last).text)),
text: splitLines(code),
origin: "setValue"}
, { 
head: top,
anchor: top}
, true ); 
} 
,
replaceRange: function (code, from, to, origin){ 
from = clipPos(this, from); 
to = to? clipPos(this, to): from; 
replaceRange(this, code, from, to, origin); 
} 
,
getRange: function (from, to, lineSep){ 
var lines = getBetween(this, clipPos(this, from), clipPos(this, to)); 
if (lineSep === false ) return lines; 
return lines.join(lineSep || "\n"); 
} 
,
getLine: function (line){ 
var l = this.getLineHandle(line); 
return l && l.text; 
} 
,
setLine: function (line, text){ 
if (isLine(this, line)) replaceRange(this, text, Pos(line, 0), clipPos(this, Pos(line))); 
} 
,
removeLine: function (line){ 
if (line) replaceRange(this, "", clipPos(this, Pos(line - 1)), clipPos(this, Pos(line))); 
 else replaceRange(this, "", Pos(0, 0), clipPos(this, Pos(1, 0))); 
} 
,
getLineHandle: function (line){ 
if (isLine(this, line)) return getLine(this, line); 
} 
,
getLineNumber: function (line){ 
return lineNo(line); 
} 
,
getLineHandleVisualStart: function (line){ 
if (typeof line == "number") line = getLine(this, line); 
return visualLine(this, line); 
} 
,
lineCount: function (){ 
return this.size; 
} 
,
firstLine: function (){ 
return this.first; 
} 
,
lastLine: function (){ 
return this.first + this.size - 1; 
} 
,
clipPos: function (pos){ 
return clipPos(this, pos); 
} 
,
getCursor: function (start){ 
var sel = this.sel, pos; 
if (start == null  || start == "head") pos = sel.head; 
 else if (start == "anchor") pos = sel.anchor; 
 else if (start == "end" || start === false ) pos = sel.to; 
 else pos = sel.from; 
return copyPos(pos); 
} 
,
somethingSelected: function (){ 
return !posEq(this.sel.head, this.sel.anchor); 
} 
,
setCursor: docOperation(function (line, ch, extend){ 
var pos = clipPos(this, typeof line == "number"? Pos(line, ch || 0): line); 
if (extend) extendSelection(this, pos); 
 else setSelection(this, pos, pos); 
} 
),
setSelection: docOperation(function (anchor, head, bias){ 
setSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), bias); 
} 
),
extendSelection: docOperation(function (from, to, bias){ 
extendSelection(this, clipPos(this, from), to && clipPos(this, to), bias); 
} 
),
getSelection: function (lineSep){ 
return this.getRange(this.sel.from, this.sel.to, lineSep); 
} 
,
replaceSelection: function (code, collapse, origin){ 
makeChange(this, { 
from: this.sel.from,
to: this.sel.to,
text: splitLines(code),
origin: origin}
, collapse || "around"); 
} 
,
undo: docOperation(function (){ 
makeChangeFromHistory(this, "undo"); 
} 
),
redo: docOperation(function (){ 
makeChangeFromHistory(this, "redo"); 
} 
),
setExtending: function (val){ 
this.sel.extend = val; 
} 
,
historySize: function (){ 
var hist = this.history; 
return { 
undo: _AN_Read_length("length", hist.done),
redo: _AN_Read_length("length", hist.undone)}
; 
} 
,
clearHistory: function (){ 
this.history = makeHistory(this.history.maxGeneration); 
} 
,
markClean: function (){ 
this.cleanGeneration = this.changeGeneration(true ); 
} 
,
changeGeneration: function (forceSplit){ 
if (forceSplit) this.history.lastOp = this.history.lastOrigin = null ; 
return this.history.generation; 
} 
,
isClean: function (gen){ 
return this.history.generation == (gen || this.cleanGeneration); 
} 
,
getHistory: function (){ 
return { 
done: copyHistoryArray(this.history.done),
undone: copyHistoryArray(this.history.undone)}
; 
} 
,
setHistory: function (histData){ 
var hist = this.history = makeHistory(this.history.maxGeneration); 
hist.done = histData.done.slice(0); 
hist.undone = histData.undone.slice(0); 
} 
,
markText: function (from, to, options){ 
return markText(this, clipPos(this, from), clipPos(this, to), options, "range"); 
} 
,
setBookmark: function (pos, options){ 
var realOpts = { 
replacedWith: options && (options.nodeType == null ? options.widget: options),
insertLeft: options && options.insertLeft,
clearWhenEmpty: false }
; 
pos = clipPos(this, pos); 
return markText(this, pos, pos, realOpts, "bookmark"); 
} 
,
findMarksAt: function (pos){ 
pos = clipPos(this, pos); 
var markers = [] , spans = getLine(this, pos.line).markedSpans; 
if (spans) for (var i = 0; 
i < _AN_Read_length("length", spans); ++i){ 
var span = spans[i]; 
if ((span.from == null  || span.from <= pos.ch) && (span.to == null  || span.to >= pos.ch)) markers.push(span.marker.parent || span.marker); 
} 
return markers; 
} 
,
getAllMarks: function (){ 
var markers = [] ; 
this.iter(function (line){ 
var sps = line.markedSpans; 
if (sps) for (var i = 0; 
i < _AN_Read_length("length", sps); ++i)if (sps[i].from != null ) markers.push(sps[i].marker); 
} 
); 
return markers; 
} 
,
posFromIndex: function (off){ 
var ch, lineNo = this.first; 
this.iter(function (line){ 
var sz = _AN_Read_length("length", line.text) + 1; 
if (sz > off) { 
ch = off; 
return true ; 
} 
off -= sz; 
++lineNo; 
} 
); 
return clipPos(this, Pos(lineNo, ch)); 
} 
,
indexFromPos: function (coords){ 
coords = clipPos(this, coords); 
var index = coords.ch; 
if (coords.line < this.first || coords.ch < 0) return 0; 
this.iter(this.first, coords.line, function (line){ 
index += _AN_Read_length("length", line.text) + 1; 
} 
); 
return index; 
} 
,
copy: function (copyHistory){ 
var doc = new Doc(getLines(this, this.first, this.first + this.size), this.modeOption, this.first); 
doc.scrollTop = this.scrollTop; 
doc.scrollLeft = this.scrollLeft; 
doc.sel = { 
from: this.sel.from,
to: this.sel.to,
head: this.sel.head,
anchor: this.sel.anchor,
shift: this.sel.shift,
extend: false ,
goalColumn: this.sel.goalColumn}
; 
if (copyHistory) { 
doc.history.undoDepth = this.history.undoDepth; 
doc.setHistory(this.getHistory()); 
} 
return doc; 
} 
,
linkedDoc: function (options){ 
if (!options) options = { 
}
; 
var from = this.first, to = this.first + this.size; 
if (options.from != null  && options.from > from) from = options.from; 
if (options.to != null  && options.to < to) to = options.to; 
var copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from); 
if (options.sharedHist) copy.history = this.history; 
(this.linked || (this.linked = [] )).push({ 
doc: copy,
sharedHist: options.sharedHist}
); 
copy.linked = [{ 
doc: this,
isParent: true ,
sharedHist: options.sharedHist}
] ; 
return copy; 
} 
,
unlinkDoc: function (other){ 
if (other instanceof CodeMirror) other = other.doc; 
if (this.linked) for (var i = 0; 
i < _AN_Read_length("length", this.linked); ++i){ 
var link = this.linked[i]; 
if (link.doc != other) continue ; 
this.linked.splice(i, 1); 
other.unlinkDoc(this); 
break ; 
} 
if (other.history == this.history) { 
var splitIds = [other.id] ; 
linkedDocs(other, function (doc){ 
splitIds.push(doc.id); 
} 
, true ); 
other.history = makeHistory(); 
other.history.done = copyHistoryArray(this.history.done, splitIds); 
other.history.undone = copyHistoryArray(this.history.undone, splitIds); 
} 
} 
,
iterLinkedDocs: function (f){ 
linkedDocs(this, f); 
} 
,
getMode: function (){ 
return this.mode; 
} 
,
getEditor: function (){ 
return this.cm; 
} 
}
); 
Doc.prototype.eachLine = Doc.prototype.iter; 
var dontDelegate = "iter insert remove copy getEditor".split(" "); 
for (var prop in Doc.prototype)if (Doc.prototype.hasOwnProperty(prop) && indexOf(dontDelegate, prop) < 0) CodeMirror.prototype[prop] = (function (method){ 
return function (){ 
return method.apply(this.doc, arguments); 
} 
; 
} 
)(Doc.prototype[prop]); 
eventMixin(Doc); 
function linkedDocs(doc, f, sharedHistOnly){ 
function propagate(doc, skip, sharedHist){ 
if (doc.linked) for (var i = 0; 
i < _AN_Read_length("length", doc.linked); ++i){ 
var rel = doc.linked[i]; 
if (rel.doc == skip) continue ; 
var shared = sharedHist && rel.sharedHist; 
if (sharedHistOnly && !shared) continue ; 
f(rel.doc, shared); 
propagate(rel.doc, doc, shared); 
} 
} 
propagate(doc, null , true ); 
} 
function attachDoc(cm, doc){ 
if (doc.cm) throw new Error("This document is already in use.")
cm.doc = doc; 
doc.cm = cm; 
estimateLineHeights(cm); 
loadMode(cm); 
if (!cm.options.lineWrapping) computeMaxLength(cm); 
cm.options.mode = doc.modeOption; 
regChange(cm); 
} 
function getLine(chunk, n){ 
n -= chunk.first; 
while (!chunk.lines){ 
for (var i = 0; 
; ++i){ 
var child = chunk.children[i], sz = child.chunkSize(); 
if (n < sz) { 
chunk = child; 
break ; 
} 
n -= sz; 
} 
} 
return chunk.lines[n]; 
} 
function getBetween(doc, start, end){ 
var out = [] , n = start.line; 
doc.iter(start.line, end.line + 1, function (line){ 
var text = line.text; 
if (n == end.line) text = text.slice(0, end.ch); 
if (n == start.line) text = text.slice(start.ch); 
out.push(text); 
++n; 
} 
); 
return out; 
} 
function getLines(doc, from, to){ 
var out = [] ; 
doc.iter(from, to, function (line){ 
out.push(line.text); 
} 
); 
return out; 
} 
function updateLineHeight(line, height){ 
var diff = height - line.height; 
for (var n = line; 
n; n = n.parent)n.height += diff; 
} 
function lineNo(line){ 
if (line.parent == null ) return null ; 
var cur = line.parent, no = indexOf(cur.lines, line); 
for (var chunk = cur.parent; 
chunk; cur = chunk, chunk = chunk.parent){ 
for (var i = 0; 
; ++i){ 
if (chunk.children[i] == cur) break ; 
no += chunk.children[i].chunkSize(); 
} 
} 
return no + cur.first; 
} 
function lineAtHeight(chunk, h){ 
var n = chunk.first; 
outer: do { 
for (var i = 0, e = _AN_Read_length("length", chunk.children); 
i < e; ++i){ 
var child = chunk.children[i], ch = child.height; 
if (h < ch) { 
chunk = child; 
continue outer; 
} 
h -= ch; 
n += child.chunkSize(); 
} 
return n; 
} 
while(!chunk.lines)for (var i = 0, e = _AN_Read_length("length", chunk.lines); 
i < e; ++i){ 
var line = chunk.lines[i], lh = line.height; 
if (h < lh) break ; 
h -= lh; 
} 
return n + i; 
} 
function heightAtLine(cm, lineObj){ 
lineObj = visualLine(cm.doc, lineObj); 
var h = 0, chunk = lineObj.parent; 
for (var i = 0; 
i < _AN_Read_length("length", chunk.lines); ++i){ 
var line = chunk.lines[i]; 
if (line == lineObj) break ; 
 else h += line.height; 
} 
for (var p = chunk.parent; 
p; chunk = p, p = chunk.parent){ 
for (var i = 0; 
i < _AN_Read_length("length", p.children); ++i){ 
var cur = p.children[i]; 
if (cur == chunk) break ; 
 else h += cur.height; 
} 
} 
return h; 
} 
function getOrder(line){ 
var order = line.order; 
if (order == null ) order = line.order = bidiOrdering(line.text); 
return order; 
} 
function makeHistory(startGen){ 
return { 
done: [] ,
undone: [] ,
undoDepth: Infinity,
lastTime: 0,
lastOp: null ,
lastOrigin: null ,
generation: startGen || 1,
maxGeneration: startGen || 1}
; 
} 
function attachLocalSpans(doc, change, from, to){ 
var existing = change["spans_" + doc.id], n = 0; 
doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), function (line){ 
if (line.markedSpans) (existing || (existing = change["spans_" + doc.id] = { 
}
))[n] = line.markedSpans; 
++n; 
} 
); 
} 
function historyChangeFromChange(doc, change){ 
var from = { 
line: change.from.line,
ch: change.from.ch}
; 
var histChange = { 
from: from,
to: changeEnd(change),
text: getBetween(doc, change.from, change.to)}
; 
attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1); 
linkedDocs(doc, function (doc){ 
attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1); 
} 
, true ); 
return histChange; 
} 
function addToHistory(doc, change, selAfter, opId){ 
var hist = doc.history; 
hist.undone.length = 0; 
var time = + new Date(), cur = lst(hist.done); 
if (cur && (hist.lastOp == opId || hist.lastOrigin == change.origin && change.origin && ((change.origin.charAt(0) == "+" && doc.cm && hist.lastTime > time - doc.cm.options.historyEventDelay) || change.origin.charAt(0) == "*"))) { 
var last = lst(cur.changes); 
if (posEq(change.from, change.to) && posEq(change.from, last.to)) { 
last.to = changeEnd(change); 
} 
 else { 
cur.changes.push(historyChangeFromChange(doc, change)); 
} 
cur.anchorAfter = selAfter.anchor; 
cur.headAfter = selAfter.head; 
} 
 else { 
cur = { 
changes: [historyChangeFromChange(doc, change)] ,
generation: hist.generation,
anchorBefore: doc.sel.anchor,
headBefore: doc.sel.head,
anchorAfter: selAfter.anchor,
headAfter: selAfter.head}
; 
hist.done.push(cur); 
while (_AN_Read_length("length", hist.done) > hist.undoDepth)hist.done.shift(); 
} 
hist.generation = ++hist.maxGeneration; 
hist.lastTime = time; 
hist.lastOp = opId; 
hist.lastOrigin = change.origin; 
} 
function removeClearedSpans(spans){ 
if (!spans) return null ; 
for (var i = 0, out; 
i < _AN_Read_length("length", spans); ++i){ 
if (spans[i].marker.explicitlyCleared) { 
if (!out) out = spans.slice(0, i); 
} 
 else if (out) out.push(spans[i]); 
} 
return !out? spans: _AN_Read_length("length", out)? out: null ; 
} 
function getOldSpans(doc, change){ 
var found = change["spans_" + doc.id]; 
if (!found) return null ; 
for (var i = 0, nw = [] ; 
i < _AN_Read_length("length", change.text); ++i)nw.push(removeClearedSpans(found[i])); 
return nw; 
} 
function copyHistoryArray(events, newGroup){ 
for (var i = 0, copy = [] ; 
i < _AN_Read_length("length", events); ++i){ 
var event = events[i], changes = event.changes, newChanges = [] ; 
copy.push({ 
changes: newChanges,
anchorBefore: event.anchorBefore,
headBefore: event.headBefore,
anchorAfter: event.anchorAfter,
headAfter: event.headAfter}
); 
for (var j = 0; 
j < _AN_Read_length("length", changes); ++j){ 
var change = changes[j], m; 
newChanges.push({ 
from: change.from,
to: change.to,
text: change.text}
); 
if (newGroup) for (var prop in change)if (m = prop.match(/^spans_(\d+)$/)) { 
if (indexOf(newGroup, Number(m[1])) > -1) { 
lst(newChanges)[prop] = change[prop]; 
delete change[prop]; 
} 
} 
} 
} 
return copy; 
} 
function rebaseHistSel(pos, from, to, diff){ 
if (to < pos.line) { 
pos.line += diff; 
} 
 else if (from < pos.line) { 
pos.line = from; 
pos.ch = 0; 
} 
} 
function rebaseHistArray(array, from, to, diff){ 
for (var i = 0; 
i < _AN_Read_length("length", array); ++i){ 
var sub = array[i], ok = true ; 
for (var j = 0; 
j < _AN_Read_length("length", sub.changes); ++j){ 
var cur = sub.changes[j]; 
if (!sub.copied) { 
cur.from = copyPos(cur.from); 
cur.to = copyPos(cur.to); 
} 
if (to < cur.from.line) { 
cur.from.line += diff; 
cur.to.line += diff; 
} 
 else if (from <= cur.to.line) { 
ok = false ; 
break ; 
} 
} 
if (!sub.copied) { 
sub.anchorBefore = copyPos(sub.anchorBefore); 
sub.headBefore = copyPos(sub.headBefore); 
sub.anchorAfter = copyPos(sub.anchorAfter); 
sub.readAfter = copyPos(sub.headAfter); 
sub.copied = true ; 
} 
if (!ok) { 
array.splice(0, i + 1); 
i = 0; 
} 
 else { 
rebaseHistSel(sub.anchorBefore); 
rebaseHistSel(sub.headBefore); 
rebaseHistSel(sub.anchorAfter); 
rebaseHistSel(sub.headAfter); 
} 
} 
} 
function rebaseHist(hist, change){ 
var from = change.from.line, to = change.to.line, diff = _AN_Read_length("length", change.text) - (to - from) - 1; 
rebaseHistArray(hist.done, from, to, diff); 
rebaseHistArray(hist.undone, from, to, diff); 
} 
function stopMethod(){ 
e_stop(this); 
} 
function addStop(event){ 
if (!event.stop) event.stop = stopMethod; 
return event; 
} 
function e_preventDefault(e){ 
if (e.preventDefault) e.preventDefault(); 
 else e.returnValue = false ; 
} 
function e_stopPropagation(e){ 
if (e.stopPropagation) e.stopPropagation(); 
 else e.cancelBubble = true ; 
} 
function e_defaultPrevented(e){ 
return e.defaultPrevented != null ? e.defaultPrevented: e.returnValue == false ; 
} 
function e_stop(e){ 
e_preventDefault(e); 
e_stopPropagation(e); 
} 
CodeMirror.e_stop = e_stop; 
CodeMirror.e_preventDefault = e_preventDefault; 
CodeMirror.e_stopPropagation = e_stopPropagation; 
function e_target(e){ 
return _AN_Read_target("target", e) || e.srcElement; 
} 
function e_button(e){ 
var b = e.which; 
if (b == null ) { 
if (e.button & 1) b = 1; 
 else if (e.button & 2) b = 3; 
 else if (e.button & 4) b = 2; 
} 
if (mac && e.ctrlKey && b == 1) b = 3; 
return b; 
} 
function on(emitter, type, f){ 
if (emitter.addEventListener) emitter.addEventListener(type, f, false ); 
 else if (emitter.attachEvent) emitter.attachEvent("on" + type, f); 
 else { 
var map = emitter._handlers || (emitter._handlers = { 
}
); 
var arr = map[type] || (map[type] = [] ); 
arr.push(f); 
} 
} 
function off(emitter, type, f){ 
if (emitter.removeEventListener) emitter.removeEventListener(type, f, false ); 
 else if (emitter.detachEvent) emitter.detachEvent("on" + type, f); 
 else { 
var arr = emitter._handlers && emitter._handlers[type]; 
if (!arr) return ; 
for (var i = 0; 
i < _AN_Read_length("length", arr); ++i)if (arr[i] == f) { 
arr.splice(i, 1); 
break ; 
} 
} 
} 
function signal(emitter, type){ 
var arr = emitter._handlers && emitter._handlers[type]; 
if (!arr) return ; 
var args = Array.prototype.slice.call(arguments, 2); 
for (var i = 0; 
i < _AN_Read_length("length", arr); ++i)arr[i].apply(null , args); 
} 
var delayedCallbacks, delayedCallbackDepth = 0; 
function signalLater(emitter, type){ 
var arr = emitter._handlers && emitter._handlers[type]; 
if (!arr) return ; 
var args = Array.prototype.slice.call(arguments, 2); 
if (!delayedCallbacks) { 
++delayedCallbackDepth; 
delayedCallbacks = [] ; 
_AN_Call_settimeout("setTimeout", window, fireDelayed, 0); 
} 
function bnd(f){ 
return function (){ 
f.apply(null , args); 
} 
; 
} 
; 
for (var i = 0; 
i < _AN_Read_length("length", arr); ++i)delayedCallbacks.push(bnd(arr[i])); 
} 
function signalDOMEvent(cm, e, override){ 
signal(cm, override || e.type, cm, e); 
return e_defaultPrevented(e) || e.codemirrorIgnore; 
} 
function fireDelayed(){ 
--delayedCallbackDepth; 
var delayed = delayedCallbacks; 
delayedCallbacks = null ; 
for (var i = 0; 
i < _AN_Read_length("length", delayed); ++i)delayed[i](); 
} 
function hasHandler(emitter, type){ 
var arr = emitter._handlers && emitter._handlers[type]; 
return arr && _AN_Read_length("length", arr) > 0; 
} 
CodeMirror.on = on; 
CodeMirror.off = off; 
CodeMirror.signal = signal; 
function eventMixin(ctor){ 
ctor.prototype.on = function (type, f){ 
on(this, type, f); 
} 
; 
ctor.prototype.off = function (type, f){ 
off(this, type, f); 
} 
; 
} 
var scrollerCutOff = 30; 
var Pass = CodeMirror.Pass = { 
toString: function (){ 
return "CodeMirror.Pass"; 
} 
}
; 
function Delayed(){ 
this.id = null ; 
} 
Delayed.prototype = { 
set: function (ms, f){ 
clearTimeout(this.id); 
this.id = _AN_Call_settimeout("setTimeout", window, f, ms); 
} 
}
; 
function countColumn(string, end, tabSize, startIndex, startValue){ 
if (end == null ) { 
end = string.search(/[^\s\u00a0]/); 
if (end == -1) end = _AN_Read_length("length", string); 
} 
for (var i = startIndex || 0, n = startValue || 0; 
i < end; ++i){ 
if (string.charAt(i) == "\t") n += tabSize - (n % tabSize); 
 else ++n; 
} 
return n; 
} 
CodeMirror.countColumn = countColumn; 
var spaceStrs = [""] ; 
function spaceStr(n){ 
while (_AN_Read_length("length", spaceStrs) <= n)spaceStrs.push(lst(spaceStrs) + " "); 
return spaceStrs[n]; 
} 
function lst(arr){ 
return arr[_AN_Read_length("length", arr) - 1]; 
} 
function selectInput(node){ 
if (ios) { 
node.selectionStart = 0; 
node.selectionEnd = _AN_Read_length("length", node.value); 
} 
 else { 
try { 
node.select(); 
} 
catch (_e) { 
} 
} 
} 
function indexOf(collection, elt){ 
if (collection.indexOf) return collection.indexOf(elt); 
for (var i = 0, e = _AN_Read_length("length", collection); 
i < e; ++i)if (collection[i] == elt) return i; 
return -1; 
} 
function createObj(base, props){ 
function Obj(){ 
} 
Obj.prototype = base; 
var inst = new Obj(); 
if (props) copyObj(props, inst); 
return inst; 
} 
function copyObj(obj, target){ 
if (!target) target = { 
}
; 
for (var prop in obj)if (obj.hasOwnProperty(prop)) target[prop] = obj[prop]; 
return target; 
} 
function emptyArray(size){ 
for (var a = [] , i = 0; 
i < size; ++i)a.push(undefined); 
return a; 
} 
function bind(f){ 
var args = Array.prototype.slice.call(arguments, 1); 
return function (){ 
return f.apply(null , args); 
} 
; 
} 
var nonASCIISingleCaseWordChar = /[\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/; 
function isWordChar(ch){ 
return /\w/.test(ch) || ch > "\x80" && (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch)); 
} 
function isEmpty(obj){ 
for (var n in obj)if (obj.hasOwnProperty(n) && obj[n]) return false ; 
return true ; 
} 
var isExtendingChar = /[\u0300-\u036F\u0483-\u0487\u0488-\u0489\u0591-\u05BD\u05BF\u05C1-\u05C2\u05C4-\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7-\u06E8\u06EA-\u06ED\uA66F\u1DC0-\u1DFF\u20D0-\u20FF\uA670-\uA672\uA674-\uA67D\uA69F\udc00-\udfff\uFE20-\uFE2F]/; 
function elt(tag, content, className, style){ 
var e = _AN_Call_createelement("createElement", document, tag); 
if (className) e.className = className; 
if (style) _AN_Write_csstext("cssText", e.style, false , style); 
if (typeof content == "string") setTextContent(e, content); 
 else if (content) for (var i = 0; 
i < _AN_Read_length("length", content); ++i)_AN_Call_appendchild("appendChild", e, content[i]); 
return e; 
} 
function removeChildren(e){ 
for (var count = _AN_Read_length("length", e.childNodes); 
count > 0; --count)e.removeChild(e.firstChild); 
return e; 
} 
function removeChildrenAndAdd(parent, e){ 
return _AN_Call_appendchild("appendChild", removeChildren(parent), e); 
} 
function setTextContent(e, str){ 
if (ie_lt9) { 
_AN_Write_innerhtml("innerHTML", e, false , ""); 
_AN_Call_appendchild("appendChild", e, document.createTextNode(str)); 
} 
 else e.textContent = str; 
} 
function getRect(node){ 
return node.getBoundingClientRect(); 
} 
CodeMirror.replaceGetRect = function (f){ 
getRect = f; 
} 
; 
var dragAndDrop = function (){ 
if (ie_lt9) return false ; 
var div = elt('div'); 
return "draggable" in div || "dragDrop" in div; 
} 
(); 
function spanAffectsWrapping(){ 
return false ; 
} 
if (gecko) spanAffectsWrapping = function (str, i){ 
return str.charCodeAt(i - 1) == 36 && str.charCodeAt(i) == 39; 
} 
; 
 else if (safari && !/Version\/([6-9]|\d\d)\b/.test(navigator.userAgent)) spanAffectsWrapping = function (str, i){ 
return /\-[^ \-?]|\?[^ !\'\"\),.\-\/:;\?\]\}]/.test(str.slice(i - 1, i + 1)); 
} 
; 
 else if (webkit && /Chrome\/(?:29|[3-9]\d|\d\d\d)\./.test(navigator.userAgent)) spanAffectsWrapping = function (str, i){ 
var code = str.charCodeAt(i - 1); 
return code >= 8208 && code <= 8212; 
} 
; 
 else if (webkit) spanAffectsWrapping = function (str, i){ 
if (i > 1 && str.charCodeAt(i - 1) == 45) { 
if (/\w/.test(str.charAt(i - 2)) && /[^\-?\.]/.test(str.charAt(i))) return true ; 
if (i > 2 && /[\d\.,]/.test(str.charAt(i - 2)) && /[\d\.,]/.test(str.charAt(i))) return false ; 
} 
return /[~!#%&*)=+}\]\\|\"\.>,:;][({[<]|-[^\-?\.\u2010-\u201f\u2026]|\?[\w~`@#$%\^&*(_=+{[|><]|\u2026[\w~`@#$%\^&*(_=+{[><]/.test(str.slice(i - 1, i + 1)); 
} 
; 
var knownScrollbarWidth; 
function scrollbarWidth(measure){ 
if (knownScrollbarWidth != null ) return knownScrollbarWidth; 
var test = elt("div", null , null , "width: 50px; height: 50px; overflow-x: scroll"); 
removeChildrenAndAdd(measure, test); 
if (test.offsetWidth) knownScrollbarWidth = test.offsetHeight - test.clientHeight; 
return knownScrollbarWidth || 0; 
} 
var zwspSupported; 
function zeroWidthElement(measure){ 
if (zwspSupported == null ) { 
var test = elt("span", "\u200b"); 
removeChildrenAndAdd(measure, elt("span", [test, document.createTextNode("x")] )); 
if (measure.firstChild.offsetHeight != 0) zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !ie_lt8; 
} 
if (zwspSupported) return elt("span", "\u200b"); 
 else return elt("span", "\u00a0", null , "display: inline-block; width: 1px; margin-right: -1px"); 
} 
var splitLines = _AN_Read_length("length", "\n\nb".split(/\n/)) != 3? function (string){ 
var pos = 0, result = [] , l = _AN_Read_length("length", string); 
while (pos <= l){ 
var nl = string.indexOf("\n", pos); 
if (nl == -1) nl = _AN_Read_length("length", string); 
var line = string.slice(pos, string.charAt(nl - 1) == "\r"? nl - 1: nl); 
var rt = line.indexOf("\r"); 
if (rt != -1) { 
result.push(line.slice(0, rt)); 
pos += rt + 1; 
} 
 else { 
result.push(line); 
pos = nl + 1; 
} 
} 
return result; 
} 
: function (string){ 
return string.split(/\r\n?|\n/); 
} 
; 
CodeMirror.splitLines = splitLines; 
var hasSelection = window.getSelection? function (te){ 
try { 
return te.selectionStart != te.selectionEnd; 
} 
catch (e) { 
return false ; 
} 
} 
: function (te){ 
try { 
var range = te.ownerDocument.selection.createRange(); 
} 
catch (e) { 
} 
if (!range || range.parentElement() != te) return false ; 
return range.compareEndPoints("StartToEnd", range) != 0; 
} 
; 
var hasCopyEvent = (function (){ 
var e = elt("div"); 
if ("oncopy" in e) return true ; 
_AN_Call_setattribute("setAttribute", e, "oncopy", "return;"); 
return typeof e.oncopy == 'function'; 
} 
)(); 
var keyNames = { 
3: "Enter",
8: "Backspace",
9: "Tab",
13: "Enter",
16: "Shift",
17: "Ctrl",
18: "Alt",
19: "Pause",
20: "CapsLock",
27: "Esc",
32: "Space",
33: "PageUp",
34: "PageDown",
35: "End",
36: "Home",
37: "Left",
38: "Up",
39: "Right",
40: "Down",
44: "PrintScrn",
45: "Insert",
46: "Delete",
59: ";",
91: "Mod",
92: "Mod",
93: "Mod",
109: "-",
107: "=",
127: "Delete",
186: ";",
187: "=",
188: ",",
189: "-",
190: ".",
191: "/",
192: "`",
219: "[",
220: "\\",
221: "]",
222: "'",
63276: "PageUp",
63277: "PageDown",
63275: "End",
63273: "Home",
63234: "Left",
63232: "Up",
63235: "Right",
63233: "Down",
63302: "Insert",
63272: "Delete"}
; 
CodeMirror.keyNames = keyNames; 
(function (){ 
for (var i = 0; 
i < 10; i++ )keyNames[i + 48] = String(i); 
for (var i = 65; 
i <= 90; i++ )keyNames[i] = String.fromCharCode(i); 
for (var i = 1; 
i <= 12; i++ )keyNames[i + 111] = keyNames[i + 63235] = "F" + i; 
} 
)(); 
function iterateBidiSections(order, from, to, f){ 
if (!order) return f(from, to, "ltr"); 
var found = false ; 
for (var i = 0; 
i < _AN_Read_length("length", order); ++i){ 
var part = order[i]; 
if (part.from < to && part.to > from || from == to && part.to == from) { 
f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1? "rtl": "ltr"); 
found = true ; 
} 
} 
if (!found) f(from, to, "ltr"); 
} 
function bidiLeft(part){ 
return part.level % 2? part.to: part.from; 
} 
function bidiRight(part){ 
return part.level % 2? part.from: part.to; 
} 
function lineLeft(line){ 
var order = getOrder(line); 
return order? bidiLeft(order[0]): 0; 
} 
function lineRight(line){ 
var order = getOrder(line); 
if (!order) return _AN_Read_length("length", line.text); 
return bidiRight(lst(order)); 
} 
function lineStart(cm, lineN){ 
var line = getLine(cm.doc, lineN); 
var visual = visualLine(cm.doc, line); 
if (visual != line) lineN = lineNo(visual); 
var order = getOrder(visual); 
var ch = !order? 0: order[0].level % 2? lineRight(visual): lineLeft(visual); 
return Pos(lineN, ch); 
} 
function lineEnd(cm, lineN){ 
var merged, line; 
while (merged = collapsedSpanAtEnd(line = getLine(cm.doc, lineN)))lineN = merged.find().to.line; 
var order = getOrder(line); 
var ch = !order? _AN_Read_length("length", line.text): order[0].level % 2? lineLeft(line): lineRight(line); 
return Pos(lineN, ch); 
} 
function compareBidiLevel(order, a, b){ 
var linedir = order[0].level; 
if (a == linedir) return true ; 
if (b == linedir) return false ; 
return a < b; 
} 
var bidiOther; 
function getBidiPartAt(order, pos){ 
bidiOther = null ; 
for (var i = 0, found; 
i < _AN_Read_length("length", order); ++i){ 
var cur = order[i]; 
if (cur.from < pos && cur.to > pos) return i; 
if ((cur.from == pos || cur.to == pos)) { 
if (found == null ) { 
found = i; 
} 
 else if (compareBidiLevel(order, cur.level, order[found].level)) { 
if (cur.from != cur.to) bidiOther = found; 
return i; 
} 
 else { 
if (cur.from != cur.to) bidiOther = i; 
return found; 
} 
} 
} 
return found; 
} 
function moveInLine(line, pos, dir, byUnit){ 
if (!byUnit) return pos + dir; 
do pos += dir; 
while(pos > 0 && isExtendingChar.test(line.text.charAt(pos)))return pos; 
} 
function moveVisually(line, start, dir, byUnit){ 
var bidi = getOrder(line); 
if (!bidi) return moveLogically(line, start, dir, byUnit); 
var pos = getBidiPartAt(bidi, start), part = bidi[pos]; 
var target = moveInLine(line, start, part.level % 2? - dir: dir, byUnit); 
for (; ; ){ 
if (target > part.from && target < part.to) return target; 
if (target == part.from || target == part.to) { 
if (getBidiPartAt(bidi, target) == pos) return target; 
part = bidi[pos += dir]; 
return (dir > 0) == part.level % 2? part.to: part.from; 
} 
 else { 
part = bidi[pos += dir]; 
if (!part) return null ; 
if ((dir > 0) == part.level % 2) target = moveInLine(line, part.to, -1, byUnit); 
 else target = moveInLine(line, part.from, 1, byUnit); 
} 
} 
} 
function moveLogically(line, start, dir, byUnit){ 
var target = start + dir; 
if (byUnit) while (target > 0 && isExtendingChar.test(line.text.charAt(target)))target += dir; 
return target < 0 || target > _AN_Read_length("length", line.text)? null : target; 
} 
var bidiOrdering = (function (){ 
var lowTypes = "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLL"; 
var arabicTypes = "rrrrrrrrrrrr,rNNmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmrrrrrrrnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmNmmmmrrrrrrrrrrrrrrrrrr"; 
function charType(code){ 
if (code <= 255) return lowTypes.charAt(code); 
 else if (1424 <= code && code <= 1524) return "R"; 
 else if (1536 <= code && code <= 1791) return arabicTypes.charAt(code - 1536); 
 else if (1792 <= code && code <= 2220) return "r"; 
 else return "L"; 
} 
var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/; 
var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/; 
var outerType = "L"; 
return function (str){ 
if (!bidiRE.test(str)) return false ; 
var len = _AN_Read_length("length", str), types = [] ; 
for (var i = 0, type; 
i < len; ++i)types.push(type = charType(str.charCodeAt(i))); 
for (var i = 0, prev = outerType; 
i < len; ++i){ 
var type = types[i]; 
if (type == "m") types[i] = prev; 
 else prev = type; 
} 
for (var i = 0, cur = outerType; 
i < len; ++i){ 
var type = types[i]; 
if (type == "1" && cur == "r") types[i] = "n"; 
 else if (isStrong.test(type)) { 
cur = type; 
if (type == "r") types[i] = "R"; 
} 
} 
for (var i = 1, prev = types[0]; 
i < len - 1; ++i){ 
var type = types[i]; 
if (type == "+" && prev == "1" && types[i + 1] == "1") types[i] = "1"; 
 else if (type == "," && prev == types[i + 1] && (prev == "1" || prev == "n")) types[i] = prev; 
prev = type; 
} 
for (var i = 0; 
i < len; ++i){ 
var type = types[i]; 
if (type == ",") types[i] = "N"; 
 else if (type == "%") { 
for (var end = i + 1; 
end < len && types[end] == "%"; ++end){ 
} 
var replace = (i && types[i - 1] == "!") || (end < len && types[end] == "1")? "1": "N"; 
for (var j = i; 
j < end; ++j)types[j] = replace; 
i = end - 1; 
} 
} 
for (var i = 0, cur = outerType; 
i < len; ++i){ 
var type = types[i]; 
if (cur == "L" && type == "1") types[i] = "L"; 
 else if (isStrong.test(type)) cur = type; 
} 
for (var i = 0; 
i < len; ++i){ 
if (isNeutral.test(types[i])) { 
for (var end = i + 1; 
end < len && isNeutral.test(types[end]); ++end){ 
} 
var before = (i? types[i - 1]: outerType) == "L"; 
var after = (end < len? types[end]: outerType) == "L"; 
var replace = before || after? "L": "R"; 
for (var j = i; 
j < end; ++j)types[j] = replace; 
i = end - 1; 
} 
} 
var order = [] , m; 
for (var i = 0; 
i < len; ){ 
if (countsAsLeft.test(types[i])) { 
var start = i; 
for (++i; i < len && countsAsLeft.test(types[i]); ++i){ 
} 
order.push({ 
from: start,
to: i,
level: 0}
); 
} 
 else { 
var pos = i, at = _AN_Read_length("length", order); 
for (++i; i < len && types[i] != "L"; ++i){ 
} 
for (var j = pos; 
j < i; ){ 
if (countsAsNum.test(types[j])) { 
if (pos < j) order.splice(at, 0, { 
from: pos,
to: j,
level: 1}
); 
var nstart = j; 
for (++j; j < i && countsAsNum.test(types[j]); ++j){ 
} 
order.splice(at, 0, { 
from: nstart,
to: j,
level: 2}
); 
pos = j; 
} 
 else ++j; 
} 
if (pos < i) order.splice(at, 0, { 
from: pos,
to: i,
level: 1}
); 
} 
} 
if (order[0].level == 1 && (m = str.match(/^\s+/))) { 
order[0].from = _AN_Read_length("length", m[0]); 
order.unshift({ 
from: 0,
to: _AN_Read_length("length", m[0]),
level: 0}
); 
} 
if (lst(order).level == 1 && (m = str.match(/\s+$/))) { 
lst(order).to -= _AN_Read_length("length", m[0]); 
order.push({ 
from: len - _AN_Read_length("length", m[0]),
to: len,
level: 0}
); 
} 
if (order[0].level != lst(order).level) order.push({ 
from: len,
to: len,
level: order[0].level}
); 
return order; 
} 
; 
} 
)(); 
CodeMirror.version = "3.20.1"; 
return CodeMirror; 
} 
)();