| line | true | false | branch | 
 
| 39 | 5 | 273 | if ($_[2]) | 
 
| 71 | 2 | 1 | if &set_le | 
 
| 72 | 2 | 1 | if &set_ge | 
 
| 82 | 0 | 0 | $a->equal($b) ? : | 
 
| 89 | 21 | 0 | if ref $a | 
 
| 90 | 4 | 17 | if ref $b | 
 
| 94 | 7 | 14 | if $a == $b | 
 
| 95 | 2 | 12 | if $a < 0 | 
 
| 96 | 1 | 11 | if $b < 0 | 
 
| 129 | 11 | 0 | $@ ? : | 
 
| 137 | 929 | 2498 | unless defined $set_spec | 
 
| 140 | 2400 | 98 | unless ref $set_spec | 
 
| 141 | 48 | 50 | if ref $set_spec eq 'ARRAY' | 
 
| 169 | 23 | 51 | if (@span == 0) { } | 
 
|  | 19 | 32 | elsif (@span == 1 and $e == $span[0] + 1) { } | 
 
|  | 6 | 26 | elsif (@span == 1 and $e > $span[0] + 1) { } | 
 
|  | 11 | 15 | elsif (@span == 2 and $e == $span[1] + 1) { } | 
 
|  | 6 | 14 | elsif (@span == 2 and $e > $span[1] + 1) { } | 
 
| 193 | 10 | 38 | if @span == 1 | 
 
| 194 | 13 | 35 | if @span == 2 | 
 
| 204 | 77 | 18 | if (defined $al and defined $bl) { } | 
 
|  | 5 | 13 | elsif (defined $al) { } | 
 
|  | 12 | 1 | elsif (defined $bl) { } | 
 
|  | 0 | 1 | elsif (defined $au) { } | 
 
|  | 0 | 1 | elsif (defined $bu) { } | 
 
| 223 | 24 | 84 | if (@spans and not defined $spans[0][0]) | 
 
| 228 | 8 | 16 | unless (defined $$span[1]) | 
 
| 239 | 0 | 0 | if $edges[0] < $$span[1] | 
 
| 245 | 65 | 35 | if (@spans and not @edges) | 
 
| 249 | 59 | 6 | if (defined $$span[1]) { } | 
 
| 264 | 47 | 8 | if ($edges[-1] < $$span[0]) { } | 
 
| 270 | 7 | 1 | if $edges[-1] < $$span[1] | 
 
| 274 | 10 | 84 | if (@spans) | 
 
| 279 | 6 | 4 | if ($edges[-1] < $$span[0]) { } | 
 
| 310 | 251 | 2160 | if $runList eq '-' | 
 
| 317 | 4 | 3077 | if $last | 
 
| 322 | 652 | 2425 | if ($run =~ /^ (-?\d+) $/x) | 
 
| 328 | 1587 | 838 | if ($run =~ /^ (-?\d+) - (-?\d+) $/x) | 
 
| 329 | 2 | 1585 | if $1 > $2 | 
 
| 336 | 293 | 545 | if ($run =~ /^ \( - (-?\d+) $/x) | 
 
| 337 | 2 | 291 | unless $first | 
 
| 345 | 298 | 247 | if ($run =~ /^ (-?\d+) - \) $/x) | 
 
| 353 | 237 | 10 | if ($run =~ /^ \( - \) $/x) | 
 
| 354 | 0 | 237 | unless $first | 
 
| 370 | 4 | 2138 | unless $set->_cleanup | 
 
| 387 | 3070 | 46 | if $cmp == -1 | 
 
| 388 | 42 | 4 | if $cmp == 0 | 
 
| 389 | 4 | 0 | if $cmp == 1 | 
 
| 401 | 240 | 818 | if $set->empty | 
 
| 406 | 176 | 642 | if $$set{'negInf'} | 
 
| 407 | 185 | 633 | if $$set{'posInf'} | 
 
| 413 | 305 | 934 | if ($lower ne '(' and $upper ne ')' and $lower + 1 == $upper) { } | 
 
| 419 | 758 | 176 | if $lower ne '(' | 
 
| 430 | 0 | 0 | $$set{'negInf'} ? : | 
 
|  | 0 | 0 | $$set{'posInf'} ? : | 
 
| 437 | 16 | 42 | if $$set{'negInf'} or $$set{'posInf'} | 
 
| 448 | 27 | 15 | wantarray ? : | 
 
| 456 | 5 | 18 | if $$set{'negInf'} | 
 
| 457 | 6 | 17 | if $$set{'posInf'} | 
 
| 464 | 18 | 5 | defined $lower ? : | 
 
