3v4l.org

run code in 300+ PHP versions simultaneously
<?php define(TRACES_MODE, 'TEXTAREA');//'TEXTAREA' or 'FIREPHP' $GLOBALS['traces.pre']=array(); function my_array_diff($arr1, $arr2) {foreach ($arr1 as $k=>$v) {if (in_array($v, $arr2, true)) {unset($arr1[$k]); } } return $arr1; } function my_var_export($var, $is_str=false) {$rtn=preg_replace(array('/Array\s+\(/', '/\[(\d+)\] => (.*)\n/', '/\[([^\d].*)\] => (.*)\n/'), array('array (', '\1 => \'\2\''."\n", '\'\1\' => \'\2\''."\n"), substr(print_r($var, true), 0, -1)); $rtn=strtr($rtn, array("=> 'array ('"=>'=> array (')); $rtn=strtr($rtn, array(")\n\n"=>")\n")); $rtn=strtr($rtn, array("'\n"=>"',\n", ")\n"=>"),\n")); $rtn=preg_replace(array('/\n +/e'), array('strtr(\'\0\', array(\' \'=>\' \'))'), $rtn); $rtn=strtr($rtn, array(" Object',"=>" Object'<-")); if ($is_str) {return $rtn; } else {echo $rtn; } } function tick_handler() {$tmp=debug_backtrace(); $trace=my_array_diff($tmp, $GLOBALS['traces.pre']); //echo '<pre>';var_export($trace);echo '</pre>';echo '<br/>'; //for debug diyism_trace.php $trace=array_values($trace); $GLOBALS['traces.pre']=$tmp; if (count($trace)>0 && $trace[0]['file'].'/'.@$tmp[1]['function']!==@$GLOBALS['traces'][count($GLOBALS['traces'])-1]['key']) //filter empty array and rearrange array_values(), because some lines will trigger two tick events per line, for example: 1.last line is "some code;questmark>" 2.error_reporting(... {for ($i=count($trace)-1; $i>=0; --$i) {$GLOBALS['traces'][]=$tmp_fb=array_merge(array('key'=>$trace[$i]['file'].'/'.@$tmp[$i+1]['function']), $trace[$i], array('function'=>strtr($trace[$i]['function'], array('tick_handler'=>'CONTINUE')), 'in_function'=>@$tmp[$i+1]['function'])); TRACES_MODE==='FIREPHP'?fb(trace_output($tmp_fb), 'diyism_trace:'.++$GLOBALS['diyism_trace_no']):''; } } } function trace_output($trace) {$trace['in_function']=strtr(@$trace['in_function'], array('require'=>'', 'require_once'=>'', 'include'=>'', 'include_once'=>'')); $trace['args']=$trace['args']?strtr(preg_replace(array('/\n +/'), array(''), preg_replace(array('/\n \d+ => /'), array(''), substr(my_var_export($trace['args'], true), 7, -3))), array("\r"=>'\r', "\n"=>'\n')):''; return $trace['file'].($trace['in_function']?'/'.$trace['in_function'].'()':'').'/'.$trace['line'].': '.$trace['function'].'('.$trace['args'].')'; } function traces_output() {echo '<textarea style="width:100%;height:300px;">'; $GLOBALS['traces']=array_slice($GLOBALS['traces'], 2);//remove registering tick line and requiring 'diyism_trace.php' line foreach ($GLOBALS['traces'] as $k=>$trace) {echo htmlentities($k.':'.trace_output($trace)."\n"); } echo '</textarea>'; } register_tick_function('tick_handler'); TRACES_MODE==='TEXTAREA'?register_shutdown_function('traces_output'):''; ?> <?php declare(ticks=1); a('a', array('hello')); 1+2; b(); function a() {$d=1; b(); $d=2; } function b() {1+1; } ?>
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 14, Position 2 = 19
Branch analysis from position: 14
1 jumps found. (Code = 42) Position 1 = 20
Branch analysis from position: 20
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 19
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/UB2iJ
function name:  (null)
number of ops:  32
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
    2     0  E >   INIT_FCALL                                               'define'
          1        FETCH_CONSTANT                                   ~0      'TRACES_MODE'
          2        SEND_VAL                                                 ~0
          3        SEND_VAL                                                 'TEXTAREA'
          4        DO_ICALL                                                 
    3     5        FETCH_W                      global              $2      'GLOBALS'
          6        ASSIGN_DIM                                               $2, 'traces.pre'
          7        OP_DATA                                                  <array>
   52     8        INIT_FCALL                                               'register_tick_function'
          9        SEND_VAL                                                 'tick_handler'
         10        DO_ICALL                                                 
   53    11        FETCH_CONSTANT                                   ~5      'TRACES_MODE'
         12        IS_IDENTICAL                                             ~5, 'TEXTAREA'
         13      > JMPZ                                                     ~6, ->19
         14    >   INIT_FCALL                                               'register_shutdown_function'
         15        SEND_VAL                                                 'traces_output'
         16        DO_ICALL                                         $7      
         17        QM_ASSIGN                                        ~8      $7
         18      > JMP                                                      ->20
         19    >   QM_ASSIGN                                        ~8      ''
         20    >   FREE                                                     ~8
   55    21        ECHO                                                     '%0A'
   57    22        TICKS                                                    
   59    23        INIT_FCALL_BY_NAME                                       'a'
         24        SEND_VAL_EX                                              'a'
         25        SEND_VAL_EX                                              <array>
         26        DO_FCALL                                      0          
         27        TICKS                                                    
   61    28        INIT_FCALL_BY_NAME                                       'b'
         29        DO_FCALL                                      0          
         30        TICKS                                                    
   70    31      > RETURN                                                   1

