|  line  | 
 !l  | 
 l&&!r  | 
 l&&r  | 
 condition  | 
 
| 
144
 | 
 3237  | 
 95  | 
 0  | 
 $qm and $1 eq '\\L' || $1 eq '\\U'  | 
 
| 
164
 | 
 3259  | 
 46  | 
 22  | 
 $unroll_plus and $qualifier =~ s/\A\+(\?)?\Z/*/  | 
 
| 
187
 | 
 437  | 
 3  | 
 3  | 
 $unroll_plus && $qualifier =~ s/\A\+(\?)?\Z/*/  | 
 
| 
198
 | 
 3  | 
 3  | 
 3  | 
 $unroll_plus && $qualifier =~ s/\A\+(\?)?\Z/*/  | 
 
| 
266
 | 
 32  | 
 4  | 
 3  | 
 $unroll_plus && $qualifier =~ s/\A\+(\?)?\Z/*/  | 
 
| 
383
 | 
 2277  | 
 1  | 
 1  | 
 $self->{'pre_filter'} and not $self->{'pre_filter'}->($record)  | 
 
| 
390
 | 
 2276  | 
 1  | 
 1  | 
 $self->{'filter'} and not $self->{'filter'}->(@$list)  | 
 
| 
431
 | 
 3396  | 
 1  | 
 1  | 
 $self->{'filter'} and not $self->{'filter'}->(@_)  | 
 
| 
464
 | 
 1  | 
 1  | 
 1  | 
 defined $pre_filter and ref $pre_filter ne 'CODE'  | 
 
| 
476
 | 
 2  | 
 1  | 
 1  | 
 defined $filter and ref $filter ne 'CODE'  | 
 
| 
497
 | 
 40  | 
 747  | 
 3  | 
 not exists $arg->{'indent'} and $self->{'indent'} > 0  | 
 
| 
498
 | 
 747  | 
 1  | 
 42  | 
 exists $arg->{'indent'} and $arg->{'indent'} > 0  | 
 
| 
582
 | 
 10  | 
 0  | 
 33  | 
 defined $-[$n] and defined $+[$n]  | 
 
| 
654
 | 
 3  | 
 1  | 
 2  | 
 defined $self->{'str'} && $self->{'str'} ne $Regexp::Assemble::Always_Fail  | 
 
| 
898
 | 
 1344  | 
 686  | 
 0  | 
 @in == 1 and !defined($in[0]) || $in[0] eq ''  | 
 
| 
1045
 | 
 7  | 
 16  | 
 30  | 
 @$old_path and _node_eq($old_path->[0], $token)  | 
 
| 
1094
 | 
 43  | 
 57  | 
 131  | 
 @$path_end and _node_eq($path_end->[0], $token)  | 
 
| 
1219
 | 
 603  | 
 110  | 
 97  | 
 @$tail > 1 and ref $tail->[0] eq 'HASH'  | 
 
| 
 | 
 713  | 
 25  | 
 72  | 
 @$tail > 1 and ref $tail->[0] eq 'HASH' and keys %{$$tail[0];} == 2  | 
 
| 
1228
 | 
 66  | 
 49  | 
 8  | 
 @$path == 1 and ref $path->[0] eq 'HASH'  | 
 
| 
1252
 | 
 959  | 
 51  | 
 70  | 
 $optional and scalar keys %$node == 1  | 
 
| 
1278
 | 
 140  | 
 365  | 
 514  | 
 @$fail == 0 and keys %$reduce == 1  | 
 
| 
 | 
 505  | 
 8  | 
 506  | 
 @$fail == 0 and keys %$reduce == 1 and not $optional  | 
 
| 
1378
 | 
 125  | 
 481  | 
 0  | 
 keys %$end == 2 and exists $end->{''}  | 
 
| 
1405
 | 
 34  | 
 26  | 
 287  | 
 ref $tail eq 'HASH' and keys %$tail == 2  | 
 
| 
1480
 | 
 31  | 
 209  | 
 154  | 
 defined $path->[0] and $path->[0] eq $slide_path->[0]  | 
 
| 
1570
 | 
 142  | 
 503  | 
 0  | 
 $self->{'fold_meta_pairs'} and exists $set{'\\d'} && exists $set{'\\D'} || exists $set{'\\s'} && exists $set{'\\S'} || exists $set{'\\w'} && exists $set{'\\W'}  | 
 
