3v4l.org

run code in 300+ PHP versions simultaneously
<?php class TimeUUID extends DateTime { // Interval between Julian and Gregorian calendar in 100nanoseconds const Interval = "122192928000000000"; const Time = 1; const DCE = 2; /** * Returns true if this UUID is parsable * * @param string $uuid * @return boolean */ private static function isUUID($uuid) { if (preg_match('/([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/', $uuid)) return true; return false; } /** * Ensure the value is not a signed extracted value * * @param char $value * @return char */ private static function ensureNotSigned8bits($value) { return (256 + $value) % 256; } /** * Create data according to the two given raw values * * @param integer $raw1 * @param integer $raw2 * @return char array[8] */ private static function createData($raw1, $raw2) { $b1 = ($raw1 & 0xFF000000) >> 24; $b2 = ($raw1 & 0x00FF0000) >> 16; $b3 = ($raw1 & 0x0000FF00) >> 8; $b4 = ($raw1 & 0x000000FF); $b5 = ($raw2 & 0xFF000000) >> 24; $b6 = ($raw2 & 0x00FF0000) >> 16; $b7 = ($raw2 & 0x0000FF00) >> 8; $b8 = ($raw2 & 0x000000FF); return array( TimeUUID::ensureNotSigned8bits($b1), // 8bits $b2, // 8bits $b3, // 8bits $b4, // 8bits TimeUUID::ensureNotSigned8bits($b5), // 8bits $b6, // 8bits $b7, // 8bits $b8, // 8bits ); } /** * Extract fields from the given UUID * * @param string $uuid * @return array */ private static function extractFields($uuid) { // remove dashes $uuid = preg_replace("/[^a-f0-9]/is", "", $uuid); $data1 = hexdec(substr($uuid, 0, 8)); $data2 = hexdec(substr($uuid, 8, 4)); $data3 = hexdec(substr($uuid, 12, 4)); $uuid332 = hexdec(substr($uuid, 16, 8)); $uuid432 = hexdec(substr($uuid, 24, 8)); return array( $data1, // 32 bits $data2, // 16 bits $data3, // 16 bits TimeUUID::createData($uuid332, $uuid432) ); } /** * Build the UUID using the raw values * * @param integer $data1 * @param integer $data2 * @param integer $data3 * @param char array[8] $data4 * @return string */ private static function composeFields($data1, $data2, $data3, $data4) { $data1Str = str_pad(dechex($data1), 8, '0', STR_PAD_LEFT); $data2Str = str_pad(dechex($data2), 4, '0', STR_PAD_LEFT); $data3Str = str_pad(dechex($data3), 4, '0', STR_PAD_LEFT); $data4Str0 = str_pad(dechex($data4[0]), 2, '0', STR_PAD_LEFT); $data4Str1 = str_pad(dechex($data4[1]), 2, '0', STR_PAD_LEFT); $result = "$data1Str-$data2Str-$data3Str-$data4Str0$data4Str1-"; foreach (range(2, 7) as $index) $result .= str_pad(dechex($data4[$index]), 2, '0', STR_PAD_LEFT); return $result; } /** * Check if the variant of this UUID 4rd node is a DCE * * @param integer $data4 * @return boolean */ private static function checkVariantDCE($data4) { return ($data4[0] & 0xC0) == (TimeUUID::DCE << 6); } /** * Check if the version of this UUID 3rd node is a Time * * @param integer $data3 * @return boolean */ private static function checkVersionTime($data3) { return ($data3 >> 12) == (TimeUUID::Time); } /** * Parse the given uuid, check if it's a TimeUUID (RFC4144), and returns parsed data * * @param type $uuid * @return array( * Unix Timestamp, * Data, * 100nanoseconds * ) */ private static function parse($uuid) { list($data1, $data2, $data3, $data4) = TimeUUID::extractFields($uuid); if (!TimeUUID::checkVariantDCE($data4)) throw new Exception("Not a valid TimeUUID: DCE not found (Variant)"); if (!TimeUUID::checkVersionTime($data3)) throw new Exception("Not a valid TimeUUID: Time not found (Version)"); // $time = ($data1 | ($data2 << 32) | (($data3 & 0xFFF) << 48)) - TimeUUID::Interval; $time = bcsub( bcadd( bcadd( bcmul( $data2, "4294967296", // 0xFFFFFFFF 0 ), $data1 ), bcmul( $data3 & 0xFFF, "281474976710656", // 0xFFFFFFFFFFFF 0 ) ), TimeUUID::Interval ); return array( // intval($time / 10000000), intval(bcdiv($time, 10000000, 0)), $data4, // intval($time % 10000000), intval(bcmod($time, 10000000)) ); } private $data = array( 0, 0, 0, 0, 0, 0, 0, 0 ); private $ticks = 0; /** * Returns $this data * * @return char array[8] */ public function getData() { return $this->data; } /** * Specify the data this TimeUUID will holds. Check TimeUUIDMax for an example * * @param char array[8] $data */ public function setData($data) { $this->data = $data; } /** * Returns $this 100nanoseconds * * @return integer */ public function getTicks() { return $this->ticks; } /** * Since DateTime doesn't support 100nanoseconds, you can give here the * missing accuracy of DateTime to build a complete TimeUUID * * @param integer $ticks */ public function setTicks($ticks) { $this->ticks = $ticks; } /** * Attempt to construct a DateTime based on the given TimeUUID, fallback on * default DateTime constructor if the given $time is not a TimeUUID * * @param type $time * @param DateTimeZone $timezone (ignored when passing a TimeUUID in $time) */ public function __construct($time, $timezone = null) { if (TimeUUID::isUUID($time)) { // TimeUUID are always UTC, and timezone parameter is ignored // when ctoring with @ syntax list($time, $this->data, $this->ticks) = TimeUUID::parse($time); parent::__construct('@' . $time); } else { parent::__construct($time, $timezone); } } /** * Return $this TimeUUID * * @return string */ public function __toString() { // ((Timesteamp() * 10000000) + Interval) + Ticks $time = bcadd( bcadd( bcmul( $this->getTimestamp(), 10000000 ), TimeUUID::Interval ), $this->getTicks() ); // $time & 32 (0xFFFFFFFF => 2^32) $data1 = bcmod($time, "4294967296"); // $time >> 32 $timeHigh = bcdiv($time, "4294967296", 0); $data2 = $timeHigh & 0xFFFF; $data3 = (($timeHigh >> 16) & 0xFFF) | TimeUUID::Time << 12; $data = $this->data; $data[0] = ($data[0] & 0x3F) | TimeUUID::DCE << 6; return TimeUUID::composeFields($data1, $data2, $data3, $data); } } $timeUuid = new TimeUUID("ffffffff-ffff-1fff-8000-000000000000"); $timeUuid->format(\DateTime::ISO8601); $timeUuid = new TimeUUID("00000000-0000-1000-8fff-ffffffffffff"); $timeUuid->format(\DateTime::ISO8601);
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/JaBAA
function name:  (null)
number of ops:  16
compiled vars:  !0 = $timeUuid
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
    3     0  E >   DECLARE_CLASS                                            'timeuuid', 'datetime'
  295     1        NEW                                              $1      'TimeUUID'
          2        SEND_VAL_EX                                              'ffffffff-ffff-1fff-8000-000000000000'
          3        DO_FCALL                                      0          
          4        ASSIGN                                                   !0, $1
  296     5        INIT_METHOD_CALL                                         !0, 'format'
          6        SEND_VAL_EX                                              'Y-m-d%5CTH%3Ai%3AsO'
          7        DO_FCALL                                      0          
  298     8        NEW                                              $5      'TimeUUID'
          9        SEND_VAL_EX                                              '00000000-0000-1000-8fff-ffffffffffff'
         10        DO_FCALL                                      0          
         11        ASSIGN                                                   !0, $5
  299    12        INIT_METHOD_CALL                                         !0, 'format'
         13        SEND_VAL_EX                                              'Y-m-d%5CTH%3Ai%3AsO'
         14        DO_FCALL                                      0          
         15      > RETURN                                                   1

Class TimeUUID:
Function isuuid:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 6, Position 2 = 7
Branch analysis from position: 6
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 7
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/JaBAA
function name:  isUUID
number of ops:  9
compiled vars:  !0 = $uuid
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   16     0  E >   RECV                                             !0      
   18     1        INIT_FCALL                                               'preg_match'
          2        SEND_VAL                                                 '%2F%28%5Ba-f0-9%5D%7B8%7D-%5Ba-f0-9%5D%7B4%7D-%5Ba-f0-9%5D%7B4%7D-%5Ba-f0-9%5D%7B4%7D-%5Ba-f0-9%5D%7B12%7D%29%2F'
          3        SEND_VAR                                                 !0
          4        DO_ICALL                                         $1      
          5      > JMPZ                                                     $1, ->7
   19     6    > > RETURN                                                   <true>
   21     7    > > RETURN                                                   <false>
   22     8*     > RETURN                                                   null

End of function isuuid

Function ensurenotsigned8bits:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/JaBAA
function name:  ensureNotSigned8bits
number of ops:  5
compiled vars:  !0 = $value
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   30     0  E >   RECV                                             !0      
   32     1        ADD                                              ~1      256, !0
          2        MOD                                              ~2      ~1, 256
          3      > RETURN                                                   ~2
   33     4*     > RETURN                                                   null

End of function ensurenotsigned8bits

Function createdata:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/JaBAA
function name:  createData
number of ops:  40
compiled vars:  !0 = $raw1, !1 = $raw2, !2 = $b1, !3 = $b2, !4 = $b3, !5 = $b4, !6 = $b5, !7 = $b6, !8 = $b7, !9 = $b8
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   42     0  E >   RECV                                             !0      
          1        RECV                                             !1      
   44     2        BW_AND                                           ~10     !0, 4278190080
          3        SR                                               ~11     ~10, 24
          4        ASSIGN                                                   !2, ~11
   45     5        BW_AND                                           ~13     !0, 16711680
          6        SR                                               ~14     ~13, 16
          7        ASSIGN                                                   !3, ~14
   46     8        BW_AND                                           ~16     !0, 65280
          9        SR                                               ~17     ~16, 8
         10        ASSIGN                                                   !4, ~17
   47    11        BW_AND                                           ~19     !0, 255
         12        ASSIGN                                                   !5, ~19
   49    13        BW_AND                                           ~21     !1, 4278190080
         14        SR                                               ~22     ~21, 24
         15        ASSIGN                                                   !6, ~22
   50    16        BW_AND                                           ~24     !1, 16711680
         17        SR                                               ~25     ~24, 16
         18        ASSIGN                                                   !7, ~25
   51    19        BW_AND                                           ~27     !1, 65280
         20        SR                                               ~28     ~27, 8
         21        ASSIGN                                                   !8, ~28
   52    22        BW_AND                                           ~30     !1, 255
         23        ASSIGN                                                   !9, ~30
   55    24        INIT_STATIC_METHOD_CALL                                  'TimeUUID', 'ensureNotSigned8bits'
         25        SEND_VAR                                                 !2
         26        DO_FCALL                                      0  $32     
         27        INIT_ARRAY                                       ~33     $32
   56    28        ADD_ARRAY_ELEMENT                                ~33     !3
   57    29        ADD_ARRAY_ELEMENT                                ~33     !4
   58    30        ADD_ARRAY_ELEMENT                                ~33     !5
   59    31        INIT_STATIC_METHOD_CALL                                  'TimeUUID', 'ensureNotSigned8bits'
         32        SEND_VAR                                                 !6
         33        DO_FCALL                                      0  $34     
         34        ADD_ARRAY_ELEMENT                                ~33     $34
   60    35        ADD_ARRAY_ELEMENT                                ~33     !7
   61    36        ADD_ARRAY_ELEMENT                                ~33     !8
   62    37        ADD_ARRAY_ELEMENT                                ~33     !9
         38      > RETURN                                                   ~33
   64    39*     > RETURN                                                   null

End of function createdata

Function extractfields:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/JaBAA
function name:  extractFields
number of ops:  62
compiled vars:  !0 = $uuid, !1 = $data1, !2 = $data2, !3 = $data3, !4 = $uuid332, !5 = $uuid432
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   72     0  E >   RECV                                             !0      
   75     1        INIT_FCALL                                               'preg_replace'
          2        SEND_VAL                                                 '%2F%5B%5Ea-f0-9%5D%2Fis'
          3        SEND_VAL                                                 ''
          4        SEND_VAR                                                 !0
          5        DO_ICALL                                         $6      
          6        ASSIGN                                                   !0, $6
   77     7        INIT_FCALL                                               'hexdec'
          8        INIT_FCALL                                               'substr'
          9        SEND_VAR                                                 !0
         10        SEND_VAL                                                 0
         11        SEND_VAL                                                 8
         12        DO_ICALL                                         $8      
         13        SEND_VAR                                                 $8
         14        DO_ICALL                                         $9      
         15        ASSIGN                                                   !1, $9
   78    16        INIT_FCALL                                               'hexdec'
         17        INIT_FCALL                                               'substr'
         18        SEND_VAR                                                 !0
         19        SEND_VAL                                                 8
         20        SEND_VAL                                                 4
         21        DO_ICALL                                         $11     
         22        SEND_VAR                                                 $11
         23        DO_ICALL                                         $12     
         24        ASSIGN                                                   !2, $12
   79    25        INIT_FCALL                                               'hexdec'
         26        INIT_FCALL                                               'substr'
         27        SEND_VAR                                                 !0
         28        SEND_VAL                                                 12
         29        SEND_VAL                                                 4
         30        DO_ICALL                                         $14     
         31        SEND_VAR                                                 $14
         32        DO_ICALL                                         $15     
         33        ASSIGN                                                   !3, $15
   81    34        INIT_FCALL                                               'hexdec'
         35        INIT_FCALL                                               'substr'
         36        SEND_VAR                                                 !0
         37        SEND_VAL                                                 16
         38        SEND_VAL                                                 8
         39        DO_ICALL                                         $17     
         40        SEND_VAR                                                 $17
         41        DO_ICALL                                         $18     
         42        ASSIGN                                                   !4, $18
   82    43        INIT_FCALL                                               'hexdec'
         44        INIT_FCALL                                               'substr'
         45        SEND_VAR                                                 !0
         46        SEND_VAL                                                 24
         47        SEND_VAL                                                 8
         48        DO_ICALL                                         $20     
         49        SEND_VAR                                                 $20
         50        DO_ICALL                                         $21     
         51        ASSIGN                                                   !5, $21
   85    52        INIT_ARRAY                                       ~23     !1
   86    53        ADD_ARRAY_ELEMENT                                ~23     !2
   87    54        ADD_ARRAY_ELEMENT                                ~23     !3
   88    55        INIT_STATIC_METHOD_CALL                                  'TimeUUID', 'createData'
         56        SEND_VAR                                                 !4
         57        SEND_VAR                                                 !5
         58        DO_FCALL                                      0  $24     
         59        ADD_ARRAY_ELEMENT                                ~23     $24
         60      > RETURN                                                   ~23
   90    61*     > RETURN                                                   null

End of function extractfields

Function composefields:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 77) Position 1 = 71, Position 2 = 84
Branch analysis from position: 71
2 jumps found. (Code = 78) Position 1 = 72, Position 2 = 84
Branch analysis from position: 72
1 jumps found. (Code = 42) Position 1 = 71
Branch analysis from position: 71
Branch analysis from position: 84
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 84
filename:       /in/JaBAA
function name:  composeFields
number of ops:  87
compiled vars:  !0 = $data1, !1 = $data2, !2 = $data3, !3 = $data4, !4 = $data1Str, !5 = $data2Str, !6 = $data3Str, !7 = $data4Str0, !8 = $data4Str1, !9 = $result, !10 = $index
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  101     0  E >   RECV                                             !0      
          1        RECV                                             !1      
          2        RECV                                             !2      
          3        RECV                                             !3      
  103     4        INIT_FCALL                                               'str_pad'
          5        INIT_FCALL                                               'dechex'
          6        SEND_VAR                                                 !0
          7        DO_ICALL                                         $11     
          8        SEND_VAR                                                 $11
          9        SEND_VAL                                                 8
         10        SEND_VAL                                                 '0'
         11        SEND_VAL                                                 0
         12        DO_ICALL                                         $12     
         13        ASSIGN                                                   !4, $12
  104    14        INIT_FCALL                                               'str_pad'
         15        INIT_FCALL                                               'dechex'
         16        SEND_VAR                                                 !1
         17        DO_ICALL                                         $14     
         18        SEND_VAR                                                 $14
         19        SEND_VAL                                                 4
         20        SEND_VAL                                                 '0'
         21        SEND_VAL                                                 0
         22        DO_ICALL                                         $15     
         23        ASSIGN                                                   !5, $15
  105    24        INIT_FCALL                                               'str_pad'
         25        INIT_FCALL                                               'dechex'
         26        SEND_VAR                                                 !2
         27        DO_ICALL                                         $17     
         28        SEND_VAR                                                 $17
         29        SEND_VAL                                                 4
         30        SEND_VAL                                                 '0'
         31        SEND_VAL                                                 0
         32        DO_ICALL                                         $18     
         33        ASSIGN                                                   !6, $18
  106    34        INIT_FCALL                                               'str_pad'
         35        INIT_FCALL                                               'dechex'
         36        FETCH_DIM_R                                      ~20     !3, 0
         37        SEND_VAL                                                 ~20
         38        DO_ICALL                                         $21     
         39        SEND_VAR                                                 $21
         40        SEND_VAL                                                 2
         41        SEND_VAL                                                 '0'
         42        SEND_VAL                                                 0
         43        DO_ICALL                                         $22     
         44        ASSIGN                                                   !7, $22
  107    45        INIT_FCALL                                               'str_pad'
         46        INIT_FCALL                                               'dechex'
         47        FETCH_DIM_R                                      ~24     !3, 1
         48        SEND_VAL                                                 ~24
         49        DO_ICALL                                         $25     
         50        SEND_VAR                                                 $25
         51        SEND_VAL                                                 2
         52        SEND_VAL                                                 '0'
         53        SEND_VAL                                                 0
         54        DO_ICALL                                         $26     
         55        ASSIGN                                                   !8, $26
  108    56        ROPE_INIT                                     9  ~29     !4
         57        ROPE_ADD                                      1  ~29     ~29, '-'
         58        ROPE_ADD                                      2  ~29     ~29, !5
         59        ROPE_ADD                                      3  ~29     ~29, '-'
         60        ROPE_ADD                                      4  ~29     ~29, !6
         61        ROPE_ADD                                      5  ~29     ~29, '-'
         62        ROPE_ADD                                      6  ~29     ~29, !7
         63        ROPE_ADD                                      7  ~29     ~29, !8
         64        ROPE_END                                      8  ~28     ~29, '-'
         65        ASSIGN                                                   !9, ~28
  109    66        INIT_FCALL                                               'range'
         67        SEND_VAL                                                 2
         68        SEND_VAL                                                 7
         69        DO_ICALL                                         $35     
         70      > FE_RESET_R                                       $36     $35, ->84
         71    > > FE_FETCH_R                                               $36, !10, ->84
  110    72    >   INIT_FCALL                                               'str_pad'
         73        INIT_FCALL                                               'dechex'
         74        FETCH_DIM_R                                      ~37     !3, !10
         75        SEND_VAL                                                 ~37
         76        DO_ICALL                                         $38     
         77        SEND_VAR                                                 $38
         78        SEND_VAL                                                 2
         79        SEND_VAL                                                 '0'
         80        SEND_VAL                                                 0
         81        DO_ICALL                                         $39     
         82        ASSIGN_OP                                     8          !9, $39
  109    83      > JMP                                                      ->71
         84    >   FE_FREE                                                  $36
  112    85      > RETURN                                                   !9
  113    86*     > RETURN                                                   null

