3v4l.org

run code in 300+ PHP versions simultaneously
<?php function consistsOfTheSameValues(array $A, array $B, $strict = false, $assumeEqual = false) { // check size of both arrays if (count($A) !== count($B)) { return false; } // optional pre-test that increases performance for most unequal arrays, but is worse for equal arrays if (! $assumeEqual) { foreach ($A as $a) { // check that expected value exists in the array if (! in_array($a, $B, $strict)) { return false; } } } foreach ($A as $a) { // check that expected value occurs the same amount of times in both arrays if (count(array_keys($A, $a, $strict)) !== count(array_keys($B, $a, $strict))) { return false; } } return true; } // A unit testing framework in a tweet. https://gist.github.com/mathiasverraes/9046427 function it($m,$p){echo ($p?'✔︎':'✘')." It $m\n"; if(!$p){$GLOBALS['f']=1;}}function done(){if(@$GLOBALS['f'])die(1);} // create two big arrays $big1 = []; for ($i = 0; $i < 999; $i++) { $big1[] = rand(); } $big2 = $big1; $big1[] = 0; $big2[] = 1; foreach ([false, true] as $ae) { foreach ([true, false] as $st) { echo '### ' . ($st ? 'strict (===)' : 'loose (==)' ) . ' - ' . ($ae ? 'skip' : 'use') . " in_array\n"; // positive tests it('consists of the same values', consistsOfTheSameValues([1], [1], $st, $ae) === true ); it('consists of the same values', consistsOfTheSameValues([1, 1], [1, 1], $st, $ae) === true ); it('consists of the same values', consistsOfTheSameValues(['1', 1], ['1', 1], $st, $ae) === true ); it('consists of the same values', consistsOfTheSameValues(['1', 1], [1, '1'], $st, $ae) === true ); it('consists of the same values', consistsOfTheSameValues([1, '1'], ['1', 1], $st, $ae) === true ); it('consists of the same values', consistsOfTheSameValues([1, '1'], [1, '1'], $st, $ae) === true ); it('consists of the same values with key', consistsOfTheSameValues(['x' => 1], ['x' => 1], $st, $ae) === true ); it('consists of the same values with key', consistsOfTheSameValues(['x' => 1], ['y' => 1], $st, $ae) === true ); it('consists of the same values with key', consistsOfTheSameValues(['y' => 1], ['x' => 1], $st, $ae) === true ); it('consists of the same values with key', consistsOfTheSameValues(['x' => 1, 'y' => 1], ['x' => 1, 'y' => 1], $st, $ae) === true ); it('consists of the same values with key', consistsOfTheSameValues(['y' => 1, 'x' => 1], ['x' => 1, 'y' => 1], $st, $ae) === true ); it('consists of the same values with key', consistsOfTheSameValues(['x' => 1, 'y' => 1], ['y' => 1, 'x' => 1], $st, $ae) === true ); it('consists of the same values with key', consistsOfTheSameValues(['y' => 1, 'x' => 1], ['y' => 1, 'x' => 1], $st, $ae) === true ); it('consists of the same values with key', consistsOfTheSameValues(['x' => 2, 'y' => 1], ['x' => 1, 'y' => 2], $st, $ae) === true ); it('consists of the same values for big1 and big1', consistsOfTheSameValues($big1, $big1, $st, $ae) === true ); it('consists of the same values for big2 and big2', consistsOfTheSameValues($big2, $big2, $st, $ae) === true ); // negative tests it('does not consist of the same values', consistsOfTheSameValues([1], [2], $st, $ae) === false ); it('does not consist of the same values', consistsOfTheSameValues([1], [1, 1], $st, $ae) === false ); it('does not consist of the same values', consistsOfTheSameValues([1, 1], [1], $st, $ae) === false ); it('does not consist of the same values', consistsOfTheSameValues([1], [1, 2], $st, $ae) === false ); it('does not consist of the same values', consistsOfTheSameValues([1], [2, 1], $st, $ae) === false ); it('does not consist of the same values', consistsOfTheSameValues([1, 2], [1], $st, $ae) === false ); it('does not consist of the same values', consistsOfTheSameValues([2, 1], [1], $st, $ae) === false ); it('does not consist of the same values with key', consistsOfTheSameValues(['x' => 1], ['x' => 2], $st, $ae) === false ); it('does not consist of the same values with key', consistsOfTheSameValues(['x' => 1, 'y' => 1], ['x' => 1, 'y' => 2], $st, $ae) === false ); it('does not consist of the same values with key', consistsOfTheSameValues(['x' => 1, 'y' => 1], ['x' => 2, 'y' => 1], $st, $ae) === false ); it('does not consist of the same values with key', consistsOfTheSameValues(['x' => 2, 'y' => 1], ['x' => 1, 'y' => 1], $st, $ae) === false ); it('does not consist of the same values for big1 and big2', consistsOfTheSameValues($big1, $big2, $st, $ae) === false ); it('does not consist of the same values for big2 and big1', consistsOfTheSameValues($big2, $big1, $st, $ae) === false ); // test strictness $consists_of = ($st ? 'does not consist of the same strict values' : 'consists of the same loose values'); it($consists_of, consistsOfTheSameValues(['1'], [1], $st, $ae) !== $st ); it($consists_of, consistsOfTheSameValues([1], ['1'], $st, $ae) !== $st ); it($consists_of, consistsOfTheSameValues(['1', 1], [1, 1], $st, $ae) !== $st ); it($consists_of, consistsOfTheSameValues([1, '1'], [1, 1], $st, $ae) !== $st ); it($consists_of, consistsOfTheSameValues([1, 1], ['1', 1], $st, $ae) !== $st ); it($consists_of, consistsOfTheSameValues([1, 1], [1, '1'], $st, $ae) !== $st ); it($consists_of, consistsOfTheSameValues(['1', '1'], [1, 1], $st, $ae) !== $st ); it($consists_of, consistsOfTheSameValues(['1', '1'], ['1', 1], $st, $ae) !== $st ); it($consists_of, consistsOfTheSameValues(['1', '1'], [1, '1'], $st, $ae) !== $st ); it($consists_of, consistsOfTheSameValues([1, 1], ['1', '1'], $st, $ae) !== $st ); it($consists_of, consistsOfTheSameValues(['1', 1], ['1', '1'], $st, $ae) !== $st ); it($consists_of, consistsOfTheSameValues([1, '1'], ['1', '1'], $st, $ae) !== $st ); } }
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 42) Position 1 = 8
Branch analysis from position: 8
2 jumps found. (Code = 44) Position 1 = 10, Position 2 = 3
Branch analysis from position: 10
2 jumps found. (Code = 77) Position 1 = 16, Position 2 = 491
Branch analysis from position: 16
2 jumps found. (Code = 78) Position 1 = 17, Position 2 = 491
Branch analysis from position: 17
2 jumps found. (Code = 77) Position 1 = 18, Position 2 = 489
Branch analysis from position: 18
2 jumps found. (Code = 78) Position 1 = 19, Position 2 = 489
Branch analysis from position: 19
2 jumps found. (Code = 43) Position 1 = 20, Position 2 = 22
Branch analysis from position: 20
1 jumps found. (Code = 42) Position 1 = 23
Branch analysis from position: 23
2 jumps found. (Code = 43) Position 1 = 26, Position 2 = 28
Branch analysis from position: 26
1 jumps found. (Code = 42) Position 1 = 29
Branch analysis from position: 29
2 jumps found. (Code = 43) Position 1 = 352, Position 2 = 354
Branch analysis from position: 352
1 jumps found. (Code = 42) Position 1 = 355
Branch analysis from position: 355
1 jumps found. (Code = 42) Position 1 = 18
Branch analysis from position: 18
Branch analysis from position: 354
1 jumps found. (Code = 42) Position 1 = 18
Branch analysis from position: 18
Branch analysis from position: 28
2 jumps found. (Code = 43) Position 1 = 352, Position 2 = 354
Branch analysis from position: 352
Branch analysis from position: 354
Branch analysis from position: 22
2 jumps found. (Code = 43) Position 1 = 26, Position 2 = 28
Branch analysis from position: 26
Branch analysis from position: 28
Branch analysis from position: 489
1 jumps found. (Code = 42) Position 1 = 16
Branch analysis from position: 16
Branch analysis from position: 489
Branch analysis from position: 491
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 491
Branch analysis from position: 3
2 jumps found. (Code = 44) Position 1 = 10, Position 2 = 3
Branch analysis from position: 10
Branch analysis from position: 3
filename:       /in/vCPFu
function name:  (null)
number of ops:  493
compiled vars:  !0 = $big1, !1 = $i, !2 = $big2, !3 = $ae, !4 = $st, !5 = $consists_of
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   37     0  E >   ASSIGN                                                   !0, <array>
   38     1        ASSIGN                                                   !1, 0
          2      > JMP                                                      ->8
          3    >   INIT_FCALL                                               'rand'
          4        DO_ICALL                                         $9      
          5        ASSIGN_DIM                                               !0
          6        OP_DATA                                                  $9
          7        PRE_INC                                                  !1
          8    >   IS_SMALLER                                               !1, 999
          9      > JMPNZ                                                    ~11, ->3
   39    10    >   ASSIGN                                                   !2, !0
   40    11        ASSIGN_DIM                                               !0
         12        OP_DATA                                                  0
   41    13        ASSIGN_DIM                                               !2
         14        OP_DATA                                                  1
   44    15      > FE_RESET_R                                       $15     <array>, ->491
         16    > > FE_FETCH_R                                               $15, !3, ->491
   45    17    > > FE_RESET_R                                       $16     <array>, ->489
         18    > > FE_FETCH_R                                               $16, !4, ->489
   46    19    > > JMPZ                                                     !4, ->22
         20    >   QM_ASSIGN                                        ~17     'strict+%28%3D%3D%3D%29'
         21      > JMP                                                      ->23
         22    >   QM_ASSIGN                                        ~17     'loose+%28%3D%3D%29'
         23    >   CONCAT                                           ~18     '%23%23%23+++', ~17
         24        CONCAT                                           ~19     ~18, '+-+'
         25      > JMPZ                                                     !3, ->28
         26    >   QM_ASSIGN                                        ~20     'skip'
         27      > JMP                                                      ->29
         28    >   QM_ASSIGN                                        ~20     'use'
         29    >   CONCAT                                           ~21     ~19, ~20
         30        CONCAT                                           ~22     ~21, '+in_array%0A'
         31        ECHO                                                     ~22
   50    32        INIT_FCALL                                               'it'
         33        SEND_VAL                                                 'consists+of+the+same+values'
   51    34        INIT_FCALL                                               'consistsofthesamevalues'
         35        SEND_VAL                                                 <array>
         36        SEND_VAL                                                 <array>
         37        SEND_VAR                                                 !4
         38        SEND_VAR                                                 !3
         39        DO_FCALL                                      0  $23     
         40        TYPE_CHECK                                    8  ~24     $23
         41        SEND_VAL                                                 ~24
   50    42        DO_FCALL                                      0          
   54    43        INIT_FCALL                                               'it'
         44        SEND_VAL                                                 'consists+of+the+same+values'
   55    45        INIT_FCALL                                               'consistsofthesamevalues'
         46        SEND_VAL                                                 <array>
         47        SEND_VAL                                                 <array>
         48        SEND_VAR                                                 !4
         49        SEND_VAR                                                 !3
         50        DO_FCALL                                      0  $26     
         51        TYPE_CHECK                                    8  ~27     $26
         52        SEND_VAL                                                 ~27
   54    53        DO_FCALL                                      0          
   58    54        INIT_FCALL                                               'it'
         55        SEND_VAL                                                 'consists+of+the+same+values'
   59    56        INIT_FCALL                                               'consistsofthesamevalues'
         57        SEND_VAL                                                 <array>
         58        SEND_VAL                                                 <array>
         59        SEND_VAR                                                 !4
         60        SEND_VAR                                                 !3
         61        DO_FCALL                                      0  $29     
         62        TYPE_CHECK                                    8  ~30     $29
         63        SEND_VAL                                                 ~30
   58    64        DO_FCALL                                      0          
   62    65        INIT_FCALL                                               'it'
         66        SEND_VAL                                                 'consists+of+the+same+values'
   63    67        INIT_FCALL                                               'consistsofthesamevalues'
         68        SEND_VAL                                                 <array>
         69        SEND_VAL                                                 <array>
         70        SEND_VAR                                                 !4
         71        SEND_VAR                                                 !3
         72        DO_FCALL                                      0  $32     
         73        TYPE_CHECK                                    8  ~33     $32
         74        SEND_VAL                                                 ~33
   62    75        DO_FCALL                                      0          
   66    76        INIT_FCALL                                               'it'
         77        SEND_VAL                                                 'consists+of+the+same+values'
   67    78        INIT_FCALL                                               'consistsofthesamevalues'
         79        SEND_VAL                                                 <array>
         80        SEND_VAL                                                 <array>
         81        SEND_VAR                                                 !4
         82        SEND_VAR                                                 !3
         83        DO_FCALL                                      0  $35     
         84        TYPE_CHECK                                    8  ~36     $35
         85        SEND_VAL                                                 ~36
   66    86        DO_FCALL                                      0          
   70    87        INIT_FCALL                                               'it'
         88        SEND_VAL                                                 'consists+of+the+same+values'
   71    89        INIT_FCALL                                               'consistsofthesamevalues'
         90        SEND_VAL                                                 <array>
         91        SEND_VAL                                                 <array>
         92        SEND_VAR                                                 !4
         93        SEND_VAR                                                 !3
         94        DO_FCALL                                      0  $38     
         95        TYPE_CHECK                                    8  ~39     $38
         96        SEND_VAL                                                 ~39
   70    97        DO_FCALL                                      0          
   74    98        INIT_FCALL                                               'it'
         99        SEND_VAL                                                 'consists+of+the+same+values+with+key'
   75   100        INIT_FCALL                                               'consistsofthesamevalues'
        101        SEND_VAL                                                 <array>
        102        SEND_VAL                                                 <array>
        103        SEND_VAR                                                 !4
        104        SEND_VAR                                                 !3
        105        DO_FCALL                                      0  $41     
        106        TYPE_CHECK                                    8  ~42     $41
        107        SEND_VAL                                                 ~42
   74   108        DO_FCALL                                      0          
   78   109        INIT_FCALL                                               'it'
        110        SEND_VAL                                                 'consists+of+the+same+values+with+key'
   79   111        INIT_FCALL                                               'consistsofthesamevalues'
        112        SEND_VAL                                                 <array>
        113        SEND_VAL                                                 <array>
        114        SEND_VAR                                                 !4
        115        SEND_VAR                                                 !3
        116        DO_FCALL                                      0  $44     
        117        TYPE_CHECK                                    8  ~45     $44
        118        SEND_VAL                                                 ~45
   78   119        DO_FCALL                                      0          
   82   120        INIT_FCALL                                               'it'
        121        SEND_VAL                                                 'consists+of+the+same+values+with+key'
   83   122        INIT_FCALL                                               'consistsofthesamevalues'
        123        SEND_VAL                                                 <array>
        124        SEND_VAL                                                 <array>
        125        SEND_VAR                                                 !4
        126        SEND_VAR                                                 !3
        127        DO_FCALL                                      0  $47     
        128        TYPE_CHECK                                    8  ~48     $47
        129        SEND_VAL                                                 ~48
   82   130        DO_FCALL                                      0          
   86   131        INIT_FCALL                                               'it'
        132        SEND_VAL                                                 'consists+of+the+same+values+with+key'
   87   133        INIT_FCALL                                               'consistsofthesamevalues'
        134        SEND_VAL                                                 <array>
        135        SEND_VAL                                                 <array>
        136        SEND_VAR                                                 !4
        137        SEND_VAR                                                 !3
        138        DO_FCALL                                      0  $50     
        139        TYPE_CHECK                                    8  ~51     $50
        140        SEND_VAL                                                 ~51
   86   141        DO_FCALL                                      0          
   90   142        INIT_FCALL                                               'it'
        143        SEND_VAL                                                 'consists+of+the+same+values+with+key'
   91   144        INIT_FCALL                                               'consistsofthesamevalues'
        145        SEND_VAL                                                 <array>
        146        SEND_VAL                                                 <array>
        147        SEND_VAR                                                 !4
        148        SEND_VAR                                                 !3
        149        DO_FCALL                                      0  $53     
        150        TYPE_CHECK                                    8  ~54     $53
        151        SEND_VAL                                                 ~54
   90   152        DO_FCALL                                      0          
   94   153        INIT_FCALL                                               'it'
        154        SEND_VAL                                                 'consists+of+the+same+values+with+key'
   95   155        INIT_FCALL                                               'consistsofthesamevalues'
        156        SEND_VAL                                                 <array>
        157        SEND_VAL                                                 <array>
        158        SEND_VAR                                                 !4
        159        SEND_VAR                                                 !3
        160        DO_FCALL                                      0  $56     
        161        TYPE_CHECK                                    8  ~57     $56
        162        SEND_VAL                                                 ~57
   94   163        DO_FCALL                                      0          
   98   164        INIT_FCALL                                               'it'
        165        SEND_VAL                                                 'consists+of+the+same+values+with+key'
   99   166        INIT_FCALL                                               'consistsofthesamevalues'
        167        SEND_VAL                                                 <array>
        168        SEND_VAL                                                 <array>
        169        SEND_VAR                                                 !4
        170        SEND_VAR                                                 !3
        171        DO_FCALL                                      0  $59     
        172        TYPE_CHECK                                    8  ~60     $59
        173        SEND_VAL                                                 ~60
   98   174        DO_FCALL                                      0          
  102   175        INIT_FCALL                                               'it'
        176        SEND_VAL                                                 'consists+of+the+same+values+with+key'
  103   177        INIT_FCALL                                               'consistsofthesamevalues'
        178        SEND_VAL                                                 <array>
        179        SEND_VAL                                                 <array>
        180        SEND_VAR                                                 !4
        181        SEND_VAR                                                 !3
        182        DO_FCALL                                      0  $62     
        183        TYPE_CHECK                                    8  ~63     $62
        184        SEND_VAL                                                 ~63
  102   185        DO_FCALL                                      0          
  106   186        INIT_FCALL                                               'it'
        187        SEND_VAL                                                 'consists+of+the+same+values+for+big1+and+big1'
  107   188        INIT_FCALL                                               'consistsofthesamevalues'
        189        SEND_VAR                                                 !0
        190        SEND_VAR                                                 !0
        191        SEND_VAR                                                 !4
        192        SEND_VAR                                                 !3
        193        DO_FCALL                                      0  $65     
        194        TYPE_CHECK                                    8  ~66     $65
        195        SEND_VAL                                                 ~66
  106   196        DO_FCALL                                      0          
  110   197        INIT_FCALL                                               'it'
        198        SEND_VAL                                                 'consists+of+the+same+values+for+big2+and+big2'
  111   199        INIT_FCALL                                               'consistsofthesamevalues'
        200        SEND_VAR                                                 !2
        201        SEND_VAR                                                 !2
        202        SEND_VAR                                                 !4
        203        SEND_VAR                                                 !3
        204        DO_FCALL                                      0  $68     
        205        TYPE_CHECK                                    8  ~69     $68
        206        SEND_VAL                                                 ~69
  110   207        DO_FCALL                                      0          
  116   208        INIT_FCALL                                               'it'
        209        SEND_VAL                                                 'does+not+consist+of+the+same+values'
  117   210        INIT_FCALL                                               'consistsofthesamevalues'
        211        SEND_VAL                                                 <array>
        212        SEND_VAL                                                 <array>
        213        SEND_VAR                                                 !4
        214        SEND_VAR                                                 !3
        215        DO_FCALL                                      0  $71     
        216        TYPE_CHECK                                    4  ~72     $71
        217        SEND_VAL                                                 ~72
  116   218        DO_FCALL                                      0          
  120   219        INIT_FCALL                                               'it'
        220        SEND_VAL                                                 'does+not+consist+of+the+same+values'
  121   221        INIT_FCALL                                               'consistsofthesamevalues'
        222        SEND_VAL                                                 <array>
        223        SEND_VAL                                                 <array>
        224        SEND_VAR                                                 !4
        225        SEND_VAR                                                 !3
        226        DO_FCALL                                      0  $74     
        227        TYPE_CHECK                                    4  ~75     $74
        228        SEND_VAL                                                 ~75
  120   229        DO_FCALL                                      0          
  124   230        INIT_FCALL                                               'it'
        231        SEND_VAL                                                 'does+not+consist+of+the+same+values'
  125   232        INIT_FCALL                                               'consistsofthesamevalues'
        233        SEND_VAL                                                 <array>
        234        SEND_VAL                                                 <array>
        235        SEND_VAR                                                 !4
        236        SEND_VAR                                                 !3
        237        DO_FCALL                                      0  $77     
        238        TYPE_CHECK                                    4  ~78     $77
        239        SEND_VAL                                                 ~78
  124   240        DO_FCALL                                      0          
  128   241        INIT_FCALL                                               'it'
        242        SEND_VAL                                                 'does+not+consist+of+the+same+values'
  129   243        INIT_FCALL                                               'consistsofthesamevalues'
        244        SEND_VAL                                                 <array>
        245        SEND_VAL                                                 <array>
        246        SEND_VAR                                                 !4
        247        SEND_VAR                                                 !3
        248        DO_FCALL                                      0  $80     
        249        TYPE_CHECK                                    4  ~81     $80
        250        SEND_VAL                                                 ~81
  128   251        DO_FCALL                                      0          
  132   252        INIT_FCALL                                               'it'
        253        SEND_VAL                                                 'does+not+consist+of+the+same+values'
  133   254        INIT_FCALL                                               'consistsofthesamevalues'
        255        SEND_VAL                                                 <array>
        256        SEND_VAL                                                 <array>
        257        SEND_VAR                                                 !4
        258        SEND_VAR                                                 !3
        259        DO_FCALL                                      0  $83     
        260        TYPE_CHECK                                    4  ~84     $83
        261        SEND_VAL                                                 ~84
  132   262        DO_FCALL                                      0          
  136   263        INIT_FCALL                                               'it'
        264        SEND_VAL                                                 'does+not+consist+of+the+same+values'
  137   265        INIT_FCALL                                               'consistsofthesamevalues'
        266        SEND_VAL                                                 <array>
        267        SEND_VAL                                                 <array>
        268        SEND_VAR                                                 !4
        269        SEND_VAR                                                 !3
        270        DO_FCALL                                      0  $86     
        271        TYPE_CHECK                                    4  ~87     $86
        272        SEND_VAL                                                 ~87
  136   273        DO_FCALL                                      0          
  140   274        INIT_FCALL                                               'it'
        275        SEND_VAL                                                 'does+not+consist+of+the+same+values'
  141   276        INIT_FCALL                                               'consistsofthesamevalues'
        277        SEND_VAL                                                 <array>
        278        SEND_VAL                                                 <array>
        279        SEND_VAR                                                 !4
        280        SEND_VAR                                                 !3
        281        DO_FCALL                                      0  $89     
        282        TYPE_CHECK                                    4  ~90     $89
        283        SEND_VAL                                                 ~90
  140   284        DO_FCALL                                      0          
  144   285        INIT_FCALL                                               'it'
        286        SEND_VAL                                                 'does+not+consist+of+the+same+values+with+key'
  145   287        INIT_FCALL                                               'consistsofthesamevalues'
        288        SEND_VAL                                                 <array>
        289        SEND_VAL                                                 <array>
        290        SEND_VAR                                                 !4
        291        SEND_VAR                                                 !3
        292        DO_FCALL                                      0  $92     
        293        TYPE_CHECK                                    4  ~93     $92
        294        SEND_VAL                                                 ~93
  144   295        DO_FCALL                                      0          
  148   296        INIT_FCALL                                               'it'
        297        SEND_VAL                                                 'does+not+consist+of+the+same+values+with+key'
  149   298        INIT_FCALL                                               'consistsofthesamevalues'
        299        SEND_VAL                                                 <array>
        300        SEND_VAL                                                 <array>
        301        SEND_VAR                                                 !4
        302        SEND_VAR                                                 !3
        303        DO_FCALL                                      0  $95     
        304        TYPE_CHECK                                    4  ~96     $95
        305        SEND_VAL                                                 ~96
  148   306        DO_FCALL                                      0          
  152   307        INIT_FCALL                                               'it'
        308        SEND_VAL                                                 'does+not+consist+of+the+same+values+with+key'
  153   309        INIT_FCALL                                               'consistsofthesamevalues'
        310        SEND_VAL                                                 <array>
        311        SEND_VAL                                                 <array>
        312        SEND_VAR                                                 !4
        313        SEND_VAR                                                 !3
        314        DO_FCALL                                      0  $98     
        315        TYPE_CHECK                                    4  ~99     $98
        316        SEND_VAL                                                 ~99
  152   317        DO_FCALL                                      0          
  156   318        INIT_FCALL                                               'it'
        319        SEND_VAL                                                 'does+not+consist+of+the+same+values+with+key'
  157   320        INIT_FCALL                                               'consistsofthesamevalues'
        321        SEND_VAL                                                 <array>
        322        SEND_VAL                                                 <array>
        323        SEND_VAR                                                 !4
        324        SEND_VAR                                                 !3
        325        DO_FCALL                                      0  $101    
        326        TYPE_CHECK                                    4  ~102    $101
        327        SEND_VAL                                                 ~102
  156   328        DO_FCALL                                      0          
  160   329        INIT_FCALL                                               'it'
        330        SEND_VAL                                                 'does+not+consist+of+the+same+values+for+big1+and+big2'
  161   331        INIT_FCALL                                               'consistsofthesamevalues'
        332        SEND_VAR                                                 !0
        333        SEND_VAR                                                 !2
        334        SEND_VAR                                                 !4
        335        SEND_VAR                                                 !3
        336        DO_FCALL                                      0  $104    
        337        TYPE_CHECK                                    4  ~105    $104
        338        SEND_VAL                                                 ~105
  160   339        DO_FCALL                                      0          
  164   340        INIT_FCALL                                               'it'
        341        SEND_VAL                                                 'does+not+consist+of+the+same+values+for+big2+and+big1'
  165   342        INIT_FCALL                                               'consistsofthesamevalues'
        343        SEND_VAR                                                 !2
        344        SEND_VAR                                                 !0
        345        SEND_VAR                                                 !4
        346        SEND_VAR                                                 !3
        347        DO_FCALL                                      0  $107    
        348        TYPE_CHECK                                    4  ~108    $107
        349        SEND_VAL                                                 ~108
  164   350        DO_FCALL                                      0          
  170   351      > JMPZ                                                     !4, ->354
        352    >   QM_ASSIGN                                        ~110    'does+not+consist+of+the+same+strict+values'
        353      > JMP                                                      ->355
        354    >   QM_ASSIGN                                        ~110    'consists+of+the+same+loose+values'
        355    >   ASSIGN                                                   !5, ~

Generated using Vulcan Logic Dumper, using php 8.0.0

preferences:
156.16 ms | 1033 KiB | 72 Q