3v4l.org

run code in 300+ PHP versions simultaneously
<?php ini_set('precision', 100); echo round('0.48499999999999', 2) . "\n"; echo round('0.484999999999999', 2) . "\n"; echo round('10.4849999999999', 2) . "\n"; echo round('10.48499999999999', 2) . "\n"; echo round('100.484999999999', 2) . "\n"; echo round('100.4849999999999', 2) . "\n"; echo round('1000.48499999999', 2) . "\n"; echo round('1000.484999999999', 2) . "\n"; echo round('10000.4849999999', 2) . "\n"; echo round('10000.48499999999', 2) . "\n"; echo round('100000.484999999', 2) . "\n"; echo round('100000.4849999999', 2) . "\n"; echo round('1000000.48499999', 2) . "\n"; echo round('1000000.484999999', 2) . "\n"; echo round('10000000.4849999', 2) . "\n"; echo round('10000000.48499999', 2) . "\n"; echo round('100000000.484999', 2) . "\n"; echo round('100000000.4849999', 2) . "\n"; echo round('1000000000.48499', 2) . "\n"; echo round('1000000000.484999', 2) . "\n"; echo round('10000000000.4849', 2) . "\n"; echo round('10000000000.48499', 2) . "\n";
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/vs6li
function name:  (null)
number of ops:  137
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
    2     0  E >   INIT_FCALL                                               'ini_set'
          1        SEND_VAL                                                 'precision'
          2        SEND_VAL                                                 100
          3        DO_ICALL                                                 
    3     4        INIT_FCALL                                               'round'
          5        SEND_VAL                                                 '0.48499999999999'
          6        SEND_VAL                                                 2
          7        DO_ICALL                                         $1      
          8        CONCAT                                           ~2      $1, '%0A'
          9        ECHO                                                     ~2
    4    10        INIT_FCALL                                               'round'
         11        SEND_VAL                                                 '0.484999999999999'
         12        SEND_VAL                                                 2
         13        DO_ICALL                                         $3      
         14        CONCAT                                           ~4      $3, '%0A'
         15        ECHO                                                     ~4
    5    16        INIT_FCALL                                               'round'
         17        SEND_VAL                                                 '10.4849999999999'
         18        SEND_VAL                                                 2
         19        DO_ICALL                                         $5      
         20        CONCAT                                           ~6      $5, '%0A'
         21        ECHO                                                     ~6
    6    22        INIT_FCALL                                               'round'
         23        SEND_VAL                                                 '10.48499999999999'
         24        SEND_VAL                                                 2
         25        DO_ICALL                                         $7      
         26        CONCAT                                           ~8      $7, '%0A'
         27        ECHO                                                     ~8
    7    28        INIT_FCALL                                               'round'
         29        SEND_VAL                                                 '100.484999999999'
         30        SEND_VAL                                                 2
         31        DO_ICALL                                         $9      
         32        CONCAT                                           ~10     $9, '%0A'
         33        ECHO                                                     ~10
    8    34        INIT_FCALL                                               'round'
         35        SEND_VAL                                                 '100.4849999999999'
         36        SEND_VAL                                                 2
         37        DO_ICALL                                         $11     
         38        CONCAT                                           ~12     $11, '%0A'
         39        ECHO                                                     ~12
    9    40        INIT_FCALL                                               'round'
         41        SEND_VAL                                                 '1000.48499999999'
         42        SEND_VAL                                                 2
         43        DO_ICALL                                         $13     
         44        CONCAT                                           ~14     $13, '%0A'
         45        ECHO                                                     ~14
   10    46        INIT_FCALL                                               'round'
         47        SEND_VAL                                                 '1000.484999999999'
         48        SEND_VAL                                                 2
         49        DO_ICALL                                         $15     
         50        CONCAT                                           ~16     $15, '%0A'
         51        ECHO                                                     ~16
   11    52        INIT_FCALL                                               'round'
         53        SEND_VAL                                                 '10000.4849999999'
         54        SEND_VAL                                                 2
         55        DO_ICALL                                         $17     
         56        CONCAT                                           ~18     $17, '%0A'
         57        ECHO                                                     ~18
   12    58        INIT_FCALL                                               'round'
         59        SEND_VAL                                                 '10000.48499999999'
         60        SEND_VAL                                                 2
         61        DO_ICALL                                         $19     
         62        CONCAT                                           ~20     $19, '%0A'
         63        ECHO                                                     ~20
   13    64        INIT_FCALL                                               'round'
         65        SEND_VAL                                                 '100000.484999999'
         66        SEND_VAL                                                 2
         67        DO_ICALL                                         $21     
         68        CONCAT                                           ~22     $21, '%0A'
         69        ECHO                                                     ~22
   14    70        INIT_FCALL                                               'round'
         71        SEND_VAL                                                 '100000.4849999999'
         72        SEND_VAL                                                 2
         73        DO_ICALL                                         $23     
         74        CONCAT                                           ~24     $23, '%0A'
         75        ECHO                                                     ~24
   15    76        INIT_FCALL                                               'round'
         77        SEND_VAL                                                 '1000000.48499999'
         78        SEND_VAL                                                 2
         79        DO_ICALL                                         $25     
         80        CONCAT                                           ~26     $25, '%0A'
         81        ECHO                                                     ~26
   16    82        INIT_FCALL                                               'round'
         83        SEND_VAL                                                 '1000000.484999999'
         84        SEND_VAL                                                 2
         85        DO_ICALL                                         $27     
         86        CONCAT                                           ~28     $27, '%0A'
         87        ECHO                                                     ~28
   17    88        INIT_FCALL                                               'round'
         89        SEND_VAL                                                 '10000000.4849999'
         90        SEND_VAL                                                 2
         91        DO_ICALL                                         $29     
         92        CONCAT                                           ~30     $29, '%0A'
         93        ECHO                                                     ~30
   18    94        INIT_FCALL                                               'round'
         95        SEND_VAL                                                 '10000000.48499999'
         96        SEND_VAL                                                 2
         97        DO_ICALL                                         $31     
         98        CONCAT                                           ~32     $31, '%0A'
         99        ECHO                                                     ~32
   19   100        INIT_FCALL                                               'round'
        101        SEND_VAL                                                 '100000000.484999'
        102        SEND_VAL                                                 2
        103        DO_ICALL                                         $33     
        104        CONCAT                                           ~34     $33, '%0A'
        105        ECHO                                                     ~34
   20   106        INIT_FCALL                                               'round'
        107        SEND_VAL                                                 '100000000.4849999'
        108        SEND_VAL                                                 2
        109        DO_ICALL                                         $35     
        110        CONCAT                                           ~36     $35, '%0A'
        111        ECHO                                                     ~36
   21   112        INIT_FCALL                                               'round'
        113        SEND_VAL                                                 '1000000000.48499'
        114        SEND_VAL                                                 2
        115        DO_ICALL                                         $37     
        116        CONCAT                                           ~38     $37, '%0A'
        117        ECHO                                                     ~38
   22   118        INIT_FCALL                                               'round'
        119        SEND_VAL                                                 '1000000000.484999'
        120        SEND_VAL                                                 2
        121        DO_ICALL                                         $39     
        122        CONCAT                                           ~40     $39, '%0A'
        123        ECHO                                                     ~40
   23   124        INIT_FCALL                                               'round'
        125        SEND_VAL                                                 '10000000000.4849'
        126        SEND_VAL                                                 2
        127        DO_ICALL                                         $41     
        128        CONCAT                                           ~42     $41, '%0A'
        129        ECHO                                                     ~42
   24   130        INIT_FCALL                                               'round'
        131        SEND_VAL                                                 '10000000000.48499'
        132        SEND_VAL                                                 2
        133        DO_ICALL                                         $43     
        134        CONCAT                                           ~44     $43, '%0A'
        135        ECHO                                                     ~44
        136      > RETURN                                                   1

Generated using Vulcan Logic Dumper, using php 8.0.0


preferences:
199.02 ms | 1404 KiB | 17 Q