Function my_array_diff:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 77) Position 1 = 3, Position 2 = 13
Branch analysis from position: 3
2 jumps found. (Code = 78) Position 1 = 4, Position 2 = 13
Branch analysis from position: 4
2 jumps found. (Code = 43) Position 1 = 11, Position 2 = 12
Branch analysis from position: 11
1 jumps found. (Code = 42) Position 1 = 3
Branch analysis from position: 3
Branch analysis from position: 12
Branch analysis from position: 13
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 13
filename:       /in/UB2iJ
function name:  my_array_diff
number of ops:  16
compiled vars:  !0 = $arr1, !1 = $arr2, !2 = $v, !3 = $k
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
    4     0  E >   RECV                                             !0      
          1        RECV                                             !1      
    5     2      > FE_RESET_R                                       $4      !0, ->13
          3    > > FE_FETCH_R                                       ~5      $4, !2, ->13
          4    >   ASSIGN                                                   !3, ~5
    6     5        INIT_FCALL                                               'in_array'
          6        SEND_VAR                                                 !2
          7        SEND_VAR                                                 !1
          8        SEND_VAL                                                 <true>
          9        DO_ICALL                                         $7      
         10      > JMPZ                                                     $7, ->12
    7    11    >   UNSET_DIM                                                !0, !3
    5    12    > > JMP                                                      ->3
         13    >   FE_FREE                                                  $4
   10    14      > RETURN                                                   !0
   11    15*     > RETURN                                                   null

End of function my_array_diff

