# regexp
..\..\..\..\regexp\onepass.go:170:7: <S> capturing by ref: ok (addr=true assign=true width=1)
..\..\..\..\regexp\onepass.go:171:4: <S> capturing by ref: merged (addr=true assign=true width=24)
..\..\..\..\regexp\onepass.go:172:4: <S> capturing by ref: next (addr=true assign=true width=24)
..\..\..\..\regexp\onepass.go:178:6: <S> capturing by ref: ix (addr=true assign=true width=8)
..\..\..\..\regexp\onepass.go:178:40: <S> capturing by ref: merged (addr=true assign=true width=24)
..\..\..\..\regexp\onepass.go:184:17: <S> capturing by ref: next (addr=true assign=true width=24)
..\..\..\..\regexp\onepass.go:316:12: <S> capturing by ref: p (addr=true assign=true width=8)
..\..\..\..\regexp\onepass.go:317:6: <S> capturing by value: visitQueue (addr=false assign=false width=8)
..\..\..\..\regexp\onepass.go:323:9: <S> capturing by ref: check (addr=true assign=true width=8)
..\..\..\..\regexp\onepass.go:343:6: <S> capturing by value: onePassRunes (addr=false assign=false width=24)
..\..\..\..\regexp\onepass.go:372:4: <S> capturing by value: instQueue (addr=false assign=false width=8)
..\..\..\..\regexp\regexp.go:485:10: <S> capturing by value: re (addr=false assign=false width=8)
..\..\..\..\regexp\regexp.go:485:25: <S> capturing by value: repl (addr=false assign=false width=16)
..\..\..\..\regexp\regexp.go:485:36: <S> capturing by value: src (addr=false assign=false width=16)
..\..\..\..\regexp\regexp.go:495:22: <S> capturing by value: repl (addr=false assign=false width=16)
..\..\..\..\regexp\regexp.go:505:22: <S> capturing by value: repl (addr=false assign=false width=8)
..\..\..\..\regexp\regexp.go:505:27: <S> capturing by value: src (addr=false assign=false width=16)
..\..\..\..\regexp\regexp.go:585:10: <S> capturing by ref: srepl (addr=true assign=true width=16)
..\..\..\..\regexp\regexp.go:585:24: <S> capturing by value: repl (addr=false assign=false width=24)
..\..\..\..\regexp\regexp.go:588:10: <S> capturing by value: re (addr=false assign=false width=8)
..\..\..\..\regexp\regexp.go:588:32: <S> capturing by value: src (addr=false assign=false width=24)
..\..\..\..\regexp\regexp.go:598:22: <S> capturing by value: repl (addr=false assign=false width=24)
..\..\..\..\regexp\regexp.go:608:22: <S> capturing by value: repl (addr=false assign=false width=8)
..\..\..\..\regexp\regexp.go:608:27: <S> capturing by value: src (addr=false assign=false width=24)
..\..\..\..\regexp\regexp.go:989:19: <S> capturing by ref: result (addr=true assign=true width=24)
..\..\..\..\regexp\regexp.go:989:27: <S> capturing by value: b (addr=false assign=false width=24)
..\..\..\..\regexp\regexp.go:1007:19: <S> capturing by ref: result (addr=true assign=true width=24)
..\..\..\..\regexp\regexp.go:1025:19: <S> capturing by ref: result (addr=true assign=true width=24)
..\..\..\..\regexp\regexp.go:1025:27: <S> capturing by value: s (addr=false assign=false width=16)
..\..\..\..\regexp\regexp.go:1043:19: <S> capturing by ref: result (addr=true assign=true width=24)
..\..\..\..\regexp\regexp.go:1064:16: <S> capturing by value: b (addr=false assign=false width=24)
..\..\..\..\regexp\regexp.go:1067:19: <S> capturing by ref: result (addr=true assign=true width=24)
..\..\..\..\regexp\regexp.go:1085:19: <S> capturing by ref: result (addr=true assign=true width=24)
..\..\..\..\regexp\regexp.go:1106:16: <S> capturing by value: s (addr=false assign=false width=16)
..\..\..\..\regexp\regexp.go:1109:19: <S> capturing by ref: result (addr=true assign=true width=24)
..\..\..\..\regexp\regexp.go:1128:19: <S> capturing by ref: result (addr=true assign=true width=24)
..\..\..\..\regexp\backtrack.go:68:6: can inline shouldBacktrack as: func(*syntax.Prog) bool { return len(prog.Inst) <= maxBacktrackProg }
..\..\..\..\regexp\backtrack.go:47:6: can inline maxBitStateLen as: func(*syntax.Prog) int { if !shouldBacktrack(prog) { return 0 }; return maxBacktrackVector / len(prog.Inst) }
..\..\..\..\regexp\backtrack.go:48:21: inlining call to shouldBacktrack func(*syntax.Prog) bool { return len(prog.Inst) <= maxBacktrackProg }
..\..\..\..\regexp\backtrack.go:57:6: can inline newBitState as: func(*syntax.Prog) *bitState { if !shouldBacktrack(prog) { return notBacktrack }; return &bitState literal }
..\..\..\..\regexp\backtrack.go:58:21: inlining call to shouldBacktrack func(*syntax.Prog) bool { return len(prog.Inst) <= maxBacktrackProg }
..\..\..\..\regexp\backtrack.go:75:6: cannot inline (*bitState).reset: unhandled op RANGE
..\..\..\..\regexp\backtrack.go:106:6: can inline (*bitState).shouldVisit as: method(*bitState) func(uint32, int) bool { n := uint(int(pc) * (b.end + 1) + pos); if b.visited[n / visitedBits] & (1 << (n & (visitedBits - 1))) != 0 { return false }; b.visited[n / visitedBits] |= 1 << (n & (visitedBits - 1)); return true }
..\..\..\..\regexp\backtrack.go:117:6: can inline (*bitState).push as: method(*bitState) func(uint32, int, bool) { if b.prog.Inst[pc].Op != syntax.InstFail && (arg || b.shouldVisit(pc, pos)) { b.jobs = append(b.jobs, job literal) } }
..\..\..\..\regexp\backtrack.go:120:67: inlining call to (*bitState).shouldVisit method(*bitState) func(uint32, int) bool { n := uint(int(pc) * (b.end + 1) + pos); if b.visited[n / visitedBits] & (1 << (n & (visitedBits - 1))) != 0 { return false }; b.visited[n / visitedBits] |= 1 << (n & (visitedBits - 1)); return true }
..\..\..\..\regexp\backtrack.go:126:6: cannot inline (*machine).tryBacktrack: unhandled op FOR
..\..\..\..\regexp\backtrack.go:130:8: inlining call to (*bitState).push method(*bitState) func(uint32, int, bool) { if b.prog.Inst[pc].Op != syntax.InstFail && (arg || b.shouldVisit(pc, pos)) { b.jobs = append(b.jobs, job literal) } }
..\..\..\..\regexp\backtrack.go:130:8: inlining call to (*bitState).shouldVisit method(*bitState) func(uint32, int) bool { n := uint(int(pc) * (b.end + 1) + pos); if b.visited[n / visitedBits] & (1 << (n & (visitedBits - 1))) != 0 { return false }; b.visited[n / visitedBits] |= 1 << (n & (visitedBits - 1)); return true }
..\..\..\..\regexp\backtrack.go:148:20: inlining call to (*bitState).shouldVisit method(*bitState) func(uint32, int) bool { n := uint(int(pc) * (b.end + 1) + pos); if b.visited[n / visitedBits] & (1 << (n & (visitedBits - 1))) != 0 { return false }; b.visited[n / visitedBits] |= 1 << (n & (visitedBits - 1)); return true }
..\..\..\..\regexp\backtrack.go:175:11: inlining call to (*bitState).push method(*bitState) func(uint32, int, bool) { if b.prog.Inst[pc].Op != syntax.InstFail && (arg || b.shouldVisit(pc, pos)) { b.jobs = append(b.jobs, job literal) } }
..\..\..\..\regexp\backtrack.go:175:11: inlining call to (*bitState).shouldVisit method(*bitState) func(uint32, int) bool { n := uint(int(pc) * (b.end + 1) + pos); if b.visited[n / visitedBits] & (1 << (n & (visitedBits - 1))) != 0 { return false }; b.visited[n / visitedBits] |= 1 << (n & (visitedBits - 1)); return true }
..\..\..\..\regexp\backtrack.go:185:11: inlining call to (*bitState).push method(*bitState) func(uint32, int, bool) { if b.prog.Inst[pc].Op != syntax.InstFail && (arg || b.shouldVisit(pc, pos)) { b.jobs = append(b.jobs, job literal) } }
..\..\..\..\regexp\backtrack.go:185:11: inlining call to (*bitState).shouldVisit method(*bitState) func(uint32, int) bool { n := uint(int(pc) * (b.end + 1) + pos); if b.visited[n / visitedBits] & (1 << (n & (visitedBits - 1))) != 0 { return false }; b.visited[n / visitedBits] |= 1 << (n & (visitedBits - 1)); return true }
..\..\..\..\regexp\backtrack.go:191:10: inlining call to (*bitState).push method(*bitState) func(uint32, int, bool) { if b.prog.Inst[pc].Op != syntax.InstFail && (arg || b.shouldVisit(pc, pos)) { b.jobs = append(b.jobs, job literal) } }
..\..\..\..\regexp\backtrack.go:191:10: inlining call to (*bitState).shouldVisit method(*bitState) func(uint32, int) bool { n := uint(int(pc) * (b.end + 1) + pos); if b.visited[n / visitedBits] & (1 << (n & (visitedBits - 1))) != 0 { return false }; b.visited[n / visitedBits] |= 1 << (n & (visitedBits - 1)); return true }
..\..\..\..\regexp\backtrack.go:239:12: inlining call to (*bitState).push method(*bitState) func(uint32, int, bool) { if b.prog.Inst[pc].Op != syntax.InstFail && (arg || b.shouldVisit(pc, pos)) { b.jobs = append(b.jobs, job literal) } }
..\..\..\..\regexp\backtrack.go:239:12: inlining call to (*bitState).shouldVisit method(*bitState) func(uint32, int) bool { n := uint(int(pc) * (b.end + 1) + pos); if b.visited[n / visitedBits] & (1 << (n & (visitedBits - 1))) != 0 { return false }; b.visited[n / visitedBits] |= 1 << (n & (visitedBits - 1)); return true }
..\..\..\..\regexp\backtrack.go:295:6: cannot inline (*machine).backtrack: non-leaf op CALLINTER
..\..\..\..\regexp\exec.go:54:6: can inline (*machine).newInputBytes as: method(*machine) func([]byte) input { m.inputBytes.str = b; return &m.inputBytes }
..\..\..\..\regexp\exec.go:59:6: can inline (*machine).newInputString as: method(*machine) func(string) input { m.inputString.str = s; return &m.inputString }
..\..\..\..\regexp\exec.go:64:6: can inline (*machine).newInputReader as: method(*machine) func(io.RuneReader) input { m.inputReader.r = r; m.inputReader.atEOT = false; m.inputReader.pos = 0; return &m.inputReader }
..\..\..\..\regexp\exec.go:72:6: cannot inline progMachine: function too complex: cost 98 exceeds budget 80
..\..\..\..\regexp\exec.go:82:36: inlining call to maxBitStateLen func(*syntax.Prog) int { if !shouldBacktrack(prog) { return 0 }; return maxBacktrackVector / len(prog.Inst) }
..\..\..\..\regexp\exec.go:82:36: inlining call to shouldBacktrack func(*syntax.Prog) bool { return len(prog.Inst) <= maxBacktrackProg }
..\..\..\..\regexp\exec.go:88:6: cannot inline (*machine).init: unhandled op RANGE
..\..\..\..\regexp\exec.go:97:6: can inline (*machine).alloc as: method(*machine) func(*syntax.Inst) *thread { var t *thread; t = <N>; if n > 0 { t = m.pool[n - 1]; m.pool = m.pool[:n - 1] } else { t = new(thread); t.cap = make([]int, len(m.matchcap), cap(m.matchcap)) }; t.inst = i; return t }
..\..\..\..\regexp\exec.go:255:6: cannot inline (*machine).add: recursive
..\..\..\..\regexp\exec.go:296:15: inlining call to (*machine).alloc method(*machine) func(*syntax.Inst) *thread { var t *thread; t = <N>; if n > 0 { t = m.pool[n - 1]; m.pool = m.pool[:n - 1] } else { t = new(thread); t.cap = make([]int, len(m.matchcap), cap(m.matchcap)) }; t.inst = i; return t }
..\..\..\..\regexp\exec.go:198:6: cannot inline (*machine).step: unhandled op FOR
..\..\..\..\regexp\exec.go:184:6: cannot inline (*machine).clear: unhandled op RANGE
..\..\..\..\regexp\exec.go:113:6: cannot inline (*machine).match: unhandled op RANGE
..\..\..\..\regexp\onepass.go:74:6: cannot inline onePassNext: non-leaf method
..\..\..\..\regexp\exec.go:313:6: cannot inline (*machine).onepass: unhandled op RANGE
..\..\..\..\regexp\regexp.go:210:6: cannot inline (*Regexp).get: non-leaf method
..\..\..\..\regexp\regexp.go:228:6: cannot inline (*Regexp).put: non-leaf method
..\..\..\..\regexp\exec.go:418:6: cannot inline (*Regexp).doExecute: non-leaf method
..\..\..\..\regexp\exec.go:428:23: inlining call to (*machine).newInputString method(*machine) func(string) input { m.inputString.str = s; return &m.inputString }
..\..\..\..\regexp\exec.go:425:22: inlining call to (*machine).newInputBytes method(*machine) func([]byte) input { m.inputBytes.str = b; return &m.inputBytes }
..\..\..\..\regexp\exec.go:423:23: inlining call to (*machine).newInputReader method(*machine) func(io.RuneReader) input { m.inputReader.r = r; m.inputReader.atEOT = false; m.inputReader.pos = 0; return &m.inputReader }
..\..\..\..\regexp\exec.go:438:21: inlining call to newBitState func(*syntax.Prog) *bitState { if !shouldBacktrack(prog) { return notBacktrack }; return &bitState literal }
..\..\..\..\regexp\exec.go:438:21: inlining call to shouldBacktrack func(*syntax.Prog) bool { return len(prog.Inst) <= maxBacktrackProg }
..\..\..\..\regexp\exec.go:410:6: cannot inline (*Regexp).doMatch: non-leaf method
..\..\..\..\regexp\onepass.go:85:6: can inline iop as: func(*syntax.Inst) syntax.InstOp { op := i.Op; switch statement; return op }
..\..\..\..\regexp\onepass.go:40:6: cannot inline onePassPrefix: unhandled op FOR
..\..\..\..\regexp\onepass.go:52:8: inlining call to iop func(*syntax.Inst) syntax.InstOp { op := i.Op; switch statement; return op }
..\..\..\..\regexp\onepass.go:58:9: inlining call to iop func(*syntax.Inst) syntax.InstOp { op := i.Op; switch statement; return op }
..\..\..\..\regexp\onepass.go:67:19: inlining call to bytes.(*Buffer).String method(*bytes.Buffer) func() string { if bytes.b·2 == nil { return string("<nil>") }; return string(bytes.b·2.buf[bytes.b·2.off:]) }
..\..\..\..\regexp\onepass.go:101:6: can inline (*queueOnePass).empty as: method(*queueOnePass) func() bool { return q.nextIndex >= q.size }
..\..\..\..\regexp\onepass.go:105:6: can inline (*queueOnePass).next as: method(*queueOnePass) func() uint32 { n = q.dense[q.nextIndex]; q.nextIndex++; return  }
..\..\..\..\regexp\onepass.go:111:6: can inline (*queueOnePass).clear as: method(*queueOnePass) func() { q.size = 0; q.nextIndex = 0 }
..\..\..\..\regexp\onepass.go:116:6: can inline (*queueOnePass).contains as: method(*queueOnePass) func(uint32) bool { if u >= uint32(len(q.sparse)) { return false }; return q.sparse[u] < q.size && q.dense[q.sparse[u]] == u }
..\..\..\..\regexp\onepass.go:129:6: can inline (*queueOnePass).insertNew as: method(*queueOnePass) func(uint32) { if u >= uint32(len(q.sparse)) { return  }; q.sparse[u] = q.size; q.dense[q.size] = u; q.size++ }
..\..\..\..\regexp\onepass.go:123:6: can inline (*queueOnePass).insert as: method(*queueOnePass) func(uint32) { if !q.contains(u) { q.insertNew(u) } }
..\..\..\..\regexp\onepass.go:124:16: inlining call to (*queueOnePass).contains method(*queueOnePass) func(uint32) bool { if u >= uint32(len(q.sparse)) { return false }; return q.sparse[u] < q.size && q.dense[q.sparse[u]] == u }
..\..\..\..\regexp\onepass.go:125:14: inlining call to (*queueOnePass).insertNew method(*queueOnePass) func(uint32) { if u >= uint32(len(q.sparse)) { return  }; q.sparse[u] = q.size; q.dense[q.size] = u; q.size++ }
..\..\..\..\regexp\onepass.go:138:6: can inline newQueue as: func(int) *queueOnePass { return &queueOnePass literal }
..\..\..\..\regexp\onepass.go:157:6: cannot inline mergeRuneSets: non-leaf op PANIC
..\..\..\..\regexp\onepass.go:177:12: can inline mergeRuneSets.func2 as: func(*int, *[]rune, uint32) bool { if ix > 0 && (*newArray)[*newLow] <= merged[ix] { return false }; merged = append(merged, (*newArray)[*newLow], (*newArray)[*newLow + 1]); *newLow += 2; ix += 2; next = append(next, pc); return true }
..\..\..\..\regexp\onepass.go:191:15: inlining call to mergeRuneSets.func2 func(*int, *[]rune, uint32) bool { if ix > 0 && (*newArray)[*newLow] <= merged[ix] { return false }; merged = append(merged, (*newArray)[*newLow], (*newArray)[*newLow + 1]); *newLow += 2; ix += 2; next = append(next, pc); return true }
..\..\..\..\regexp\onepass.go:193:15: inlining call to mergeRuneSets.func2 func(*int, *[]rune, uint32) bool { if ix > 0 && (*newArray)[*newLow] <= merged[ix] { return false }; merged = append(merged, (*newArray)[*newLow], (*newArray)[*newLow + 1]); *newLow += 2; ix += 2; next = append(next, pc); return true }
..\..\..\..\regexp\onepass.go:195:15: inlining call to mergeRuneSets.func2 func(*int, *[]rune, uint32) bool { if ix > 0 && (*newArray)[*newLow] <= merged[ix] { return false }; merged = append(merged, (*newArray)[*newLow], (*newArray)[*newLow + 1]); *newLow += 2; ix += 2; next = append(next, pc); return true }
..\..\..\..\regexp\onepass.go:197:15: inlining call to mergeRuneSets.func2 func(*int, *[]rune, uint32) bool { if ix > 0 && (*newArray)[*newLow] <= merged[ix] { return false }; merged = append(merged, (*newArray)[*newLow], (*newArray)[*newLow + 1]); *newLow += 2; ix += 2; next = append(next, pc); return true }
..\..\..\..\regexp\onepass.go:169:8: can inline mergeRuneSets.func1 as: func() { if !ok { merged = nil; next = nil } }
..\..\..\..\regexp\onepass.go:207:6: cannot inline cleanupOnePass: unhandled op RANGE
..\..\..\..\regexp\onepass.go:221:6: cannot inline onePassCopy: unhandled op RANGE
..\..\..\..\regexp\onepass.go:287:6: can inline runeSlice.Len as: method(runeSlice) func() int { return len(p) }
..\..\..\..\regexp\onepass.go:288:6: can inline runeSlice.Less as: method(runeSlice) func(int, int) bool { return p[i] < p[j] }
..\..\..\..\regexp\onepass.go:289:6: can inline runeSlice.Swap as: method(runeSlice) func(int, int) { p[i], p[j] = p[j], p[i] }
..\..\..\..\regexp\onepass.go:299:6: cannot inline makeOnePass: unhandled op CLOSURE
..\..\..\..\regexp\onepass.go:306:26: inlining call to newQueue func(int) *queueOnePass { return &queueOnePass literal }
..\..\..\..\regexp\onepass.go:307:26: inlining call to newQueue func(int) *queueOnePass { return &queueOnePass literal }
..\..\..\..\regexp\onepass.go:442:17: inlining call to (*queueOnePass).clear method(*queueOnePass) func() { q.size = 0; q.nextIndex = 0 }
..\..\..\..\regexp\onepass.go:443:18: inlining call to (*queueOnePass).insert method(*queueOnePass) func(uint32) { if !q.contains(u) { q.insertNew(u) } }
..\..\..\..\regexp\onepass.go:443:18: inlining call to (*queueOnePass).contains method(*queueOnePass) func(uint32) bool { if u >= uint32(len(q.sparse)) { return false }; return q.sparse[u] < q.size && q.dense[q.sparse[u]] == u }
..\..\..\..\regexp\onepass.go:443:18: inlining call to (*queueOnePass).insertNew method(*queueOnePass) func(uint32) { if u >= uint32(len(q.sparse)) { return  }; q.sparse[u] = q.size; q.dense[q.size] = u; q.size++ }
..\..\..\..\regexp\onepass.go:445:22: inlining call to (*queueOnePass).empty method(*queueOnePass) func() bool { return q.nextIndex >= q.size }
..\..\..\..\regexp\onepass.go:446:19: inlining call to (*queueOnePass).clear method(*queueOnePass) func() { q.size = 0; q.nextIndex = 0 }
..\..\..\..\regexp\onepass.go:447:23: inlining call to (*queueOnePass).next method(*queueOnePass) func() uint32 { n = q.dense[q.nextIndex]; q.nextIndex++; return  }
..\..\..\..\regexp\onepass.go:314:10: cannot inline makeOnePass.func1: non-leaf function
..\..\..\..\regexp\onepass.go:317:25: inlining call to (*queueOnePass).contains method(*queueOnePass) func(uint32) bool { if u >= uint32(len(q.sparse)) { return false }; return q.sparse[u] < q.size && q.dense[q.sparse[u]] == u }
..\..\..\..\regexp\onepass.go:320:20: inlining call to (*queueOnePass).insert method(*queueOnePass) func(uint32) { if !q.contains(u) { q.insertNew(u) } }
..\..\..\..\regexp\onepass.go:320:20: inlining call to (*queueOnePass).contains method(*queueOnePass) func(uint32) bool { if u >= uint32(len(q.sparse)) { return false }; return q.sparse[u] < q.size && q.dense[q.sparse[u]] == u }
..\..\..\..\regexp\onepass.go:320:20: inlining call to (*queueOnePass).insertNew method(*queueOnePass) func(uint32) { if u >= uint32(len(q.sparse)) { return  }; q.sparse[u] = q.size; q.dense[q.size] = u; q.size++ }
..\..\..\..\regexp\onepass.go:372:20: inlining call to (*queueOnePass).insert method(*queueOnePass) func(uint32) { if !q.contains(u) { q.insertNew(u) } }
..\..\..\..\regexp\onepass.go:372:20: inlining call to (*queueOnePass).contains method(*queueOnePass) func(uint32) bool { if u >= uint32(len(q.sparse)) { return false }; return q.sparse[u] < q.size && q.dense[q.sparse[u]] == u }
..\..\..\..\regexp\onepass.go:372:20: inlining call to (*queueOnePass).insertNew method(*queueOnePass) func(uint32) { if u >= uint32(len(q.sparse)) { return  }; q.sparse[u] = q.size; q.dense[q.size] = u; q.size++ }
..\..\..\..\regexp\onepass.go:400:20: inlining call to (*queueOnePass).insert method(*queueOnePass) func(uint32) { if !q.contains(u) { q.insertNew(u) } }
..\..\..\..\regexp\onepass.go:400:20: inlining call to (*queueOnePass).contains method(*queueOnePass) func(uint32) bool { if u >= uint32(len(q.sparse)) { return false }; return q.sparse[u] < q.size && q.dense[q.sparse[u]] == u }
..\..\..\..\regexp\onepass.go:400:20: inlining call to (*queueOnePass).insertNew method(*queueOnePass) func(uint32) { if u >= uint32(len(q.sparse)) { return  }; q.sparse[u] = q.size; q.dense[q.size] = u; q.size++ }
..\..\..\..\regexp\onepass.go:424:20: inlining call to (*queueOnePass).insert method(*queueOnePass) func(uint32) { if !q.contains(u) { q.insertNew(u) } }
..\..\..\..\regexp\onepass.go:424:20: inlining call to (*queueOnePass).contains method(*queueOnePass) func(uint32) bool { if u >= uint32(len(q.sparse)) { return false }; return q.sparse[u] < q.size && q.dense[q.sparse[u]] == u }
..\..\..\..\regexp\onepass.go:424:20: inlining call to (*queueOnePass).insertNew method(*queueOnePass) func(uint32) { if u >= uint32(len(q.sparse)) { return  }; q.sparse[u] = q.size; q.dense[q.size] = u; q.size++ }
..\..\..\..\regexp\onepass.go:432:20: inlining call to (*queueOnePass).insert method(*queueOnePass) func(uint32) { if !q.contains(u) { q.insertNew(u) } }
..\..\..\..\regexp\onepass.go:432:20: inlining call to (*queueOnePass).contains method(*queueOnePass) func(uint32) bool { if u >= uint32(len(q.sparse)) { return false }; return q.sparse[u] < q.size && q.dense[q.sparse[u]] == u }
..\..\..\..\regexp\onepass.go:432:20: inlining call to (*queueOnePass).insertNew method(*queueOnePass) func(uint32) { if u >= uint32(len(q.sparse)) { return  }; q.sparse[u] = q.size; q.dense[q.size] = u; q.size++ }
..\..\..\..\regexp\onepass.go:467:6: cannot inline compileOnePass: unhandled op RANGE
..\..\..\..\regexp\regexp.go:106:6: can inline (*Regexp).String as: method(*Regexp) func() string { return re.regexpRO.expr }
..\..\..\..\regexp\regexp.go:114:6: can inline (*Regexp).Copy as: method(*Regexp) func() *Regexp { return &Regexp literal }
..\..\..\..\regexp\regexp.go:169:6: cannot inline compile: non-leaf function
..\..\..\..\regexp\regexp.go:132:6: cannot inline Compile: non-leaf function
..\..\..\..\regexp\regexp.go:155:6: cannot inline CompilePOSIX: non-leaf function
..\..\..\..\regexp\regexp.go:165:6: can inline (*Regexp).Longest as: method(*Regexp) func() { re.regexpRO.longest = true }
..\..\..\..\regexp\regexp.go:256:6: cannot inline quote: non-leaf function
..\..\..\..\regexp\regexp.go:237:6: cannot inline MustCompile: non-leaf function
..\..\..\..\regexp\regexp.go:248:6: cannot inline MustCompilePOSIX: non-leaf function
..\..\..\..\regexp\regexp.go:264:6: can inline (*Regexp).NumSubexp as: method(*Regexp) func() int { return re.regexpRO.numSubexp }
..\..\..\..\regexp\regexp.go:273:6: can inline (*Regexp).SubexpNames as: method(*Regexp) func() []string { return re.regexpRO.subexpNames }
..\..\..\..\regexp\regexp.go:294:6: cannot inline (*inputString).step: non-leaf function
..\..\..\..\regexp\regexp.go:305:6: can inline (*inputString).canCheckPrefix as: method(*inputString) func() bool { return true }
..\..\..\..\regexp\regexp.go:309:6: can inline (*inputString).hasPrefix as: method(*inputString) func(*Regexp) bool { return strings.HasPrefix(i.str, re.regexpRO.prefix) }
..\..\..\..\regexp\regexp.go:310:26: inlining call to strings.HasPrefix func(string, string) bool { return len(strings.s·2) >= len(strings.prefix·3) && strings.s·2[int(0):len(strings.prefix·3)] == strings.prefix·3 }
..\..\..\..\regexp\regexp.go:313:6: cannot inline (*inputString).index: non-leaf function
..\..\..\..\regexp\regexp.go:317:6: cannot inline (*inputString).context: non-leaf function
..\..\..\..\regexp\regexp.go:341:6: cannot inline (*inputBytes).step: non-leaf function
..\..\..\..\regexp\regexp.go:352:6: can inline (*inputBytes).canCheckPrefix as: method(*inputBytes) func() bool { return true }
..\..\..\..\regexp\regexp.go:356:6: cannot inline (*inputBytes).hasPrefix: non-leaf function
..\..\..\..\regexp\regexp.go:360:6: cannot inline (*inputBytes).index: non-leaf function
..\..\..\..\regexp\regexp.go:364:6: cannot inline (*inputBytes).context: non-leaf function
..\..\..\..\regexp\regexp.go:390:6: cannot inline (*inputReader).step: non-leaf op CALLINTER
..\..\..\..\regexp\regexp.go:404:6: can inline (*inputReader).canCheckPrefix as: method(*inputReader) func() bool { return false }
..\..\..\..\regexp\regexp.go:408:6: can inline (*inputReader).hasPrefix as: method(*inputReader) func(*Regexp) bool { return false }
..\..\..\..\regexp\regexp.go:412:6: can inline (*inputReader).index as: method(*inputReader) func(*Regexp, int) int { return -1 }
..\..\..\..\regexp\regexp.go:416:6: can inline (*inputReader).context as: method(*inputReader) func(int) syntax.EmptyOp { return 0 }
..\..\..\..\regexp\regexp.go:423:6: can inline (*Regexp).LiteralPrefix as: method(*Regexp) func() (string, bool) { return re.regexpRO.prefix, re.regexpRO.prefixComplete }
..\..\..\..\regexp\regexp.go:429:6: cannot inline (*Regexp).MatchReader: non-leaf method
..\..\..\..\regexp\regexp.go:434:6: cannot inline (*Regexp).MatchString: non-leaf method
..\..\..\..\regexp\regexp.go:439:6: cannot inline (*Regexp).Match: non-leaf method
..\..\..\..\regexp\regexp.go:446:6: cannot inline MatchReader: non-leaf function
..\..\..\..\regexp\regexp.go:457:6: cannot inline MatchString: non-leaf function
..\..\..\..\regexp\regexp.go:468:6: cannot inline Match: non-leaf function
..\..\..\..\regexp\regexp.go:879:6: cannot inline extract: unhandled op FOR
..\..\..\..\regexp\regexp.go:830:6: cannot inline (*Regexp).expand: unhandled op FOR
..\..\..\..\regexp\regexp.go:510:6: cannot inline (*Regexp).replaceAll: unhandled op FOR
..\..\..\..\regexp\regexp.go:479:6: cannot inline (*Regexp).ReplaceAllString: non-leaf function
..\..\..\..\regexp\regexp.go:484:34: cannot inline (*Regexp).ReplaceAllString.func1: non-leaf method
..\..\..\..\regexp\regexp.go:493:6: cannot inline (*Regexp).ReplaceAllLiteralString: non-leaf method
..\..\..\..\regexp\regexp.go:494:43: can inline (*Regexp).ReplaceAllLiteralString.func1 as: func([]byte, []int) []byte { return append(dst, repl...) }
..\..\..\..\regexp\regexp.go:503:6: cannot inline (*Regexp).ReplaceAllStringFunc: non-leaf method
..\..\..\..\regexp\regexp.go:504:34: cannot inline (*Regexp).ReplaceAllStringFunc.func1: non-leaf function
..\..\..\..\regexp\regexp.go:578:6: cannot inline (*Regexp).ReplaceAll: non-leaf function
..\..\..\..\regexp\regexp.go:584:33: cannot inline (*Regexp).ReplaceAll.func1: non-leaf method
..\..\..\..\regexp\regexp.go:596:6: cannot inline (*Regexp).ReplaceAllLiteral: non-leaf method
..\..\..\..\regexp\regexp.go:597:35: can inline (*Regexp).ReplaceAllLiteral.func1 as: func([]byte, []int) []byte { return append(dst, repl...) }
..\..\..\..\regexp\regexp.go:606:6: cannot inline (*Regexp).ReplaceAllFunc: non-leaf method
..\..\..\..\regexp\regexp.go:607:35: cannot inline (*Regexp).ReplaceAllFunc.func1: non-leaf function
..\..\..\..\regexp\regexp.go:616:6: can inline special as: func(byte) bool { return b < utf8.RuneSelf && specialBytes[b % 16] & (1 << (b / 16)) != 0 }
..\..\..\..\regexp\regexp.go:620:6: cannot inline init.0: unhandled op RANGE
..\..\..\..\regexp\regexp.go:629:6: cannot inline QuoteMeta: unhandled op FOR
..\..\..\..\regexp\regexp.go:633:13: inlining call to special func(byte) bool { return b < utf8.RuneSelf && specialBytes[b % 16] & (1 << (b / 16)) != 0 }
..\..\..\..\regexp\regexp.go:646:13: inlining call to special func(byte) bool { return b < utf8.RuneSelf && specialBytes[b % 16] & (1 << (b / 16)) != 0 }
..\..\..\..\regexp\regexp.go:661:6: cannot inline (*Regexp).pad: unhandled op FOR
..\..\..\..\regexp\regexp.go:674:6: cannot inline (*Regexp).allMatches: unhandled op FOR
..\..\..\..\regexp\regexp.go:722:6: cannot inline (*Regexp).Find: non-leaf method
..\..\..\..\regexp\regexp.go:735:6: cannot inline (*Regexp).FindIndex: non-leaf method
..\..\..\..\regexp\regexp.go:748:6: cannot inline (*Regexp).FindString: non-leaf method
..\..\..\..\regexp\regexp.go:761:6: cannot inline (*Regexp).FindStringIndex: non-leaf method
..\..\..\..\regexp\regexp.go:774:6: cannot inline (*Regexp).FindReaderIndex: non-leaf method
..\..\..\..\regexp\regexp.go:787:6: cannot inline (*Regexp).FindSubmatch: non-leaf method
..\..\..\..\regexp\regexp.go:819:6: cannot inline (*Regexp).Expand: non-leaf method
..\..\..\..\regexp\regexp.go:826:6: cannot inline (*Regexp).ExpandString: non-leaf method
..\..\..\..\regexp\regexp.go:935:6: cannot inline (*Regexp).FindSubmatchIndex: non-leaf method
..\..\..\..\regexp\regexp.go:944:6: cannot inline (*Regexp).FindStringSubmatch: non-leaf method
..\..\..\..\regexp\regexp.go:964:6: cannot inline (*Regexp).FindStringSubmatchIndex: non-leaf method
..\..\..\..\regexp\regexp.go:973:6: cannot inline (*Regexp).FindReaderSubmatchIndex: non-leaf method
..\..\..\..\regexp\regexp.go:983:6: cannot inline (*Regexp).FindAll: non-leaf method
..\..\..\..\regexp\regexp.go:988:26: can inline (*Regexp).FindAll.func1 as: func([]int) { result = append(result, b[match[0]:match[1]]) }
..\..\..\..\regexp\regexp.go:1001:6: cannot inline (*Regexp).FindAllIndex: non-leaf method
..\..\..\..\regexp\regexp.go:1006:26: can inline (*Regexp).FindAllIndex.func1 as: func([]int) { result = append(result, match[0:2]) }
..\..\..\..\regexp\regexp.go:1019:6: cannot inline (*Regexp).FindAllString: non-leaf method
..\..\..\..\regexp\regexp.go:1024:27: can inline (*Regexp).FindAllString.func1 as: func([]int) { result = append(result, s[match[0]:match[1]]) }
..\..\..\..\regexp\regexp.go:1037:6: cannot inline (*Regexp).FindAllStringIndex: non-leaf method
..\..\..\..\regexp\regexp.go:1042:27: can inline (*Regexp).FindAllStringIndex.func1 as: func([]int) { result = append(result, match[0:2]) }
..\..\..\..\regexp\regexp.go:1055:6: cannot inline (*Regexp).FindAllSubmatch: non-leaf method
..\..\..\..\regexp\regexp.go:1060:26: cannot inline (*Regexp).FindAllSubmatch.func1: unhandled op RANGE
..\..\..\..\regexp\regexp.go:1079:6: cannot inline (*Regexp).FindAllSubmatchIndex: non-leaf method
..\..\..\..\regexp\regexp.go:1084:26: can inline (*Regexp).FindAllSubmatchIndex.func1 as: func([]int) { result = append(result, match) }
..\..\..\..\regexp\regexp.go:1097:6: cannot inline (*Regexp).FindAllStringSubmatch: non-leaf method
..\..\..\..\regexp\regexp.go:1102:27: cannot inline (*Regexp).FindAllStringSubmatch.func1: unhandled op RANGE
..\..\..\..\regexp\regexp.go:1122:6: cannot inline (*Regexp).FindAllStringSubmatchIndex: non-leaf method
..\..\..\..\regexp\regexp.go:1127:27: can inline (*Regexp).FindAllStringSubmatchIndex.func1 as: func([]int) { result = append(result, match) }
..\..\..\..\regexp\regexp.go:1151:6: cannot inline (*Regexp).Split: non-leaf method
..\..\..\..\regexp\backtrack.go:47:40: maxBitStateLen prog does not escape
..\..\..\..\regexp\backtrack.go:62:7: &bitState literal escapes to heap
..\..\..\..\regexp\backtrack.go:62:7: 	from ~r1 (return) at ..\..\..\..\regexp\backtrack.go:61:2
..\..\..\..\regexp\backtrack.go:57:38: leaking param: prog to result ~r1 level=-1
..\..\..\..\regexp\backtrack.go:57:38: 	from &bitState literal (struct literal element) at ..\..\..\..\regexp\backtrack.go:61:18
..\..\..\..\regexp\backtrack.go:57:38: 	from &bitState literal (pointer literal) at ..\..\..\..\regexp\backtrack.go:62:7
..\..\..\..\regexp\backtrack.go:57:38: 	from ~r1 (return) at ..\..\..\..\regexp\backtrack.go:61:2
..\..\..\..\regexp\backtrack.go:68:41: shouldBacktrack prog does not escape
..\..\..\..\regexp\backtrack.go:81:10: (*bitState).reset ignoring self-assignment to b.jobs
..\..\..\..\regexp\backtrack.go:88:13: (*bitState).reset ignoring self-assignment to b.visited
..\..\..\..\regexp\backtrack.go:97:9: (*bitState).reset ignoring self-assignment to b.cap
..\..\..\..\regexp\backtrack.go:79:16: make([]job, 0, 256) escapes to heap
..\..\..\..\regexp\backtrack.go:79:16: 	from b.jobs (star-dot-equals) at ..\..\..\..\regexp\backtrack.go:79:10
..\..\..\..\regexp\backtrack.go:86:19: make([]uint32, visitedSize, maxBacktrackVector / visitedBits) escapes to heap
..\..\..\..\regexp\backtrack.go:86:19: 	from make([]uint32, visitedSize, maxBacktrackVector / visitedBits) (too large for stack) at ..\..\..\..\regexp\backtrack.go:86:19
..\..\..\..\regexp\backtrack.go:95:15: make([]int, ncap) escapes to heap
..\..\..\..\regexp\backtrack.go:95:15: 	from make([]int, ncap) (too large for stack) at ..\..\..\..\regexp\backtrack.go:95:15
..\..\..\..\regexp\backtrack.go:75:40: (*bitState).reset b does not escape
..\..\..\..\regexp\backtrack.go:106:52: (*bitState).shouldVisit b does not escape
..\..\..\..\regexp\backtrack.go:117:49: leaking param content: b
..\..\..\..\regexp\backtrack.go:117:49: 	from b.jobs (dot of pointer) at ..\..\..\..\regexp\backtrack.go:121:20
..\..\..\..\regexp\backtrack.go:117:49: 	from *b.jobs (indirection) at ..\..\..\..\regexp\backtrack.go:121:20
..\..\..\..\regexp\backtrack.go:117:49: 	from append(b.jobs, job literal) (appendee slice) at ..\..\..\..\regexp\backtrack.go:121:18
..\..\..\..\regexp\backtrack.go:137:10: (*machine).tryBacktrack ignoring self-assignment to b.jobs
..\..\..\..\regexp\backtrack.go:126:74: leaking param content: b
..\..\..\..\regexp\backtrack.go:126:74: 	from b (assigned) at ..\..\..\..\regexp\backtrack.go:130:8
..\..\..\..\regexp\backtrack.go:126:74: 	from b.jobs (dot of pointer) at ..\..\..\..\regexp\backtrack.go:130:8
..\..\..\..\regexp\backtrack.go:126:74: 	from *b.jobs (indirection) at ..\..\..\..\regexp\backtrack.go:130:8
..\..\..\..\regexp\backtrack.go:126:74: 	from append(b.jobs, job literal) (appendee slice) at ..\..\..\..\regexp\backtrack.go:130:8
..\..\..\..\regexp\backtrack.go:126:74: leaking param: i
..\..\..\..\regexp\backtrack.go:126:74: 	from i.step(pos) (receiver in indirect call) at ..\..\..\..\regexp\backtrack.go:196:22
..\..\..\..\regexp\backtrack.go:126:74: (*machine).tryBacktrack m does not escape
..\..\..\..\regexp\backtrack.go:197:12: (*machine).tryBacktrack inst does not escape
..\..\..\..\regexp\backtrack.go:312:13: (*machine).backtrack ignoring self-assignment to m.matchcap
..\..\..\..\regexp\backtrack.go:295:66: leaking param: i
..\..\..\..\regexp\backtrack.go:295:66: 	from i.canCheckPrefix() (receiver in indirect call) at ..\..\..\..\regexp\backtrack.go:296:22
..\..\..\..\regexp\backtrack.go:295:66: leaking param content: m
..\..\..\..\regexp\backtrack.go:295:66: 	from m.b (dot of pointer) at ..\..\..\..\regexp\backtrack.go:309:8
..\..\..\..\regexp\backtrack.go:295:66: 	from b (assigned) at ..\..\..\..\regexp\backtrack.go:309:4
..\..\..\..\regexp\backtrack.go:295:66: 	from *b (indirection) at ..\..\..\..\regexp\backtrack.go:309:2
..\..\..\..\regexp\backtrack.go:295:66: 	from b (passed to call[argument content escapes]) at ..\..\..\..\regexp\backtrack.go:322:24
..\..\..\..\regexp\exec.go:54:43: leaking param: b
..\..\..\..\regexp\exec.go:54:43: 	from m.inputBytes.str (dot-equals) at ..\..\..\..\regexp\exec.go:55:19
..\..\..\..\regexp\exec.go:56:9: &m.inputBytes escapes to heap
..\..\..\..\regexp\exec.go:56:9: 	from ~r1 (return) at ..\..\..\..\regexp\exec.go:56:2
..\..\..\..\regexp\exec.go:56:9: &m.inputBytes escapes to heap
..\..\..\..\regexp\exec.go:56:9: 	from &m.inputBytes (interface-converted) at ..\..\..\..\regexp\exec.go:56:9
..\..\..\..\regexp\exec.go:56:9: 	from ~r1 (return) at ..\..\..\..\regexp\exec.go:56:2
..\..\..\..\regexp\exec.go:54:43: leaking param: m to result ~r1 level=0
..\..\..\..\regexp\exec.go:54:43: 	from m.inputBytes (dot of pointer) at ..\..\..\..\regexp\exec.go:56:11
..\..\..\..\regexp\exec.go:54:43: 	from &m.inputBytes (address-of) at ..\..\..\..\regexp\exec.go:56:9
..\..\..\..\regexp\exec.go:54:43: 	from &m.inputBytes (interface-converted) at ..\..\..\..\regexp\exec.go:56:9
..\..\..\..\regexp\exec.go:54:43: 	from ~r1 (return) at ..\..\..\..\regexp\exec.go:56:2
..\..\..\..\regexp\exec.go:59:44: leaking param: s
..\..\..\..\regexp\exec.go:59:44: 	from m.inputString.str (dot-equals) at ..\..\..\..\regexp\exec.go:60:20
..\..\..\..\regexp\exec.go:61:9: &m.inputString escapes to heap
..\..\..\..\regexp\exec.go:61:9: 	from ~r1 (return) at ..\..\..\..\regexp\exec.go:61:2
..\..\..\..\regexp\exec.go:61:9: &m.inputString escapes to heap
..\..\..\..\regexp\exec.go:61:9: 	from &m.inputString (interface-converted) at ..\..\..\..\regexp\exec.go:61:9
..\..\..\..\regexp\exec.go:61:9: 	from ~r1 (return) at ..\..\..\..\regexp\exec.go:61:2
..\..\..\..\regexp\exec.go:59:44: leaking param: m to result ~r1 level=0
..\..\..\..\regexp\exec.go:59:44: 	from m.inputString (dot of pointer) at ..\..\..\..\regexp\exec.go:61:11
..\..\..\..\regexp\exec.go:59:44: 	from &m.inputString (address-of) at ..\..\..\..\regexp\exec.go:61:9
..\..\..\..\regexp\exec.go:59:44: 	from &m.inputString (interface-converted) at ..\..\..\..\regexp\exec.go:61:9
..\..\..\..\regexp\exec.go:59:44: 	from ~r1 (return) at ..\..\..\..\regexp\exec.go:61:2
..\..\..\..\regexp\exec.go:64:51: leaking param: r
..\..\..\..\regexp\exec.go:64:51: 	from m.inputReader.r (dot-equals) at ..\..\..\..\regexp\exec.go:65:18
..\..\..\..\regexp\exec.go:68:9: &m.inputReader escapes to heap
..\..\..\..\regexp\exec.go:68:9: 	from ~r1 (return) at ..\..\..\..\regexp\exec.go:68:2
..\..\..\..\regexp\exec.go:68:9: &m.inputReader escapes to heap
..\..\..\..\regexp\exec.go:68:9: 	from &m.inputReader (interface-converted) at ..\..\..\..\regexp\exec.go:68:9
..\..\..\..\regexp\exec.go:68:9: 	from ~r1 (return) at ..\..\..\..\regexp\exec.go:68:2
..\..\..\..\regexp\exec.go:64:51: leaking param: m to result ~r1 level=0
..\..\..\..\regexp\exec.go:64:51: 	from m.inputReader (dot of pointer) at ..\..\..\..\regexp\exec.go:68:11
..\..\..\..\regexp\exec.go:64:51: 	from &m.inputReader (address-of) at ..\..\..\..\regexp\exec.go:68:9
..\..\..\..\regexp\exec.go:64:51: 	from &m.inputReader (interface-converted) at ..\..\..\..\regexp\exec.go:68:9
..\..\..\..\regexp\exec.go:64:51: 	from ~r1 (return) at ..\..\..\..\regexp\exec.go:68:2
..\..\..\..\regexp\exec.go:75:19: make([]uint32, n) escapes to heap
..\..\..\..\regexp\exec.go:75:19: 	from make([]uint32, n) (too large for stack) at ..\..\..\..\regexp\exec.go:75:19
..\..\..\..\regexp\exec.go:75:38: make([]entry, 0, n) escapes to heap
..\..\..\..\regexp\exec.go:75:38: 	from make([]entry, 0, n) (too large for stack) at ..\..\..\..\regexp\exec.go:75:38
..\..\..\..\regexp\exec.go:76:19: make([]uint32, n) escapes to heap
..\..\..\..\regexp\exec.go:76:19: 	from make([]uint32, n) (too large for stack) at ..\..\..\..\regexp\exec.go:76:19
..\..\..\..\regexp\exec.go:76:38: make([]entry, 0, n) escapes to heap
..\..\..\..\regexp\exec.go:76:38: 	from make([]entry, 0, n) (too large for stack) at ..\..\..\..\regexp\exec.go:76:38
..\..\..\..\regexp\exec.go:84:19: make([]int, ncap) escapes to heap
..\..\..\..\regexp\exec.go:84:19: 	from make([]int, ncap) (too large for stack) at ..\..\..\..\regexp\exec.go:84:19
..\..\..\..\regexp\exec.go:73:24: &machine literal escapes to heap
..\..\..\..\regexp\exec.go:73:24: 	from m (assigned) at ..\..\..\..\regexp\exec.go:73:4
..\..\..\..\regexp\exec.go:73:24: 	from ~r2 (return) at ..\..\..\..\regexp\exec.go:85:2
..\..\..\..\regexp\exec.go:72:52: leaking param: p to result ~r2 level=-1
..\..\..\..\regexp\exec.go:72:52: 	from &machine literal (struct literal element) at ..\..\..\..\regexp\exec.go:73:15
..\..\..\..\regexp\exec.go:72:52: 	from &machine literal (pointer literal) at ..\..\..\..\regexp\exec.go:73:24
..\..\..\..\regexp\exec.go:72:52: 	from m (assigned) at ..\..\..\..\regexp\exec.go:73:4
..\..\..\..\regexp\exec.go:72:52: 	from ~r2 (return) at ..\..\..\..\regexp\exec.go:85:2
..\..\..\..\regexp\exec.go:72:52: leaking param: op to result ~r2 level=-1
..\..\..\..\regexp\exec.go:72:52: 	from &machine literal (struct literal element) at ..\..\..\..\regexp\exec.go:73:15
..\..\..\..\regexp\exec.go:72:52: 	from &machine literal (pointer literal) at ..\..\..\..\regexp\exec.go:73:24
..\..\..\..\regexp\exec.go:72:52: 	from m (assigned) at ..\..\..\..\regexp\exec.go:73:4
..\..\..\..\regexp\exec.go:72:52: 	from ~r2 (return) at ..\..\..\..\regexp\exec.go:85:2
..\..\..\..\regexp\exec.go:90:9: (*machine).init ignoring self-assignment to t.cap
..\..\..\..\regexp\exec.go:92:13: (*machine).init ignoring self-assignment to m.matchcap
..\..\..\..\regexp\exec.go:88:29: (*machine).init m does not escape
..\..\..\..\regexp\exec.go:101:10: (*machine).alloc ignoring self-assignment to m.pool
..\..\..\..\regexp\exec.go:104:15: make([]int, len(m.matchcap), cap(m.matchcap)) escapes to heap
..\..\..\..\regexp\exec.go:104:15: 	from make([]int, len(m.matchcap), cap(m.matchcap)) (too large for stack) at ..\..\..\..\regexp\exec.go:104:15
..\..\..\..\regexp\exec.go:97:42: leaking param: i
..\..\..\..\regexp\exec.go:97:42: 	from t.inst (star-dot-equals) at ..\..\..\..\regexp\exec.go:106:9
..\..\..\..\regexp\exec.go:97:42: leaking param: m to result ~r1 level=2
..\..\..\..\regexp\exec.go:97:42: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:100:8
..\..\..\..\regexp\exec.go:97:42: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:100:13
..\..\..\..\regexp\exec.go:97:42: 	from t (assigned) at ..\..\..\..\regexp\exec.go:100:5
..\..\..\..\regexp\exec.go:97:42: 	from ~r1 (return) at ..\..\..\..\regexp\exec.go:107:2
..\..\..\..\regexp\exec.go:103:10: new(thread) escapes to heap
..\..\..\..\regexp\exec.go:103:10: 	from t (assigned) at ..\..\..\..\regexp\exec.go:103:5
..\..\..\..\regexp\exec.go:103:10: 	from ~r1 (return) at ..\..\..\..\regexp\exec.go:107:2
..\..\..\..\regexp\exec.go:264:10: (*machine).add ignoring self-assignment to q.dense
..\..\..\..\regexp\exec.go:296:15: (*machine).add ignoring self-assignment to m.pool
..\..\..\..\regexp\exec.go:255:97: leaking param: t
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:257:3
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (returned from recursive function) at ..\..\..\..\regexp\exec.go:255:97
..\..\..\..\regexp\exec.go:255:97: leaking param content: m
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:257:3
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (returned from recursive function) at ..\..\..\..\regexp\exec.go:255:97
..\..\..\..\regexp\exec.go:296:15: new(thread) escapes to heap
..\..\..\..\regexp\exec.go:296:15: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:296:15: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:296:15: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:296:15: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:257:3
..\..\..\..\regexp\exec.go:296:15: 	from ~r6 (returned from recursive function) at ..\..\..\..\regexp\exec.go:255:97
..\..\..\..\regexp\exec.go:296:15: make([]int, len(m.matchcap), cap(m.matchcap)) escapes to heap
..\..\..\..\regexp\exec.go:296:15: 	from make([]int, len(m.matchcap), cap(m.matchcap)) (too large for stack) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:270:7: &m.p.Inst[pc] escapes to heap
..\..\..\..\regexp\exec.go:270:7: 	from i (assigned) at ..\..\..\..\regexp\exec.go:270:4
..\..\..\..\regexp\exec.go:270:7: 	from i (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:270:7: 	from t.inst (star-dot-equals) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: leaking param content: cap
..\..\..\..\regexp\exec.go:255:97: 	from *cap (indirection) at ..\..\..\..\regexp\exec.go:255:97
..\..\..\..\regexp\exec.go:255:97: 	from copy(t.cap, cap) (copied slice) at ..\..\..\..\regexp\exec.go:301:8
..\..\..\..\regexp\exec.go:255:97: leaking param: m to result ~r6 level=2
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:257:3
..\..\..\..\regexp\exec.go:255:97: leaking param: m to result ~r6 level=2
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:260:3
..\..\..\..\regexp\exec.go:255:97: leaking param: m to result ~r6 level=2
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:306:2
..\..\..\..\regexp\exec.go:255:97: mark escaped content: m
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:257:3
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:255:97
..\..\..\..\regexp\exec.go:255:97: mark escaped content: m
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:257:3
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:255:97
..\..\..\..\regexp\exec.go:255:97: mark escaped content: m
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:257:3
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:255:97
..\..\..\..\regexp\exec.go:255:97: mark escaped content: m
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:257:3
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:255:97
..\..\..\..\regexp\exec.go:255:97: mark escaped content: m
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:257:3
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:255:97
..\..\..\..\regexp\exec.go:255:97: mark escaped content: m
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: mark escaped content: m
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:257:3
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:255:97
..\..\..\..\regexp\exec.go:255:97: mark escaped content: m
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:257:3
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:255:97
..\..\..\..\regexp\exec.go:255:97: mark escaped content: m
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:257:3
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:255:97
..\..\..\..\regexp\exec.go:255:97: mark escaped content: m
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:257:3
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:255:97
..\..\..\..\regexp\exec.go:255:97: mark escaped content: m
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:257:3
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:255:97
..\..\..\..\regexp\exec.go:255:97: mark escaped content: m
..\..\..\..\regexp\exec.go:255:97: 	from m (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from m.pool[n - 1] (dot of pointer) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:296:15
..\..\..\..\regexp\exec.go:255:97: 	from t (assigned) at ..\..\..\..\regexp\exec.go:296:6
..\..\..\..\regexp\exec.go:255:97: (*machine).add q does not escape
..\..\..\..\regexp\exec.go:265:7: (*machine).add &q.dense[j] does not escape
..\..\..\..\regexp\exec.go:300:22: (*machine).add &t.cap[0] does not escape
..\..\..\..\regexp\exec.go:300:35: (*machine).add &cap[0] does not escape
..\..\..\..\regexp\exec.go:228:16: (*machine).step ignoring self-assignment to runq.dense
..\..\..\..\regexp\exec.go:248:13: (*machine).step ignoring self-assignment to runq.dense
..\..\..\..\regexp\exec.go:198:79: leaking param content: runq
..\..\..\..\regexp\exec.go:198:79: 	from runq.dense (dot of pointer) at ..\..\..\..\regexp\exec.go:201:13
..\..\..\..\regexp\exec.go:198:79: 	from runq.dense[j] (dot of pointer) at ..\..\..\..\regexp\exec.go:201:19
..\..\..\..\regexp\exec.go:198:79: 	from &runq.dense[j] (address-of) at ..\..\..\..\regexp\exec.go:201:8
..\..\..\..\regexp\exec.go:198:79: 	from d (assigned) at ..\..\..\..\regexp\exec.go:201:5
..\..\..\..\regexp\exec.go:198:79: 	from d.t (dot of pointer) at ..\..\..\..\regexp\exec.go:202:9
..\..\..\..\regexp\exec.go:198:79: 	from t (assigned) at ..\..\..\..\regexp\exec.go:202:5
..\..\..\..\regexp\exec.go:198:79: 	from append(m.pool, t) (appended to slice) at ..\..\..\..\regexp\exec.go:207:19
..\..\..\..\regexp\exec.go:198:79: leaking param content: m
..\..\..\..\regexp\exec.go:198:79: 	from *m (indirection) at ..\..\..\..\regexp\exec.go:198:79
..\..\..\..\regexp\exec.go:198:79: 	from * (*m) (indirection) at ..\..\..\..\regexp\exec.go:198:79
..\..\..\..\regexp\exec.go:198:79: 	from .out0 (passed-to-and-returned-from-call) at ..\..\..\..\regexp\exec.go:242:13
..\..\..\..\regexp\exec.go:198:79: 	from t (assigned) at ..\..\..\..\regexp\exec.go:202:3
..\..\..\..\regexp\exec.go:198:79: 	from append(m.pool, t) (appended to slice) at ..\..\..\..\regexp\exec.go:207:19
..\..\..\..\regexp\exec.go:198:79: (*machine).step nextq does not escape
..\..\..\..\regexp\exec.go:201:8: (*machine).step &runq.dense[j] does not escape
..\..\..\..\regexp\exec.go:190:10: (*machine).clear ignoring self-assignment to q.dense
..\..\..\..\regexp\exec.go:184:28: leaking param content: q
..\..\..\..\regexp\exec.go:184:28: 	from q.dense (dot of pointer) at ..\..\..\..\regexp\exec.go:185:21
..\..\..\..\regexp\exec.go:184:28: 	from *q.dense (indirection) at ..\..\..\..\regexp\exec.go:185:21
..\..\..\..\regexp\exec.go:184:28: 	from d (range-deref) at ..\..\..\..\regexp\exec.go:185:14
..\..\..\..\regexp\exec.go:184:28: 	from append(m.pool, d.t) (appended to slice) at ..\..\..\..\regexp\exec.go:187:19
..\..\..\..\regexp\exec.go:184:28: leaking param content: m
..\..\..\..\regexp\exec.go:184:28: 	from m.pool (dot of pointer) at ..\..\..\..\regexp\exec.go:187:21
..\..\..\..\regexp\exec.go:184:28: 	from *m.pool (indirection) at ..\..\..\..\regexp\exec.go:187:21
..\..\..\..\regexp\exec.go:184:28: 	from append(m.pool, d.t) (appendee slice) at ..\..\..\..\regexp\exec.go:187:19
..\..\..\..\regexp\exec.go:113:43: leaking param: i
..\..\..\..\regexp\exec.go:113:43: 	from i.step(pos) (receiver in indirect call) at ..\..\..\..\regexp\exec.go:125:19
..\..\..\..\regexp\exec.go:113:43: leaking param content: m
..\..\..\..\regexp\exec.go:113:43: 	from m.re (dot of pointer) at ..\..\..\..\regexp\exec.go:147:25
..\..\..\..\regexp\exec.go:113:43: 	from i.index(m.re, pos) (parameter to indirect call) at ..\..\..\..\regexp\exec.go:147:23
..\..\..\..\regexp\exec.go:122:17: (*machine).match &m.q0 does not escape
..\..\..\..\regexp\exec.go:122:24: (*machine).match &m.q1 does not escape
..\..\..\..\regexp\onepass.go:74:42: onePassNext i does not escape
..\..\..\..\regexp\onepass.go:75:11: onePassNext i.Inst does not escape
..\..\..\..\regexp\exec.go:319:13: (*machine).onepass ignoring self-assignment to m.matchcap
..\..\..\..\regexp\exec.go:313:51: leaking param: i
..\..\..\..\regexp\exec.go:313:51: 	from i.step(pos) (receiver in indirect call) at ..\..\..\..\regexp\exec.go:325:19
..\..\..\..\regexp\exec.go:313:51: leaking param content: m
..\..\..\..\regexp\exec.go:313:51: 	from m.re (dot of pointer) at ..\..\..\..\regexp\exec.go:341:20
..\..\..\..\regexp\exec.go:313:51: 	from i.hasPrefix(m.re) (parameter to indirect call) at ..\..\..\..\regexp\exec.go:341:18
..\..\..\..\regexp\exec.go:364:12: (*machine).onepass inst.Inst does not escape
..\..\..\..\regexp\exec.go:379:25: (*machine).onepass &inst does not escape
..\..\..\..\regexp\regexp.go:214:14: (*Regexp).get ignoring self-assignment to re.machine
..\..\..\..\regexp\regexp.go:211:7: re.mu escapes to heap
..\..\..\..\regexp\regexp.go:211:7: 	from re.mu (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:211:12
..\..\..\..\regexp\regexp.go:210:26: leaking param: re
..\..\..\..\regexp\regexp.go:210:26: 	from re.mu (dot of pointer) at ..\..\..\..\regexp\regexp.go:211:4
..\..\..\..\regexp\regexp.go:210:26: 	from re.mu (address-of) at ..\..\..\..\regexp\regexp.go:211:7
..\..\..\..\regexp\regexp.go:210:26: 	from re.mu (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:211:12
..\..\..\..\regexp\regexp.go:215:8: re.mu escapes to heap
..\..\..\..\regexp\regexp.go:215:8: 	from re.mu (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:215:15
..\..\..\..\regexp\regexp.go:218:7: re.mu escapes to heap
..\..\..\..\regexp\regexp.go:218:7: 	from re.mu (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:218:14
..\..\..\..\regexp\regexp.go:229:7: re.mu escapes to heap
..\..\..\..\regexp\regexp.go:229:7: 	from re.mu (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:229:12
..\..\..\..\regexp\regexp.go:228:26: leaking param: re
..\..\..\..\regexp\regexp.go:228:26: 	from re.mu (dot of pointer) at ..\..\..\..\regexp\regexp.go:229:4
..\..\..\..\regexp\regexp.go:228:26: 	from re.mu (address-of) at ..\..\..\..\regexp\regexp.go:229:7
..\..\..\..\regexp\regexp.go:228:26: 	from re.mu (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:229:12
..\..\..\..\regexp\regexp.go:228:26: leaking param: z
..\..\..\..\regexp\regexp.go:228:26: 	from append(re.machine, z) (appended to slice) at ..\..\..\..\regexp\regexp.go:230:21
..\..\..\..\regexp\regexp.go:231:7: re.mu escapes to heap
..\..\..\..\regexp\regexp.go:231:7: 	from re.mu (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:231:14
..\..\..\..\regexp\exec.go:418:101: leaking param: re
..\..\..\..\regexp\exec.go:418:101: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\exec.go:419:13
..\..\..\..\regexp\exec.go:418:101: leaking param: r
..\..\..\..\regexp\exec.go:418:101: 	from r (assign-pair) at ..\..\..\..\regexp\exec.go:423:23
..\..\..\..\regexp\exec.go:418:101: 	from m.inputReader.r (dot-equals) at ..\..\..\..\regexp\exec.go:423:23
..\..\..\..\regexp\exec.go:418:101: leaking param: b
..\..\..\..\regexp\exec.go:418:101: 	from b (assign-pair) at ..\..\..\..\regexp\exec.go:425:22
..\..\..\..\regexp\exec.go:418:101: 	from m.inputBytes.str (dot-equals) at ..\..\..\..\regexp\exec.go:425:22
..\..\..\..\regexp\exec.go:418:101: leaking param: s
..\..\..\..\regexp\exec.go:418:101: 	from s (assign-pair) at ..\..\..\..\regexp\exec.go:428:23
..\..\..\..\regexp\exec.go:418:101: 	from m.inputString.str (dot-equals) at ..\..\..\..\regexp\exec.go:428:23
..\..\..\..\regexp\exec.go:423:23: &m.inputReader escapes to heap
..\..\..\..\regexp\exec.go:423:23: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:423:23
..\..\..\..\regexp\exec.go:423:23: 	from i (assigned) at ..\..\..\..\regexp\exec.go:423:5
..\..\..\..\regexp\exec.go:423:23: 	from i (passed to call[argument escapes]) at ..\..\..\..\regexp\exec.go:432:16
..\..\..\..\regexp\exec.go:423:23: &m.inputReader escapes to heap
..\..\..\..\regexp\exec.go:423:23: 	from &m.inputReader (interface-converted) at ..\..\..\..\regexp\exec.go:423:23
..\..\..\..\regexp\exec.go:423:23: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:423:23
..\..\..\..\regexp\exec.go:423:23: 	from i (assigned) at ..\..\..\..\regexp\exec.go:423:5
..\..\..\..\regexp\exec.go:423:23: 	from i (passed to call[argument escapes]) at ..\..\..\..\regexp\exec.go:432:16
..\..\..\..\regexp\exec.go:425:22: &m.inputBytes escapes to heap
..\..\..\..\regexp\exec.go:425:22: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:425:22
..\..\..\..\regexp\exec.go:425:22: 	from i (assigned) at ..\..\..\..\regexp\exec.go:425:5
..\..\..\..\regexp\exec.go:425:22: 	from i (passed to call[argument escapes]) at ..\..\..\..\regexp\exec.go:432:16
..\..\..\..\regexp\exec.go:425:22: &m.inputBytes escapes to heap
..\..\..\..\regexp\exec.go:425:22: 	from &m.inputBytes (interface-converted) at ..\..\..\..\regexp\exec.go:425:22
..\..\..\..\regexp\exec.go:425:22: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:425:22
..\..\..\..\regexp\exec.go:425:22: 	from i (assigned) at ..\..\..\..\regexp\exec.go:425:5
..\..\..\..\regexp\exec.go:425:22: 	from i (passed to call[argument escapes]) at ..\..\..\..\regexp\exec.go:432:16
..\..\..\..\regexp\exec.go:428:23: &m.inputString escapes to heap
..\..\..\..\regexp\exec.go:428:23: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:428:23
..\..\..\..\regexp\exec.go:428:23: 	from i (assigned) at ..\..\..\..\regexp\exec.go:428:5
..\..\..\..\regexp\exec.go:428:23: 	from i (passed to call[argument escapes]) at ..\..\..\..\regexp\exec.go:432:16
..\..\..\..\regexp\exec.go:428:23: &m.inputString escapes to heap
..\..\..\..\regexp\exec.go:428:23: 	from &m.inputString (interface-converted) at ..\..\..\..\regexp\exec.go:428:23
..\..\..\..\regexp\exec.go:428:23: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:428:23
..\..\..\..\regexp\exec.go:428:23: 	from i (assigned) at ..\..\..\..\regexp\exec.go:428:5
..\..\..\..\regexp\exec.go:428:23: 	from i (passed to call[argument escapes]) at ..\..\..\..\regexp\exec.go:432:16
..\..\..\..\regexp\exec.go:438:21: &bitState literal escapes to heap
..\..\..\..\regexp\exec.go:438:21: 	from ~r1 (assign-pair) at ..\..\..\..\regexp\exec.go:438:21
..\..\..\..\regexp\exec.go:438:21: 	from m.b (star-dot-equals) at ..\..\..\..\regexp\exec.go:438:8
..\..\..\..\regexp\exec.go:418:101: leaking param content: dstCap
..\..\..\..\regexp\exec.go:418:101: 	from *dstCap (indirection) at ..\..\..\..\regexp\exec.go:418:101
..\..\..\..\regexp\exec.go:418:101: 	from append(dstCap, m.matchcap...) (appendee slice) at ..\..\..\..\regexp\exec.go:451:17
..\..\..\..\regexp\exec.go:418:101: leaking param: dstCap to result ~r6 level=0
..\..\..\..\regexp\exec.go:418:101: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:457:2
..\..\..\..\regexp\exec.go:454:23: arrayNoInts escapes to heap
..\..\..\..\regexp\exec.go:454:23: 	from dstCap (assigned) at ..\..\..\..\regexp\exec.go:454:10
..\..\..\..\regexp\exec.go:454:23: 	from ~r6 (return) at ..\..\..\..\regexp\exec.go:457:2
..\..\..\..\regexp\exec.go:410:64: leaking param: re
..\..\..\..\regexp\exec.go:410:64: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\exec.go:411:21
..\..\..\..\regexp\exec.go:410:64: leaking param: r
..\..\..\..\regexp\exec.go:410:64: 	from r (passed to call[argument escapes]) at ..\..\..\..\regexp\exec.go:411:21
..\..\..\..\regexp\exec.go:410:64: leaking param: b
..\..\..\..\regexp\exec.go:410:64: 	from b (passed to call[argument escapes]) at ..\..\..\..\regexp\exec.go:411:21
..\..\..\..\regexp\exec.go:410:64: leaking param: s
..\..\..\..\regexp\exec.go:410:64: 	from s (passed to call[argument escapes]) at ..\..\..\..\regexp\exec.go:411:21
..\..\..\..\regexp\onepass.go:49:7: &p.Inst[pc] escapes to heap
..\..\..\..\regexp\onepass.go:49:7: 	from i (assigned) at ..\..\..\..\regexp\onepass.go:49:5
..\..\..\..\regexp\onepass.go:60:18: &p.Inst[i.Out] escapes to heap
..\..\..\..\regexp\onepass.go:60:18: 	from i (assign-pair) at ..\..\..\..\regexp\onepass.go:41:2
..\..\..\..\regexp\onepass.go:59:6: buf escapes to heap
..\..\..\..\regexp\onepass.go:59:6: 	from buf (passed to call[argument escapes]) at ..\..\..\..\regexp\onepass.go:59:16
..\..\..\..\regexp\onepass.go:57:6: moved to heap: buf
..\..\..\..\regexp\onepass.go:67:19: string(bytes.b·2.buf[bytes.b·2.off:]) escapes to heap
..\..\..\..\regexp\onepass.go:67:19: 	from ~r0 (assign-pair) at ..\..\..\..\regexp\onepass.go:67:19
..\..\..\..\regexp\onepass.go:67:19: 	from prefix (return) at ..\..\..\..\regexp\onepass.go:67:2
..\..\..\..\regexp\onepass.go:40:70: onePassPrefix p does not escape
..\..\..\..\regexp\onepass.go:41:7: onePassPrefix &p.Inst[p.Start] does not escape
..\..\..\..\regexp\onepass.go:46:6: onePassPrefix &p.Inst[pc] does not escape
..\..\..\..\regexp\onepass.go:67:12: onePassPrefix buf does not escape
..\..\..\..\regexp\onepass.go:85:26: iop i does not escape
..\..\..\..\regexp\onepass.go:101:32: (*queueOnePass).empty q does not escape
..\..\..\..\regexp\onepass.go:105:34: (*queueOnePass).next q does not escape
..\..\..\..\regexp\onepass.go:111:10: (*queueOnePass).clear q does not escape
..\..\..\..\regexp\onepass.go:116:43: (*queueOnePass).contains q does not escape
..\..\..\..\regexp\onepass.go:123:33: (*queueOnePass).insert q does not escape
..\..\..\..\regexp\onepass.go:129:36: (*queueOnePass).insertNew q does not escape
..\..\..\..\regexp\onepass.go:140:15: make([]uint32, size) escapes to heap
..\..\..\..\regexp\onepass.go:140:15: 	from make([]uint32, size) (too large for stack) at ..\..\..\..\regexp\onepass.go:140:15
..\..\..\..\regexp\onepass.go:141:15: make([]uint32, size) escapes to heap
..\..\..\..\regexp\onepass.go:141:15: 	from make([]uint32, size) (too large for stack) at ..\..\..\..\regexp\onepass.go:141:15
..\..\..\..\regexp\onepass.go:141:8: &queueOnePass literal escapes to heap
..\..\..\..\regexp\onepass.go:141:8: 	from q (return) at ..\..\..\..\regexp\onepass.go:139:2
..\..\..\..\regexp\onepass.go:166:16: make([]rune, 0) escapes to heap
..\..\..\..\regexp\onepass.go:166:16: 	from merged (assigned) at ..\..\..\..\regexp\onepass.go:166:9
..\..\..\..\regexp\onepass.go:166:16: 	from &merged (address-of) at ..\..\..\..\regexp\onepass.go:191:15
..\..\..\..\regexp\onepass.go:166:16: 	from &merged (assigned) at ..\..\..\..\regexp\onepass.go:191:15
..\..\..\..\regexp\onepass.go:166:16: 	from *&merged (indirection) at ..\..\..\..\regexp\onepass.go:191:15
..\..\..\..\regexp\onepass.go:166:16: 	from .sink (star-equals) at ..\..\..\..\regexp\onepass.go:191:15
..\..\..\..\regexp\onepass.go:167:14: make([]uint32, 0) escapes to heap
..\..\..\..\regexp\onepass.go:167:14: 	from next (assigned) at ..\..\..\..\regexp\onepass.go:167:7
..\..\..\..\regexp\onepass.go:167:14: 	from &next (address-of) at ..\..\..\..\regexp\onepass.go:191:15
..\..\..\..\regexp\onepass.go:167:14: 	from &next (assigned) at ..\..\..\..\regexp\onepass.go:191:15
..\..\..\..\regexp\onepass.go:167:14: 	from *&next (indirection) at ..\..\..\..\regexp\onepass.go:191:15
..\..\..\..\regexp\onepass.go:167:14: 	from .sink (star-equals) at ..\..\..\..\regexp\onepass.go:191:15
..\..\..\..\regexp\onepass.go:157:86: mergeRuneSets leftRunes does not escape
..\..\..\..\regexp\onepass.go:157:86: mergeRuneSets rightRunes does not escape
..\..\..\..\regexp\onepass.go:169:8: mergeRuneSets func literal does not escape
..\..\..\..\regexp\onepass.go:177:12: mergeRuneSets func literal does not escape
..\..\..\..\regexp\onepass.go:191:15: mergeRuneSets &ix does not escape
..\..\..\..\regexp\onepass.go:191:15: mergeRuneSets &merged does not escape
..\..\..\..\regexp\onepass.go:191:15: mergeRuneSets &next does not escape
..\..\..\..\regexp\onepass.go:191:16: mergeRuneSets &lx does not escape
..\..\..\..\regexp\onepass.go:193:15: mergeRuneSets &ix does not escape
..\..\..\..\regexp\onepass.go:193:15: mergeRuneSets &merged does not escape
..\..\..\..\regexp\onepass.go:193:15: mergeRuneSets &next does not escape
..\..\..\..\regexp\onepass.go:193:16: mergeRuneSets &rx does not escape
..\..\..\..\regexp\onepass.go:195:15: mergeRuneSets &ix does not escape
..\..\..\..\regexp\onepass.go:195:15: mergeRuneSets &merged does not escape
..\..\..\..\regexp\onepass.go:195:15: mergeRuneSets &next does not escape
..\..\..\..\regexp\onepass.go:195:16: mergeRuneSets &rx does not escape
..\..\..\..\regexp\onepass.go:197:15: mergeRuneSets &ix does not escape
..\..\..\..\regexp\onepass.go:197:15: mergeRuneSets &merged does not escape
..\..\..\..\regexp\onepass.go:197:15: mergeRuneSets &next does not escape
..\..\..\..\regexp\onepass.go:197:16: mergeRuneSets &lx does not escape
..\..\..\..\regexp\onepass.go:177:59: mergeRuneSets.func2 newLow does not escape
..\..\..\..\regexp\onepass.go:177:59: mergeRuneSets.func2 newArray does not escape
..\..\..\..\regexp\onepass.go:207:50: leaking param content: original
..\..\..\..\regexp\onepass.go:207:50: 	from original.Inst (dot of pointer) at ..\..\..\..\regexp\onepass.go:208:40
..\..\..\..\regexp\onepass.go:207:50: 	from *original.Inst (indirection) at ..\..\..\..\regexp\onepass.go:208:40
..\..\..\..\regexp\onepass.go:207:50: 	from instOriginal (range-deref) at ..\..\..\..\regexp\onepass.go:208:26
..\..\..\..\regexp\onepass.go:207:50: 	from onePassInst literal (struct literal element) at ..\..\..\..\regexp\onepass.go:215:31
..\..\..\..\regexp\onepass.go:207:50: 	from prog.Inst[ix] (slice-element-equals) at ..\..\..\..\regexp\onepass.go:215:18
..\..\..\..\regexp\onepass.go:207:50: cleanupOnePass prog does not escape
..\..\..\..\regexp\onepass.go:225:15: make([]onePassInst, len(prog.Inst)) escapes to heap
..\..\..\..\regexp\onepass.go:225:15: 	from make([]onePassInst, len(prog.Inst)) (too large for stack) at ..\..\..\..\regexp\onepass.go:225:15
..\..\..\..\regexp\onepass.go:221:38: leaking param content: prog
..\..\..\..\regexp\onepass.go:221:38: 	from prog.Inst (dot of pointer) at ..\..\..\..\regexp\onepass.go:227:27
..\..\..\..\regexp\onepass.go:221:38: 	from *prog.Inst (indirection) at ..\..\..\..\regexp\onepass.go:227:27
..\..\..\..\regexp\onepass.go:221:38: 	from inst (range-deref) at ..\..\..\..\regexp\onepass.go:227:17
..\..\..\..\regexp\onepass.go:221:38: 	from onePassInst literal (struct literal element) at ..\..\..\..\regexp\onepass.go:228:26
..\..\..\..\regexp\onepass.go:221:38: 	from p.Inst[i] (slice-element-equals) at ..\..\..\..\regexp\onepass.go:228:13
..\..\..\..\regexp\onepass.go:225:7: &onePassProg literal escapes to heap
..\..\..\..\regexp\onepass.go:225:7: 	from p (assigned) at ..\..\..\..\regexp\onepass.go:222:4
..\..\..\..\regexp\onepass.go:225:7: 	from ~r1 (return) at ..\..\..\..\regexp\onepass.go:281:2
..\..\..\..\regexp\onepass.go:242:17: onePassCopy &p.Inst[pc].Inst.Out does not escape
..\..\..\..\regexp\onepass.go:243:15: onePassCopy &p.Inst[pc].Inst.Arg does not escape
..\..\..\..\regexp\onepass.go:261:15: onePassCopy &p.Inst[*p_A_Alt].Inst.Out does not escape
..\..\..\..\regexp\onepass.go:262:17: onePassCopy &p.Inst[*p_A_Alt].Inst.Arg does not escape
..\..\..\..\regexp\onepass.go:287:26: runeSlice.Len p does not escape
..\..\..\..\regexp\onepass.go:288:35: runeSlice.Less p does not escape
..\..\..\..\regexp\onepass.go:289:30: runeSlice.Swap p does not escape
..\..\..\..\regexp\onepass.go:299:35: leaking param: p to result ~r1 level=0
..\..\..\..\regexp\onepass.go:299:35: 	from ~r1 (return) at ..\..\..\..\regexp\onepass.go:458:2
..\..\..\..\regexp\onepass.go:306:26: make([]uint32, size) escapes to heap
..\..\..\..\regexp\onepass.go:306:26: 	from make([]uint32, size) (too large for stack) at ..\..\..\..\regexp\onepass.go:306:26
..\..\..\..\regexp\onepass.go:306:26: make([]uint32, size) escapes to heap
..\..\..\..\regexp\onepass.go:306:26: 	from make([]uint32, size) (too large for stack) at ..\..\..\..\regexp\onepass.go:306:26
..\..\..\..\regexp\onepass.go:307:26: make([]uint32, size) escapes to heap
..\..\..\..\regexp\onepass.go:307:26: 	from make([]uint32, size) (too large for stack) at ..\..\..\..\regexp\onepass.go:307:26
..\..\..\..\regexp\onepass.go:307:26: make([]uint32, size) escapes to heap
..\..\..\..\regexp\onepass.go:307:26: 	from make([]uint32, size) (too large for stack) at ..\..\..\..\regexp\onepass.go:307:26
..\..\..\..\regexp\onepass.go:309:22: make([][]rune, len(p.Inst)) escapes to heap
..\..\..\..\regexp\onepass.go:309:22: 	from make([][]rune, len(p.Inst)) (too large for stack) at ..\..\..\..\regexp\onepass.go:309:22
..\..\..\..\regexp\onepass.go:444:11: make([]bool, len(p.Inst)) escapes to heap
..\..\..\..\regexp\onepass.go:444:11: 	from make([]bool, len(p.Inst)) (too large for stack) at ..\..\..\..\regexp\onepass.go:444:11
..\..\..\..\regexp\onepass.go:314:40: leaking param: m
..\..\..\..\regexp\onepass.go:314:40: 	from check(inst.Inst.Out, m) (parameter to indirect call) at ..\..\..\..\regexp\onepass.go:323:14
..\..\..\..\regexp\onepass.go:352:36: []rune literal escapes to heap
..\..\..\..\regexp\onepass.go:352:36: 	from .sink (slice-element-equals) at ..\..\..\..\regexp\onepass.go:352:21
..\..\..\..\regexp\onepass.go:353:20: make([]uint32, len(onePassRunes[pc]) / 2 + 1) escapes to heap
..\..\..\..\regexp\onepass.go:353:20: 	from make([]uint32, len(onePassRunes[pc]) / 2 + 1) (too large for stack) at ..\..\..\..\regexp\onepass.go:353:20
..\..\..\..\regexp\onepass.go:360:36: []rune literal escapes to heap
..\..\..\..\regexp\onepass.go:360:36: 	from .sink (slice-element-equals) at ..\..\..\..\regexp\onepass.go:360:21
..\..\..\..\regexp\onepass.go:361:20: make([]uint32, len(onePassRunes[pc]) / 2 + 1) escapes to heap
..\..\..\..\regexp\onepass.go:361:20: 	from make([]uint32, len(onePassRunes[pc]) / 2 + 1) (too large for stack) at ..\..\..\..\regexp\onepass.go:361:20
..\..\..\..\regexp\onepass.go:374:30: []rune literal escapes to heap
..\..\..\..\regexp\onepass.go:374:30: 	from onePassRunes[pc] (slice-element-equals) at ..\..\..\..\regexp\onepass.go:374:22
..\..\..\..\regexp\onepass.go:316:11: &p.Inst[pc] escapes to heap
..\..\..\..\regexp\onepass.go:316:11: 	from inst (assigned) at ..\..\..\..\regexp\onepass.go:316:8
..\..\..\..\regexp\onepass.go:316:11: 	from inst.Inst (dot of pointer) at ..\..\..\..\regexp\onepass.go:375:30
..\..\..\..\regexp\onepass.go:316:11: 	from inst.Inst.Out (dot) at ..\..\..\..\regexp\onepass.go:375:30
..\..\..\..\regexp\onepass.go:316:11: 	from []uint32 literal (slice-literal-element) at ..\..\..\..\regexp\onepass.go:375:25
..\..\..\..\regexp\onepass.go:316:11: 	from inst.Next (star-dot-equals) at ..\..\..\..\regexp\onepass.go:375:15
..\..\..\..\regexp\onepass.go:299:35: leaking param content: p
..\..\..\..\regexp\onepass.go:299:35: 	from p (closure-var) at ..\..\..\..\regexp\onepass.go:316:12
..\..\..\..\regexp\onepass.go:299:35: 	from p.Inst (dot of pointer) at ..\..\..\..\regexp\onepass.go:316:13
..\..\..\..\regexp\onepass.go:299:35: 	from p.Inst[pc] (dot of pointer) at ..\..\..\..\regexp\onepass.go:316:18
..\..\..\..\regexp\onepass.go:299:35: 	from &p.Inst[pc] (address-of) at ..\..\..\..\regexp\onepass.go:316:11
..\..\..\..\regexp\onepass.go:299:35: 	from inst (assigned) at ..\..\..\..\regexp\onepass.go:316:8
..\..\..\..\regexp\onepass.go:299:35: 	from inst.Inst (dot of pointer) at ..\..\..\..\regexp\onepass.go:375:30
..\..\..\..\regexp\onepass.go:299:35: 	from inst.Inst.Out (dot) at ..\..\..\..\regexp\onepass.go:375:30
..\..\..\..\regexp\onepass.go:299:35: 	from []uint32 literal (slice-literal-element) at ..\..\..\..\regexp\onepass.go:375:25
..\..\..\..\regexp\onepass.go:299:35: 	from inst.Next (star-dot-equals) at ..\..\..\..\regexp\onepass.go:375:15
..\..\..\..\regexp\onepass.go:375:25: []uint32 literal escapes to heap
..\..\..\..\regexp\onepass.go:375:25: 	from inst.Next (star-dot-equals) at ..\..\..\..\regexp\onepass.go:375:15
..\..\..\..\regexp\onepass.go:385:24: runeSlice(runes) escapes to heap
..\..\..\..\regexp\onepass.go:385:24: 	from runeSlice(runes) (passed to call[argument escapes]) at ..\..\..\..\regexp\onepass.go:385:14
..\..\..\..\regexp\onepass.go:378:17: make([]rune, 0) escapes to heap
..\..\..\..\regexp\onepass.go:378:17: 	from runes (assigned) at ..\..\..\..\regexp\onepass.go:378:10
..\..\..\..\regexp\onepass.go:378:17: 	from runeSlice(runes) (interface-converted) at ..\..\..\..\regexp\onepass.go:385:24
..\..\..\..\regexp\onepass.go:378:17: 	from runeSlice(runes) (passed to call[argument escapes]) at ..\..\..\..\regexp\onepass.go:385:14
..\..\..\..\regexp\onepass.go:390:20: make([]uint32, len(onePassRunes[pc]) / 2 + 1) escapes to heap
..\..\..\..\regexp\onepass.go:390:20: 	from make([]uint32, len(onePassRunes[pc]) / 2 + 1) (too large for stack) at ..\..\..\..\regexp\onepass.go:390:20
..\..\..\..\regexp\onepass.go:409:24: runeSlice(runes) escapes to heap
..\..\..\..\regexp\onepass.go:409:24: 	from runeSlice(runes) (passed to call[argument escapes]) at ..\..\..\..\regexp\onepass.go:409:14
..\..\..\..\regexp\onepass.go:401:19: []rune literal escapes to heap
..\..\..\..\regexp\onepass.go:401:19: 	from runes (assigned) at ..\..\..\..\regexp\onepass.go:401:10
..\..\..\..\regexp\onepass.go:401:19: 	from runeSlice(runes) (interface-converted) at ..\..\..\..\regexp\onepass.go:409:24
..\..\..\..\regexp\onepass.go:401:19: 	from runeSlice(runes) (passed to call[argument escapes]) at ..\..\..\..\regexp\onepass.go:409:14
..\..\..\..\regexp\onepass.go:414:20: make([]uint32, len(onePassRunes[pc]) / 2 + 1) escapes to heap
..\..\..\..\regexp\onepass.go:414:20: 	from make([]uint32, len(onePassRunes[pc]) / 2 + 1) (too large for stack) at ..\..\..\..\regexp\onepass.go:414:20
..\..\..\..\regexp\onepass.go:425:36: []rune literal escapes to heap
..\..\..\..\regexp\onepass.go:425:36: 	from .sink (slice-element-equals) at ..\..\..\..\regexp\onepass.go:425:21
..\..\..\..\regexp\onepass.go:426:24: []uint32 literal escapes to heap
..\..\..\..\regexp\onepass.go:426:24: 	from inst.Next (star-dot-equals) at ..\..\..\..\regexp\onepass.go:426:14
..\..\..\..\regexp\onepass.go:433:36: []rune literal escapes to heap
..\..\..\..\regexp\onepass.go:433:36: 	from .sink (slice-element-equals) at ..\..\..\..\regexp\onepass.go:433:21
..\..\..\..\regexp\onepass.go:434:20: make([]uint32, len(onePassRunes[pc]) / 2 + 1) escapes to heap
..\..\..\..\regexp\onepass.go:434:20: 	from make([]uint32, len(onePassRunes[pc]) / 2 + 1) (too large for stack) at ..\..\..\..\regexp\onepass.go:434:20
..\..\..\..\regexp\onepass.go:306:26: makeOnePass &queueOnePass literal does not escape
..\..\..\..\regexp\onepass.go:307:26: makeOnePass &queueOnePass literal does not escape
..\..\..\..\regexp\onepass.go:314:10: makeOnePass func literal does not escape
..\..\..\..\regexp\onepass.go:343:5: makeOnePass.func1 &onePassRunes[inst.Inst.Out] does not escape
..\..\..\..\regexp\onepass.go:343:30: makeOnePass.func1 &onePassRunes[inst.Inst.Arg] does not escape
..\..\..\..\regexp\onepass.go:467:44: leaking param content: prog
..\..\..\..\regexp\onepass.go:467:44: 	from *prog (indirection) at ..\..\..\..\regexp\onepass.go:467:44
..\..\..\..\regexp\onepass.go:467:44: 	from prog (passed to call[argument content escapes]) at ..\..\..\..\regexp\onepass.go:499:17
..\..\..\..\regexp\regexp.go:106:28: leaking param: re to result ~r0 level=1
..\..\..\..\regexp\regexp.go:106:28: 	from re.regexpRO (dot of pointer) at ..\..\..\..\regexp\regexp.go:107:11
..\..\..\..\regexp\regexp.go:106:28: 	from ~r0 (return) at ..\..\..\..\regexp\regexp.go:107:2
..\..\..\..\regexp\regexp.go:118:11: &Regexp literal escapes to heap
..\..\..\..\regexp\regexp.go:118:11: 	from ~r0 (return) at ..\..\..\..\regexp\regexp.go:117:2
..\..\..\..\regexp\regexp.go:114:27: leaking param: re to result ~r0 level=0
..\..\..\..\regexp\regexp.go:114:27: 	from re.regexpRO (dot of pointer) at ..\..\..\..\regexp\regexp.go:118:15
..\..\..\..\regexp\regexp.go:114:27: 	from &Regexp literal (struct literal element) at ..\..\..\..\regexp\regexp.go:117:16
..\..\..\..\regexp\regexp.go:114:27: 	from &Regexp literal (pointer literal) at ..\..\..\..\regexp\regexp.go:118:11
..\..\..\..\regexp\regexp.go:114:27: 	from ~r0 (return) at ..\..\..\..\regexp\regexp.go:117:2
..\..\..\..\regexp\regexp.go:169:70: leaking param: expr
..\..\..\..\regexp\regexp.go:169:70: 	from expr (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:170:25
..\..\..\..\regexp\regexp.go:201:30: ([]byte)(regexp.regexpRO.prefix) escapes to heap
..\..\..\..\regexp\regexp.go:201:30: 	from regexp.regexpRO.prefixBytes (dot-equals) at ..\..\..\..\regexp\regexp.go:201:22
..\..\..\..\regexp\regexp.go:183:11: &Regexp literal escapes to heap
..\..\..\..\regexp\regexp.go:183:11: 	from regexp (assigned) at ..\..\..\..\regexp\regexp.go:182:9
..\..\..\..\regexp\regexp.go:183:11: 	from ~r3 (return) at ..\..\..\..\regexp\regexp.go:204:2
..\..\..\..\regexp\regexp.go:132:37: leaking param: expr
..\..\..\..\regexp\regexp.go:132:37: 	from expr (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:133:16
..\..\..\..\regexp\regexp.go:155:42: leaking param: expr
..\..\..\..\regexp\regexp.go:155:42: 	from expr (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:156:16
..\..\..\..\regexp\regexp.go:165:11: (*Regexp).Longest re does not escape
..\..\..\..\regexp\regexp.go:258:18: "`" + s + "`" escapes to heap
..\..\..\..\regexp\regexp.go:258:18: 	from ~r1 (return) at ..\..\..\..\regexp\regexp.go:258:3
..\..\..\..\regexp\regexp.go:256:22: quote s does not escape
..\..\..\..\regexp\regexp.go:237:31: leaking param: str
..\..\..\..\regexp\regexp.go:237:31: 	from str (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:238:26
..\..\..\..\regexp\regexp.go:240:49: "regexp: Compile(" + quote(str) + "): " + error.Error() escapes to heap
..\..\..\..\regexp\regexp.go:240:49: 	from panic("regexp: Compile(" + quote(str) + "): " + error.Error()) (panic) at ..\..\..\..\regexp\regexp.go:240:8
..\..\..\..\regexp\regexp.go:248:36: leaking param: str
..\..\..\..\regexp\regexp.go:248:36: 	from str (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:249:31
..\..\..\..\regexp\regexp.go:251:54: "regexp: CompilePOSIX(" + quote(str) + "): " + error.Error() escapes to heap
..\..\..\..\regexp\regexp.go:251:54: 	from panic("regexp: CompilePOSIX(" + quote(str) + "): " + error.Error()) (panic) at ..\..\..\..\regexp\regexp.go:251:8
..\..\..\..\regexp\regexp.go:264:31: (*Regexp).NumSubexp re does not escape
..\..\..\..\regexp\regexp.go:273:35: leaking param: re to result ~r0 level=1
..\..\..\..\regexp\regexp.go:273:35: 	from re.regexpRO (dot of pointer) at ..\..\..\..\regexp\regexp.go:274:11
..\..\..\..\regexp\regexp.go:273:35: 	from ~r0 (return) at ..\..\..\..\regexp\regexp.go:274:2
..\..\..\..\regexp\regexp.go:294:44: (*inputString).step i does not escape
..\..\..\..\regexp\regexp.go:305:40: (*inputString).canCheckPrefix i does not escape
..\..\..\..\regexp\regexp.go:309:45: (*inputString).hasPrefix i does not escape
..\..\..\..\regexp\regexp.go:309:45: (*inputString).hasPrefix re does not escape
..\..\..\..\regexp\regexp.go:313:50: leaking param content: i
..\..\..\..\regexp\regexp.go:313:50: 	from i.str (dot of pointer) at ..\..\..\..\regexp\regexp.go:314:24
..\..\..\..\regexp\regexp.go:313:50: 	from i.str[pos:] (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:314:22
..\..\..\..\regexp\regexp.go:313:50: (*inputString).index re does not escape
..\..\..\..\regexp\regexp.go:317:40: (*inputString).context i does not escape
..\..\..\..\regexp\regexp.go:341:43: (*inputBytes).step i does not escape
..\..\..\..\regexp\regexp.go:352:39: (*inputBytes).canCheckPrefix i does not escape
..\..\..\..\regexp\regexp.go:356:44: (*inputBytes).hasPrefix i does not escape
..\..\..\..\regexp\regexp.go:356:44: (*inputBytes).hasPrefix re does not escape
..\..\..\..\regexp\regexp.go:360:49: (*inputBytes).index i does not escape
..\..\..\..\regexp\regexp.go:360:49: (*inputBytes).index re does not escape
..\..\..\..\regexp\regexp.go:364:39: (*inputBytes).context i does not escape
..\..\..\..\regexp\regexp.go:390:44: leaking param content: i
..\..\..\..\regexp\regexp.go:390:44: 	from i.r (dot of pointer) at ..\..\..\..\regexp\regexp.go:395:16
..\..\..\..\regexp\regexp.go:390:44: 	from i.r.ReadRune() (receiver in indirect call) at ..\..\..\..\regexp\regexp.go:395:27
..\..\..\..\regexp\regexp.go:404:40: (*inputReader).canCheckPrefix i does not escape
..\..\..\..\regexp\regexp.go:408:45: (*inputReader).hasPrefix i does not escape
..\..\..\..\regexp\regexp.go:408:45: (*inputReader).hasPrefix re does not escape
..\..\..\..\regexp\regexp.go:412:50: (*inputReader).index i does not escape
..\..\..\..\regexp\regexp.go:412:50: (*inputReader).index re does not escape
..\..\..\..\regexp\regexp.go:416:40: (*inputReader).context i does not escape
..\..\..\..\regexp\regexp.go:423:60: leaking param: re to result prefix level=1
..\..\..\..\regexp\regexp.go:423:60: 	from re.regexpRO (dot of pointer) at ..\..\..\..\regexp\regexp.go:424:11
..\..\..\..\regexp\regexp.go:423:60: 	from prefix (return) at ..\..\..\..\regexp\regexp.go:424:2
..\..\..\..\regexp\regexp.go:429:48: leaking param: re
..\..\..\..\regexp\regexp.go:429:48: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:430:19
..\..\..\..\regexp\regexp.go:429:48: leaking param: r
..\..\..\..\regexp\regexp.go:429:48: 	from r (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:430:19
..\..\..\..\regexp\regexp.go:434:41: leaking param: re
..\..\..\..\regexp\regexp.go:434:41: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:435:19
..\..\..\..\regexp\regexp.go:434:41: leaking param: s
..\..\..\..\regexp\regexp.go:434:41: 	from s (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:435:19
..\..\..\..\regexp\regexp.go:439:35: leaking param: re
..\..\..\..\regexp\regexp.go:439:35: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:440:19
..\..\..\..\regexp\regexp.go:439:35: leaking param: b
..\..\..\..\regexp\regexp.go:439:35: 	from b (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:440:19
..\..\..\..\regexp\regexp.go:446:70: leaking param: pattern
..\..\..\..\regexp\regexp.go:446:70: 	from pattern (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:447:20
..\..\..\..\regexp\regexp.go:446:70: leaking param: r
..\..\..\..\regexp\regexp.go:446:70: 	from r (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:451:23
..\..\..\..\regexp\regexp.go:457:63: leaking param: pattern
..\..\..\..\regexp\regexp.go:457:63: 	from pattern (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:458:20
..\..\..\..\regexp\regexp.go:457:63: leaking param: s
..\..\..\..\regexp\regexp.go:457:63: 	from s (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:462:23
..\..\..\..\regexp\regexp.go:468:57: leaking param: pattern
..\..\..\..\regexp\regexp.go:468:57: 	from pattern (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:469:20
..\..\..\..\regexp\regexp.go:468:57: leaking param: b
..\..\..\..\regexp\regexp.go:468:57: 	from b (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:473:17
..\..\..\..\regexp\regexp.go:879:65: leaking param: str to result name level=0
..\..\..\..\regexp\regexp.go:879:65: 	from name (assigned) at ..\..\..\..\regexp\regexp.go:902:7
..\..\..\..\regexp\regexp.go:879:65: leaking param: str to result rest level=0
..\..\..\..\regexp\regexp.go:879:65: 	from rest (assigned) at ..\..\..\..\regexp\regexp.go:925:7
..\..\..\..\regexp\regexp.go:830:95: leaking param: template
..\..\..\..\regexp\regexp.go:830:95: 	from template (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:832:21
..\..\..\..\regexp\regexp.go:830:95: leaking param content: dst
..\..\..\..\regexp\regexp.go:830:95: 	from *dst (indirection) at ..\..\..\..\regexp\regexp.go:830:95
..\..\..\..\regexp\regexp.go:830:95: 	from append(dst, template[:i]...) (appendee slice) at ..\..\..\..\regexp\regexp.go:836:15
..\..\..\..\regexp\regexp.go:830:95: leaking param content: bsrc
..\..\..\..\regexp\regexp.go:830:95: 	from bsrc[match[2 * num]:match[2 * num + 1]] (slice) at ..\..\..\..\regexp\regexp.go:855:28
..\..\..\..\regexp\regexp.go:830:95: 	from *bsrc[match[2 * num]:match[2 * num + 1]] (indirection) at ..\..\..\..\regexp\regexp.go:855:28
..\..\..\..\regexp\regexp.go:830:95: 	from append(dst, bsrc[match[2 * num]:match[2 * num + 1]]...) (appended slice...) at ..\..\..\..\regexp\regexp.go:855:18
..\..\..\..\regexp\regexp.go:830:95: leaking param content: src
..\..\..\..\regexp\regexp.go:830:95: 	from src[match[2 * num]:match[2 * num + 1]] (slice) at ..\..\..\..\regexp\regexp.go:857:27
..\..\..\..\regexp\regexp.go:830:95: 	from *src[match[2 * num]:match[2 * num + 1]] (indirection) at ..\..\..\..\regexp\regexp.go:857:27
..\..\..\..\regexp\regexp.go:830:95: 	from append(dst, src[match[2 * num]:match[2 * num + 1]]...) (appended slice...) at ..\..\..\..\regexp\regexp.go:857:18
..\..\..\..\regexp\regexp.go:830:95: leaking param: dst to result ~r5 level=0
..\..\..\..\regexp\regexp.go:830:95: 	from ~r5 (return) at ..\..\..\..\regexp\regexp.go:874:2
..\..\..\..\regexp\regexp.go:830:95: (*Regexp).expand re does not escape
..\..\..\..\regexp\regexp.go:830:95: (*Regexp).expand match does not escape
..\..\..\..\regexp\regexp.go:510:108: leaking param: re
..\..\..\..\regexp\regexp.go:510:108: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:526:20
..\..\..\..\regexp\regexp.go:510:108: leaking param: bsrc
..\..\..\..\regexp\regexp.go:510:108: 	from bsrc (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:526:20
..\..\..\..\regexp\regexp.go:510:108: leaking param: src
..\..\..\..\regexp\regexp.go:510:108: 	from src (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:526:20
..\..\..\..\regexp\regexp.go:510:108: leaking param content: repl
..\..\..\..\regexp\regexp.go:510:108: 	from *repl (indirection) at ..\..\..\..\regexp\regexp.go:510:108
..\..\..\..\regexp\regexp.go:510:108: 	from .out0 (captured by called closure) at ..\..\..\..\regexp\regexp.go:543:14
..\..\..\..\regexp\regexp.go:510:108: 	from buf (assigned) at ..\..\..\..\regexp\regexp.go:513:6
..\..\..\..\regexp\regexp.go:510:108: 	from *buf (indirection) at ..\..\..\..\regexp\regexp.go:513:6
..\..\..\..\regexp\regexp.go:510:108: 	from append(buf, bsrc[lastMatchEnd:a[0]]...) (appendee slice) at ..\..\..\..\regexp\regexp.go:533:16
..\..\..\..\regexp\regexp.go:526:62: dstCap escapes to heap
..\..\..\..\regexp\regexp.go:526:62: 	from .out0 (passed-to-and-returned-from-call) at ..\..\..\..\regexp\regexp.go:526:20
..\..\..\..\regexp\regexp.go:526:62: 	from a (assigned) at ..\..\..\..\regexp\regexp.go:526:3
..\..\..\..\regexp\regexp.go:526:62: 	from repl(buf, a) (parameter to indirect call) at ..\..\..\..\regexp\regexp.go:543:14
..\..\..\..\regexp\regexp.go:524:6: moved to heap: dstCap
..\..\..\..\regexp\regexp.go:510:108: leaking param: repl to result ~r4 level=1
..\..\..\..\regexp\regexp.go:510:108: 	from *repl (indirection) at ..\..\..\..\regexp\regexp.go:510:108
..\..\..\..\regexp\regexp.go:510:108: 	from .out0 (captured by called closure) at ..\..\..\..\regexp\regexp.go:543:14
..\..\..\..\regexp\regexp.go:510:108: 	from buf (assigned) at ..\..\..\..\regexp\regexp.go:513:6
..\..\..\..\regexp\regexp.go:510:108: 	from ~r4 (return) at ..\..\..\..\regexp\regexp.go:572:2
..\..\..\..\regexp\regexp.go:479:54: leaking param: repl
..\..\..\..\regexp\regexp.go:479:54: 	from repl (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:481:21
..\..\..\..\regexp\regexp.go:479:54: leaking param: re
..\..\..\..\regexp\regexp.go:479:54: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:484:20
..\..\..\..\regexp\regexp.go:479:54: leaking param: src
..\..\..\..\regexp\regexp.go:479:54: 	from src (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:484:20
..\..\..\..\regexp\regexp.go:484:66: leaking param content: dst
..\..\..\..\regexp\regexp.go:484:66: 	from *dst (indirection) at ..\..\..\..\regexp\regexp.go:484:66
..\..\..\..\regexp\regexp.go:484:66: 	from dst (passed to call[argument content escapes]) at ..\..\..\..\regexp\regexp.go:485:19
..\..\..\..\regexp\regexp.go:485:25: leaking closure reference repl
..\..\..\..\regexp\regexp.go:485:25: 	from repl (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:485:19
..\..\..\..\regexp\regexp.go:487:15: string(b) escapes to heap
..\..\..\..\regexp\regexp.go:487:15: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:487:2
..\..\..\..\regexp\regexp.go:484:66: leaking param: dst to result ~r2 level=0
..\..\..\..\regexp\regexp.go:484:66: 	from .out0 (passed-to-and-returned-from-call) at ..\..\..\..\regexp\regexp.go:485:19
..\..\..\..\regexp\regexp.go:484:66: 	from ~r2 (assigned) at ..\..\..\..\regexp\regexp.go:484:66
..\..\..\..\regexp\regexp.go:484:34: (*Regexp).ReplaceAllString func literal does not escape
..\..\..\..\regexp\regexp.go:484:66: (*Regexp).ReplaceAllString.func1 match does not escape
..\..\..\..\regexp\regexp.go:493:61: leaking param: re
..\..\..\..\regexp\regexp.go:493:61: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:494:29
..\..\..\..\regexp\regexp.go:493:61: leaking param: src
..\..\..\..\regexp\regexp.go:493:61: 	from src (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:494:29
..\..\..\..\regexp\regexp.go:493:61: leaking param content: repl
..\..\..\..\regexp\regexp.go:493:61: 	from func literal (captured by a closure) at ..\..\..\..\regexp\regexp.go:494:43
..\..\..\..\regexp\regexp.go:493:61: 	from *(func literal) (indirection) at ..\..\..\..\regexp\regexp.go:494:43
..\..\..\..\regexp\regexp.go:493:61: 	from func literal (passed to call[argument content escapes]) at ..\..\..\..\regexp\regexp.go:494:29
..\..\..\..\regexp\regexp.go:494:75: leaking param content: dst
..\..\..\..\regexp\regexp.go:494:75: 	from *dst (indirection) at ..\..\..\..\regexp\regexp.go:494:75
..\..\..\..\regexp\regexp.go:494:75: 	from append(dst, repl...) (appendee slice) at ..\..\..\..\regexp\regexp.go:495:16
..\..\..\..\regexp\regexp.go:494:15: string(re.replaceAll(nil, src, 2, func literal)) escapes to heap
..\..\..\..\regexp\regexp.go:494:15: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:494:2
..\..\..\..\regexp\regexp.go:494:75: leaking param: dst to result ~r2 level=0
..\..\..\..\regexp\regexp.go:494:75: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:495:3
..\..\..\..\regexp\regexp.go:494:43: (*Regexp).ReplaceAllLiteralString func literal does not escape
..\..\..\..\regexp\regexp.go:494:75: (*Regexp).ReplaceAllLiteralString.func1 match does not escape
..\..\..\..\regexp\regexp.go:503:78: leaking param: re
..\..\..\..\regexp\regexp.go:503:78: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:504:20
..\..\..\..\regexp\regexp.go:503:78: leaking param: src
..\..\..\..\regexp\regexp.go:503:78: 	from src (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:504:20
..\..\..\..\regexp\regexp.go:503:78: leaking param content: repl
..\..\..\..\regexp\regexp.go:503:78: 	from func literal (captured by a closure) at ..\..\..\..\regexp\regexp.go:504:34
..\..\..\..\regexp\regexp.go:503:78: 	from *(func literal) (indirection) at ..\..\..\..\regexp\regexp.go:504:34
..\..\..\..\regexp\regexp.go:503:78: 	from func literal (passed to call[argument content escapes]) at ..\..\..\..\regexp\regexp.go:504:20
..\..\..\..\regexp\regexp.go:505:27: leaking closure reference src
..\..\..\..\regexp\regexp.go:505:27: 	from repl(src[match[0]:match[1]]) (parameter to indirect call) at ..\..\..\..\regexp\regexp.go:505:26
..\..\..\..\regexp\regexp.go:504:66: leaking param content: dst
..\..\..\..\regexp\regexp.go:504:66: 	from *dst (indirection) at ..\..\..\..\regexp\regexp.go:504:66
..\..\..\..\regexp\regexp.go:504:66: 	from append(dst, repl(src[match[0]:match[1]])...) (appendee slice) at ..\..\..\..\regexp\regexp.go:505:16
..\..\..\..\regexp\regexp.go:507:15: string(b) escapes to heap
..\..\..\..\regexp\regexp.go:507:15: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:507:2
..\..\..\..\regexp\regexp.go:504:66: leaking param: dst to result ~r2 level=0
..\..\..\..\regexp\regexp.go:504:66: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:505:3
..\..\..\..\regexp\regexp.go:504:34: (*Regexp).ReplaceAllStringFunc func literal does not escape
..\..\..\..\regexp\regexp.go:504:66: (*Regexp).ReplaceAllStringFunc.func1 match does not escape
..\..\..\..\regexp\regexp.go:578:50: leaking param: re
..\..\..\..\regexp\regexp.go:578:50: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:584:20
..\..\..\..\regexp\regexp.go:578:50: leaking param: src
..\..\..\..\regexp\regexp.go:578:50: 	from src (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:584:20
..\..\..\..\regexp\regexp.go:578:50: leaking param content: repl
..\..\..\..\regexp\regexp.go:578:50: 	from func literal (captured by a closure) at ..\..\..\..\regexp\regexp.go:584:33
..\..\..\..\regexp\regexp.go:578:50: 	from *(func literal) (indirection) at ..\..\..\..\regexp\regexp.go:584:33
..\..\..\..\regexp\regexp.go:578:50: 	from func literal (passed to call[argument content escapes]) at ..\..\..\..\regexp\regexp.go:584:20
..\..\..\..\regexp\regexp.go:584:65: leaking param content: dst
..\..\..\..\regexp\regexp.go:584:65: 	from *dst (indirection) at ..\..\..\..\regexp\regexp.go:584:65
..\..\..\..\regexp\regexp.go:584:65: 	from dst (passed to call[argument content escapes]) at ..\..\..\..\regexp\regexp.go:588:19
..\..\..\..\regexp\regexp.go:585:10: leaking closure reference srepl
..\..\..\..\regexp\regexp.go:585:10: 	from srepl (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:588:19
..\..\..\..\regexp\regexp.go:586:18: string(repl) escapes to heap
..\..\..\..\regexp\regexp.go:586:18: 	from srepl (assigned) at ..\..\..\..\regexp\regexp.go:586:10
..\..\..\..\regexp\regexp.go:586:18: 	from srepl (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:588:19
..\..\..\..\regexp\regexp.go:578:50: leaking param: repl to result ~r2 level=1
..\..\..\..\regexp\regexp.go:578:50: 	from func literal (captured by a closure) at ..\..\..\..\regexp\regexp.go:584:33
..\..\..\..\regexp\regexp.go:578:50: 	from *(func literal) (indirection) at ..\..\..\..\regexp\regexp.go:584:33
..\..\..\..\regexp\regexp.go:578:50: 	from .out0 (passed-to-and-returned-from-call) at ..\..\..\..\regexp\regexp.go:584:20
..\..\..\..\regexp\regexp.go:578:50: 	from b (assigned) at ..\..\..\..\regexp\regexp.go:584:2
..\..\..\..\regexp\regexp.go:578:50: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:590:2
..\..\..\..\regexp\regexp.go:584:65: leaking param: dst to result ~r2 level=0
..\..\..\..\regexp\regexp.go:584:65: 	from .out0 (passed-to-and-returned-from-call) at ..\..\..\..\regexp\regexp.go:588:19
..\..\..\..\regexp\regexp.go:584:65: 	from ~r2 (assigned) at ..\..\..\..\regexp\regexp.go:584:65
..\..\..\..\regexp\regexp.go:584:33: (*Regexp).ReplaceAll func literal does not escape
..\..\..\..\regexp\regexp.go:584:65: (*Regexp).ReplaceAll.func1 match does not escape
..\..\..\..\regexp\regexp.go:596:57: leaking param: re
..\..\..\..\regexp\regexp.go:596:57: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:597:22
..\..\..\..\regexp\regexp.go:596:57: leaking param: src
..\..\..\..\regexp\regexp.go:596:57: 	from src (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:597:22
..\..\..\..\regexp\regexp.go:596:57: leaking param content: repl
..\..\..\..\regexp\regexp.go:596:57: 	from func literal (captured by a closure) at ..\..\..\..\regexp\regexp.go:597:35
..\..\..\..\regexp\regexp.go:596:57: 	from *(func literal) (indirection) at ..\..\..\..\regexp\regexp.go:597:35
..\..\..\..\regexp\regexp.go:596:57: 	from func literal (passed to call[argument content escapes]) at ..\..\..\..\regexp\regexp.go:597:22
..\..\..\..\regexp\regexp.go:597:67: leaking param content: dst
..\..\..\..\regexp\regexp.go:597:67: 	from *dst (indirection) at ..\..\..\..\regexp\regexp.go:597:67
..\..\..\..\regexp\regexp.go:597:67: 	from append(dst, repl...) (appendee slice) at ..\..\..\..\regexp\regexp.go:598:16
..\..\..\..\regexp\regexp.go:596:57: leaking param: repl to result ~r2 level=1
..\..\..\..\regexp\regexp.go:596:57: 	from func literal (captured by a closure) at ..\..\..\..\regexp\regexp.go:597:35
..\..\..\..\regexp\regexp.go:596:57: 	from *(func literal) (indirection) at ..\..\..\..\regexp\regexp.go:597:35
..\..\..\..\regexp\regexp.go:596:57: 	from .out0 (passed-to-and-returned-from-call) at ..\..\..\..\regexp\regexp.go:597:22
..\..\..\..\regexp\regexp.go:596:57: 	from ~r2 (assigned) at ..\..\..\..\regexp\regexp.go:596:57
..\..\..\..\regexp\regexp.go:597:67: leaking param: dst to result ~r2 level=0
..\..\..\..\regexp\regexp.go:597:67: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:598:3
..\..\..\..\regexp\regexp.go:597:35: (*Regexp).ReplaceAllLiteral func literal does not escape
..\..\..\..\regexp\regexp.go:597:67: (*Regexp).ReplaceAllLiteral.func1 match does not escape
..\..\..\..\regexp\regexp.go:606:74: leaking param: re
..\..\..\..\regexp\regexp.go:606:74: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:607:22
..\..\..\..\regexp\regexp.go:606:74: leaking param: src
..\..\..\..\regexp\regexp.go:606:74: 	from src (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:607:22
..\..\..\..\regexp\regexp.go:606:74: leaking param content: repl
..\..\..\..\regexp\regexp.go:606:74: 	from func literal (captured by a closure) at ..\..\..\..\regexp\regexp.go:607:35
..\..\..\..\regexp\regexp.go:606:74: 	from *(func literal) (indirection) at ..\..\..\..\regexp\regexp.go:607:35
..\..\..\..\regexp\regexp.go:606:74: 	from func literal (passed to call[argument content escapes]) at ..\..\..\..\regexp\regexp.go:607:22
..\..\..\..\regexp\regexp.go:608:27: leaking closure reference src
..\..\..\..\regexp\regexp.go:608:27: 	from repl(src[match[0]:match[1]]) (parameter to indirect call) at ..\..\..\..\regexp\regexp.go:608:26
..\..\..\..\regexp\regexp.go:607:67: leaking param content: dst
..\..\..\..\regexp\regexp.go:607:67: 	from *dst (indirection) at ..\..\..\..\regexp\regexp.go:607:67
..\..\..\..\regexp\regexp.go:607:67: 	from append(dst, repl(src[match[0]:match[1]])...) (appendee slice) at ..\..\..\..\regexp\regexp.go:608:16
..\..\..\..\regexp\regexp.go:606:74: leaking param: repl to result ~r2 level=1
..\..\..\..\regexp\regexp.go:606:74: 	from func literal (captured by a closure) at ..\..\..\..\regexp\regexp.go:607:35
..\..\..\..\regexp\regexp.go:606:74: 	from *(func literal) (indirection) at ..\..\..\..\regexp\regexp.go:607:35
..\..\..\..\regexp\regexp.go:606:74: 	from .out0 (passed-to-and-returned-from-call) at ..\..\..\..\regexp\regexp.go:607:22
..\..\..\..\regexp\regexp.go:606:74: 	from ~r2 (assigned) at ..\..\..\..\regexp\regexp.go:606:74
..\..\..\..\regexp\regexp.go:607:67: leaking param: dst to result ~r2 level=0
..\..\..\..\regexp\regexp.go:607:67: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:608:3
..\..\..\..\regexp\regexp.go:607:35: (*Regexp).ReplaceAllFunc func literal does not escape
..\..\..\..\regexp\regexp.go:607:67: (*Regexp).ReplaceAllFunc.func1 match does not escape
..\..\..\..\regexp\regexp.go:621:26: init.0 ([]byte)("\\.+*?()|[]{}^$") does not escape
..\..\..\..\regexp\regexp.go:629:26: leaking param: s to result ~r1 level=0
..\..\..\..\regexp\regexp.go:629:26: 	from ~r1 (return) at ..\..\..\..\regexp\regexp.go:639:3
..\..\..\..\regexp\regexp.go:653:15: string(b[:j]) escapes to heap
..\..\..\..\regexp\regexp.go:653:15: 	from ~r1 (return) at ..\..\..\..\regexp\regexp.go:653:2
..\..\..\..\regexp\regexp.go:642:11: make([]byte, 2 * len(s) - i) escapes to heap
..\..\..\..\regexp\regexp.go:642:11: 	from make([]byte, 2 * len(s) - i) (too large for stack) at ..\..\..\..\regexp\regexp.go:642:11
..\..\..\..\regexp\regexp.go:629:26: leaking param content: s
..\..\..\..\regexp\regexp.go:629:26: 	from s[:i] (slice) at ..\..\..\..\regexp\regexp.go:643:11
..\..\..\..\regexp\regexp.go:629:26: 	from *s[:i] (indirection) at ..\..\..\..\regexp\regexp.go:643:11
..\..\..\..\regexp\regexp.go:629:26: 	from copy(b, s[:i]) (copied slice) at ..\..\..\..\regexp\regexp.go:643:6
..\..\..\..\regexp\regexp.go:661:34: leaking param content: a
..\..\..\..\regexp\regexp.go:661:34: 	from *a (indirection) at ..\..\..\..\regexp\regexp.go:661:34
..\..\..\..\regexp\regexp.go:661:34: 	from append(a, -1) (appendee slice) at ..\..\..\..\regexp\regexp.go:668:13
..\..\..\..\regexp\regexp.go:661:34: leaking param: a to result ~r1 level=0
..\..\..\..\regexp\regexp.go:661:34: 	from ~r1 (return) at ..\..\..\..\regexp\regexp.go:670:2
..\..\..\..\regexp\regexp.go:661:34: (*Regexp).pad re does not escape
..\..\..\..\regexp\regexp.go:674:72: leaking param: re
..\..\..\..\regexp\regexp.go:674:72: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:683:26
..\..\..\..\regexp\regexp.go:674:72: leaking param: b
..\..\..\..\regexp\regexp.go:674:72: 	from b (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:683:26
..\..\..\..\regexp\regexp.go:674:72: leaking param: s
..\..\..\..\regexp\regexp.go:674:72: 	from s (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:683:26
..\..\..\..\regexp\regexp.go:674:72: (*Regexp).allMatches deliver does not escape
..\..\..\..\regexp\regexp.go:722:36: leaking param: re
..\..\..\..\regexp\regexp.go:722:36: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:724:19
..\..\..\..\regexp\regexp.go:722:36: leaking param: b
..\..\..\..\regexp\regexp.go:722:36: 	from b (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:724:19
..\..\..\..\regexp\regexp.go:724:44: (*Regexp).Find dstCap does not escape
..\..\..\..\regexp\regexp.go:735:46: leaking param: re
..\..\..\..\regexp\regexp.go:735:46: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:736:19
..\..\..\..\regexp\regexp.go:735:46: leaking param: b
..\..\..\..\regexp\regexp.go:735:46: 	from b (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:736:19
..\..\..\..\regexp\regexp.go:748:40: leaking param: re
..\..\..\..\regexp\regexp.go:748:40: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:750:19
..\..\..\..\regexp\regexp.go:748:40: leaking param: s
..\..\..\..\regexp\regexp.go:748:40: 	from s (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:750:19
..\..\..\..\regexp\regexp.go:750:45: (*Regexp).FindString dstCap does not escape
..\..\..\..\regexp\regexp.go:761:52: leaking param: re
..\..\..\..\regexp\regexp.go:761:52: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:762:19
..\..\..\..\regexp\regexp.go:761:52: leaking param: s
..\..\..\..\regexp\regexp.go:761:52: 	from s (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:762:19
..\..\..\..\regexp\regexp.go:774:59: leaking param: re
..\..\..\..\regexp\regexp.go:774:59: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:775:19
..\..\..\..\regexp\regexp.go:774:59: leaking param: r
..\..\..\..\regexp\regexp.go:774:59: 	from r (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:775:19
..\..\..\..\regexp\regexp.go:787:46: leaking param: re
..\..\..\..\regexp\regexp.go:787:46: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:789:19
..\..\..\..\regexp\regexp.go:787:46: leaking param: b
..\..\..\..\regexp\regexp.go:787:46: 	from b (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:789:19
..\..\..\..\regexp\regexp.go:793:13: make([][]byte, 1 + re.regexpRO.numSubexp) escapes to heap
..\..\..\..\regexp\regexp.go:793:13: 	from make([][]byte, 1 + re.regexpRO.numSubexp) (too large for stack) at ..\..\..\..\regexp\regexp.go:793:13
..\..\..\..\regexp\regexp.go:789:57: (*Regexp).FindSubmatch dstCap does not escape
..\..\..\..\regexp\regexp.go:819:82: leaking param content: dst
..\..\..\..\regexp\regexp.go:819:82: 	from *dst (indirection) at ..\..\..\..\regexp\regexp.go:819:82
..\..\..\..\regexp\regexp.go:819:82: 	from dst (passed to call[argument content escapes]) at ..\..\..\..\regexp\regexp.go:820:18
..\..\..\..\regexp\regexp.go:820:30: string(template) escapes to heap
..\..\..\..\regexp\regexp.go:820:30: 	from string(template) (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:820:18
..\..\..\..\regexp\regexp.go:819:82: leaking param content: src
..\..\..\..\regexp\regexp.go:819:82: 	from *src (indirection) at ..\..\..\..\regexp\regexp.go:819:82
..\..\..\..\regexp\regexp.go:819:82: 	from src (passed to call[argument content escapes]) at ..\..\..\..\regexp\regexp.go:820:18
..\..\..\..\regexp\regexp.go:819:82: leaking param: dst to result ~r4 level=0
..\..\..\..\regexp\regexp.go:819:82: 	from .out0 (passed-to-and-returned-from-call) at ..\..\..\..\regexp\regexp.go:820:18
..\..\..\..\regexp\regexp.go:819:82: 	from ~r4 (assigned) at ..\..\..\..\regexp\regexp.go:819:82
..\..\..\..\regexp\regexp.go:819:82: (*Regexp).Expand re does not escape
..\..\..\..\regexp\regexp.go:819:82: (*Regexp).Expand template does not escape
..\..\..\..\regexp\regexp.go:819:82: (*Regexp).Expand match does not escape
..\..\..\..\regexp\regexp.go:826:88: leaking param content: dst
..\..\..\..\regexp\regexp.go:826:88: 	from *dst (indirection) at ..\..\..\..\regexp\regexp.go:826:88
..\..\..\..\regexp\regexp.go:826:88: 	from dst (passed to call[argument content escapes]) at ..\..\..\..\regexp\regexp.go:827:18
..\..\..\..\regexp\regexp.go:826:88: leaking param: template
..\..\..\..\regexp\regexp.go:826:88: 	from template (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:827:18
..\..\..\..\regexp\regexp.go:826:88: leaking param content: src
..\..\..\..\regexp\regexp.go:826:88: 	from *src (indirection) at ..\..\..\..\regexp\regexp.go:826:88
..\..\..\..\regexp\regexp.go:826:88: 	from src (passed to call[argument content escapes]) at ..\..\..\..\regexp\regexp.go:827:18
..\..\..\..\regexp\regexp.go:826:88: leaking param: dst to result ~r4 level=0
..\..\..\..\regexp\regexp.go:826:88: 	from .out0 (passed-to-and-returned-from-call) at ..\..\..\..\regexp\regexp.go:827:18
..\..\..\..\regexp\regexp.go:826:88: 	from ~r4 (assigned) at ..\..\..\..\regexp\regexp.go:826:88
..\..\..\..\regexp\regexp.go:826:88: (*Regexp).ExpandString re does not escape
..\..\..\..\regexp\regexp.go:826:88: (*Regexp).ExpandString match does not escape
..\..\..\..\regexp\regexp.go:935:49: leaking param: re
..\..\..\..\regexp\regexp.go:935:49: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:936:28
..\..\..\..\regexp\regexp.go:935:49: leaking param: b
..\..\..\..\regexp\regexp.go:935:49: 	from b (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:936:28
..\..\..\..\regexp\regexp.go:944:50: leaking param: re
..\..\..\..\regexp\regexp.go:944:50: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:946:19
..\..\..\..\regexp\regexp.go:944:50: leaking param: s
..\..\..\..\regexp\regexp.go:944:50: 	from s (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:946:19
..\..\..\..\regexp\regexp.go:950:13: make([]string, 1 + re.regexpRO.numSubexp) escapes to heap
..\..\..\..\regexp\regexp.go:950:13: 	from make([]string, 1 + re.regexpRO.numSubexp) (too large for stack) at ..\..\..\..\regexp\regexp.go:950:13
..\..\..\..\regexp\regexp.go:946:58: (*Regexp).FindStringSubmatch dstCap does not escape
..\..\..\..\regexp\regexp.go:964:55: leaking param: re
..\..\..\..\regexp\regexp.go:964:55: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:965:28
..\..\..\..\regexp\regexp.go:964:55: leaking param: s
..\..\..\..\regexp\regexp.go:964:55: 	from s (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:965:28
..\..\..\..\regexp\regexp.go:973:62: leaking param: re
..\..\..\..\regexp\regexp.go:973:62: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:974:28
..\..\..\..\regexp\regexp.go:973:62: leaking param: r
..\..\..\..\regexp\regexp.go:973:62: 	from r (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:974:28
..\..\..\..\regexp\regexp.go:983:48: leaking param: re
..\..\..\..\regexp\regexp.go:983:48: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:988:15
..\..\..\..\regexp\regexp.go:983:48: leaking param: b
..\..\..\..\regexp\regexp.go:983:48: 	from b (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:988:15
..\..\..\..\regexp\regexp.go:989:27: leaking closure reference b
..\..\..\..\regexp\regexp.go:989:27: 	from append(result, b[match[0]:match[1]]) (appended to slice) at ..\..\..\..\regexp\regexp.go:989:18
..\..\..\..\regexp\regexp.go:987:16: make([][]byte, 0, startSize) escapes to heap
..\..\..\..\regexp\regexp.go:987:16: 	from result (assigned) at ..\..\..\..\regexp\regexp.go:987:9
..\..\..\..\regexp\regexp.go:987:16: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:994:2
..\..\..\..\regexp\regexp.go:988:26: (*Regexp).FindAll func literal does not escape
..\..\..\..\regexp\regexp.go:988:39: (*Regexp).FindAll.func1 match does not escape
..\..\..\..\regexp\regexp.go:1001:53: leaking param: re
..\..\..\..\regexp\regexp.go:1001:53: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1006:15
..\..\..\..\regexp\regexp.go:1001:53: leaking param: b
..\..\..\..\regexp\regexp.go:1001:53: 	from b (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1006:15
..\..\..\..\regexp\regexp.go:1006:39: leaking param: match
..\..\..\..\regexp\regexp.go:1006:39: 	from append(result, match[0:2]) (appended to slice) at ..\..\..\..\regexp\regexp.go:1007:18
..\..\..\..\regexp\regexp.go:1005:16: make([][]int, 0, startSize) escapes to heap
..\..\..\..\regexp\regexp.go:1005:16: 	from result (assigned) at ..\..\..\..\regexp\regexp.go:1005:9
..\..\..\..\regexp\regexp.go:1005:16: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:1012:2
..\..\..\..\regexp\regexp.go:1006:26: (*Regexp).FindAllIndex func literal does not escape
..\..\..\..\regexp\regexp.go:1019:52: leaking param: re
..\..\..\..\regexp\regexp.go:1019:52: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1024:15
..\..\..\..\regexp\regexp.go:1019:52: leaking param: s
..\..\..\..\regexp\regexp.go:1019:52: 	from s (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1024:15
..\..\..\..\regexp\regexp.go:1025:27: leaking closure reference s
..\..\..\..\regexp\regexp.go:1025:27: 	from append(result, s[match[0]:match[1]]) (appended to slice) at ..\..\..\..\regexp\regexp.go:1025:18
..\..\..\..\regexp\regexp.go:1023:16: make([]string, 0, startSize) escapes to heap
..\..\..\..\regexp\regexp.go:1023:16: 	from result (assigned) at ..\..\..\..\regexp\regexp.go:1023:9
..\..\..\..\regexp\regexp.go:1023:16: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:1030:2
..\..\..\..\regexp\regexp.go:1024:27: (*Regexp).FindAllString func literal does not escape
..\..\..\..\regexp\regexp.go:1024:40: (*Regexp).FindAllString.func1 match does not escape
..\..\..\..\regexp\regexp.go:1037:59: leaking param: re
..\..\..\..\regexp\regexp.go:1037:59: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1042:15
..\..\..\..\regexp\regexp.go:1037:59: leaking param: s
..\..\..\..\regexp\regexp.go:1037:59: 	from s (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1042:15
..\..\..\..\regexp\regexp.go:1042:40: leaking param: match
..\..\..\..\regexp\regexp.go:1042:40: 	from append(result, match[0:2]) (appended to slice) at ..\..\..\..\regexp\regexp.go:1043:18
..\..\..\..\regexp\regexp.go:1041:16: make([][]int, 0, startSize) escapes to heap
..\..\..\..\regexp\regexp.go:1041:16: 	from result (assigned) at ..\..\..\..\regexp\regexp.go:1041:9
..\..\..\..\regexp\regexp.go:1041:16: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:1048:2
..\..\..\..\regexp\regexp.go:1042:27: (*Regexp).FindAllStringIndex func literal does not escape
..\..\..\..\regexp\regexp.go:1055:58: leaking param: re
..\..\..\..\regexp\regexp.go:1055:58: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1060:15
..\..\..\..\regexp\regexp.go:1055:58: leaking param: b
..\..\..\..\regexp\regexp.go:1055:58: 	from b (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1060:15
..\..\..\..\regexp\regexp.go:1061:16: make([][]byte, len(match) / 2) escapes to heap
..\..\..\..\regexp\regexp.go:1061:16: 	from make([][]byte, len(match) / 2) (too large for stack) at ..\..\..\..\regexp\regexp.go:1061:16
..\..\..\..\regexp\regexp.go:1064:16: leaking closure reference b
..\..\..\..\regexp\regexp.go:1064:16: 	from slice[j] (slice-element-equals) at ..\..\..\..\regexp\regexp.go:1064:14
..\..\..\..\regexp\regexp.go:1059:16: make([][][]byte, 0, startSize) escapes to heap
..\..\..\..\regexp\regexp.go:1059:16: 	from result (assigned) at ..\..\..\..\regexp\regexp.go:1059:9
..\..\..\..\regexp\regexp.go:1059:16: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:1072:2
..\..\..\..\regexp\regexp.go:1060:26: (*Regexp).FindAllSubmatch func literal does not escape
..\..\..\..\regexp\regexp.go:1060:39: (*Regexp).FindAllSubmatch.func1 match does not escape
..\..\..\..\regexp\regexp.go:1079:61: leaking param: re
..\..\..\..\regexp\regexp.go:1079:61: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1084:15
..\..\..\..\regexp\regexp.go:1079:61: leaking param: b
..\..\..\..\regexp\regexp.go:1079:61: 	from b (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1084:15
..\..\..\..\regexp\regexp.go:1084:39: leaking param: match
..\..\..\..\regexp\regexp.go:1084:39: 	from append(result, match) (appended to slice) at ..\..\..\..\regexp\regexp.go:1085:18
..\..\..\..\regexp\regexp.go:1083:16: make([][]int, 0, startSize) escapes to heap
..\..\..\..\regexp\regexp.go:1083:16: 	from result (assigned) at ..\..\..\..\regexp\regexp.go:1083:9
..\..\..\..\regexp\regexp.go:1083:16: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:1090:2
..\..\..\..\regexp\regexp.go:1084:26: (*Regexp).FindAllSubmatchIndex func literal does not escape
..\..\..\..\regexp\regexp.go:1097:62: leaking param: re
..\..\..\..\regexp\regexp.go:1097:62: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1102:15
..\..\..\..\regexp\regexp.go:1097:62: leaking param: s
..\..\..\..\regexp\regexp.go:1097:62: 	from s (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1102:15
..\..\..\..\regexp\regexp.go:1103:16: make([]string, len(match) / 2) escapes to heap
..\..\..\..\regexp\regexp.go:1103:16: 	from make([]string, len(match) / 2) (too large for stack) at ..\..\..\..\regexp\regexp.go:1103:16
..\..\..\..\regexp\regexp.go:1106:16: leaking closure reference s
..\..\..\..\regexp\regexp.go:1106:16: 	from slice[j] (slice-element-equals) at ..\..\..\..\regexp\regexp.go:1106:14
..\..\..\..\regexp\regexp.go:1101:16: make([][]string, 0, startSize) escapes to heap
..\..\..\..\regexp\regexp.go:1101:16: 	from result (assigned) at ..\..\..\..\regexp\regexp.go:1101:9
..\..\..\..\regexp\regexp.go:1101:16: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:1114:2
..\..\..\..\regexp\regexp.go:1102:27: (*Regexp).FindAllStringSubmatch func literal does not escape
..\..\..\..\regexp\regexp.go:1102:40: (*Regexp).FindAllStringSubmatch.func1 match does not escape
..\..\..\..\regexp\regexp.go:1122:67: leaking param: re
..\..\..\..\regexp\regexp.go:1122:67: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1127:15
..\..\..\..\regexp\regexp.go:1122:67: leaking param: s
..\..\..\..\regexp\regexp.go:1122:67: 	from s (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1127:15
..\..\..\..\regexp\regexp.go:1127:40: leaking param: match
..\..\..\..\regexp\regexp.go:1127:40: 	from append(result, match) (appended to slice) at ..\..\..\..\regexp\regexp.go:1128:18
..\..\..\..\regexp\regexp.go:1126:16: make([][]int, 0, startSize) escapes to heap
..\..\..\..\regexp\regexp.go:1126:16: 	from result (assigned) at ..\..\..\..\regexp\regexp.go:1126:9
..\..\..\..\regexp\regexp.go:1126:16: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:1133:2
..\..\..\..\regexp\regexp.go:1127:27: (*Regexp).FindAllStringSubmatchIndex func literal does not escape
..\..\..\..\regexp\regexp.go:1158:18: []string literal escapes to heap
..\..\..\..\regexp\regexp.go:1158:18: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:1158:3
..\..\..\..\regexp\regexp.go:1162:17: make([]string, 0, len(matches)) escapes to heap
..\..\..\..\regexp\regexp.go:1162:17: 	from strings (assigned) at ..\..\..\..\regexp\regexp.go:1162:10
..\..\..\..\regexp\regexp.go:1162:17: 	from ~r2 (return) at ..\..\..\..\regexp\regexp.go:1182:2
..\..\..\..\regexp\regexp.go:1151:44: leaking param: re
..\..\..\..\regexp\regexp.go:1151:44: 	from re (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1161:34
..\..\..\..\regexp\regexp.go:1151:44: leaking param: s
..\..\..\..\regexp\regexp.go:1151:44: 	from s (passed to call[argument escapes]) at ..\..\..\..\regexp\regexp.go:1161:34
<autogenerated>:1:0: leaking param: .this
<autogenerated>:1:0: 	from .this.canCheckPrefix() (receiver in indirect call) at <autogenerated>:1:0
<autogenerated>:1:0: leaking param: .this
<autogenerated>:1:0: 	from .this.context(pos) (receiver in indirect call) at <autogenerated>:1:0
<autogenerated>:1:0: leaking param: re
<autogenerated>:1:0: 	from .this.hasPrefix(re) (parameter to indirect call) at <autogenerated>:1:0
<autogenerated>:1:0: leaking param: .this
<autogenerated>:1:0: 	from .this.hasPrefix(re) (receiver in indirect call) at <autogenerated>:1:0
<autogenerated>:1:0: leaking param: re
<autogenerated>:1:0: 	from .this.index(re, pos) (parameter to indirect call) at <autogenerated>:1:0
<autogenerated>:1:0: leaking param: .this
<autogenerated>:1:0: 	from .this.index(re, pos) (receiver in indirect call) at <autogenerated>:1:0
<autogenerated>:1:0: leaking param: .this
<autogenerated>:1:0: 	from .this.step(pos) (receiver in indirect call) at <autogenerated>:1:0
<autogenerated>:1:0: (*onePassInst).MatchEmptyWidth .this does not escape
..\..\..\..\regexp\regexp.go:617:42: index bounds check elided
..\..\..\..\regexp\regexp.go:633:13: index bounds check elided
..\..\..\..\regexp\regexp.go:646:13: index bounds check elided
<autogenerated>:1:0: (*onePassInst).MatchEmptyWidth &.this.Inst does not escape
<autogenerated>:1:0: (*onePassInst).MatchRune .this does not escape
<autogenerated>:1:0: (*onePassInst).MatchRune &.this.Inst does not escape
<autogenerated>:1:0: (*onePassInst).MatchRunePos .this does not escape
<autogenerated>:1:0: (*onePassInst).MatchRunePos &.this.Inst does not escape
<autogenerated>:1:0: (*onePassInst).String .this does not escape
<autogenerated>:1:0: (*onePassInst).String &.this.Inst does not escape
<autogenerated>:1:0: (*onePassInst).regexp/syntax.op .this does not escape
<autogenerated>:1:0: (*onePassInst).regexp/syntax.op &.this.Inst does not escape
<autogenerated>:1:0: inlining call to runeSlice.Len method(runeSlice) func() int { return len(p) }
<autogenerated>:1:0: (*runeSlice).Len .this does not escape
<autogenerated>:1:0: inlining call to runeSlice.Less method(runeSlice) func(int, int) bool { return p[i] < p[j] }
<autogenerated>:1:0: (*runeSlice).Less .this does not escape
<autogenerated>:1:0: inlining call to runeSlice.Swap method(runeSlice) func(int, int) { p[i], p[j] = p[j], p[i] }
<autogenerated>:1:0: (*runeSlice).Swap .this does not escape
<autogenerated>:1:0: leaking param: .this
<autogenerated>:1:0: 	from .this.Len() (receiver in indirect call) at <autogenerated>:1:0
<autogenerated>:1:0: leaking param: .this
<autogenerated>:1:0: 	from .this.Less(sort.i, sort.j) (receiver in indirect call) at <autogenerated>:1:0
<autogenerated>:1:0: leaking param: .this
<autogenerated>:1:0: 	from .this.Swap(sort.i, sort.j) (receiver in indirect call) at <autogenerated>:1:0