End of function composefields

Function checkvariantdce:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/JaBAA
function name:  checkVariantDCE
number of ops:  6
compiled vars:  !0 = $data4
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  121     0  E >   RECV                                             !0      
  123     1        FETCH_DIM_R                                      ~1      !0, 0
          2        BW_AND                                           ~2      ~1, 192
          3        IS_EQUAL                                         ~3      ~2, 128
          4      > RETURN                                                   ~3
  124     5*     > RETURN                                                   null

End of function checkvariantdce

Function checkversiontime:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/JaBAA
function name:  checkVersionTime
number of ops:  5
compiled vars:  !0 = $data3
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  132     0  E >   RECV                                             !0      
  134     1        SR                                               ~1      !0, 12
          2        IS_EQUAL                                         ~2      ~1, 1
          3      > RETURN                                                   ~2
  135     4*     > RETURN                                                   null

End of function checkversiontime

Function parse:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 18, Position 2 = 22
Branch analysis from position: 18
1 jumps found. (Code = 108) Position 1 = -2
Branch analysis from position: 22
2 jumps found. (Code = 43) Position 1 = 27, Position 2 = 31
Branch analysis from position: 27
1 jumps found. (Code = 108) Position 1 = -2
Branch analysis from position: 31
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/JaBAA
function name:  parse
number of ops:  71
compiled vars:  !0 = $uuid, !1 = $data1, !2 = $data2, !3 = $data3, !4 = $data4, !5 = $time
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  147     0  E >   RECV                                             !0      
  149     1        INIT_STATIC_METHOD_CALL                                  'TimeUUID', 'extractFields'
          2        SEND_VAR                                                 !0
          3        DO_FCALL                                      0  $6      
          4        FETCH_LIST_R                                     $7      $6, 0
          5        ASSIGN                                                   !1, $7
          6        FETCH_LIST_R                                     $9      $6, 1
          7        ASSIGN                                                   !2, $9
          8        FETCH_LIST_R                                     $11     $6, 2
          9        ASSIGN                                                   !3, $11
         10        FETCH_LIST_R                                     $13     $6, 3
         11        ASSIGN                                                   !4, $13
         12        FREE                                                     $6
  150    13        INIT_STATIC_METHOD_CALL                                  'TimeUUID', 'checkVariantDCE'
         14        SEND_VAR                                                 !4
         15        DO_FCALL                                      0  $15     
         16        BOOL_NOT                                         ~16     $15
         17      > JMPZ                                                     ~16, ->22
  151    18    >   NEW                                              $17     'Exception'
         19        SEND_VAL_EX                                              'Not+a+valid+TimeUUID%3A+DCE+not+found+%28Variant%29'
         20        DO_FCALL                                      0          
         21      > THROW                                         0          $17
  153    22    >   INIT_STATIC_METHOD_CALL                                  'TimeUUID', 'checkVersionTime'
         23        SEND_VAR                                                 !3
         24        DO_FCALL                                      0  $19     
         25        BOOL_NOT                                         ~20     $19
         26      > JMPZ                                                     ~20, ->31
  154    27    >   NEW                                              $21     'Exception'
         28        SEND_VAL_EX                                              'Not+a+valid+TimeUUID%3A+Time+not+found+%28Version%29'
         29        DO_FCALL                                      0          
         30      > THROW                                         0          $21
  158    31    >   INIT_FCALL_BY_NAME                                       'bcsub'
  159    32        INIT_FCALL_BY_NAME                                       'bcadd'
  160    33        INIT_FCALL_BY_NAME                                       'bcadd'
  161    34        INIT_FCALL_BY_NAME                                       'bcmul'
  162    35        SEND_VAR_EX                                              !2
  163    36        SEND_VAL_EX                                              '4294967296'
  164    37        SEND_VAL_EX                                              0
         38        DO_FCALL                                      0  $23     
         39        SEND_VAR_NO_REF_EX                                       $23
  161    40        SEND_VAR_EX                                              !1
         41        DO_FCALL                                      0  $24     
         42        SEND_VAR_NO_REF_EX                                       $24
  168    43        INIT_FCALL_BY_NAME                                       'bcmul'
  169    44        BW_AND                                           ~25     !3, 4095
         45        SEND_VAL_EX                                              ~25
  170    46        SEND_VAL_EX                                              '281474976710656'
  171    47        SEND_VAL_EX                                              0
         48        DO_FCALL                                      0  $26     
         49        SEND_VAR_NO_REF_EX                                       $26
         50        DO_FCALL                                      0  $27     
         51        SEND_VAR_NO_REF_EX                                       $27
  174    52        SEND_VAL_EX                                              '122192928000000000'
         53        DO_FCALL                                      0  $28     
  157    54        ASSIGN                                                   !5, $28
  179    55        INIT_FCALL_BY_NAME                                       'bcdiv'
         56        SEND_VAR_EX                                              !5
         57        SEND_VAL_EX                                              10000000
         58        SEND_VAL_EX                                              0
         59        DO_FCALL                                      0  $30     
         60        CAST                                          4  ~31     $30
         61        INIT_ARRAY                                       ~32     ~31
  180    62        ADD_ARRAY_ELEMENT                                ~32     !4
  182    63        INIT_FCALL_BY_NAME                                       'bcmod'
         64        SEND_VAR_EX                                              !5
         65        SEND_VAL_EX                                              10000000
         66        DO_FCALL                                      0  $33     
         67        CAST                                          4  ~34     $33
         68        ADD_ARRAY_ELEMENT                                ~32     ~34
         69      > RETURN                                                   ~32
  184    70*     > RETURN                                                   null