| 
1588
 | 
 620  | 
 2  | 
 3  | 
 $class =~ s/0123456789/\\d/ and $class eq '\\d'  | 
 
| 
1628
 | 
 1201  | 
 172  | 
 365  | 
 @short == 1 and @long == 0  | 
 
| 
 | 
 865  | 
 14  | 
 494  | 
 @short > 1 and @short == @_  | 
 
| 
1656
 | 
 47  | 
 44  | 
 7  | 
 $i < $#arr and $arr[$i + 1] =~ /\A$arr[$i]\*(\??)\Z/  | 
 
| 
1711
 | 
 10  | 
 5  | 
 11  | 
 ref $in->{$path}[$next] eq 'HASH' and @{$in->{$path};} > $next + 1  | 
 
| 
1764
 | 
 62  | 
 35  | 
 12  | 
 exists $in->[$p]{''} and $p + 1 < @$in  | 
 
| 
1781
 | 
 88  | 
 3  | 
 18  | 
 $nr_one > 1 and $nr_one == $nr  | 
 
| 
1815
 | 
 23  | 
 72  | 
 9  | 
 $n < @$in - 1 and ref $$in[$n + 1] eq 'HASH'  | 
 
| 
 | 
 95  | 
 9  | 
 0  | 
 $n < @$in - 1 and ref $$in[$n + 1] eq 'HASH' and exists $$in[$n + 1]{''}  | 
 
| 
1907
 | 
 2  | 
 423  | 
 0  | 
 defined $_[0] and defined $_[1]  | 
 
| 
1916
 | 
 33  | 
 28  | 
 244  | 
 keys %{$_[0];} == keys %{$_[1];} and join('|', sort(keys %{$_[0];})) eq join('|', sort(keys %{$_[1];}))  | 
|  line  | 
 l  | 
 !l&&r  | 
 !l&&!r  | 
 condition  | 
 
| 
79
 | 
 7  | 
 1  | 
 2189  | 
 $args{'flags'} ||= delete $args{'modifiers'} || ''  | 
 
| 
144
 | 
 3  | 
 2  | 
 90  | 
 $1 eq '\\L' || $1 eq '\\U'  | 
 
| 
405
 | 
 1  | 
 0  | 
 2  | 
 $arg->{'rs'} || $arg->{'input_record_separator'} || $self->{'input_record_separator'} || $/  | 
 
| 
411
 | 
 2  | 
 0  | 
 5  | 
 $self->{'input_record_separator'} || $/  | 
 
| 
440
 | 
 6959  | 
 114  | 
 11  | 
 not defined $self->{'stats_dup'} or $dup == $self->{'stats_dup'}  | 
 
| 
494
 | 
 8  | 
 18  | 
 764  | 
 $self->{'mutable'} or not $self->{'reduce'}  | 
 
| 
898
 | 
 2  | 
 28  | 
 656  | 
 !defined($in[0]) || $in[0] eq ''  | 
 
| 
 | 
 3  | 
 0  | 
 2030  | 
 @in == 0 or @in == 1 and !defined($in[0]) || $in[0] eq ''  | 
 
| 
1443
 | 
 276  | 
 26  | 
 811  | 
 scalar grep({ref $_ eq 'HASH';} @$a) <=> scalar grep({ref $_ eq 'HASH';} @$b) or _node_offset($b) <=> _node_offset($a)  | 
 
| 
1545
 | 
 205  | 
 85  | 
 84  | 
 $key eq '' or $key gt $k  | 
 
| 
1570
 | 
 4  | 
 0  | 
 494  | 
 exists $set{'\\d'} && exists $set{'\\D'} || exists $set{'\\s'} && exists $set{'\\S'} || exists $set{'\\w'} && exists $set{'\\W'}  | 
 
| 
 | 
 5  | 
 0  | 
 645  | 
 exists $set{'.'} or $self->{'fold_meta_pairs'} and exists $set{'\\d'} && exists $set{'\\D'} || exists $set{'\\s'} && exists $set{'\\S'} || exists $set{'\\w'} && exists $set{'\\W'}  | 
 
| 
1593
 | 
 792  | 
 206  | 
 1  | 
 length $b <=> length $a || $a cmp $b  | 
 
| 
1815
 | 
 1  | 
 23  | 
 80  | 
 $n < @$in - 1 and ref $$in[$n + 1] eq 'HASH' and exists $$in[$n + 1]{''} or $n == @$in - 1  |