Function my_var_export:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 44, Position 2 = 46
Branch analysis from position: 44
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 46
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/UB2iJ
function name:  my_var_export
number of ops:  48
compiled vars:  !0 = $var, !1 = $is_str, !2 = $rtn
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   12     0  E >   RECV                                             !0      
          1        RECV_INIT                                        !1      <false>
   13     2        INIT_FCALL                                               'preg_replace'
          3        SEND_VAL                                                 <array>
          4        SEND_VAL                                                 <array>
          5        INIT_FCALL                                               'substr'
          6        INIT_FCALL                                               'print_r'
          7        SEND_VAR                                                 !0
          8        SEND_VAL                                                 <true>
          9        DO_ICALL                                         $3      
         10        SEND_VAR                                                 $3
         11        SEND_VAL                                                 0
         12        SEND_VAL                                                 -1
         13        DO_ICALL                                         $4      
         14        SEND_VAR                                                 $4
         15        DO_ICALL                                         $5      
         16        ASSIGN                                                   !2, $5
   14    17        INIT_FCALL                                               'strtr'
         18        SEND_VAR                                                 !2
         19        SEND_VAL                                                 <array>
         20        DO_ICALL                                         $7      
         21        ASSIGN                                                   !2, $7
   15    22        INIT_FCALL                                               'strtr'
         23        SEND_VAR                                                 !2
         24        SEND_VAL                                                 <array>
         25        DO_ICALL                                         $9      
         26        ASSIGN                                                   !2, $9
   16    27        INIT_FCALL                                               'strtr'
         28        SEND_VAR                                                 !2
         29        SEND_VAL                                                 <array>
         30        DO_ICALL                                         $11     
         31        ASSIGN                                                   !2, $11
   17    32        INIT_FCALL                                               'preg_replace'
         33        SEND_VAL                                                 <array>
         34        SEND_VAL                                                 <array>
         35        SEND_VAR                                                 !2
         36        DO_ICALL                                         $13     
         37        ASSIGN                                                   !2, $13
   18    38        INIT_FCALL                                               'strtr'
         39        SEND_VAR                                                 !2
         40        SEND_VAL                                                 <array>
         41        DO_ICALL                                         $15     
         42        ASSIGN                                                   !2, $15
   19    43      > JMPZ                                                     !1, ->46
   20    44    > > RETURN                                                   !2
         45*       JMP                                                      ->47
   23    46    >   ECHO                                                     !2
   25    47      > RETURN                                                   null

End of function my_var_export