| 465 | 17 | 6 | defined $upper ? : | 
 
| 479 | 10 | 28 | if $$set{'negInf'} | 
 
| 480 | 10 | 28 | if $$set{'posInf'} | 
 
| 486 | 42 | 10 | if defined $lower | 
 
| 499 | 963 | 83 | defined $set_spec && ref $set_spec && ref $set_spec ne 'ARRAY' ? : | 
 
| 537 | 62 | 93 | if ($xA < $xB) { } | 
 
|  | 58 | 35 | elsif ($xB < $xA) { } | 
 
| 541 | 33 | 29 | unless $inB | 
 
| 547 | 25 | 33 | unless $inA | 
 
| 555 | 18 | 17 | if $inA == $inB | 
 
| 559 | 22 | 63 | if $iA < @$eA and not $inB | 
 
| 560 | 32 | 53 | if $iB < @$eB and not $inA | 
 
| 600 | 46 | 78 | if ($xA < $xB) { } | 
 
|  | 43 | 35 | elsif ($xB < $xA) { } | 
 
| 604 | 24 | 22 | if $inB | 
 
| 610 | 24 | 19 | if $inA | 
 
| 618 | 18 | 17 | if $inA == $inB | 
 
| 622 | 4 | 63 | if $iA < @$eA and $inB | 
 
| 623 | 4 | 63 | if $iB < @$eB and $inA | 
 
| 666 | 107 | 218 | if ($xA < $xB) { } | 
 
|  | 107 | 111 | elsif ($xB < $xA) { } | 
 
| 670 | 61 | 46 | unless $inB | 
 
| 676 | 47 | 60 | if $inA | 
 
| 684 | 32 | 79 | if $inA != $inB | 
 
| 688 | 60 | 183 | if $iA < @$eA and not $inB | 
 
| 689 | 34 | 209 | if $iB < @$eB and $inA | 
 
| 726 | 45 | 77 | if ($xA < $xB) { } | 
 
|  | 43 | 34 | elsif ($xB < $xA) { } | 
 
| 743 | 21 | 46 | if $iA < @$eA | 
 
| 744 | 24 | 43 | if $iB < @$eB | 
 
| 788 | 30 | 319 | unless $$a{'negInf'} == $$b{'negInf'} | 
 
| 789 | 14 | 305 | unless $$a{'posInf'} == $$b{'posInf'} | 
 
| 793 | 18 | 287 | unless @$aEdge == @$bEdge | 
 
| 797 | 16 | 548 | unless $$aEdge[$i] == $$bEdge[$i] | 
 
| 817 | 60 | 138 | if $$set{'negInf'} or $$set{'posInf'} | 
 
| 858 | 7 | 2 | unless $$set{'negInf'} | 
 
| 866 | 1 | 8 | if $$set{'negInf'} and not @{$$set{'edges'};} | 
 
| 888 | 0 | 510 | unless defined $n | 
 
| 893 | 87 | 423 | if $$set{'negInf'} xor $i & 1 xor $indel | 
 
| 898 | 81 | 342 | if ($lGap and $rGap) { } | 
 
|  | 284 | 58 | elsif (not $lGap and $rGap) { } | 
 
|  | 55 | 3 | elsif ($lGap and not $rGap) { } | 
 
| 911 | 75 | 681 | unless @$edges | 
 
| 920 | 264 | 463 | if ($target <= $$edges[$mid]) { } | 
 
| 930 | 188 | 493 | if $target <= $$edges[$lower] | 
 
| 931 | 135 | 358 | if $target <= $$edges[$upper] | 
 
| 940 | 15 | 9 | ($$set{'negInf'} xor $i & 1) ? : | 
 
| 947 | 3 | 23 | if $set->empty | 
 
| 948 | 4 | 19 | if $set->neg_inf | 
 
| 957 | 3 | 23 | if $set->empty | 
 
| 958 | 4 | 19 | if $set->pos_inf | 
 
| 970 | 2 | 11 | if ($negInf and $posInf) { } | 
 
|  | 2 | 9 | elsif ($negInf and not $posInf) { } | 
 
|  | 2 | 7 | elsif (not $negInf and $posInf) { } | 
 
|  | 5 | 2 | elsif (@$edges) { } | 
 
| 1005 | 2 | 11 | if ($negInf and $posInf) { } | 
 
|  | 2 | 9 | elsif ($negInf and not $posInf) { } | 
 
|  | 2 | 7 | elsif (not $negInf and $posInf) { } | 
 
|  | 5 | 2 | elsif (@$edges) { } | 
 
| 1042 | 13 | 24 | if (@edges and ($$inset{'negInf'} xor $n < 0)) | 
 
