     guard let token = parseTagOrText() else { return nil }
     
     switch token {
-      case .Text        (let s): return .text(s)
-      case .Tag         (let s): return .tag(s)
-      case .UnescapedTag(let s): return .unescapedTag(s)
-      case .Partial     (let s): return .partial(s)
-      
-      case .SectionStart(let s):
+      case .text        (let s): return .text(s)
+      case .tag         (let s): return .tag(s)
+      case .unescapedTag(let s): return .unescapedTag(s)
+      case .partial     (let s): return .partial(s)
+      
+      case .sectionStart(let s):
         guard let children = parseNodes(section: s) else { return .empty }
         return .section(s, children)
       
-      case .InvertedSectionStart(let s):
+      case .invertedSectionStart(let s):
         guard let children = parseNodes(section: s) else { return .empty }
         return .invertedSection(s, children)
       
-      case .SectionEnd(let s):
+      case .sectionEnd(let s):
         if !s.isEmpty && s != se {
           print("section tags not balanced: \(s) expected \(se as Optional)")
         }

      return parseTag()
    }
    else {
      return .Text(parseText())
    }
  }
  
  mutating private func parseTag() -> MustacheToken {
    guard p != nil else { return .Text("") }
    guard p!.pointee == cStart && la1 == cStart else { return .Text("") }
    
    let isUnescaped = la2 == cStart
    

        if isUnescaped {
          p = p! + 3 // skip }}}
          let s = String.fromCString(marker, length: len)!
          return .unescapedTag(s)
        }
        
        p = p! + 2 // skip }}