Function tick_handler:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 46) Position 1 = 20, Position 2 = 40
Branch analysis from position: 20
2 jumps found. (Code = 43) Position 1 = 41, Position 2 = 100
Branch analysis from position: 41
1 jumps found. (Code = 42) Position 1 = 98
Branch analysis from position: 98
2 jumps found. (Code = 44) Position 1 = 100, Position 2 = 45
Branch analysis from position: 100
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 45
2 jumps found. (Code = 43) Position 1 = 82, Position 2 = 95
Branch analysis from position: 82
1 jumps found. (Code = 42) Position 1 = 96
Branch analysis from position: 96
2 jumps found. (Code = 44) Position 1 = 100, Position 2 = 45
Branch analysis from position: 100
Branch analysis from position: 45
Branch analysis from position: 95
2 jumps found. (Code = 44) Position 1 = 100, Position 2 = 45
Branch analysis from position: 100
Branch analysis from position: 45
Branch analysis from position: 100
Branch analysis from position: 40
filename:       /in/UB2iJ
function name:  tick_handler
number of ops:  101
compiled vars:  !0 = $tmp, !1 = $trace, !2 = $i, !3 = $tmp_fb
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   27     0  E >   INIT_FCALL                                               'debug_backtrace'
          1        DO_ICALL                                         $4      
          2        ASSIGN                                                   !0, $4
   28     3        INIT_FCALL                                               'my_array_diff'
          4        SEND_VAR                                                 !0
          5        FETCH_R                      global              ~6      'GLOBALS'
          6        FETCH_DIM_R                                      ~7      ~6, 'traces.pre'
          7        SEND_VAL                                                 ~7
          8        DO_FCALL                                      0  $8      
          9        ASSIGN                                                   !1, $8
   30    10        INIT_FCALL                                               'array_values'
         11        SEND_VAR                                                 !1
         12        DO_ICALL                                         $10     
         13        ASSIGN                                                   !1, $10
   31    14        FETCH_W                      global              $12     'GLOBALS'
         15        ASSIGN_DIM                                               $12, 'traces.pre'
         16        OP_DATA                                                  !0
   32    17        COUNT                                            ~14     !1
         18        IS_SMALLER                                       ~15     0, ~14
         19      > JMPZ_EX                                          ~15     ~15, ->40
         20    >   FETCH_DIM_R                                      ~16     !1, 0
         21        FETCH_DIM_R                                      ~17     ~16, 'file'
         22        CONCAT                                           ~18     ~17, '%2F'
         23        BEGIN_SILENCE                                    ~19     
         24        FETCH_DIM_R                                      ~20     !0, 1
         25        FETCH_DIM_R                                      ~21     ~20, 'function'
         26        END_SILENCE                                              ~19
         27        CONCAT                                           ~22     ~18, ~21
         28        BEGIN_SILENCE                                    ~23     
         29        FETCH_R                      global              ~26     'GLOBALS'
         30        FETCH_DIM_R                                      ~27     ~26, 'traces'
         31        COUNT                                            ~28     ~27
         32        SUB                                              ~29     ~28, 1
         33        FETCH_R                      global              ~24     'GLOBALS'
         34        FETCH_DIM_R                                      ~25     ~24, 'traces'
         35        FETCH_DIM_R                                      ~30     ~25, ~29
         36        FETCH_DIM_R                                      ~31     ~30, 'key'
         37        END_SILENCE                                              ~23
         38        IS_NOT_IDENTICAL                                 ~32     ~22, ~31
         39        BOOL                                             ~15     ~32
         40    > > JMPZ                                                     ~15, ->100
   33    41    >   COUNT                                            ~33     !1
         42        SUB                                              ~34     ~33, 1
         43        ASSIGN                                                   !2, ~34
         44      > JMP                                                      ->98
   34    45    >   INIT_FCALL                                               'array_merge'
         46        FETCH_DIM_R                                      ~39     !1, !2
         47        FETCH_DIM_R                                      ~40     ~39, 'file'
         48        CONCAT                                           ~41     ~40, '%2F'
         49        BEGIN_SILENCE                                    ~42     
         50        ADD                                              ~43     !2, 1
         51        FETCH_DIM_R                                      ~44     !0, ~43
         52        FETCH_DIM_R                                      ~45     ~44, 'function'
         53        END_SILENCE                                              ~42
         54        CONCAT                                           ~46     ~41, ~45
         55        INIT_ARRAY                                       ~47     ~46, 'key'
         56        SEND_VAL                                                 ~47
         57        FETCH_DIM_R                                      ~48     !1, !2
         58        SEND_VAL                                                 ~48
         59        INIT_FCALL                                               'strtr'
         60        FETCH_DIM_R                                      ~49     !1, !2
         61        FETCH_DIM_R                                      ~50     ~49, 'function'
         62        SEND_VAL                                                 ~50
         63        SEND_VAL                                                 <array>
         64        DO_ICALL                                         $51     
         65        INIT_ARRAY                                       ~52     $51, 'function'
         66        BEGIN_SILENCE                                    ~53     
         67        ADD                                              ~54     !2, 1
         68        FETCH_DIM_R                                      ~55     !0, ~54
         69        FETCH_DIM_R                                      ~56     ~55, 'function'
         70        END_SILENCE                                              ~53
         71        ADD_ARRAY_ELEMENT                                ~52     ~56, 'in_function'
         72        SEND_VAL                                                 ~52
         73        DO_ICALL                                         $57     
         74        ASSIGN                                           ~58     !3, $57
         75        FETCH_W                      global              $36     'GLOBALS'
         76        FETCH_DIM_W                                      $37     $36, 'traces'
         77        ASSIGN_DIM                                               $37
         78        OP_DATA                                                  ~58
   35    79        FETCH_CONSTANT                                   ~59     'TRACES_MODE'
         80        IS_IDENTICAL                                             ~59, 'FIREPHP'
         81      > JMPZ                                                     ~60, ->95
         82    >   INIT_FCALL_BY_NAME                                       'fb'
         83        INIT_FCALL_BY_NAME                                       'trace_output'
         84        SEND_VAR_EX                                              !3
         85        DO_FCALL                                      0  $61     
         86        SEND_VAR_NO_REF_EX                                       $61
         87        FETCH_RW                     global              $62     'GLOBALS'
         88        FETCH_DIM_RW                                     $63     $62, 'diyism_trace_no'
         89        PRE_INC                                          ~64     $63
         90        CONCAT                                           ~65     'diyism_trace%3A', ~64
         91        SEND_VAL_EX                                              ~65
         92        DO_FCALL                                      0  $66     
         93        QM_ASSIGN                                        ~67     $66
         94      > JMP                                                      ->96
         95    >   QM_ASSIGN                                        ~67     ''
         96    >   FREE                                                     ~67
   33    97        PRE_DEC                                                  !2
         98    >   IS_SMALLER_OR_EQUAL                                      0, !2
         99      > JMPNZ                                                    ~69, ->45
   38   100    > > RETURN                                                   null