| 1054 | 45 | 34 | if $lower < $upper | 
 
| 1058 | 13 | 24 | if (@edges) | 
 
| 1082 | 15 | 30 | if $$set{'negInf'} or $$set{'posInf'} | 
 
| 1094 | 90 | 60 | unless &$block() | 
 
| 1096 | 29 | 31 | if (@sub_edges and $sub_edges[-1] == $i - 1) { } | 
 
| 1117 | 21 | 42 | if $$set{'negInf'} or $$set{'posInf'} | 
 
| 1151 | 4 | 36 | if ($$set{'negInf'} and $$set{'posInf'}) { } | 
 
|  | 4 | 32 | elsif ($$set{'negInf'}) { } | 
 
| 1154 | 2 | 2 | if (&$block()) | 
 
| 1164 | 2 | 2 | if (&$block()) | 
 
| 1175 | 20 | 20 | if &$block() | 
 
| 1178 | 8 | 32 | if (@edges) | 
 
| 1182 | 4 | 4 | if (&$block()) | 
 
| 1200 | 6 | 54 | if ($$set{'negInf'} and $$set{'posInf'}) { } | 
 
|  | 6 | 48 | elsif ($$set{'negInf'}) { } | 
 
| 1219 | 12 | 48 | if (@edges) | 
 
| 1236 | 15 | 2 | $#{$$set{'edges'};} ? : | 
 
| 1248 | 15 | 2 | $lastEdge ? : | 
 
| 1260 | 0 | 58 | unless defined $start | 
 
| 1267 | 82 | 89 | if ($inSet) { } | 
 
| 1269 | 29 | 53 | if ($start <= $$edges[$i]) | 
 
| 1272 | 21 | 8 | $i ? : | 
 
| 1280 | 18 | 71 | if ($start <= $$edges[$i]) | 
 
| 1288 | 8 | 3 | if ($inSet) | 
 
| 1291 | 7 | 1 | @$edges ? : | 
 
| 1306 | 2 | 42 | unless defined $$set{'iterator'} | 
 
| 1309 | 1 | 41 | unless defined $run1 | 
 
| 1312 | 28 | 13 | if $$set{'iterator'} < $$edges[$run1] | 
 
| 1314 | 4 | 9 | if ($run1 < $#$edges - 1) { } | 
 
|  | 2 | 7 | elsif ($run1 < $#$edges) { } | 
 
| 1339 | 2 | 37 | unless defined $$set{'iterator'} | 
 
| 1342 | 1 | 36 | unless defined $run0 | 
 
| 1345 | 25 | 11 | if $$set{'iterator'} > $$edges[$run0] + 1 | 
 
| 1347 | 3 | 8 | if ($run0 > 1) { } | 
 
|  | 1 | 7 | elsif ($run0 > 0) { } | 
 
| 1371 | 15 | 14 | $i < 0 ? : | 
 
| 1378 | 1 | 13 | if $set->neg_inf | 
 
| 1389 | 6 | 10 | if $i < $size | 
 
| 1394 | 3 | 4 | @edges ? : | 
 
| 1401 | 1 | 14 | if $set->pos_inf | 
 
| 1413 | 7 | 12 | if -$i < $size | 
 
| 1418 | 3 | 4 | @edges ? : | 
 
| 1425 | 1 | 15 | if $$set{'negInf'} | 
 
| 1428 | 0 | 15 | unless defined $n | 
 
| 1437 | 4 | 17 | if $n <= $lower | 
 
| 1439 | 9 | 8 | if (defined $upper and $upper < $n) | 
 
| 1466 | 117 | 116 | $offset < 0 ? : | 
 
| 1475 | 2 | 114 | if $set->neg_inf | 
 
| 1486 | 89 | 62 | if $offset < $size | 
 
| 1493 | 12 | 102 | unless @edges | 
 
| 1505 | 3 | 114 | if $set->pos_inf | 
 
| 1519 | 92 | 101 | if -$offset < $size | 
 
| 1525 | 100 | 14 | if (@edges) { } | 
 
|  | 2 | 12 | elsif ($$set{'slicing'}) { } | 
 
| 1543 | 23 | 193 | unless defined $length | 
 
| 1544 | 78 | 115 | if $length < 0 | 
 
| 1545 | 103 | 12 | if $length > 0 | 
 
| 1561 | 71 | 54 | if $length <= $size | 
 
| 1567 | 84 | 19 | if (@$edges) | 
 
| 1580 | 1 | 77 | if $set->pos_inf | 
 
| 1588 | 53 | 73 | if $length < $size | 
 
| 1594 | 53 | 24 | if (@$edges) |