[GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
51 messages Options
123
Reply | Threaded
Open this post in threaded view
|

[GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
           Reporter:  ntc2           |             Owner:  (none)
               Type:  bug            |            Status:  new
           Priority:  normal         |         Milestone:
          Component:  Compiler       |           Version:  8.2.2
           Keywords:                 |  Operating System:  Unknown/Multiple
       Architecture:                 |   Type of failure:  Runtime
  Unknown/Multiple                   |  performance bug
          Test Case:                 |        Blocked By:
  https://github.com/ntc2/ghc-8.2.1  |
  -regex-lazy-text-bug               |
           Blocking:                 |   Related Tickets:  13745
Differential Rev(s):                 |         Wiki Page:
-------------------------------------+-------------------------------------
 When using `Text.RE.TDFA` from the regex-tdfa package on GHC 8.2 to match
 trivial regexes against `Data.Text.Lazy` strings, I see **exponential
 runtime**. On GHC 8.0, or using `Data.Text` strict strings or `String`
 strings, the runtime is as expected.

 Here's my repo with simple test code illustrating the regression and
 timing stats: https://github.com/ntc2/ghc-8.2.1-regex-lazy-text-bug.

 In summary, for the problematic combination of GHC version and libraries,
 the run times are 3s, 10s, 22s, and 40s
 for counting regex matches in files with 10000,
 20000, 30000, and 40000 lines, respectively. For all of the
 unproblematic combinations -- i.e. GHC 8.0.2, `String`, strict
 `Data.Text`, or building with profiling -- the run time is always about
 1s!

 And **this is a Heisenbug**, in that the performance problem goes away if
 I build with profiling support!

 There is the separate Issue #13745 about **compile-time regressions** in
 GHC 8.2 + the regex-tdfa package, that
 [https://ghc.haskell.org/trac/ghc/ticket/13745#comment:18 I commented on].

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  (none)
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-bug
      Blocked By:                    |             Blocking:
 Related Tickets:  13745             |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------
Changes (by ntc2):

 * Attachment "Main.hs" added.

 Test code that exhibits exponential runtime regression

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  (none)
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-bug
      Blocked By:                    |             Blocking:
 Related Tickets:  13745             |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------
Changes (by ntc2):

 * Attachment "defs-30000.txt" added.

 Input file for test program

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  (none)
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-bug
      Blocked By:                    |             Blocking:
 Related Tickets:  13745             |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by ntc2):

 As suggested by @nomeata, I'm going to try bisecting GHC between 8.0.2 and
 8.2.0 to discover when the performance regression was introduced.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:1>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  (none)
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-bug
      Blocked By:                    |             Blocking:
 Related Tickets:  13745             |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by ntc2):

 Having "unusable due to shadowed dependencies" trouble with the GHC 8.2.1
 I built from source when trying to build my test code. Links to possibly
 related issues and a patch:

 - https://github.com/haskell/cabal/issues/4728
 - https://github.com/commercialhaskell/stack/issues/3554
 - https://phabricator.haskell.org/D4159
 - https://ghc.haskell.org/trac/ghc/ticket/14381

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:2>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-bug
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745            |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------
Changes (by bgamari):

 * owner:  (none) => tdammers
 * related:  13745 => #13745
 * milestone:   => 8.4.1


--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:3>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-
                                     |  bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745            |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------
Changes (by ntc2):

 * testcase:  https://github.com/ntc2/ghc-8.2.1-regex-lazy-text-bug =>
     https://github.com/ntc2/ghc-8.2.1-regex-lazy-text-
     bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53


Old description:

> When using `Text.RE.TDFA` from the regex-tdfa package on GHC 8.2 to match
> trivial regexes against `Data.Text.Lazy` strings, I see **exponential
> runtime**. On GHC 8.0, or using `Data.Text` strict strings or `String`
> strings, the runtime is as expected.
>
> Here's my repo with simple test code illustrating the regression and
> timing stats: https://github.com/ntc2/ghc-8.2.1-regex-lazy-text-bug.
>
> In summary, for the problematic combination of GHC version and libraries,
> the run times are 3s, 10s, 22s, and 40s
> for counting regex matches in files with 10000,
> 20000, 30000, and 40000 lines, respectively. For all of the
> unproblematic combinations -- i.e. GHC 8.0.2, `String`, strict
> `Data.Text`, or building with profiling -- the run time is always about
> 1s!
>
> And **this is a Heisenbug**, in that the performance problem goes away if
> I build with profiling support!
>
> There is the separate Issue #13745 about **compile-time regressions** in
> GHC 8.2 + the regex-tdfa package, that
> [https://ghc.haskell.org/trac/ghc/ticket/13745#comment:18 I commented
> on].
New description:

 When using `Text.RE.TDFA` from the regex-tdfa package on GHC 8.2 to match
 trivial regexes against `Data.Text.Lazy` strings, I see **exponential
 runtime**. On GHC 8.0, or using `Data.Text` strict strings or `String`
 strings, the runtime is as expected.

 Here's my repo with simple test code illustrating the regression and
 timing stats: https://github.com/ntc2/ghc-8.2.1-regex-lazy-text-
 bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53 .

 In summary, for the problematic combination of GHC version and libraries,
 the run times are 3s, 10s, 22s, and 40s
 for counting regex matches in files with 10000,
 20000, 30000, and 40000 lines, respectively. For all of the
 unproblematic combinations -- i.e. GHC 8.0.2, `String`, strict
 `Data.Text`, or building with profiling -- the run time is always about
 1s!

 And **this is a Heisenbug**, in that the performance problem goes away if
 I build with profiling support!

 There is the separate Issue #13745 about **compile-time regressions** in
 GHC 8.2 + the regex-tdfa package, that
 [https://ghc.haskell.org/trac/ghc/ticket/13745#comment:18 I commented on].

--

Comment:

 I'm having trouble with the bisection search because `hashable` won't
 build on some intermediate dev GHCs I've tried. I tried changing the test
 case to use `regex-tdfa-text`+`Data.Text.Lazy` directly, instead of via
 the common interface provided by `regex`, but then the problem goes away.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:4>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-
                                     |  bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745            |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by simonpj):

 Don't forget to try with `-fno-state-hack`.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:5>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-
                                     |  bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745, #14564    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------
Changes (by ntc2):

 * related:  #13745 => #13745, #14564


--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:6>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-
                                     |  bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745, #14564    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by tdammers):

 I took a stab at bisecting this myself, the problem however is that I'm
 getting too many false positives, even when cleaning thoroughly and
 starting with as clean a slate as possible, and when I do that, build
 times become prohibitive, so I gave up after a few night-long attempts. So
 I will now take a different route, trying to isolate the problem further
 on current GHC HEAD, see if I can pin it down.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:7>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-
                                     |  bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745, #14564    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by tdammers):

 Quick data point: in a test case using a modified `Lazy.hs`, the bad
 behavior can be reproduced when running certain regular expressions
 against a large test data set, but not others:

 - `^def `: bad
 - `^def[^.]`: bad
 - `^[^.]`: good
 - `^d[^.]`: good
 - `^de[^.]`: good
 - `^def[^.]`: bad
 - `^[^.]def`: good

 (I picked `[^.]` as a subexpression that can never match).

 Particularly interesting is `^de[^.]` vs. `^def[^.]`: it seems that having
 to consume 4 or more tokens from the start of the input triggers the bad
 behavior.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:8>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-
                                     |  bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745, #14564    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by tdammers):

 Actually it turns out that I must have done something wrong with my
 benchmarking; proper testing shows that *all* the examples that start with
 `^[.^]` (i.e. everything that fails on the first token) runs fast (~20
 ms), while everything that matches on the first token at least runs slowly
 (~30,000 ms).

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:9>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-
                                     |  bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745, #14564    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by simonpj):

 I would urge you to build the program and libraries with `-ticky` and see
 which function is getting executed a lot.   The advantage of `-ticky` is
 that it's guaranteed not to affect optimisation or indeed anything.  It
 just logs what happens.

 Then you'll need a `-ddump-simpl -ddump-stg` of the relevant modules to
 match up with the ticky logs.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:10>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-
                                     |  bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745, #14564    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by tdammers):

 > I would urge you to build the program and libraries with -ticky and see
 which function is getting executed a lot. The advantage of -ticky is that
 it's guaranteed not to affect optimisation or indeed anything. It just
 logs what happens.

 That's actually exactly what I'm doing right now. A comparison of running
 two regular expressions such that one is fast (`^[^.]d`) and the other is
 slow (`^def`) shows that all the metrics are the same, or nearly the same,
 except for ALLOC_PRIM_gds (from 669 up to 1801526) and ALLOC_PRIM_ctr
 (from 371392 up to 9325581456).

 I should probably dig a bit deeper from here.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:11>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-
                                     |  bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745, #14564    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by simonpj):

 Interesting.  I was thinking of this part of the ticky file
 {{{
     Entries      Alloc    Alloc'd  Non-void Arguments      STG Name
 --------------------------------------------------------------------------------
     1800047   78722320          0   1 L                    p_term{v raIX}
 (main:Main) (fun)
     2160065   50401232          0   2 >L
 base:GHC.List.takeWhile{v rcW} (fun)
     1509183   43941968          0   2 LL
 base:GHC.Base.++{v 03} (fun)
     1086514   43446320          0   2 LL
 base:GHC.List.zip{v 0x} (fun)
     1088129   37257616          0   2 >L
 base:GHC.Base.map{v 01X} (fun)
      480015   24961008          0   1 L                    p2{v raIU}
 (main:Main) (fun)
      240001   19200080          0   2 ML                   $w$j{v raIV}
 (main:Main) (fun,se)
      665502   17440560          0   2 iL                   go1{v raJb}
 (main:Main) (fun)
      545117   17421624          0   1 M                    subterms{v
 r1ki} (main:Main) (fun)
      723688   15430288          0   3 LMM                  $wmatch'{v
 raJ5} (main:Main) (fun)
      662950   15428096          0   3 MML                  $sfind'{v raIM}
 (main:Main) (fun)
      363373   12627992          0   1 L                    go11{v saSX}
 (main:Main) (fun) in raJb
      487124   11666944          0   3 >>M                  expr_fold{v
 r1jH} (main:Main) (fun)
     1267348   11605760          0   2 LM                   find'{v raIN}
 (main:Main) (fun)
 }}}
 Usually when something exponential is going on you get some very bug
 numbers at the top.  (You may need to sort first.)

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:12>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-
                                     |  bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745, #14564    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by tdammers):

 Correct, but that's why I needed to dig deeper - ticky-ing only the module
 itself didn't reveal anything, but compiling a bunch of dependencies with
 -ticky as well gives me this line:

 {{{
  2250377760180010799840          0   2 Mi                   $wnext2{v
 reC2} (regex-tdfa-
 text-1.0.0.3-CIfFZ6rjdCoJI5EFpqTwBO:Text.Regex.TDFA.Text.Lazy) (fun)
 }}}

 (note that it actually overflows the `Alloc` field, so that's two large
 numbers concatenated together there)

 I can't seem to find `wnext2` anywhere in the dumps though, which is a bit
 strange.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:13>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-
                                     |  bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745, #14564    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by simonpj):

 Compile `Text.Regex.TDFA.Text.Lazy` with `-ddump-simpl -ddump-stg -ticky`.
 I'd be surprised if `$wnext2{v reC2}` doesn't show up.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:14>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-
                                     |  bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745, #14564    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by tdammers):

 That's what I thought I was doing, but apparently I fat-fingered a cabal
 command. Recompiling as we speak, will report back.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:15>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-
                                     |  bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745, #14564    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by tdammers):

 Recompiled everything, with `--force-reinstalls` and `-fforce-recomp`, and
 `-ddump-stg` on everything including dependencies, however, grepping the
 entire project tree for `wnext` only matches binaries (`.o`, `.a` and the
 like), but none of the dumps.

 So I ran GHC directly on the source file inside the cabal tree:

 {{{
 ../ghc/inplace/bin/ghc-stage2 regex-tdfa-
 text-1.0.0.3/Text/Regex/TDFA/Text/Lazy.hs -fforce-recomp -package-db
 .cabal-sandbox/x86_64-linux-ghc-8.5.20180108-packages.conf.d -ticky -c
 -ddump-stg -rtsopts -XMultiParamTypeClasses
 }}}

 But to no avail, `wnext2` does not appear in the STG dump:

 {{{

 ==================== Pre unarise: ====================
 sat_s6o2 :: GHC.Types.Int -> GHC.Int.Int64
 [LclId] =
     [] \u [] GHC.Enum.toEnum GHC.Int.$fEnumInt64;

 $cafter_r6mQ
   :: GHC.Types.Int
      -> Data.Text.Internal.Lazy.Text -> Data.Text.Internal.Lazy.Text
 [GblId] =
     [] \u [] GHC.Base.. Data.Text.Lazy.drop sat_s6o2;

 sat_s6o3 :: GHC.Types.Int -> GHC.Int.Int64
 [LclId] =
     [] \u [] GHC.Enum.toEnum GHC.Int.$fEnumInt64;

 $cbefore_r6nJ
   :: GHC.Types.Int
      -> Data.Text.Internal.Lazy.Text -> Data.Text.Internal.Lazy.Text
 [GblId] =
     [] \u [] GHC.Base.. Data.Text.Lazy.take sat_s6o3;

 Text.Regex.TDFA.Text.Lazy.$fExtractText [InlPrag=NOUSERINLINE CONLIKE]
   :: Text.Regex.Base.RegexLike.Extract Data.Text.Internal.Lazy.Text
 [GblId[DFunId]] =
     NO_CCS Text.Regex.Base.RegexLike.C:Extract! [$cbefore_r6nJ
                                                  $cafter_r6mQ
 Data.Text.Internal.Lazy.empty
                                                  $cextract_r6nK];
 $cextract_r6nK
   :: (GHC.Types.Int, GHC.Types.Int)
      -> Data.Text.Internal.Lazy.Text -> Data.Text.Internal.Lazy.Text
 [GblId] =
     [] \u []
         Text.Regex.Base.RegexLike.$dmextract
             Text.Regex.TDFA.Text.Lazy.$fExtractText;

 Text.Regex.TDFA.Text.Lazy.$fUnconsText [InlPrag=INLINE (sat-args=0)]
   :: Text.Regex.TDFA.NewDFA.Uncons.Uncons
        Data.Text.Internal.Lazy.Text
 [GblId[DFunId(nt)]] =
     [] \u [] Data.Text.Lazy.uncons;

 $cmakeRegexOptsM_r6nL
   :: forall (m :: * -> *).
      GHC.Base.Monad m =>
      Text.Regex.TDFA.Common.CompOption
      -> Text.Regex.TDFA.Common.ExecOption
      -> Data.Text.Internal.Lazy.Text
      -> m Text.Regex.TDFA.Common.Regex
 [GblId, Arity=4, Unf=OtherCon []] =
     [] \r [$dMonad_s6o4 c_s6o5 e_s6o6 source_s6o7]
         let {
           sat_s6o8 [Occ=Once] :: GHC.Base.String
           [LclId] =
               [source_s6o7] \u [] Data.Text.Lazy.unpack source_s6o7;
         } in
           Text.Regex.Base.RegexLike.makeRegexOptsM
 Text.Regex.TDFA.String.$fRegexMakerRegexCompOptionExecOption[]
               $dMonad_s6o4
               c_s6o5
               e_s6o6
               sat_s6o8;

 Text.Regex.TDFA.Text.Lazy.$fRegexMakerRegexCompOptionExecOptionText
 [InlPrag=NOUSERINLINE CONLIKE]
   :: Text.Regex.Base.RegexLike.RegexMaker
        Text.Regex.TDFA.Common.Regex
        Text.Regex.TDFA.Common.CompOption
        Text.Regex.TDFA.Common.ExecOption
        Data.Text.Internal.Lazy.Text
 [GblId[DFunId]] =
     NO_CCS Text.Regex.Base.RegexLike.C:RegexMaker!
 [Text.Regex.TDFA.Common.$fRegexOptionsRegexCompOptionExecOption
                                                     $cmakeRegex_r6nN
                                                     $cmakeRegexOpts_r6nM
                                                     $cmakeRegexM_r6nO
 $cmakeRegexOptsM_r6nL];
 $cmakeRegexOpts_r6nM
   :: Text.Regex.TDFA.Common.CompOption
      -> Text.Regex.TDFA.Common.ExecOption
      -> Data.Text.Internal.Lazy.Text
      -> Text.Regex.TDFA.Common.Regex
 [GblId] =
     [] \u []
         Text.Regex.Base.RegexLike.$dmmakeRegexOpts
 Text.Regex.TDFA.Text.Lazy.$fRegexMakerRegexCompOptionExecOptionText;
 $cmakeRegex_r6nN
   :: Data.Text.Internal.Lazy.Text -> Text.Regex.TDFA.Common.Regex
 [GblId] =
     [] \u []
         Text.Regex.Base.RegexLike.$dmmakeRegex
 Text.Regex.TDFA.Text.Lazy.$fRegexMakerRegexCompOptionExecOptionText;
 $cmakeRegexM_r6nO
   :: forall (m :: * -> *).
      GHC.Base.Monad m =>
      Data.Text.Internal.Lazy.Text -> m Text.Regex.TDFA.Common.Regex
 [GblId, Arity=1, Unf=OtherCon []] =
     [] \r [$dMonad_s6o9]
         Text.Regex.Base.RegexLike.$dmmakeRegexM
 Text.Regex.TDFA.Text.Lazy.$fRegexMakerRegexCompOptionExecOptionText
             $dMonad_s6o9;

 $trModule1_r6nP :: GHC.Prim.Addr#
 [GblId, Caf=NoCafRefs, Unf=OtherCon []] =
     "main"#;

 $trModule2_r6nQ :: GHC.Types.TrName
 [GblId, Caf=NoCafRefs, Unf=OtherCon []] =
     NO_CCS GHC.Types.TrNameS! [$trModule1_r6nP];

 $trModule3_r6nR :: GHC.Prim.Addr#
 [GblId, Caf=NoCafRefs, Unf=OtherCon []] =
     "Text.Regex.TDFA.Text.Lazy"#;

 $trModule4_r6nS :: GHC.Types.TrName
 [GblId, Caf=NoCafRefs, Unf=OtherCon []] =
     NO_CCS GHC.Types.TrNameS! [$trModule3_r6nR];

 Text.Regex.TDFA.Text.Lazy.$trModule :: GHC.Types.Module
 [GblId, Caf=NoCafRefs, Unf=OtherCon []] =
     NO_CCS GHC.Types.Module! [$trModule2_r6nQ $trModule4_r6nS];

 $cmatchTest_r6nT
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text -> GHC.Types.Bool
 [GblId] =
     [] \u []
         Text.Regex.TDFA.NewDFA.Tester.matchTest Data.Text.Lazy.uncons;

 $cmatchAll_r6nU
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text
      -> [Text.Regex.Base.RegexLike.MatchArray]
 [GblId, Arity=2, Unf=OtherCon []] =
     [] \r [r_s6oa s_s6ob]
         let {
           sat_s6od [Occ=Once] :: GHC.Types.Char
           [LclId] =
               NO_CCS GHC.Types.C#! ['\n'#]; } in
         let {
           sat_s6oc [Occ=Once] :: Text.Regex.TDFA.Common.Position
           [LclId] =
               NO_CCS GHC.Types.I#! [0#];
         } in
           Text.Regex.TDFA.NewDFA.Engine.execMatch
               Data.Text.Lazy.uncons r_s6oa sat_s6oc sat_s6od s_s6ob;

 Text.Regex.TDFA.Text.Lazy.compile
   :: Text.Regex.TDFA.Common.CompOption
      -> Text.Regex.TDFA.Common.ExecOption
      -> Data.Text.Internal.Lazy.Text
      -> Data.Either.Either GHC.Base.String Text.Regex.TDFA.Common.Regex
 [GblId, Arity=3, Unf=OtherCon []] =
     [] \r [compOpt_s6oe execOpt_s6of txt_s6og]
         let {
           sat_s6oh [Occ=Once] :: GHC.Base.String
           [LclId] =
               [txt_s6og] \u [] Data.Text.Lazy.unpack txt_s6og;
         } in
           case Text.Regex.TDFA.ReadRegex.parseRegex sat_s6oh of {
             Data.Either.Left err_s6oj [Occ=Once] ->
                 let {
                   sat_s6om [Occ=Once] :: [GHC.Types.Char]
                   [LclId] =
                       [err_s6oj] \u []
                           let {
                             sat_s6ol [Occ=Once] :: [GHC.Types.Char]
                             [LclId] =
                                 [err_s6oj] \u []
                                     GHC.Show.show
 Text.Parsec.Error.$fShowParseError err_s6oj; } in
                           let {
                             sat_s6ok [Occ=Once] :: [GHC.Types.Char]
                             [LclId] =
                                 [] \u []
                                     GHC.CString.unpackCString#
                                         "parseRegex for
 Text.Regex.TDFA.Text.Lazy failed:"#;
                           } in  GHC.Base.++ sat_s6ok sat_s6ol;
                 } in  Data.Either.Left [sat_s6om];
             Data.Either.Right pattern_s6on [Occ=Once] ->
                 let {
                   sat_s6oo [Occ=Once] :: Text.Regex.TDFA.Common.Regex
                   [LclId] =
                       [compOpt_s6oe execOpt_s6of pattern_s6on] \u []
                           Text.Regex.TDFA.TDFA.patternToRegex
                               pattern_s6on compOpt_s6oe execOpt_s6of;
                 } in  Data.Either.Right [sat_s6oo];
           };

 $cmatchOnce_r6nV
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text
      -> GHC.Base.Maybe Text.Regex.Base.RegexLike.MatchArray
 [GblId, Arity=2, Unf=OtherCon []] =
     [] \r [r_s6op s_s6oq]
         let {
           sat_s6or [Occ=Once] :: [Text.Regex.Base.RegexLike.MatchArray]
           [LclId] =
               [r_s6op s_s6oq] \u [] $cmatchAll_r6nU r_s6op s_s6oq;
         } in  Data.Maybe.listToMaybe sat_s6or;

 $cmatchAllText_r6nW
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text
      -> [Text.Regex.Base.RegexLike.MatchText
            Data.Text.Internal.Lazy.Text]
 [GblId, Arity=2, Unf=OtherCon []] =
     [] \r [regex_s6os source_s6ot]
         let {
           go_s6ou [Occ=LoopBreaker]
             :: GHC.Types.Int
                -> Data.Text.Internal.Lazy.Text
                -> [GHC.Arr.Array GHC.Types.Int (GHC.Types.Int,
 GHC.Types.Int)]
                -> [GHC.Arr.Array
                      GHC.Types.Int
                      (Data.Text.Internal.Lazy.Text, (GHC.Types.Int,
 GHC.Types.Int))]
           [LclId, Arity=3, Unf=OtherCon []] =
               sat-only [go_s6ou] \r [i_s6ov ds_s6ow ds1_s6ox]
                   case i_s6ov of i1_s6oy {
                     GHC.Types.I# _ [Occ=Dead] ->
                         case ds1_s6ox of {
                           [] -> [] [];
                           : x_s6oB xs_s6oC [Occ=Once] ->
                               let {
                                 ds2_s6oD :: (GHC.Types.Int, GHC.Types.Int)
                                 [LclId] =
                                     [x_s6oB] \u []
                                         let {
                                           sat_s6oE [Occ=Once] ::
 GHC.Types.Int
                                           [LclId] =
                                               NO_CCS GHC.Types.I#! [0#];
                                         } in
                                           Data.Array.Base.!
 Data.Array.Base.$fIArrayArraye
                                               GHC.Arr.$fIxInt
                                               x_s6oB
                                               sat_s6oE; } in
                               let {
                                 off0_s6oF :: GHC.Types.Int
                                 [LclId] =
                                     [ds2_s6oD] \u []
                                         case ds2_s6oD of {
                                           (,) off1_s6oH [Occ=Once] _
 [Occ=Dead] -> off1_s6oH;
                                         }; } in
                               let {
                                 len0_s6oJ :: GHC.Types.Int
                                 [LclId] =
                                     [ds2_s6oD] \u []
                                         case ds2_s6oD of {
                                           (,) _ [Occ=Dead] len1_s6oM
 [Occ=Once] -> len1_s6oM;
                                         }; } in
                               let {
                                 sat_s6p0 [Occ=Once]
                                   :: [GHC.Arr.Array
                                         GHC.Types.Int
                                         (Data.Text.Internal.Lazy.Text,
                                          (GHC.Types.Int, GHC.Types.Int))]
                                 [LclId] =
                                     [go_s6ou ds_s6ow i1_s6oy xs_s6oC
 off0_s6oF len0_s6oJ] \u []
                                         let {
                                           sat_s6oX [Occ=Once] ::
 GHC.Types.Int
                                           [LclId] =
                                               [i1_s6oy off0_s6oF
 len0_s6oJ] \u []
                                                   let {
                                                     sat_s6oW [Occ=Once] ::
 GHC.Types.Int
                                                     [LclId] =
                                                         [i1_s6oy
 len0_s6oJ] \u []
                                                             GHC.Num.-
 GHC.Num.$fNumInt len0_s6oJ i1_s6oy;
                                                   } in
                                                     GHC.Num.+
 GHC.Num.$fNumInt off0_s6oF sat_s6oW;
                                         } in
                                           case $cafter_r6mQ sat_s6oX
 ds_s6ow of t'_s6oY {
                                             __DEFAULT ->
                                                 let {
                                                   sat_s6oZ [Occ=Once] ::
 GHC.Types.Int
                                                   [LclId] =
                                                       [off0_s6oF
 len0_s6oJ] \u []
                                                           GHC.Num.+
 GHC.Num.$fNumInt off0_s6oF len0_s6oJ;
                                                 } in  go_s6ou sat_s6oZ
 t'_s6oY xs_s6oC;
                                           }; } in
                               let {
                                 sat_s6oV [Occ=Once]
                                   :: GHC.Arr.Array
                                        GHC.Types.Int
                                        (Data.Text.Internal.Lazy.Text,
                                         (GHC.Types.Int, GHC.Types.Int))
                                 [LclId] =
                                     [ds_s6ow i1_s6oy x_s6oB] \u []
                                         let {
                                           sat_s6oU [Occ=Once]
                                             :: (GHC.Types.Int,
 GHC.Types.Int)
                                                ->
 (Data.Text.Internal.Lazy.Text,
                                                    (GHC.Types.Int,
 GHC.Types.Int))
                                           [LclId] =
                                               [ds_s6ow i1_s6oy] \r
 [pair_s6oN]
                                                   case pair_s6oN of
 wild1_s6oO {
                                                     (,) off_s6oP
 [Occ=Once] len_s6oQ [Occ=Once] ->
                                                         let {
                                                           sat_s6oT
 [Occ=Once]
                                                             ::
 Data.Text.Internal.Lazy.Text
                                                           [LclId] =
                                                               [ds_s6ow
                                                                i1_s6oy
                                                                off_s6oP
                                                                len_s6oQ]
 \u []
                                                                   let {
 sat_s6oR [Occ=Once]
                                                                       ::
 GHC.Types.Int
 [LclId] =
 [i1_s6oy off_s6oP] \u []
 GHC.Num.-
 GHC.Num.$fNumInt
 off_s6oP
 i1_s6oy; } in
                                                                   let {
 sat_s6oS [Occ=Once]
                                                                       ::
 (GHC.Types.Int,
 GHC.Types.Int)
 [LclId] =
 NO_CCS (,)! [sat_s6oR
 len_s6oQ];
                                                                   } in
 $cextract_r6nK sat_s6oS ds_s6ow;
                                                         } in  (,)
 [sat_s6oT wild1_s6oO];
                                                   };
                                         } in  GHC.Base.fmap
 GHC.Arr.$fFunctorArray sat_s6oU x_s6oB;
                               } in  : [sat_s6oV sat_s6p0];
                         };
                   }; } in
         let {
           sat_s6p2 [Occ=Once]
             :: [GHC.Arr.Array GHC.Types.Int (GHC.Types.Int,
 GHC.Types.Int)]
           [LclId] =
               [regex_s6os source_s6ot] \u []
                   $cmatchAll_r6nU regex_s6os source_s6ot; } in
         let {
           sat_s6p1 [Occ=Once] :: GHC.Types.Int
           [LclId] =
               NO_CCS GHC.Types.I#! [0#];
         } in  go_s6ou sat_s6p1 source_s6ot sat_s6p2;

 $cmatchCount_r6nX
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text -> GHC.Types.Int
 [GblId, Arity=2, Unf=OtherCon []] =
     [] \r [r_s6p3 s_s6p4]
         let {
           sat_s6pm [Occ=Once] :: [Text.Regex.Base.RegexLike.MatchArray]
           [LclId] =
               [r_s6p3 s_s6p4] \u []
                   let {
                     sat_s6pl [Occ=Once] :: GHC.Types.Char
                     [LclId] =
                         NO_CCS GHC.Types.C#! ['\n'#]; } in
                   let {
                     sat_s6pk [Occ=Once] :: Text.Regex.TDFA.Common.Position
                     [LclId] =
                         NO_CCS GHC.Types.I#! [0#]; } in
                   let {
                     sat_s6pj [Occ=Once] :: Text.Regex.TDFA.Common.Regex
                     [LclId] =
                         [r_s6p3] \u []
                             case r_s6p3 of wild_s6p5 {
                               Text.Regex.TDFA.Common.Regex ds_s6p6
 [Occ=Once]
                                                            ds1_s6p7
 [Occ=Once]
                                                            ds2_s6p8
 [Occ=Once]
                                                            ds3_s6p9
 [Occ=Once]
                                                            ds4_s6pa
 [Occ=Once]
                                                            ds5_s6pb
 [Occ=Once]
                                                            ds6_s6pc
 [Occ=Once]
                                                            ds7_s6pd
 [Occ=Once]
                                                            ds8_s6pe
 [Occ=Once]
                                                            _ [Occ=Dead] ->
                                   let {
                                     sat_s6pi [Occ=Once] ::
 Text.Regex.TDFA.Common.ExecOption
                                     [LclId] =
                                         [wild_s6p5] \u []
                                             case
 Text.Regex.TDFA.Common.regex_execOptions wild_s6p5
                                             of
                                             {
 Text.Regex.TDFA.Common.ExecOption _ [Occ=Dead] ->
 Text.Regex.TDFA.Common.ExecOption [GHC.Types.False];
                                             };
                                   } in
                                     Text.Regex.TDFA.Common.Regex [ds_s6p6
                                                                   ds1_s6p7
                                                                   ds2_s6p8
                                                                   ds3_s6p9
                                                                   ds4_s6pa
                                                                   ds5_s6pb
                                                                   ds6_s6pc
                                                                   ds7_s6pd
                                                                   ds8_s6pe
 sat_s6pi];
                             };
                   } in
                     Text.Regex.TDFA.NewDFA.Engine.execMatch
                         Data.Text.Lazy.uncons sat_s6pj sat_s6pk sat_s6pl
 s_s6p4;
         } in  Data.Foldable.length Data.Foldable.$fFoldable[] sat_s6pm;

 $cmatchOnceText_r6nY
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text
      -> GHC.Base.Maybe
           (Data.Text.Internal.Lazy.Text,
            Text.Regex.Base.RegexLike.MatchText
 Data.Text.Internal.Lazy.Text,
            Data.Text.Internal.Lazy.Text)
 [GblId, Arity=2, Unf=OtherCon []] =
     [] \r [regex_s6pn source_s6po]
         let {
           sat_s6pL [Occ=Once]
             :: GHC.Base.Maybe
                  (GHC.Arr.Array GHC.Types.Int (GHC.Types.Int,
 GHC.Types.Int))
           [LclId] =
               [regex_s6pn source_s6po] \u []
                   let {
                     sat_s6pK [Occ=Once] ::
 [Text.Regex.Base.RegexLike.MatchArray]
                     [LclId] =
                         [regex_s6pn source_s6po] \u []
                             let {
                               sat_s6pJ [Occ=Once] :: GHC.Types.Char
                               [LclId] =
                                   NO_CCS GHC.Types.C#! ['\n'#]; } in
                             let {
                               sat_s6pI [Occ=Once] ::
 Text.Regex.TDFA.Common.Position
                               [LclId] =
                                   NO_CCS GHC.Types.I#! [0#];
                             } in
                               Text.Regex.TDFA.NewDFA.Engine.execMatch
                                   Data.Text.Lazy.uncons regex_s6pn
 sat_s6pI sat_s6pJ source_s6po;
                   } in  Data.Maybe.listToMaybe sat_s6pK; } in
         let {
           sat_s6pH [Occ=Once]
             :: GHC.Arr.Array GHC.Types.Int (GHC.Types.Int, GHC.Types.Int)
                -> (Data.Text.Internal.Lazy.Text,
                    GHC.Arr.Array
                      GHC.Types.Int
                      (Data.Text.Internal.Lazy.Text, (GHC.Types.Int,
 GHC.Types.Int)),
                    Data.Text.Internal.Lazy.Text)
           [LclId] =
               [source_s6po] \r [ma_s6pp]
                   let {
                     ds_s6pq :: (GHC.Types.Int, GHC.Types.Int)
                     [LclId] =
                         [ma_s6pp] \u []
                             let {
                               sat_s6pr [Occ=Once] :: GHC.Types.Int
                               [LclId] =
                                   NO_CCS GHC.Types.I#! [0#];
                             } in
                               Data.Array.Base.!
                                   Data.Array.Base.$fIArrayArraye
                                   GHC.Arr.$fIxInt
                                   ma_s6pp
                                   sat_s6pr; } in
                   let {
                     o_s6ps :: GHC.Types.Int
                     [LclId] =
                         [ds_s6pq] \u []
                             case ds_s6pq of {
                               (,) o1_s6pu [Occ=Once] _ [Occ=Dead] ->
 o1_s6pu;
                             }; } in
                   let {
                     sat_s6pG [Occ=Once] :: Data.Text.Internal.Lazy.Text
                     [LclId] =
                         [source_s6po ds_s6pq o_s6ps] \u []
                             let {
                               sat_s6pF [Occ=Once] :: GHC.Types.Int
                               [LclId] =
                                   [ds_s6pq o_s6ps] \u []
                                       let {
                                         sat_s6pE [Occ=Once] ::
 GHC.Types.Int
                                         [LclId] =
                                             [ds_s6pq] \u []
                                                 case ds_s6pq of {
                                                   (,) _ [Occ=Dead] l_s6pD
 [Occ=Once] -> l_s6pD;
                                                 };
                                       } in  GHC.Num.+ GHC.Num.$fNumInt
 o_s6ps sat_s6pE;
                             } in  $cafter_r6mQ sat_s6pF source_s6po; } in
                   let {
                     sat_s6pA [Occ=Once]
                       :: GHC.Arr.Array
                            GHC.Types.Int
                            (Data.Text.Internal.Lazy.Text, (GHC.Types.Int,
 GHC.Types.Int))
                     [LclId] =
                         [source_s6po ma_s6pp] \u []
                             let {
                               sat_s6pz [Occ=Once]
                                 :: (GHC.Types.Int, GHC.Types.Int)
                                    -> (Data.Text.Internal.Lazy.Text,
 (GHC.Types.Int, GHC.Types.Int))
                               [LclId] =
                                   [source_s6po] \r [ol_s6px]
                                       let {
                                         sat_s6py [Occ=Once] ::
 Data.Text.Internal.Lazy.Text
                                         [LclId] =
                                             [source_s6po ol_s6px] \u []
                                                 $cextract_r6nK ol_s6px
 source_s6po;
                                       } in  (,) [sat_s6py ol_s6px];
                             } in  GHC.Base.fmap GHC.Arr.$fFunctorArray
 sat_s6pz ma_s6pp; } in
                   let {
                     sat_s6pw [Occ=Once] :: Data.Text.Internal.Lazy.Text
                     [LclId] =
                         [source_s6po o_s6ps] \u [] $cbefore_r6nJ o_s6ps
 source_s6po;
                   } in  (,,) [sat_s6pw sat_s6pA sat_s6pG];
         } in  GHC.Base.fmap GHC.Base.$fFunctorMaybe sat_s6pH sat_s6pL;

 Text.Regex.TDFA.Text.Lazy.$fRegexLikeRegexText [InlPrag=NOUSERINLINE
 CONLIKE]
   :: Text.Regex.Base.RegexLike.RegexLike
        Text.Regex.TDFA.Common.Regex Data.Text.Internal.Lazy.Text
 [GblId[DFunId]] =
     NO_CCS Text.Regex.Base.RegexLike.C:RegexLike!
 [Text.Regex.TDFA.Text.Lazy.$fExtractText
                                                    $cmatchOnce_r6nV
                                                    $cmatchAll_r6nU
                                                    $cmatchCount_r6nX
                                                    $cmatchTest_r6nT
                                                    $cmatchAllText_r6nW
                                                    $cmatchOnceText_r6nY];

 Text.Regex.TDFA.Text.Lazy.regexec
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text
      -> Data.Either.Either
           GHC.Base.String
           (GHC.Base.Maybe
              (Data.Text.Internal.Lazy.Text, Data.Text.Internal.Lazy.Text,
               Data.Text.Internal.Lazy.Text,
 [Data.Text.Internal.Lazy.Text]))
 [GblId, Arity=2, Unf=OtherCon []] =
     [] \r [r_s6pM txt_s6pN]
         case $cmatchOnceText_r6nY r_s6pM txt_s6pN of {
           GHC.Base.Nothing -> Data.Either.Right [GHC.Base.Nothing];
           GHC.Base.Just ds_s6pP [Occ=Once!] ->
               case ds_s6pP of {
                 (,,) pre_s6pR [Occ=Once] mt_s6pS post_s6pT [Occ=Once] ->
                     let {
                       sat_s6pZ [Occ=Once] ::
 [Data.Text.Internal.Lazy.Text]
                       [LclId] =
                           [mt_s6pS] \u []
                               let {
                                 sat_s6pY [Occ=Once]
                                   :: [(Data.Text.Internal.Lazy.Text,
 (Text.Regex.Base.RegexLike.MatchOffset,
 Text.Regex.Base.RegexLike.MatchLength))]
                                 [LclId] =
                                     [mt_s6pS] \u []
                                         let {
                                           sat_s6pX [Occ=Once]
                                             ::
 [(Data.Text.Internal.Lazy.Text,
 (Text.Regex.Base.RegexLike.MatchOffset,
 Text.Regex.Base.RegexLike.MatchLength))]
                                           [LclId] =
                                               [mt_s6pS] \u []
                                                   Data.Array.Base.elems
 Data.Array.Base.$fIArrayArraye
                                                       GHC.Arr.$fIxInt
                                                       mt_s6pS;
                                         } in  GHC.List.tail sat_s6pX;
                               } in  GHC.Base.map Data.Tuple.fst sat_s6pY;
 } in
                     let {
                       sat_s6pW [Occ=Once] :: Data.Text.Internal.Lazy.Text
                       [LclId] =
                           [mt_s6pS] \u []
                               let {
                                 sat_s6pV [Occ=Once]
                                   :: (Data.Text.Internal.Lazy.Text,
 (Text.Regex.Base.RegexLike.MatchOffset,
 Text.Regex.Base.RegexLike.MatchLength))
                                 [LclId] =
                                     [mt_s6pS] \u []
                                         let {
                                           sat_s6pU [Occ=Once] ::
 GHC.Types.Int
                                           [LclId] =
                                               NO_CCS GHC.Types.I#! [0#];
                                         } in
                                           Data.Array.Base.!
 Data.Array.Base.$fIArrayArraye
                                               GHC.Arr.$fIxInt
                                               mt_s6pS
                                               sat_s6pU;
                               } in  Data.Tuple.fst sat_s6pV; } in
                     let {
                       sat_s6q0 [Occ=Once]
                         :: (Data.Text.Internal.Lazy.Text,
 Data.Text.Internal.Lazy.Text,
                             Data.Text.Internal.Lazy.Text,
 [Data.Text.Internal.Lazy.Text])
                       [LclId] =
                           NO_CCS (,,,)! [pre_s6pR sat_s6pW post_s6pT
 sat_s6pZ]; } in
                     let {
                       sat_s6q1 [Occ=Once]
                         :: GHC.Base.Maybe
                              (Data.Text.Internal.Lazy.Text,
 Data.Text.Internal.Lazy.Text,
                               Data.Text.Internal.Lazy.Text,
 [Data.Text.Internal.Lazy.Text])
                       [LclId] =
                           NO_CCS GHC.Base.Just! [sat_s6q0];
                     } in  Data.Either.Right [sat_s6q1];
               };
         };

 $cmatch_r6nZ
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text -> Data.Text.Internal.Lazy.Text
 [GblId] =
     [] \u []
         Text.Regex.Base.Impl.polymatch
             Text.Regex.TDFA.Text.Lazy.$fRegexLikeRegexText;

 $cmatchM_r6o0
   :: forall (m :: * -> *).
      GHC.Base.Monad m =>
      Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text -> m Data.Text.Internal.Lazy.Text
 [GblId, Arity=1, Unf=OtherCon []] =
     [] \r [$dMonad_s6q2]
         Text.Regex.Base.Impl.polymatchM
             Text.Regex.TDFA.Text.Lazy.$fRegexLikeRegexText $dMonad_s6q2;

 Text.Regex.TDFA.Text.Lazy.$fRegexContextRegexTextText
 [InlPrag=NOUSERINLINE CONLIKE]
   :: Text.Regex.Base.RegexLike.RegexContext
        Text.Regex.TDFA.Common.Regex
        Data.Text.Internal.Lazy.Text
        Data.Text.Internal.Lazy.Text
 [GblId[DFunId]] =
     NO_CCS Text.Regex.Base.RegexLike.C:RegexContext!
 [Text.Regex.TDFA.Text.Lazy.$fRegexLikeRegexText
                                                       $cmatch_r6nZ
                                                       $cmatchM_r6o0];

 Text.Regex.TDFA.Text.Lazy.execute
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text
      -> Data.Either.Either
           GHC.Base.String
           (GHC.Base.Maybe Text.Regex.Base.RegexLike.MatchArray)
 [GblId, Arity=2, Unf=OtherCon []] =
     [] \r [r_s6q3 txt_s6q4]
         let {
           sat_s6q5 [Occ=Once]
             :: GHC.Base.Maybe Text.Regex.Base.RegexLike.MatchArray
           [LclId] =
               [r_s6q3 txt_s6q4] \u [] $cmatchOnce_r6nV r_s6q3 txt_s6q4;
         } in  Data.Either.Right [sat_s6q5];



 ==================== STG syntax: ====================
 sat_s6o2 :: GHC.Types.Int -> GHC.Int.Int64
 [LclId] =
     [] \u [] GHC.Enum.toEnum GHC.Int.$fEnumInt64;

 $cafter_r6mQ
   :: GHC.Types.Int
      -> Data.Text.Internal.Lazy.Text -> Data.Text.Internal.Lazy.Text
 [GblId] =
     [] \u [] GHC.Base.. Data.Text.Lazy.drop sat_s6o2;

 sat_s6o3 :: GHC.Types.Int -> GHC.Int.Int64
 [LclId] =
     [] \u [] GHC.Enum.toEnum GHC.Int.$fEnumInt64;

 $cbefore_r6nJ
   :: GHC.Types.Int
      -> Data.Text.Internal.Lazy.Text -> Data.Text.Internal.Lazy.Text
 [GblId] =
     [] \u [] GHC.Base.. Data.Text.Lazy.take sat_s6o3;

 Text.Regex.TDFA.Text.Lazy.$fExtractText [InlPrag=NOUSERINLINE CONLIKE]
   :: Text.Regex.Base.RegexLike.Extract Data.Text.Internal.Lazy.Text
 [GblId[DFunId]] =
     NO_CCS Text.Regex.Base.RegexLike.C:Extract! [$cbefore_r6nJ
                                                  $cafter_r6mQ
 Data.Text.Internal.Lazy.empty
                                                  $cextract_r6nK];
 $cextract_r6nK
   :: (GHC.Types.Int, GHC.Types.Int)
      -> Data.Text.Internal.Lazy.Text -> Data.Text.Internal.Lazy.Text
 [GblId] =
     [] \u []
         Text.Regex.Base.RegexLike.$dmextract
             Text.Regex.TDFA.Text.Lazy.$fExtractText;

 Text.Regex.TDFA.Text.Lazy.$fUnconsText [InlPrag=INLINE (sat-args=0)]
   :: Text.Regex.TDFA.NewDFA.Uncons.Uncons
        Data.Text.Internal.Lazy.Text
 [GblId[DFunId(nt)]] =
     [] \u [] Data.Text.Lazy.uncons;

 $cmakeRegexOptsM_r6nL
   :: forall (m :: * -> *).
      GHC.Base.Monad m =>
      Text.Regex.TDFA.Common.CompOption
      -> Text.Regex.TDFA.Common.ExecOption
      -> Data.Text.Internal.Lazy.Text
      -> m Text.Regex.TDFA.Common.Regex
 [GblId, Arity=4, Unf=OtherCon []] =
     [] \r [$dMonad_s6o4 c_s6o5 e_s6o6 source_s6o7]
         let {
           sat_s6o8 [Occ=Once] :: GHC.Base.String
           [LclId] =
               [source_s6o7] \u [] Data.Text.Lazy.unpack source_s6o7;
         } in
           Text.Regex.Base.RegexLike.makeRegexOptsM
 Text.Regex.TDFA.String.$fRegexMakerRegexCompOptionExecOption[]
               $dMonad_s6o4
               c_s6o5
               e_s6o6
               sat_s6o8;

 Text.Regex.TDFA.Text.Lazy.$fRegexMakerRegexCompOptionExecOptionText
 [InlPrag=NOUSERINLINE CONLIKE]
   :: Text.Regex.Base.RegexLike.RegexMaker
        Text.Regex.TDFA.Common.Regex
        Text.Regex.TDFA.Common.CompOption
        Text.Regex.TDFA.Common.ExecOption
        Data.Text.Internal.Lazy.Text
 [GblId[DFunId]] =
     NO_CCS Text.Regex.Base.RegexLike.C:RegexMaker!
 [Text.Regex.TDFA.Common.$fRegexOptionsRegexCompOptionExecOption
                                                     $cmakeRegex_r6nN
                                                     $cmakeRegexOpts_r6nM
                                                     $cmakeRegexM_r6nO
 $cmakeRegexOptsM_r6nL];
 $cmakeRegexOpts_r6nM
   :: Text.Regex.TDFA.Common.CompOption
      -> Text.Regex.TDFA.Common.ExecOption
      -> Data.Text.Internal.Lazy.Text
      -> Text.Regex.TDFA.Common.Regex
 [GblId] =
     [] \u []
         Text.Regex.Base.RegexLike.$dmmakeRegexOpts
 Text.Regex.TDFA.Text.Lazy.$fRegexMakerRegexCompOptionExecOptionText;
 $cmakeRegex_r6nN
   :: Data.Text.Internal.Lazy.Text -> Text.Regex.TDFA.Common.Regex
 [GblId] =
     [] \u []
         Text.Regex.Base.RegexLike.$dmmakeRegex
 Text.Regex.TDFA.Text.Lazy.$fRegexMakerRegexCompOptionExecOptionText;
 $cmakeRegexM_r6nO
   :: forall (m :: * -> *).
      GHC.Base.Monad m =>
      Data.Text.Internal.Lazy.Text -> m Text.Regex.TDFA.Common.Regex
 [GblId, Arity=1, Unf=OtherCon []] =
     [] \r [$dMonad_s6o9]
         Text.Regex.Base.RegexLike.$dmmakeRegexM
 Text.Regex.TDFA.Text.Lazy.$fRegexMakerRegexCompOptionExecOptionText
             $dMonad_s6o9;

 $trModule1_r6nP :: GHC.Prim.Addr#
 [GblId, Caf=NoCafRefs, Unf=OtherCon []] =
     "main"#;

 $trModule2_r6nQ :: GHC.Types.TrName
 [GblId, Caf=NoCafRefs, Unf=OtherCon []] =
     NO_CCS GHC.Types.TrNameS! [$trModule1_r6nP];

 $trModule3_r6nR :: GHC.Prim.Addr#
 [GblId, Caf=NoCafRefs, Unf=OtherCon []] =
     "Text.Regex.TDFA.Text.Lazy"#;

 $trModule4_r6nS :: GHC.Types.TrName
 [GblId, Caf=NoCafRefs, Unf=OtherCon []] =
     NO_CCS GHC.Types.TrNameS! [$trModule3_r6nR];

 Text.Regex.TDFA.Text.Lazy.$trModule :: GHC.Types.Module
 [GblId, Caf=NoCafRefs, Unf=OtherCon []] =
     NO_CCS GHC.Types.Module! [$trModule2_r6nQ $trModule4_r6nS];

 $cmatchTest_r6nT
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text -> GHC.Types.Bool
 [GblId] =
     [] \u []
         Text.Regex.TDFA.NewDFA.Tester.matchTest Data.Text.Lazy.uncons;

 $cmatchAll_r6nU
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text
      -> [Text.Regex.Base.RegexLike.MatchArray]
 [GblId, Arity=2, Unf=OtherCon []] =
     [] \r [r_s6oa s_s6ob]
         let {
           sat_s6od [Occ=Once] :: GHC.Types.Char
           [LclId] =
               NO_CCS GHC.Types.C#! ['\n'#]; } in
         let {
           sat_s6oc [Occ=Once] :: Text.Regex.TDFA.Common.Position
           [LclId] =
               NO_CCS GHC.Types.I#! [0#];
         } in
           Text.Regex.TDFA.NewDFA.Engine.execMatch
               Data.Text.Lazy.uncons r_s6oa sat_s6oc sat_s6od s_s6ob;

 Text.Regex.TDFA.Text.Lazy.compile
   :: Text.Regex.TDFA.Common.CompOption
      -> Text.Regex.TDFA.Common.ExecOption
      -> Data.Text.Internal.Lazy.Text
      -> Data.Either.Either GHC.Base.String Text.Regex.TDFA.Common.Regex
 [GblId, Arity=3, Unf=OtherCon []] =
     [] \r [compOpt_s6oe execOpt_s6of txt_s6og]
         let {
           sat_s6oh [Occ=Once] :: GHC.Base.String
           [LclId] =
               [txt_s6og] \u [] Data.Text.Lazy.unpack txt_s6og;
         } in
           case Text.Regex.TDFA.ReadRegex.parseRegex sat_s6oh of {
             Data.Either.Left err_s6oj [Occ=Once] ->
                 let {
                   sat_s6om [Occ=Once] :: [GHC.Types.Char]
                   [LclId] =
                       [err_s6oj] \u []
                           let {
                             sat_s6ol [Occ=Once] :: [GHC.Types.Char]
                             [LclId] =
                                 [err_s6oj] \u []
                                     GHC.Show.show
 Text.Parsec.Error.$fShowParseError err_s6oj; } in
                           let {
                             sat_s6ok [Occ=Once] :: [GHC.Types.Char]
                             [LclId] =
                                 [] \u []
                                     GHC.CString.unpackCString#
                                         "parseRegex for
 Text.Regex.TDFA.Text.Lazy failed:"#;
                           } in  GHC.Base.++ sat_s6ok sat_s6ol;
                 } in  Data.Either.Left [sat_s6om];
             Data.Either.Right pattern_s6on [Occ=Once] ->
                 let {
                   sat_s6oo [Occ=Once] :: Text.Regex.TDFA.Common.Regex
                   [LclId] =
                       [compOpt_s6oe execOpt_s6of pattern_s6on] \u []
                           Text.Regex.TDFA.TDFA.patternToRegex
                               pattern_s6on compOpt_s6oe execOpt_s6of;
                 } in  Data.Either.Right [sat_s6oo];
           };

 $cmatchOnce_r6nV
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text
      -> GHC.Base.Maybe Text.Regex.Base.RegexLike.MatchArray
 [GblId, Arity=2, Unf=OtherCon []] =
     [] \r [r_s6op s_s6oq]
         let {
           sat_s6or [Occ=Once] :: [Text.Regex.Base.RegexLike.MatchArray]
           [LclId] =
               [r_s6op s_s6oq] \u [] $cmatchAll_r6nU r_s6op s_s6oq;
         } in  Data.Maybe.listToMaybe sat_s6or;

 $cmatchAllText_r6nW
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text
      -> [Text.Regex.Base.RegexLike.MatchText
            Data.Text.Internal.Lazy.Text]
 [GblId, Arity=2, Unf=OtherCon []] =
     [] \r [regex_s6os source_s6ot]
         let {
           go_s6ou [Occ=LoopBreaker]
             :: GHC.Types.Int
                -> Data.Text.Internal.Lazy.Text
                -> [GHC.Arr.Array GHC.Types.Int (GHC.Types.Int,
 GHC.Types.Int)]
                -> [GHC.Arr.Array
                      GHC.Types.Int
                      (Data.Text.Internal.Lazy.Text, (GHC.Types.Int,
 GHC.Types.Int))]
           [LclId, Arity=3, Unf=OtherCon []] =
               sat-only [go_s6ou] \r [i_s6ov ds_s6ow ds1_s6ox]
                   case i_s6ov of i1_s6oy {
                     GHC.Types.I# _ [Occ=Dead] ->
                         case ds1_s6ox of {
                           [] -> [] [];
                           : x_s6oB xs_s6oC [Occ=Once] ->
                               let {
                                 ds2_s6oD :: (GHC.Types.Int, GHC.Types.Int)
                                 [LclId] =
                                     [x_s6oB] \u []
                                         let {
                                           sat_s6oE [Occ=Once] ::
 GHC.Types.Int
                                           [LclId] =
                                               NO_CCS GHC.Types.I#! [0#];
                                         } in
                                           Data.Array.Base.!
 Data.Array.Base.$fIArrayArraye
                                               GHC.Arr.$fIxInt
                                               x_s6oB
                                               sat_s6oE; } in
                               let {
                                 off0_s6oF :: GHC.Types.Int
                                 [LclId] =
                                     [ds2_s6oD] \u []
                                         case ds2_s6oD of {
                                           (,) off1_s6oH [Occ=Once] _
 [Occ=Dead] -> off1_s6oH;
                                         }; } in
                               let {
                                 len0_s6oJ :: GHC.Types.Int
                                 [LclId] =
                                     [ds2_s6oD] \u []
                                         case ds2_s6oD of {
                                           (,) _ [Occ=Dead] len1_s6oM
 [Occ=Once] -> len1_s6oM;
                                         }; } in
                               let {
                                 sat_s6p0 [Occ=Once]
                                   :: [GHC.Arr.Array
                                         GHC.Types.Int
                                         (Data.Text.Internal.Lazy.Text,
                                          (GHC.Types.Int, GHC.Types.Int))]
                                 [LclId] =
                                     [go_s6ou ds_s6ow i1_s6oy xs_s6oC
 off0_s6oF len0_s6oJ] \u []
                                         let {
                                           sat_s6oX [Occ=Once] ::
 GHC.Types.Int
                                           [LclId] =
                                               [i1_s6oy off0_s6oF
 len0_s6oJ] \u []
                                                   let {
                                                     sat_s6oW [Occ=Once] ::
 GHC.Types.Int
                                                     [LclId] =
                                                         [i1_s6oy
 len0_s6oJ] \u []
                                                             GHC.Num.-
 GHC.Num.$fNumInt len0_s6oJ i1_s6oy;
                                                   } in
                                                     GHC.Num.+
 GHC.Num.$fNumInt off0_s6oF sat_s6oW;
                                         } in
                                           case $cafter_r6mQ sat_s6oX
 ds_s6ow of t'_s6oY {
                                             __DEFAULT ->
                                                 let {
                                                   sat_s6oZ [Occ=Once] ::
 GHC.Types.Int
                                                   [LclId] =
                                                       [off0_s6oF
 len0_s6oJ] \u []
                                                           GHC.Num.+
 GHC.Num.$fNumInt off0_s6oF len0_s6oJ;
                                                 } in  go_s6ou sat_s6oZ
 t'_s6oY xs_s6oC;
                                           }; } in
                               let {
                                 sat_s6oV [Occ=Once]
                                   :: GHC.Arr.Array
                                        GHC.Types.Int
                                        (Data.Text.Internal.Lazy.Text,
                                         (GHC.Types.Int, GHC.Types.Int))
                                 [LclId] =
                                     [ds_s6ow i1_s6oy x_s6oB] \u []
                                         let {
                                           sat_s6oU [Occ=Once]
                                             :: (GHC.Types.Int,
 GHC.Types.Int)
                                                ->
 (Data.Text.Internal.Lazy.Text,
                                                    (GHC.Types.Int,
 GHC.Types.Int))
                                           [LclId] =
                                               [ds_s6ow i1_s6oy] \r
 [pair_s6oN]
                                                   case pair_s6oN of
 wild1_s6oO {
                                                     (,) off_s6oP
 [Occ=Once] len_s6oQ [Occ=Once] ->
                                                         let {
                                                           sat_s6oT
 [Occ=Once]
                                                             ::
 Data.Text.Internal.Lazy.Text
                                                           [LclId] =
                                                               [ds_s6ow
                                                                i1_s6oy
                                                                off_s6oP
                                                                len_s6oQ]
 \u []
                                                                   let {
 sat_s6oR [Occ=Once]
                                                                       ::
 GHC.Types.Int
 [LclId] =
 [i1_s6oy off_s6oP] \u []
 GHC.Num.-
 GHC.Num.$fNumInt
 off_s6oP
 i1_s6oy; } in
                                                                   let {
 sat_s6oS [Occ=Once]
                                                                       ::
 (GHC.Types.Int,
 GHC.Types.Int)
 [LclId] =
 NO_CCS (,)! [sat_s6oR
 len_s6oQ];
                                                                   } in
 $cextract_r6nK sat_s6oS ds_s6ow;
                                                         } in  (,)
 [sat_s6oT wild1_s6oO];
                                                   };
                                         } in  GHC.Base.fmap
 GHC.Arr.$fFunctorArray sat_s6oU x_s6oB;
                               } in  : [sat_s6oV sat_s6p0];
                         };
                   }; } in
         let {
           sat_s6p2 [Occ=Once]
             :: [GHC.Arr.Array GHC.Types.Int (GHC.Types.Int,
 GHC.Types.Int)]
           [LclId] =
               [regex_s6os source_s6ot] \u []
                   $cmatchAll_r6nU regex_s6os source_s6ot; } in
         let {
           sat_s6p1 [Occ=Once] :: GHC.Types.Int
           [LclId] =
               NO_CCS GHC.Types.I#! [0#];
         } in  go_s6ou sat_s6p1 source_s6ot sat_s6p2;

 $cmatchCount_r6nX
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text -> GHC.Types.Int
 [GblId, Arity=2, Unf=OtherCon []] =
     [] \r [r_s6p3 s_s6p4]
         let {
           sat_s6pm [Occ=Once] :: [Text.Regex.Base.RegexLike.MatchArray]
           [LclId] =
               [r_s6p3 s_s6p4] \u []
                   let {
                     sat_s6pl [Occ=Once] :: GHC.Types.Char
                     [LclId] =
                         NO_CCS GHC.Types.C#! ['\n'#]; } in
                   let {
                     sat_s6pk [Occ=Once] :: Text.Regex.TDFA.Common.Position
                     [LclId] =
                         NO_CCS GHC.Types.I#! [0#]; } in
                   let {
                     sat_s6pj [Occ=Once] :: Text.Regex.TDFA.Common.Regex
                     [LclId] =
                         [r_s6p3] \u []
                             case r_s6p3 of wild_s6p5 {
                               Text.Regex.TDFA.Common.Regex ds_s6p6
 [Occ=Once]
                                                            ds1_s6p7
 [Occ=Once]
                                                            ds2_s6p8
 [Occ=Once]
                                                            ds3_s6p9
 [Occ=Once]
                                                            ds4_s6pa
 [Occ=Once]
                                                            ds5_s6pb
 [Occ=Once]
                                                            ds6_s6pc
 [Occ=Once]
                                                            ds7_s6pd
 [Occ=Once]
                                                            ds8_s6pe
 [Occ=Once]
                                                            _ [Occ=Dead] ->
                                   let {
                                     sat_s6pi [Occ=Once] ::
 Text.Regex.TDFA.Common.ExecOption
                                     [LclId] =
                                         [wild_s6p5] \u []
                                             case
 Text.Regex.TDFA.Common.regex_execOptions wild_s6p5
                                             of
                                             {
 Text.Regex.TDFA.Common.ExecOption _ [Occ=Dead] ->
 Text.Regex.TDFA.Common.ExecOption [GHC.Types.False];
                                             };
                                   } in
                                     Text.Regex.TDFA.Common.Regex [ds_s6p6
                                                                   ds1_s6p7
                                                                   ds2_s6p8
                                                                   ds3_s6p9
                                                                   ds4_s6pa
                                                                   ds5_s6pb
                                                                   ds6_s6pc
                                                                   ds7_s6pd
                                                                   ds8_s6pe
 sat_s6pi];
                             };
                   } in
                     Text.Regex.TDFA.NewDFA.Engine.execMatch
                         Data.Text.Lazy.uncons sat_s6pj sat_s6pk sat_s6pl
 s_s6p4;
         } in  Data.Foldable.length Data.Foldable.$fFoldable[] sat_s6pm;

 $cmatchOnceText_r6nY
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text
      -> GHC.Base.Maybe
           (Data.Text.Internal.Lazy.Text,
            Text.Regex.Base.RegexLike.MatchText
 Data.Text.Internal.Lazy.Text,
            Data.Text.Internal.Lazy.Text)
 [GblId, Arity=2, Unf=OtherCon []] =
     [] \r [regex_s6pn source_s6po]
         let {
           sat_s6pL [Occ=Once]
             :: GHC.Base.Maybe
                  (GHC.Arr.Array GHC.Types.Int (GHC.Types.Int,
 GHC.Types.Int))
           [LclId] =
               [regex_s6pn source_s6po] \u []
                   let {
                     sat_s6pK [Occ=Once] ::
 [Text.Regex.Base.RegexLike.MatchArray]
                     [LclId] =
                         [regex_s6pn source_s6po] \u []
                             let {
                               sat_s6pJ [Occ=Once] :: GHC.Types.Char
                               [LclId] =
                                   NO_CCS GHC.Types.C#! ['\n'#]; } in
                             let {
                               sat_s6pI [Occ=Once] ::
 Text.Regex.TDFA.Common.Position
                               [LclId] =
                                   NO_CCS GHC.Types.I#! [0#];
                             } in
                               Text.Regex.TDFA.NewDFA.Engine.execMatch
                                   Data.Text.Lazy.uncons regex_s6pn
 sat_s6pI sat_s6pJ source_s6po;
                   } in  Data.Maybe.listToMaybe sat_s6pK; } in
         let {
           sat_s6pH [Occ=Once]
             :: GHC.Arr.Array GHC.Types.Int (GHC.Types.Int, GHC.Types.Int)
                -> (Data.Text.Internal.Lazy.Text,
                    GHC.Arr.Array
                      GHC.Types.Int
                      (Data.Text.Internal.Lazy.Text, (GHC.Types.Int,
 GHC.Types.Int)),
                    Data.Text.Internal.Lazy.Text)
           [LclId] =
               [source_s6po] \r [ma_s6pp]
                   let {
                     ds_s6pq :: (GHC.Types.Int, GHC.Types.Int)
                     [LclId] =
                         [ma_s6pp] \u []
                             let {
                               sat_s6pr [Occ=Once] :: GHC.Types.Int
                               [LclId] =
                                   NO_CCS GHC.Types.I#! [0#];
                             } in
                               Data.Array.Base.!
                                   Data.Array.Base.$fIArrayArraye
                                   GHC.Arr.$fIxInt
                                   ma_s6pp
                                   sat_s6pr; } in
                   let {
                     o_s6ps :: GHC.Types.Int
                     [LclId] =
                         [ds_s6pq] \u []
                             case ds_s6pq of {
                               (,) o1_s6pu [Occ=Once] _ [Occ=Dead] ->
 o1_s6pu;
                             }; } in
                   let {
                     sat_s6pG [Occ=Once] :: Data.Text.Internal.Lazy.Text
                     [LclId] =
                         [source_s6po ds_s6pq o_s6ps] \u []
                             let {
                               sat_s6pF [Occ=Once] :: GHC.Types.Int
                               [LclId] =
                                   [ds_s6pq o_s6ps] \u []
                                       let {
                                         sat_s6pE [Occ=Once] ::
 GHC.Types.Int
                                         [LclId] =
                                             [ds_s6pq] \u []
                                                 case ds_s6pq of {
                                                   (,) _ [Occ=Dead] l_s6pD
 [Occ=Once] -> l_s6pD;
                                                 };
                                       } in  GHC.Num.+ GHC.Num.$fNumInt
 o_s6ps sat_s6pE;
                             } in  $cafter_r6mQ sat_s6pF source_s6po; } in
                   let {
                     sat_s6pA [Occ=Once]
                       :: GHC.Arr.Array
                            GHC.Types.Int
                            (Data.Text.Internal.Lazy.Text, (GHC.Types.Int,
 GHC.Types.Int))
                     [LclId] =
                         [source_s6po ma_s6pp] \u []
                             let {
                               sat_s6pz [Occ=Once]
                                 :: (GHC.Types.Int, GHC.Types.Int)
                                    -> (Data.Text.Internal.Lazy.Text,
 (GHC.Types.Int, GHC.Types.Int))
                               [LclId] =
                                   [source_s6po] \r [ol_s6px]
                                       let {
                                         sat_s6py [Occ=Once] ::
 Data.Text.Internal.Lazy.Text
                                         [LclId] =
                                             [source_s6po ol_s6px] \u []
                                                 $cextract_r6nK ol_s6px
 source_s6po;
                                       } in  (,) [sat_s6py ol_s6px];
                             } in  GHC.Base.fmap GHC.Arr.$fFunctorArray
 sat_s6pz ma_s6pp; } in
                   let {
                     sat_s6pw [Occ=Once] :: Data.Text.Internal.Lazy.Text
                     [LclId] =
                         [source_s6po o_s6ps] \u [] $cbefore_r6nJ o_s6ps
 source_s6po;
                   } in  (,,) [sat_s6pw sat_s6pA sat_s6pG];
         } in  GHC.Base.fmap GHC.Base.$fFunctorMaybe sat_s6pH sat_s6pL;

 Text.Regex.TDFA.Text.Lazy.$fRegexLikeRegexText [InlPrag=NOUSERINLINE
 CONLIKE]
   :: Text.Regex.Base.RegexLike.RegexLike
        Text.Regex.TDFA.Common.Regex Data.Text.Internal.Lazy.Text
 [GblId[DFunId]] =
     NO_CCS Text.Regex.Base.RegexLike.C:RegexLike!
 [Text.Regex.TDFA.Text.Lazy.$fExtractText
                                                    $cmatchOnce_r6nV
                                                    $cmatchAll_r6nU
                                                    $cmatchCount_r6nX
                                                    $cmatchTest_r6nT
                                                    $cmatchAllText_r6nW
                                                    $cmatchOnceText_r6nY];

 Text.Regex.TDFA.Text.Lazy.regexec
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text
      -> Data.Either.Either
           GHC.Base.String
           (GHC.Base.Maybe
              (Data.Text.Internal.Lazy.Text, Data.Text.Internal.Lazy.Text,
               Data.Text.Internal.Lazy.Text,
 [Data.Text.Internal.Lazy.Text]))
 [GblId, Arity=2, Unf=OtherCon []] =
     [] \r [r_s6pM txt_s6pN]
         case $cmatchOnceText_r6nY r_s6pM txt_s6pN of {
           GHC.Base.Nothing -> Data.Either.Right [GHC.Base.Nothing];
           GHC.Base.Just ds_s6pP [Occ=Once!] ->
               case ds_s6pP of {
                 (,,) pre_s6pR [Occ=Once] mt_s6pS post_s6pT [Occ=Once] ->
                     let {
                       sat_s6pZ [Occ=Once] ::
 [Data.Text.Internal.Lazy.Text]
                       [LclId] =
                           [mt_s6pS] \u []
                               let {
                                 sat_s6pY [Occ=Once]
                                   :: [(Data.Text.Internal.Lazy.Text,
 (Text.Regex.Base.RegexLike.MatchOffset,
 Text.Regex.Base.RegexLike.MatchLength))]
                                 [LclId] =
                                     [mt_s6pS] \u []
                                         let {
                                           sat_s6pX [Occ=Once]
                                             ::
 [(Data.Text.Internal.Lazy.Text,
 (Text.Regex.Base.RegexLike.MatchOffset,
 Text.Regex.Base.RegexLike.MatchLength))]
                                           [LclId] =
                                               [mt_s6pS] \u []
                                                   Data.Array.Base.elems
 Data.Array.Base.$fIArrayArraye
                                                       GHC.Arr.$fIxInt
                                                       mt_s6pS;
                                         } in  GHC.List.tail sat_s6pX;
                               } in  GHC.Base.map Data.Tuple.fst sat_s6pY;
 } in
                     let {
                       sat_s6pW [Occ=Once] :: Data.Text.Internal.Lazy.Text
                       [LclId] =
                           [mt_s6pS] \u []
                               let {
                                 sat_s6pV [Occ=Once]
                                   :: (Data.Text.Internal.Lazy.Text,
 (Text.Regex.Base.RegexLike.MatchOffset,
 Text.Regex.Base.RegexLike.MatchLength))
                                 [LclId] =
                                     [mt_s6pS] \u []
                                         let {
                                           sat_s6pU [Occ=Once] ::
 GHC.Types.Int
                                           [LclId] =
                                               NO_CCS GHC.Types.I#! [0#];
                                         } in
                                           Data.Array.Base.!
 Data.Array.Base.$fIArrayArraye
                                               GHC.Arr.$fIxInt
                                               mt_s6pS
                                               sat_s6pU;
                               } in  Data.Tuple.fst sat_s6pV; } in
                     let {
                       sat_s6q0 [Occ=Once]
                         :: (Data.Text.Internal.Lazy.Text,
 Data.Text.Internal.Lazy.Text,
                             Data.Text.Internal.Lazy.Text,
 [Data.Text.Internal.Lazy.Text])
                       [LclId] =
                           NO_CCS (,,,)! [pre_s6pR sat_s6pW post_s6pT
 sat_s6pZ]; } in
                     let {
                       sat_s6q1 [Occ=Once]
                         :: GHC.Base.Maybe
                              (Data.Text.Internal.Lazy.Text,
 Data.Text.Internal.Lazy.Text,
                               Data.Text.Internal.Lazy.Text,
 [Data.Text.Internal.Lazy.Text])
                       [LclId] =
                           NO_CCS GHC.Base.Just! [sat_s6q0];
                     } in  Data.Either.Right [sat_s6q1];
               };
         };

 $cmatch_r6nZ
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text -> Data.Text.Internal.Lazy.Text
 [GblId] =
     [] \u []
         Text.Regex.Base.Impl.polymatch
             Text.Regex.TDFA.Text.Lazy.$fRegexLikeRegexText;

 $cmatchM_r6o0
   :: forall (m :: * -> *).
      GHC.Base.Monad m =>
      Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text -> m Data.Text.Internal.Lazy.Text
 [GblId, Arity=1, Unf=OtherCon []] =
     [] \r [$dMonad_s6q2]
         Text.Regex.Base.Impl.polymatchM
             Text.Regex.TDFA.Text.Lazy.$fRegexLikeRegexText $dMonad_s6q2;

 Text.Regex.TDFA.Text.Lazy.$fRegexContextRegexTextText
 [InlPrag=NOUSERINLINE CONLIKE]
   :: Text.Regex.Base.RegexLike.RegexContext
        Text.Regex.TDFA.Common.Regex
        Data.Text.Internal.Lazy.Text
        Data.Text.Internal.Lazy.Text
 [GblId[DFunId]] =
     NO_CCS Text.Regex.Base.RegexLike.C:RegexContext!
 [Text.Regex.TDFA.Text.Lazy.$fRegexLikeRegexText
                                                       $cmatch_r6nZ
                                                       $cmatchM_r6o0];

 Text.Regex.TDFA.Text.Lazy.execute
   :: Text.Regex.TDFA.Common.Regex
      -> Data.Text.Internal.Lazy.Text
      -> Data.Either.Either
           GHC.Base.String
           (GHC.Base.Maybe Text.Regex.Base.RegexLike.MatchArray)
 [GblId, Arity=2, Unf=OtherCon []] =
     [] \r [r_s6q3 txt_s6q4]
         let {
           sat_s6q5 [Occ=Once]
             :: GHC.Base.Maybe Text.Regex.Base.RegexLike.MatchArray
           [LclId] =
               [r_s6q3 txt_s6q4] \u [] $cmatchOnce_r6nV r_s6q3 txt_s6q4;
         } in  Data.Either.Right [sat_s6q5];

 }}}

 Which I think is strange, because `wnext2` doesn't look like anything GHC
 would autogenerate, but rather like a name a human would choose on
 purpose.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:16>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14519: Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy +
Text.RE.TDFA
-------------------------------------+-------------------------------------
        Reporter:  ntc2              |                Owner:  tdammers
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Runtime           |            Test Case:
  performance bug                    |  https://github.com/ntc2/ghc-8.2.1
                                     |  -regex-lazy-text-
                                     |  bug/tree/07b7bb32c6e90e8f2d2eada4b59943f37e632d53
      Blocked By:                    |             Blocking:
 Related Tickets:  #13745, #14564    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by mpickering):

 There is a function called `next` in `regex-tdfa` in
 `Text/Regex/TDFA/NewDFA` which is probably the one you are looking for?

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14519#comment:17>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
123