diff --git a/nfa.go b/nfa.go
index ff6fdc6..a7ef67b 100644
--- a/nfa.go
+++ b/nfa.go
@@ -21,18 +21,22 @@ const (
 )
 
 type State struct {
-	content         stateContents    // Contents of current state
-	isEmpty         bool             // If it is empty - Union operator and Kleene star states will be empty
-	isLast          bool             // If it is the last state (acept state)
-	output          []*State         // The outputs of the current state ie. the 'outward arrows'. A union operator state will have more than one of these.
-	transitions     map[int][]*State // Transitions to different states (maps a character (int representation) to a _list of states. This is useful if one character can lead multiple states eg. ab|aa)
-	isKleene        bool             // Identifies whether current node is a 0-state representing Kleene star
-	assert          assertType       // Type of assertion of current node - NONE means that the node doesn't assert anything
-	zeroMatchFound  bool             // Whether or not the state has been used for a zero-length match - only relevant for zero states
-	allChars        bool             // Whether or not the state represents all characters (eg. a 'dot' metacharacter). A 'dot' node doesn't store any contents directly, as it would take up too much space
-	except          []rune           // Only valid if allChars is true - match all characters _except_ the ones in this block. Useful for inverting character classes.
-	lookaroundRegex string           // Only for lookaround states - Contents of the regex that the lookaround state holds
-	lookaroundNFA   *State           // Holds the NFA of the lookaroundRegex - if it exists
+	content                    stateContents    // Contents of current state
+	isEmpty                    bool             // If it is empty - Union operator and Kleene star states will be empty
+	isLast                     bool             // If it is the last state (acept state)
+	output                     []*State         // The outputs of the current state ie. the 'outward arrows'. A union operator state will have more than one of these.
+	transitions                map[int][]*State // Transitions to different states (maps a character (int representation) to a _list of states. This is useful if one character can lead multiple states eg. ab|aa)
+	isKleene                   bool             // Identifies whether current node is a 0-state representing Kleene star
+	assert                     assertType       // Type of assertion of current node - NONE means that the node doesn't assert anything
+	zeroMatchFound             bool             // Whether or not the state has been used for a zero-length match - only relevant for zero states
+	allChars                   bool             // Whether or not the state represents all characters (eg. a 'dot' metacharacter). A 'dot' node doesn't store any contents directly, as it would take up too much space
+	except                     []rune           // Only valid if allChars is true - match all characters _except_ the ones in this block. Useful for inverting character classes.
+	lookaroundRegex            string           // Only for lookaround states - Contents of the regex that the lookaround state holds
+	lookaroundNFA              *State           // Holds the NFA of the lookaroundRegex - if it exists
+	lookaroundNumCaptureGroups int              // Number of capturing groups if current node is a lookaround
+	groupBegin                 bool             // Whether or not the node starts a capturing group
+	groupEnd                   bool             // Whether or not the node ends a capturing group
+	groupNum                   int              // Which capturing group the node starts / ends
 }
 
 // Clones the NFA starting from the given state.
@@ -65,6 +69,9 @@ func cloneStateHelper(state *State, cloneMap map[*State]*State) *State {
 		allChars:        state.allChars,
 		except:          append([]rune{}, state.except...),
 		lookaroundRegex: state.lookaroundRegex,
+		groupEnd:        state.groupEnd,
+		groupBegin:      state.groupBegin,
+		groupNum:        state.groupNum,
 	}
 	cloneMap[state] = clone
 	for i, s := range state.output {
@@ -113,17 +120,17 @@ func (s State) checkAssertion(str []rune, idx int) bool {
 		// 		2. Run it on the test string.
 		// 		3. Based on the kind of lookaround (and the indices we get), determine what action to take.
 		startState := s.lookaroundNFA
-		matchIndices := findAllMatches(startState, str)
+		matchIndices := findAllMatches(startState, str, startState.lookaroundNumCaptureGroups)
 
 		numMatchesFound := 0
 		for _, matchIdx := range matchIndices {
 			if s.assert == PLA || s.assert == NLA { // Lookahead - return true (or false) if at least one match starts at the current index
-				if matchIdx.startIdx == idx {
+				if matchIdx[0].startIdx == idx {
 					numMatchesFound++
 				}
 			}
 			if s.assert == PLB || s.assert == NLB { // Lookbehind - return true (or false) if at least one match _ends_ at the current index.
-				if matchIdx.endIdx == idx {
+				if matchIdx[0].endIdx == idx {
 					numMatchesFound++
 				}
 			}