End of function tick_handler

Function trace_output:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 12, Position 2 = 38
Branch analysis from position: 12
1 jumps found. (Code = 42) Position 1 = 39
Branch analysis from position: 39
2 jumps found. (Code = 43) Position 1 = 44, Position 2 = 49
Branch analysis from position: 44
1 jumps found. (Code = 42) Position 1 = 50
Branch analysis from position: 50
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 49
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 38
2 jumps found. (Code = 43) Position 1 = 44, Position 2 = 49
Branch analysis from position: 44
Branch analysis from position: 49
filename:       /in/UB2iJ
function name:  trace_output
number of ops:  63
compiled vars:  !0 = $trace
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   39     0  E >   RECV                                             !0      
   40     1        INIT_FCALL                                               'strtr'
          2        BEGIN_SILENCE                                    ~2      
          3        FETCH_DIM_R                                      ~3      !0, 'in_function'
          4        END_SILENCE                                              ~2
          5        SEND_VAL                                                 ~3
          6        SEND_VAL                                                 <array>
          7        DO_ICALL                                         $4      
          8        ASSIGN_DIM                                               !0, 'in_function'
          9        OP_DATA                                                  $4
   41    10        FETCH_DIM_R                                      ~6      !0, 'args'
         11      > JMPZ                                                     ~6, ->38
         12    >   INIT_FCALL                                               'strtr'
         13        INIT_FCALL                                               'preg_replace'
         14        SEND_VAL                                                 <array>
         15        SEND_VAL                                                 <array>
         16        INIT_FCALL                                               'preg_replace'
         17        SEND_VAL                                                 <array>
         18        SEND_VAL                                                 <array>
         19        INIT_FCALL                                               'substr'
         20        INIT_FCALL                                               'my_var_export'
         21        FETCH_DIM_R                                      ~7      !0, 'args'
         22        SEND_VAL                                                 ~7
         23        SEND_VAL                                                 <true>
         24        DO_FCALL                                      0  $8      
         25        SEND_VAR                                                 $8
         26        SEND_VAL                                                 7
         27        SEND_VAL                                                 -3
         28        DO_ICALL                                         $9      
         29        SEND_VAR                                                 $9
         30        DO_ICALL                                         $10     
         31        SEND_VAR                                                 $10
         32        DO_ICALL                                         $11     
         33        SEND_VAR                                                 $11
         34        SEND_VAL                                                 <array>
         35        DO_ICALL                                         $12     
         36        QM_ASSIGN                                        ~13     $12
         37      > JMP                                                      ->39
         38    >   QM_ASSIGN                                        ~13     ''
         39    >   ASSIGN_DIM                                               !0, 'args'
         40        OP_DATA                                                  ~13
   42    41        FETCH_DIM_R                                      ~14     !0, 'file'
         42        FETCH_DIM_R                                      ~15     !0, 'in_function'
         43      > JMPZ                                                     ~15, ->49
         44    >   FETCH_DIM_R                                      ~16     !0, 'in_function'
         45        CONCAT                                           ~17     '%2F', ~16
         46        CONCAT                                           ~18     ~17, '%28%29'
         47        QM_ASSIGN                                        ~19     ~18
         48      > JMP                                                      ->50
         49    >   QM_ASSIGN                                        ~19     ''
         50    >   CONCAT                                           ~20     ~14, ~19
         51        CONCAT                                           ~21     ~20, '%2F'
         52        FETCH_DIM_R                                      ~22     !0, 'line'
         53        CONCAT                                           ~23     ~21, ~22
         54        CONCAT                                           ~24     ~23, '%3A+'
         55        FETCH_DIM_R                                      ~25     !0, 'function'
         56        CONCAT                                           ~26     ~24, ~25
         57        CONCAT                                           ~27     ~26, '%28'
         58        FETCH_DIM_R                                      ~28     !0, 'args'
         59        CONCAT                                           ~29     ~27, ~28
         60        CONCAT                                           ~30     ~29, '%29'
         61      > RETURN                                                   ~30
   43    62*     > RETURN                                                   null

