3v4l.org

run code in 300+ PHP versions simultaneously
<?php error_reporting(-1); header("Content-Type: text/plain; charset=utf-8"); mb_internal_encoding('utf-8'); define('SUBWAY', 'sub'); define('FOOT', 'foot'); define('BUS', 'bus'); $transportName = array( SUBWAY => 'едешь на метро', FOOT => 'идешь пешком', BUS => 'едешь на автобусе' ); $startPoint = 'pet'; // Петроградская $endPoint = 'nov'; // Новая Голландия $pointNames = array( 'pet' => 'ст. м. Петроградская', 'chk' => 'ст. м. Чкаловская', 'gor' => 'ст. м. Горьковская', 'spo' => 'ст. м. Спортивная', 'vas' => 'ст. м. Василеостровская', 'kre' => 'Петропавловская крепость', 'let' => 'Летний сад', 'dvo' => 'Дворцовая площадь', 'isa' => 'Исакиевский собор', 'nov' => 'Новая Голландия', 'ras' => 'Дом Раскольникова', 'gos' => 'Гостиный Двор', 'sen' => 'Сенная Площадь', 'vla' => 'ст. м. Владимирская', 'vit' => 'Витебский вокзал', 'teh' => 'Технолоческий Институт' ); $paths = array( 'pet' => array( 'chk' => canGet(10, BUS), 'gor' => canGet(3, SUBWAY) ), 'chk' => array( 'pet' => canGet(10, BUS), 'spo' => canGet(3, SUBWAY) ), 'gor' => array( 'pet' => canGet(3, BUS), 'kre' => canGet(5, FOOT), 'gos' => canGet(6, SUBWAY) ), 'spo' => array( 'chk' => canGet(3, SUBWAY), 'vas' => canGet(10, BUS), 'sen' => canGet(7, SUBWAY) ), 'vas' => array( 'spo' => canGet(10, BUS), 'gos' => canGet(7, SUBWAY), 'nov' => canGet(11, FOOT) ), 'kre' => array( 'gor' => canGet(5, FOOT) ), 'let' => array( 'dvo' => canGet(6, FOOT), 'gos' => canGet(7, FOOT) ), 'dvo' => array( 'isa' => canGet(6, FOOT), 'gos' => canGet(6, FOOT), 'let' => canGet(6, FOOT) ), 'isa' => array( 'dvo' => canGet(6, FOOT), 'nov' => canGet(5, FOOT) ), 'nov' => array( 'vas' => canGet(11, FOOT), 'isa' => canGet(5, FOOT), 'ras' => canGet(7, BUS) ), 'ras' => array( 'nov' => canGet(7, BUS), 'sen' => canGet(3, FOOT) ), 'gos' => array( 'vas' => canGet(7, SUBWAY), 'sen' => canGet(3, SUBWAY), 'dvo' => canGet(6, FOOT), 'gor' => canGet(6, SUBWAY), 'let' => canGet(7, FOOT), 'vla' => canGet(7, FOOT) ), 'sen' => array( 'ras' => canGet(3, FOOT), 'spo' => canGet(7, SUBWAY), 'gos' => canGet(3, SUBWAY), 'vla' => canGet(4, SUBWAY), 'vit' => canGet(2, SUBWAY), 'teh' => canGet(3, SUBWAY) ), 'vla' => array( 'sen' => canGet(4, SUBWAY), 'gos' => canGet(7, FOOT), 'vit' => canGet(3, SUBWAY) ), 'vit' => array( 'sen' => canGet(2, SUBWAY), 'teh' => canGet(2, SUBWAY), 'vla' => canGet(3, SUBWAY) ), 'teh' => array( 'sen' => canGet(3, SUBWAY), 'vit' => canGet(2, SUBWAY) ) ); function canGet($time, $byWhat) { return array('time' => $time, 'by' => $byWhat); } function makeOneStep($paths, $pathDone, $time, $point, $target) { foreach ($paths[$point] as $subPoint => $values) { if ($subPoint == $target) { $pathDone[] = $subPoint; $result = array(); $result['path'] = $pathDone; $result['time'] = $time + $paths[$point][$subPoint]['time']; return $result; } elseif (!in_array($subPoint, $pathDone)) { $newPathDone = $pathDone; $newPathDone[] = $subPoint; $time += $paths[$point][$subPoint]['time']; return makeOneStep($paths, $newPathDone, $time, $subPoint, $target); } } } $truePaths[] = makeOneStep($paths, array($startPoint), 0, $startPoint, $endPoint); var_dump($truePaths);
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/vVLL8
function name:  (null)
number of ops:  338
compiled vars:  !0 = $transportName, !1 = $startPoint, !2 = $endPoint, !3 = $pointNames, !4 = $paths, !5 = $truePaths
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
    2     0  E >   INIT_FCALL                                               'error_reporting'
          1        SEND_VAL                                                 -1
          2        DO_ICALL                                                 
    3     3        INIT_FCALL                                               'header'
          4        SEND_VAL                                                 'Content-Type%3A+text%2Fplain%3B+charset%3Dutf-8'
          5        DO_ICALL                                                 
    4     6        INIT_FCALL                                               'mb_internal_encoding'
          7        SEND_VAL                                                 'utf-8'
          8        DO_ICALL                                                 
    6     9        INIT_FCALL                                               'define'
         10        SEND_VAL                                                 'SUBWAY'
         11        SEND_VAL                                                 'sub'
         12        DO_ICALL                                                 
    7    13        INIT_FCALL                                               'define'
         14        SEND_VAL                                                 'FOOT'
         15        SEND_VAL                                                 'foot'
         16        DO_ICALL                                                 
    8    17        INIT_FCALL                                               'define'
         18        SEND_VAL                                                 'BUS'
         19        SEND_VAL                                                 'bus'
         20        DO_ICALL                                                 
   11    21        FETCH_CONSTANT                                   ~12     'SUBWAY'
         22        INIT_ARRAY                                       ~13     '%D0%B5%D0%B4%D0%B5%D1%88%D1%8C+%D0%BD%D0%B0+%D0%BC%D0%B5%D1%82%D1%80%D0%BE', ~12
   12    23        FETCH_CONSTANT                                   ~14     'FOOT'
         24        ADD_ARRAY_ELEMENT                                ~13     '%D0%B8%D0%B4%D0%B5%D1%88%D1%8C+%D0%BF%D0%B5%D1%88%D0%BA%D0%BE%D0%BC', ~14
   13    25        FETCH_CONSTANT                                   ~15     'BUS'
         26        ADD_ARRAY_ELEMENT                                ~13     '%D0%B5%D0%B4%D0%B5%D1%88%D1%8C+%D0%BD%D0%B0+%D0%B0%D0%B2%D1%82%D0%BE%D0%B1%D1%83%D1%81%D0%B5', ~15
   10    27        ASSIGN                                                   !0, ~13
   16    28        ASSIGN                                                   !1, 'pet'
   17    29        ASSIGN                                                   !2, 'nov'
   19    30        ASSIGN                                                   !3, <array>
   40    31        INIT_FCALL_BY_NAME                                       'canGet'
         32        SEND_VAL_EX                                              10
         33        FETCH_CONSTANT                                   ~20     'BUS'
         34        SEND_VAL_EX                                              ~20
         35        DO_FCALL                                      0  $21     
         36        INIT_ARRAY                                       ~22     $21, 'chk'
   41    37        INIT_FCALL_BY_NAME                                       'canGet'
         38        SEND_VAL_EX                                              3
         39        FETCH_CONSTANT                                   ~23     'SUBWAY'
         40        SEND_VAL_EX                                              ~23
         41        DO_FCALL                                      0  $24     
         42        ADD_ARRAY_ELEMENT                                ~22     $24, 'gor'
         43        INIT_ARRAY                                       ~25     ~22, 'pet'
   45    44        INIT_FCALL_BY_NAME                                       'canGet'
         45        SEND_VAL_EX                                              10
         46        FETCH_CONSTANT                                   ~26     'BUS'
         47        SEND_VAL_EX                                              ~26
         48        DO_FCALL                                      0  $27     
         49        INIT_ARRAY                                       ~28     $27, 'pet'
   46    50        INIT_FCALL_BY_NAME                                       'canGet'
         51        SEND_VAL_EX                                              3
         52        FETCH_CONSTANT                                   ~29     'SUBWAY'
         53        SEND_VAL_EX                                              ~29
         54        DO_FCALL                                      0  $30     
         55        ADD_ARRAY_ELEMENT                                ~28     $30, 'spo'
         56        ADD_ARRAY_ELEMENT                                ~25     ~28, 'chk'
   50    57        INIT_FCALL_BY_NAME                                       'canGet'
         58        SEND_VAL_EX                                              3
         59        FETCH_CONSTANT                                   ~31     'BUS'
         60        SEND_VAL_EX                                              ~31
         61        DO_FCALL                                      0  $32     
         62        INIT_ARRAY                                       ~33     $32, 'pet'
   51    63        INIT_FCALL_BY_NAME                                       'canGet'
         64        SEND_VAL_EX                                              5
         65        FETCH_CONSTANT                                   ~34     'FOOT'
         66        SEND_VAL_EX                                              ~34
         67        DO_FCALL                                      0  $35     
         68        ADD_ARRAY_ELEMENT                                ~33     $35, 'kre'
   52    69        INIT_FCALL_BY_NAME                                       'canGet'
         70        SEND_VAL_EX                                              6
         71        FETCH_CONSTANT                                   ~36     'SUBWAY'
         72        SEND_VAL_EX                                              ~36
         73        DO_FCALL                                      0  $37     
         74        ADD_ARRAY_ELEMENT                                ~33     $37, 'gos'
         75        ADD_ARRAY_ELEMENT                                ~25     ~33, 'gor'
   56    76        INIT_FCALL_BY_NAME                                       'canGet'
         77        SEND_VAL_EX                                              3
         78        FETCH_CONSTANT                                   ~38     'SUBWAY'
         79        SEND_VAL_EX                                              ~38
         80        DO_FCALL                                      0  $39     
         81        INIT_ARRAY                                       ~40     $39, 'chk'
   57    82        INIT_FCALL_BY_NAME                                       'canGet'
         83        SEND_VAL_EX                                              10
         84        FETCH_CONSTANT                                   ~41     'BUS'
         85        SEND_VAL_EX                                              ~41
         86        DO_FCALL                                      0  $42     
         87        ADD_ARRAY_ELEMENT                                ~40     $42, 'vas'
   58    88        INIT_FCALL_BY_NAME                                       'canGet'
         89        SEND_VAL_EX                                              7
         90        FETCH_CONSTANT                                   ~43     'SUBWAY'
         91        SEND_VAL_EX                                              ~43
         92        DO_FCALL                                      0  $44     
         93        ADD_ARRAY_ELEMENT                                ~40     $44, 'sen'
         94        ADD_ARRAY_ELEMENT                                ~25     ~40, 'spo'
   62    95        INIT_FCALL_BY_NAME                                       'canGet'
         96        SEND_VAL_EX                                              10
         97        FETCH_CONSTANT                                   ~45     'BUS'
         98        SEND_VAL_EX                                              ~45
         99        DO_FCALL                                      0  $46     
        100        INIT_ARRAY                                       ~47     $46, 'spo'
   63   101        INIT_FCALL_BY_NAME                                       'canGet'
        102        SEND_VAL_EX                                              7
        103        FETCH_CONSTANT                                   ~48     'SUBWAY'
        104        SEND_VAL_EX                                              ~48
        105        DO_FCALL                                      0  $49     
        106        ADD_ARRAY_ELEMENT                                ~47     $49, 'gos'
   64   107        INIT_FCALL_BY_NAME                                       'canGet'
        108        SEND_VAL_EX                                              11
        109        FETCH_CONSTANT                                   ~50     'FOOT'
        110        SEND_VAL_EX                                              ~50
        111        DO_FCALL                                      0  $51     
        112        ADD_ARRAY_ELEMENT                                ~47     $51, 'nov'
        113        ADD_ARRAY_ELEMENT                                ~25     ~47, 'vas'
   68   114        INIT_FCALL_BY_NAME                                       'canGet'
        115        SEND_VAL_EX                                              5
        116        FETCH_CONSTANT                                   ~52     'FOOT'
        117        SEND_VAL_EX                                              ~52
        118        DO_FCALL                                      0  $53     
        119        INIT_ARRAY                                       ~54     $53, 'gor'
        120        ADD_ARRAY_ELEMENT                                ~25     ~54, 'kre'
   72   121        INIT_FCALL_BY_NAME                                       'canGet'
        122        SEND_VAL_EX                                              6
        123        FETCH_CONSTANT                                   ~55     'FOOT'
        124        SEND_VAL_EX                                              ~55
        125        DO_FCALL                                      0  $56     
        126        INIT_ARRAY                                       ~57     $56, 'dvo'
   73   127        INIT_FCALL_BY_NAME                                       'canGet'
        128        SEND_VAL_EX                                              7
        129        FETCH_CONSTANT                                   ~58     'FOOT'
        130        SEND_VAL_EX                                              ~58
        131        DO_FCALL                                      0  $59     
        132        ADD_ARRAY_ELEMENT                                ~57     $59, 'gos'
        133        ADD_ARRAY_ELEMENT                                ~25     ~57, 'let'
   77   134        INIT_FCALL_BY_NAME                                       'canGet'
        135        SEND_VAL_EX                                              6
        136        FETCH_CONSTANT                                   ~60     'FOOT'
        137        SEND_VAL_EX                                              ~60
        138        DO_FCALL                                      0  $61     
        139        INIT_ARRAY                                       ~62     $61, 'isa'
   78   140        INIT_FCALL_BY_NAME                                       'canGet'
        141        SEND_VAL_EX                                              6
        142        FETCH_CONSTANT                                   ~63     'FOOT'
        143        SEND_VAL_EX                                              ~63
        144        DO_FCALL                                      0  $64     
        145        ADD_ARRAY_ELEMENT                                ~62     $64, 'gos'
   79   146        INIT_FCALL_BY_NAME                                       'canGet'
        147        SEND_VAL_EX                                              6
        148        FETCH_CONSTANT                                   ~65     'FOOT'
        149        SEND_VAL_EX                                              ~65
        150        DO_FCALL                                      0  $66     
        151        ADD_ARRAY_ELEMENT                                ~62     $66, 'let'
        152        ADD_ARRAY_ELEMENT                                ~25     ~62, 'dvo'
   83   153        INIT_FCALL_BY_NAME                                       'canGet'
        154        SEND_VAL_EX                                              6
        155        FETCH_CONSTANT                                   ~67     'FOOT'
        156        SEND_VAL_EX                                              ~67
        157        DO_FCALL                                      0  $68     
        158        INIT_ARRAY                                       ~69     $68, 'dvo'
   84   159        INIT_FCALL_BY_NAME                                       'canGet'
        160        SEND_VAL_EX                                              5
        161        FETCH_CONSTANT                                   ~70     'FOOT'
        162        SEND_VAL_EX                                              ~70
        163        DO_FCALL                                      0  $71     
        164        ADD_ARRAY_ELEMENT                                ~69     $71, 'nov'
        165        ADD_ARRAY_ELEMENT                                ~25     ~69, 'isa'
   88   166        INIT_FCALL_BY_NAME                                       'canGet'
        167        SEND_VAL_EX                                              11
        168        FETCH_CONSTANT                                   ~72     'FOOT'
        169        SEND_VAL_EX                                              ~72
        170        DO_FCALL                                      0  $73     
        171        INIT_ARRAY                                       ~74     $73, 'vas'
   89   172        INIT_FCALL_BY_NAME                                       'canGet'
        173        SEND_VAL_EX                                              5
        174        FETCH_CONSTANT                                   ~75     'FOOT'
        175        SEND_VAL_EX                                              ~75
        176        DO_FCALL                                      0  $76     
        177        ADD_ARRAY_ELEMENT                                ~74     $76, 'isa'
   90   178        INIT_FCALL_BY_NAME                                       'canGet'
        179        SEND_VAL_EX                                              7
        180        FETCH_CONSTANT                                   ~77     'BUS'
        181        SEND_VAL_EX                                              ~77
        182        DO_FCALL                                      0  $78     
        183        ADD_ARRAY_ELEMENT                                ~74     $78, 'ras'
        184        ADD_ARRAY_ELEMENT                                ~25     ~74, 'nov'
   94   185        INIT_FCALL_BY_NAME                                       'canGet'
        186        SEND_VAL_EX                                              7
        187        FETCH_CONSTANT                                   ~79     'BUS'
        188        SEND_VAL_EX                                              ~79
        189        DO_FCALL                                      0  $80     
        190        INIT_ARRAY                                       ~81     $80, 'nov'
   95   191        INIT_FCALL_BY_NAME                                       'canGet'
        192        SEND_VAL_EX                                              3
        193        FETCH_CONSTANT                                   ~82     'FOOT'
        194        SEND_VAL_EX                                              ~82
        195        DO_FCALL                                      0  $83     
        196        ADD_ARRAY_ELEMENT                                ~81     $83, 'sen'
        197        ADD_ARRAY_ELEMENT                                ~25     ~81, 'ras'
   99   198        INIT_FCALL_BY_NAME                                       'canGet'
        199        SEND_VAL_EX                                              7
        200        FETCH_CONSTANT                                   ~84     'SUBWAY'
        201        SEND_VAL_EX                                              ~84
        202        DO_FCALL                                      0  $85     
        203        INIT_ARRAY                                       ~86     $85, 'vas'
  100   204        INIT_FCALL_BY_NAME                                       'canGet'
        205        SEND_VAL_EX                                              3
        206        FETCH_CONSTANT                                   ~87     'SUBWAY'
        207        SEND_VAL_EX                                              ~87
        208        DO_FCALL                                      0  $88     
        209        ADD_ARRAY_ELEMENT                                ~86     $88, 'sen'
  101   210        INIT_FCALL_BY_NAME                                       'canGet'
        211        SEND_VAL_EX                                              6
        212        FETCH_CONSTANT                                   ~89     'FOOT'
        213        SEND_VAL_EX                                              ~89
        214        DO_FCALL                                      0  $90     
        215        ADD_ARRAY_ELEMENT                                ~86     $90, 'dvo'
  102   216        INIT_FCALL_BY_NAME                                       'canGet'
        217        SEND_VAL_EX                                              6
        218        FETCH_CONSTANT                                   ~91     'SUBWAY'
        219        SEND_VAL_EX                                              ~91
        220        DO_FCALL                                      0  $92     
        221        ADD_ARRAY_ELEMENT                                ~86     $92, 'gor'
  103   222        INIT_FCALL_BY_NAME                                       'canGet'
        223        SEND_VAL_EX                                              7
        224        FETCH_CONSTANT                                   ~93     'FOOT'
        225        SEND_VAL_EX                                              ~93
        226        DO_FCALL                                      0  $94     
        227        ADD_ARRAY_ELEMENT                                ~86     $94, 'let'
  104   228        INIT_FCALL_BY_NAME                                       'canGet'
        229        SEND_VAL_EX                                              7
        230        FETCH_CONSTANT                                   ~95     'FOOT'
        231        SEND_VAL_EX                                              ~95
        232        DO_FCALL                                      0  $96     
        233        ADD_ARRAY_ELEMENT                                ~86     $96, 'vla'
        234        ADD_ARRAY_ELEMENT                                ~25     ~86, 'gos'
  108   235        INIT_FCALL_BY_NAME                                       'canGet'
        236        SEND_VAL_EX                                              3
        237        FETCH_CONSTANT                                   ~97     'FOOT'
        238        SEND_VAL_EX                                              ~97
        239        DO_FCALL                                      0  $98     
        240        INIT_ARRAY                                       ~99     $98, 'ras'
  109   241        INIT_FCALL_BY_NAME                                       'canGet'
        242        SEND_VAL_EX                                              7
        243        FETCH_CONSTANT                                   ~100    'SUBWAY'
        244        SEND_VAL_EX                                              ~100
        245        DO_FCALL                                      0  $101    
        246        ADD_ARRAY_ELEMENT                                ~99     $101, 'spo'
  110   247        INIT_FCALL_BY_NAME                                       'canGet'
        248        SEND_VAL_EX                                              3
        249        FETCH_CONSTANT                                   ~102    'SUBWAY'
        250        SEND_VAL_EX                                              ~102
        251        DO_FCALL                                      0  $103    
        252        ADD_ARRAY_ELEMENT                                ~99     $103, 'gos'
  111   253        INIT_FCALL_BY_NAME                                       'canGet'
        254        SEND_VAL_EX                                              4
        255        FETCH_CONSTANT                                   ~104    'SUBWAY'
        256        SEND_VAL_EX                                              ~104
        257        DO_FCALL                                      0  $105    
        258        ADD_ARRAY_ELEMENT                                ~99     $105, 'vla'
  112   259        INIT_FCALL_BY_NAME                                       'canGet'
        260        SEND_VAL_EX                                              2
        261        FETCH_CONSTANT                                   ~106    'SUBWAY'
        262        SEND_VAL_EX                                              ~106
        263        DO_FCALL                                      0  $107    
        264        ADD_ARRAY_ELEMENT                                ~99     $107, 'vit'
  113   265        INIT_FCALL_BY_NAME                                       'canGet'
        266        SEND_VAL_EX                                              3
        267        FETCH_CONSTANT                                   ~108    'SUBWAY'
        268        SEND_VAL_EX                                              ~108
        269        DO_FCALL                                      0  $109    
        270        ADD_ARRAY_ELEMENT                                ~99     $109, 'teh'
        271        ADD_ARRAY_ELEMENT                                ~25     ~99, 'sen'
  117   272        INIT_FCALL_BY_NAME                                       'canGet'
        273        SEND_VAL_EX                                              4
        274        FETCH_CONSTANT                                   ~110    'SUBWAY'
        275        SEND_VAL_EX                                              ~110
        276        DO_FCALL                                      0  $111    
        277        INIT_ARRAY                                       ~112    $111, 'sen'
  118   278        INIT_FCALL_BY_NAME                                       'canGet'
        279        SEND_VAL_EX                                              7
        280        FETCH_CONSTANT                                   ~113    'FOOT'
        281        SEND_VAL_EX                                              ~113
        282        DO_FCALL                                      0  $114    
        283        ADD_ARRAY_ELEMENT                                ~112    $114, 'gos'
  119   284        INIT_FCALL_BY_NAME                                       'canGet'
        285        SEND_VAL_EX                                              3
        286        FETCH_CONSTANT                                   ~115    'SUBWAY'
        287        SEND_VAL_EX                                              ~115
        288        DO_FCALL                                      0  $116    
        289        ADD_ARRAY_ELEMENT                                ~112    $116, 'vit'
        290        ADD_ARRAY_ELEMENT                                ~25     ~112, 'vla'
  123   291        INIT_FCALL_BY_NAME                                       'canGet'
        292        SEND_VAL_EX                                              2
        293        FETCH_CONSTANT                                   ~117    'SUBWAY'
        294        SEND_VAL_EX                                              ~117
        295        DO_FCALL                                      0  $118    
        296        INIT_ARRAY                                       ~119    $118, 'sen'
  124   297        INIT_FCALL_BY_NAME                                       'canGet'
        298        SEND_VAL_EX                                              2
        299        FETCH_CONSTANT                                   ~120    'SUBWAY'
        300        SEND_VAL_EX                                              ~120
        301        DO_FCALL                                      0  $121    
        302        ADD_ARRAY_ELEMENT                                ~119    $121, 'teh'
  125   303        INIT_FCALL_BY_NAME                                       'canGet'
        304        SEND_VAL_EX                                              3
        305        FETCH_CONSTANT                                   ~122    'SUBWAY'
        306        SEND_VAL_EX                                              ~122
        307        DO_FCALL                                      0  $123    
        308        ADD_ARRAY_ELEMENT                                ~119    $123, 'vla'
        309        ADD_ARRAY_ELEMENT                                ~25     ~119, 'vit'
  129   310        INIT_FCALL_BY_NAME                                       'canGet'
        311        SEND_VAL_EX                                              3
        312        FETCH_CONSTANT                                   ~124    'SUBWAY'
        313        SEND_VAL_EX                                              ~124
        314        DO_FCALL                                      0  $125    
        315        INIT_ARRAY                                       ~126    $125, 'sen'
  130   316        INIT_FCALL_BY_NAME                                       'canGet'
        317        SEND_VAL_EX                                              2
        318        FETCH_CONSTANT                                   ~127    'SUBWAY'
        319        SEND_VAL_EX                                              ~127
        320        DO_FCALL                                      0  $128    
        321        ADD_ARRAY_ELEMENT                                ~126    $128, 'vit'
        322        ADD_ARRAY_ELEMENT                                ~25     ~126, 'teh'
   38   323        ASSIGN                                                   !4, ~25
  157   324        INIT_FCALL                                               'makeonestep'
        325        SEND_VAR                                                 !4
        326        INIT_ARRAY                                       ~131    !1
        327        SEND_VAL                                                 ~131
        328        SEND_VAL                                                 0
        329        SEND_VAR                                                 !1
        330        SEND_VAR                                                 !2
        331        DO_FCALL                                      0  $132    
        332        ASSIGN_DIM                                               !5
        333        OP_DATA                                                  $132
  159   334        INIT_FCALL                                               'var_dump'
        335        SEND_VAR                                                 !5
        336        DO_ICALL                                                 
        337      > RETURN                                                   1

