3v4l.org

run code in 500+ 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 = 45
Branch analysis from position: 7
2 jumps found. (Code = 78) Position 1 = 8, Position 2 = 45
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 = 28, Position 2 = 44
Branch analysis from position: 28
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 44
1 jumps found. (Code = 42) Position 1 = 7
Branch analysis from position: 7
Branch analysis from position: 45
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 45
filename:       /in/vVLL8
function name:  makeOneStep
number of ops:  47
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, ->45
          7    > > FE_FETCH_R                                           ~11     $10, !5, ->45
          8    >   ASSIGN                                                       !6, ~11
  142     

Generated using Vulcan Logic Dumper, using php 8.5.0


preferences:
165.11 ms | 2210 KiB | 19 Q