End of function trace_output

Function traces_output:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 77) Position 1 = 13, Position 2 = 26
Branch analysis from position: 13
2 jumps found. (Code = 78) Position 1 = 14, Position 2 = 26
Branch analysis from position: 14
1 jumps found. (Code = 42) Position 1 = 13
Branch analysis from position: 13
Branch analysis from position: 26
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 26
filename:       /in/UB2iJ
function name:  traces_output
number of ops:  29
compiled vars:  !0 = $trace, !1 = $k
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   45     0  E >   ECHO                                                     '%3Ctextarea+style%3D%22width%3A100%25%3Bheight%3A300px%3B%22%3E'
   46     1        INIT_FCALL                                               'array_slice'
          2        FETCH_R                      global              ~4      'GLOBALS'
          3        FETCH_DIM_R                                      ~5      ~4, 'traces'
          4        SEND_VAL                                                 ~5
          5        SEND_VAL                                                 2
          6        DO_ICALL                                         $6      
          7        FETCH_W                      global              $2      'GLOBALS'
          8        ASSIGN_DIM                                               $2, 'traces'
          9        OP_DATA                                                  $6
   47    10        FETCH_R                      global              ~7      'GLOBALS'
         11        FETCH_DIM_R                                      ~8      ~7, 'traces'
         12      > FE_RESET_R                                       $9      ~8, ->26
         13    > > FE_FETCH_R                                       ~10     $9, !0, ->26
         14    >   ASSIGN                                                   !1, ~10
   48    15        INIT_FCALL                                               'htmlentities'
         16        CONCAT                                           ~12     !1, '%3A'
         17        INIT_FCALL                                               'trace_output'
         18        SEND_VAR                                                 !0
         19        DO_FCALL                                      0  $13     
         20        CONCAT                                           ~14     ~12, $13
         21        CONCAT                                           ~15     ~14, '%0A'
         22        SEND_VAL                                                 ~15
         23        DO_ICALL                                         $16     
         24        ECHO                                                     $16
   47    25      > JMP                                                      ->13
         26    >   FE_FREE                                                  $9
   50    27        ECHO                                                     '%3C%2Ftextarea%3E'
   51    28      > RETURN                                                   null

End of function traces_output

Function a:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/UB2iJ
function name:  a
number of ops:  8
compiled vars:  !0 = $d
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   63     0  E >   ASSIGN                                                   !0, 1
          1        TICKS                                                    
   64     2        INIT_FCALL_BY_NAME                                       'b'
          3        DO_FCALL                                      0          
          4        TICKS                                                    
   65     5        ASSIGN                                                   !0, 2
          6        TICKS                                                    
   66     7      > RETURN                                                   null

End of function a

Function b:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/UB2iJ
function name:  b
number of ops:  2
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   68     0  E >   TICKS                                                    
   69     1      > RETURN                                                   null

End of function b

Generated using Vulcan Logic Dumper, using php 8.0.0


preferences:
176.35 ms | 1427 KiB | 42 Q