Function canget:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/vVLL8
function name:  canGet
number of ops:  6
compiled vars:  !0 = $time, !1 = $byWhat
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  134     0  E >   RECV                                             !0      
          1        RECV                                             !1      
  136     2        INIT_ARRAY                                       ~2      !0, 'time'
          3        ADD_ARRAY_ELEMENT                                ~2      !1, 'by'
          4      > RETURN                                                   ~2
  137     5*     > RETURN                                                   null

End of function canget

Function makeonestep:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 77) Position 1 = 7, Position 2 = 48
Branch analysis from position: 7
2 jumps found. (Code = 78) Position 1 = 8, Position 2 = 48
Branch analysis from position: 8
2 jumps found. (Code = 43) Position 1 = 11, Position 2 = 25
Branch analysis from position: 11
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 25
2 jumps found. (Code = 43) Position 1 = 31, Position 2 = 47
Branch analysis from position: 31
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 47
1 jumps found. (Code = 42) Position 1 = 7
Branch analysis from position: 7
Branch analysis from position: 48
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 48
filename:       /in/vVLL8
function name:  makeOneStep
number of ops:  50
compiled vars:  !0 = $paths, !1 = $pathDone, !2 = $time, !3 = $point, !4 = $target, !5 = $values, !6 = $subPoint, !7 = $result, !8 = $newPathDone
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  139     0  E >   RECV                                             !0      
          1        RECV                                             !1      
          2        RECV                                             !2      
          3        RECV                                             !3      
          4        RECV                                             !4      
  141     5        FETCH_DIM_R                                      ~9      !0, !3
          6      > FE_RESET_R                                       $10     ~9, ->48
          7    > > FE_FETCH_R                                       ~11     $10, !5, ->48
          8    >   ASSIGN                                                   !6, ~11
  142     9        IS_EQUAL                                                 !6, !4
         10      > JMPZ                                                     ~13, ->25
  143    11    >   ASSIGN_DIM                                               !1
         12        OP_DATA                                                  !6
  144    13        ASSIGN                                                   !7, <array>
  145    14        ASSIGN_DIM                                               !7, 'path'
         15        OP_DATA                                                  !1
  146    16        FETCH_DIM_R                                      ~18     !0, !3
         17        FETCH_DIM_R                                      ~19     ~18, !6
         18        FETCH_DIM_R                                      ~20     ~19, 'time'
         19        ADD                                              ~21     !2, ~20
         20        ASSIGN_DIM                                               !7, 'time'
         21        OP_DATA                                                  ~21
  147    22        FE_FREE                                                  $10
         23      > RETURN                                                   !7
         24*       JMP                                                      ->47
  148    25    >   INIT_FCALL                                               'in_array'
         26        SEND_VAR     

Generated using Vulcan Logic Dumper, using php 8.0.0


preferences:
157.36 ms | 1431 KiB | 26 Q