End of function parse

Function getdata:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/JaBAA
function name:  getData
number of ops:  3
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  206     0  E >   FETCH_OBJ_R                                      ~0      'data'
          1      > RETURN                                                   ~0
  207     2*     > RETURN                                                   null

End of function getdata

Function setdata:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/JaBAA
function name:  setData
number of ops:  4
compiled vars:  !0 = $data
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  214     0  E >   RECV                                             !0      
  216     1        ASSIGN_OBJ                                               'data'
          2        OP_DATA                                                  !0
  217     3      > RETURN                                                   null

End of function setdata

Function getticks:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/JaBAA
function name:  getTicks
number of ops:  3
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  226     0  E >   FETCH_OBJ_R                                      ~0      'ticks'
          1      > RETURN                                                   ~0
  227     2*     > RETURN                                                   null

End of function getticks

Function setticks:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/JaBAA
function name:  setTicks
number of ops:  4
compiled vars:  !0 = $ticks
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  235     0  E >   RECV                                             !0      
  237     1        ASSIGN_OBJ                                               'ticks'
          2        OP_DATA                                                  !0
  238     3      > RETURN                                                   null

End of function setticks

Function __construct:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 6, Position 2 = 23
Branch analysis from

Generated using Vulcan Logic Dumper, using php 8.0.0


preferences:
172.92 ms | 1428 KiB | 42 Q