text
stringlengths 0
601k
|
|---|
let to_bytes s = s |
let of_bytes ( ? pos = 0 ) s = let len = String . length s in if pos + 16 > len then None else if pos = 0 && len = 16 then Some s else Some ( String . sub s pos 16 ) |
let mixed_swaps s = let swap b i j = let t = Bytes . get b i in Bytes . set b i ( Bytes . get b j ) ; Bytes . set b j t in let b = Bytes . of_string s in swap b 0 3 ; swap b 1 2 ; swap b 4 5 ; swap b 6 7 ; Bytes . unsafe_to_string b |
let to_mixed_endian_bytes s = mixed_swaps s |
let of_mixed_endian_bytes ? pos s = match of_bytes ? pos s with |
let unsafe_of_bytes u = u |
let unsafe_to_bytes u = u |
let of_string ( ? pos = 0 ) s = let len = String . length s in if pos + 36 > len || s . [ pos + 8 ] <> ' ' - || s . [ pos + 13 ] <> ' ' - || s . [ pos + 18 ] <> ' ' - || s . [ pos + 23 ] <> ' ' - then None else try let u = Bytes . create 16 in let i = ref 0 in let j = ref pos in let ihex c = let i = Char . code c in if i < 0x30 then raise Exit else if i <= 0x39 then i - 0x30 else if i < 0x41 then raise Exit else if i <= 0x46 then i - 0x37 else if i < 0x61 then raise Exit else if i <= 0x66 then i - 0x57 else raise Exit in let byte s j = Char . unsafe_chr ( ihex s . [ j ] lsl 4 lor ihex s . [ j + 1 ] ) in while ( ! i < 4 ) do Bytes . set u ! i ( byte s ! j ) ; j := ! j + 2 ; incr i done ; incr j ; while ( ! i < 6 ) do Bytes . set u ! i ( byte s ! j ) ; j := ! j + 2 ; incr i done ; incr j ; while ( ! i < 8 ) do Bytes . set u ! i ( byte s ! j ) ; j := ! j + 2 ; incr i done ; incr j ; while ( ! i < 10 ) do Bytes . set u ! i ( byte s ! j ) ; j := ! j + 2 ; incr i done ; incr j ; while ( ! i < 16 ) do Bytes . set u ! i ( byte s ! j ) ; j := ! j + 2 ; incr i done ; Some ( Bytes . unsafe_to_string u ) with Exit -> None |
let to_string ( ? upper = false ) u = let hbase = if upper then 0x37 else 0x57 in let hex hbase i = Char . unsafe_chr ( if i < 10 then 0x30 + i else hbase + i ) in let s = Bytes . of_string " XXXXXXXX - XXXX - XXXX - XXXX - XXXXXXXXXXXX " in let i = ref 0 in let j = ref 0 in let byte s i c = Bytes . set s i @@ hex hbase ( c lsr 4 ) ; Bytes . set s ( i + 1 ) @@ hex hbase ( c land 0x0F ) in while ( ! j < 4 ) do byte s ! i ( Char . code u . [ ! j ] ) ; i := ! i + 2 ; incr j ; done ; incr i ; while ( ! j < 6 ) do byte s ! i ( Char . code u . [ ! j ] ) ; i := ! i + 2 ; incr j ; done ; incr i ; while ( ! j < 8 ) do byte s ! i ( Char . code u . [ ! j ] ) ; i := ! i + 2 ; incr j ; done ; incr i ; while ( ! j < 10 ) do byte s ! i ( Char . code u . [ ! j ] ) ; i := ! i + 2 ; incr j ; done ; incr i ; while ( ! j < 16 ) do byte s ! i ( Char . code u . [ ! j ] ) ; i := ! i + 2 ; incr j ; done ; Bytes . unsafe_to_string s |
let pp ppf u = Format . pp_print_string ppf ( to_string u ) |
let pp_string ? upper ppf u = Format . pp_print_string ppf ( to_string ? upper u ) |
let gen version ns name upper binary = let version = match version with | ` V3 -> ` V3 ( ns , name ) | ` V4 -> ` V4 | ` V5 -> ` V5 ( ns , name ) in let u = Uuidm . v version in let s = match binary with | true -> Uuidm . to_bytes u | false -> strf " % s \ n " ( Uuidm . to_string ~ upper u ) in print_string s ; flush stdout |
let version = let v3 = let doc = " Generate a MD5 name based UUID version 3 , see option ( $ b , -- name ) . " in ` V3 , Arg . info [ " md5 " ] ~ doc in let v4 = let doc = " Generate a random based UUID version 4 ( default ) . " in ` V4 , Arg . info [ " r " ; " random " ] ~ doc in let v5 = let doc = " Generate a SHA - 1 name based UUID version 5 , see option ( $ b , -- name ) . " in ` V5 , Arg . info [ " sha1 " ] ~ doc in Arg . ( value & vflag ` V4 [ v3 ; v4 ; v5 ] ) |
let ns = let ns_arg = let parse s = match Uuidm . of_string s with | None -> ` Error ( strf " % S : could not parse namespace UUID " s ) | Some ns -> ` Ok ns in parse , Uuidm . pp in let doc = " Namespace UUID for name based UUIDs ( version 4 or 5 ) . Defaults to the DNS namespace UUID . " in Arg . ( value & opt ns_arg Uuidm . ns_dns & info [ " ns " ; " namespace " ] ~ doc ) |
let name_ = let doc = " Name for name based UUIDs ( version 4 or 5 ) . " in Arg . ( value & opt string " www . example . org " & info [ " name " ] ~ doc ) |
let upper = let doc = " Output hexadecimal letters in uppercase " in Arg . ( value & flag & info [ " u " ; " uppercase " ] ~ doc ) |
let binary = let doc = " Output the UUID as its 16 bytes binary representation . " in Arg . ( value & flag & info [ " b " ; " binary " ] ~ doc ) |
let cmd = let doc = " Generates universally unique identifiers ( UUIDs ) " in let man = [ ` S " DESCRIPTION " ; ` P " ( $ tname ) generates 128 bits universally unique identifiers version 3 , 5 ( name based with MD5 , SHA - 1 hashing ) and 4 ( random based ) according to RFC 4122 . " ; ` P " Invoked without any option , a random based version 4 UUID is generated and written on stdout . " ; ` S " SEE ALSO " ; ` P " P . Leach et al . A universally unique identifier ( UUID ) URN Namespace , 2005 . ( $ i , http :// tools . ietf . org / html / rfc4122 ) " ; ` S " BUGS " ; ` P " This program is distributed with the Uuidm OCaml library . See %% PKG_HOMEPAGE %% for contact information . " ; ] in Cmd . v ( Cmd . info " uuidtrip " ~ version " :%% VERSION " %% ~ doc ~ man ) Term . ( const gen $ version $ ns $ name_ $ upper $ binary ) |
let ( ) = exit ( Cmd . eval cmd ) |
type ret = [ ` Uchar of Uchar . t | ` End | ` Await ] |
let pp_ret ppf v = match ( v :> ret ) with |
let err_exp_await add = invalid_arg ( Format . asprintf " can ' t add % a , expected ` Await " pp_ret add ) |
let err_ended add = invalid_arg ( Format . asprintf " can ' t add % a , ` End already added " pp_ret add ) |
let u_dumb = ` Uchar ( Uchar . of_int 0x0000 ) |
let nfc_boundary u = Uunf_tmapbool . get Uunf_data . nfc_boundary_map u |
let nfd_boundary u = Uunf_tmapbool . get Uunf_data . nfd_boundary_map u |
let nfkc_boundary u = Uunf_tmapbool . get Uunf_data . nfkc_boundary_map u |
let nfkd_boundary u = Uunf_tmapbool . get Uunf_data . nfkd_boundary_map u |
let _ccc u = Uunf_tmapbyte . get Uunf_data . ccc_map u |
let ccc u = _ccc ( Uchar . to_int u ) |
let decomp_prop u = Uunf_tmap . get Uunf_data . decomp_map u |
let compose_prop u = Uunf_tmap . get Uunf_data . compose_map u |
module H = struct let sbase = 0xAC00 let lbase = 0x1100 let vbase = 0x1161 let tbase = 0x11A7 let scount = 11172 let lcount = 19 let vcount = 21 let tcount = 28 let ncount = 588 let scount = 11172 end |
let decomp u = let u = Uchar . to_int u in if u < 0xAC00 || 0xD7A3 < u then decomp_prop u else begin let sindex = u - H . sbase in let l = H . lbase + ( sindex / H . ncount ) in let v = H . vbase + ( sindex mod H . ncount ) / H . tcount in let t = H . tbase + ( sindex mod H . tcount ) in if t = H . tbase then [ | l ; v ] | else [ | l ; v ; t ] | end |
let d_compatibility i = i land ( 1 lsl 24 ) > 0 |
let _d_uchar i = i land 0x1FFFFF |
let d_uchar i = Uchar . unsafe_of_int ( _d_uchar i ) |
let _composite u1 u2 = if 0x1100 <= u1 && u1 <= 0x1112 then begin if u2 < 0x1161 || 0x1175 < u2 then ux_none else let l = u1 - H . lbase in let v = u2 - H . vbase in H . sbase + l * H . ncount + v * H . tcount end else if 0xAC00 <= u1 && u1 <= 0xD788 && ( u1 - 0x0AC00 ) mod H . tcount = 0 then begin if u2 < 0x11A8 || u2 > 0x11C3 then ux_none else ( u1 + u2 - H . tbase ) end else match compose_prop u1 with | [ ] || -> ux_none | a -> let len = Array . length a / 2 in let i = ref 0 in try while ( ! i < len ) do if a . ( ! i * 2 ) = u2 then raise Exit else incr i ; done ; ux_none with Exit -> ( a . ( ! i * 2 + 1 ) ) |
let composite u1 u2 = let u = _composite ( Uchar . to_int u1 ) ( Uchar . to_int u2 ) in if u = ux_none then None else Some ( Uchar . unsafe_of_int u ) |
type form = [ ` NFC | ` NFD | ` NFKC | ` NFKD ] |
type t = { form : form ; compat : bool ; compose : bool ; boundary : int -> bool ; mutable state : state ; mutable uc : [ ` Uchar of Uchar . t ] ; mutable acc : int array ; mutable first : int ; mutable last : int ; mutable is_end : bool ; } |
let create_acc ( ) = Array . make 35 ux_none |
let create form = let boundary , compat , compose = match form with | ` NFC -> nfc_boundary , false , true | ` NFD -> nfd_boundary , false , false | ` NFKC -> nfkc_boundary , true , true | ` NFKD -> nfkd_boundary , true , false in { form = ( form :> form ) ; compat ; compose ; boundary ; state = Start ; uc = u_dumb ; acc = create_acc ( ) ; first = 0 ; last = - 1 ; is_end = false } |
let get_u n = let ` Uchar u = n . uc in Uchar . to_int u |
let acc_empty n = n . first > n . last |
let form n = n . form |
let copy n = { n with acc = Array . copy n . acc } |
let reset n = n . state <- Start ; n . uc <- u_dumb ; n . acc <- create_acc ( ) ; n . first <- 0 ; n . last <- - 1 ; n . is_end <- false |
let grow_acc n = let len = Array . length n . acc in let acc ' = Array . make ( 2 * len ) ux_none in Array . blit n . acc 0 acc ' 0 len ; n . acc <- acc ' |
let ordered_add n u = n . last <- n . last + 1 ; if n . last = Array . length n . acc then grow_acc n ; let c = _ccc u in if c = 0 then n . acc . ( n . last ) <- u else begin let i = ref ( n . last - 1 ) in while ( ! i >= 0 && _ccc ( n . acc . ( ! i ) ) > c ) do n . acc . ( ! i + 1 ) <- n . acc . ( ! i ) ; decr i ; done ; n . acc . ( ! i + 1 ) <- u end |
let rec add n u = if 0xAC00 <= u && u <= 0xD7A3 then begin let sindex = u - H . sbase in let l = H . lbase + ( sindex / H . ncount ) in let v = H . vbase + ( sindex mod H . ncount ) / H . tcount in let t = H . tbase + ( sindex mod H . tcount ) in if t = H . tbase then ( ordered_add n l ; ordered_add n v ) else ( ordered_add n l ; ordered_add n v ; ordered_add n t ) end else begin match decomp_prop u with | [ ] || -> ordered_add n u | d -> if d_compatibility d . ( 0 ) && not n . compat then ordered_add n u else begin add n ( _d_uchar d . ( 0 ) ) ; for i = 1 to Array . length d - 1 do add n d . ( i ) done end end |
let compose n = let rec loop ~ last_starter ~ prev_ccc i = if i > n . last then ( ) else let ccc_i = _ccc n . acc . ( i ) in let u_comp = _composite n . acc . ( last_starter ) n . acc . ( i ) in match ( u_comp = ux_none || ( ccc_i = 0 && last_starter <> i - 1 ) ) with | true -> let last_starter = if ccc_i = 0 then i else last_starter in loop ~ last_starter ~ prev_ccc : ccc_i ( i + 1 ) | false -> match prev_ccc <> 0 && prev_ccc >= ccc_i with | true -> loop ~ last_starter ~ prev_ccc : ccc_i ( i + 1 ) | false -> n . acc . ( last_starter ) <- u_comp ; Array . blit n . acc ( i + 1 ) n . acc i ( n . last - i ) ; n . last <- n . last - 1 ; let prev_ccc = _ccc n . acc . ( last_starter ) in loop ~ last_starter ~ prev_ccc ( last_starter + 1 ) in let last_starter = n . first in let prev_ccc = _ccc n . acc . ( last_starter ) in loop ~ last_starter ~ prev_ccc ( last_starter + 1 ) |
let flush_next n = let ret = ` Uchar ( Uchar . unsafe_of_int n . acc . ( n . first ) ) in if n . first = n . last then ( n . first <- 0 ; n . last <- - 1 ) else ( n . first <- n . first + 1 ) ; ret |
let flush_start n = if n . compose then compose n ; flush_next n |
let add n = function let u = Uchar . to_int u in begin match n . state with | Boundary -> if n . boundary u then ( let prev = n . uc in n . uc <- uc ; ( prev :> ret ) ) else ( n . state <- Acc ; add n ( get_u n ) ; add n u ; ` Await ) | Acc -> if n . boundary u then ( n . state <- Flush ; n . uc <- uc ; flush_start n ) else ( add n u ; ` Await ) | Start -> if n . boundary u then ( n . state <- Boundary ; n . uc <- uc ; ` Await ) else ( n . state <- Acc ; add n u ; ` Await ) | Flush -> err_exp_await uc | End -> err_ended uc end begin match n . state with | Flush -> if not ( acc_empty n ) then flush_next n else if n . is_end then ( n . state <- End ; ` End ) else ( n . state <- Boundary ; ` Await ) | Start | Boundary | Acc -> ` Await | End -> ` End end n . is_end <- true ; begin match n . state with | Boundary -> n . state <- End ; ( n . uc :> ret ) | Acc -> n . state <- Flush ; flush_start n | Start -> n . state <- End ; ` End | Flush -> err_exp_await ` End | End -> err_ended ` End end |
let string_X ppf s = Format . pp_open_vbox ppf 1 ; string ppf " " " ; \ for i = 0 to String . length s - 1 do if i mod 16 = 0 && i > 0 then pf ppf " \\@\ n " ; pf ppf " \\ x % 02x " ( Char . code s . [ i ] ) done ; string ppf " " " ; \ Format . pp_close_box ppf ( ) |
let string_XN ppf = function " " -> string ppf " snil " | x -> string_X ppf x |
let semi ppf ( ) = string ppf " ; " ; sp ppf ( ) |
let iter i ( ? sep = sp ) pp ppf x = let fst = ref true in i ( fun v -> ( if ! fst then fst := false else sep ppf ( ) ) ; pp ppf v ) x |
let as_array i pp ppf = pf ppf " [ @< 2 [ >|% a ] ] " |@ ( iter i ~ sep : semi pp ) |
let array pp = as_array Array . iter pp |
let array_N pp ppf = function [ ] || -> string ppf " nil " | x -> array pp ppf x |
module R = struct type _ record = | [ ] : unit record | ( ) :: : ( string * ( Format . formatter -> ' a -> unit ) ) * ' b record -> ( ' a -> ' b ) record end |
let record record ppf = let field name pp_v ppf v = pf ppf " [ @< 1 >% s =@ % a ] " @ name pp_v v in let open R in let rec go : type a . ( unit -> unit ) -> a R . record -> a = fun k -> function | [ ] -> pf ppf " [ @< 2 { > % a } ] " @ ( fun _ -> k ) ( ) | [ name , pp_v ] -> fun v -> go ( fun ( ) -> k ( ) ; field name pp_v ppf v ) [ ] | ( name , pp_v ) :: record -> fun v -> go ( fun ( ) -> k ( ) ; field name pp_v ppf v ; semi ppf ( ) ) record in go ignore record |
type ' a t = { default : ' a ; l0 : ' a array array array } |
let get m u = let l1 = Array . unsafe_get m . l0 ( u lsr l0_shift ) in if l1 == nil then m . default else let l2 = Array . unsafe_get l1 ( u lsr l1_shift land l1_mask ) in if l2 == nil then m . default else Array . unsafe_get l2 ( u land l2_mask ) |
let create default = { default ; l0 = Array . make l0_size nil } |
let set m u v = if v = m . default then ( ) else let i = u lsr l0_shift in if m . l0 . ( i ) == nil then m . l0 . ( i ) <- Array . make l1_size nil ; let j = u lsr l1_shift land l1_mask in if m . l0 . ( i ) . ( j ) == nil then m . l0 . ( i ) . ( j ) <- Array . make l2_size m . default ; m . l0 . ( i ) . ( j ) . ( u land l2_mask ) <- v |
let size v_size m = match m . l0 with let size = ref ( 3 + v_size m . default + 1 + Array . length l0 ) in for i = 0 to Array . length l0 - 1 do match l0 . ( i ) with | [ ] || -> ( ) | l1 -> size := ! size + ( 1 + Array . length l1 ) ; for j = 0 to Array . length l1 - 1 do match l1 . ( j ) with | [ ] || -> ( ) | l2 -> size := ! size + ( 1 + Array . length l2 ) ; for k = 0 to Array . length l2 - 1 do size := ! size + v_size l2 . ( k ) done ; done ; done ; ! size |
let dump pp_v ppf m = let open Uunf_fmt in record [ " default " , pp_v ; " l0 " , pp_v |> array_N |> array_N |> array ] ppf m . default m . l0 |
type t = { default : bool ; l0 : string array array } |
let get m u = let l1 = Array . unsafe_get m . l0 ( u lsr l0_shift ) in if l1 == nil then m . default else let l2 = Array . unsafe_get l1 ( u lsr l1_shift land l1_mask ) in if l2 == snil then m . default else let k = u land l2_mask in let byte_num = k lsr 3 in let bit_num = k land 7 in let byte = Char . code ( String . unsafe_get l2 byte_num ) in byte land ( 1 lsl bit_num ) > 0 |
let create default = { default ; l0 = Array . make l0_size nil } |
let set m u b = let l2_make m = Bytes . make l2_size ( if m . default then ' \ xFF ' else ' \ x00 ' ) in if b = m . default then ( ) else let i = u lsr l0_shift in if m . l0 . ( i ) == nil then m . l0 . ( i ) <- Array . make l1_size snil ; let j = u lsr l1_shift land l1_mask in if m . l0 . ( i ) . ( j ) == snil then m . l0 . ( i ) . ( j ) <- Bytes . unsafe_to_string ( l2_make m ) ; let k = u land l2_mask in let byte_num = k lsr 3 in let bit_num = k land 7 in let byte = Char . code m . l0 . ( i ) . ( j ) . [ byte_num ] in let new_byte = if b then ( Char . unsafe_chr ( byte lor ( 1 lsl bit_num ) ) ) else ( Char . unsafe_chr ( byte land lnot ( 1 lsl bit_num ) ) ) in Bytes . set ( Bytes . unsafe_of_string m . l0 . ( i ) . ( j ) ) byte_num new_byte |
let size m = match m . l0 with let size = ref ( 3 + 1 + Array . length l0 ) in for i = 0 to Array . length l0 - 1 do match l0 . ( i ) with | [ ] || -> ( ) | l1 -> size := ! size + 1 + Array . length l1 ; for j = 0 to Array . length l1 - 1 do size := ! size + 1 + ( ( String . length l1 . ( j ) * 8 ) / Sys . word_size ) done ; done ; ! size |
let iter_blobs i m = Array . ( iter ( iter i ) ) m . l0 |
let dump_pp pp_v ppf m = let open Uunf_fmt in record [ " default " , bool ; " l0 " , pp_v |> array_N |> array ] ppf m . default m . l0 |
let dump = dump_pp pp_v |
type t = { default : int ; l0 : string array array } |
let get m u = let l1 = Array . get m . l0 ( u lsr l0_shift ) in if l1 == nil then m . default else let l2 = Array . unsafe_get l1 ( u lsr l1_shift land l1_mask ) in if l2 == snil then m . default else Char . code ( String . unsafe_get l2 ( u land l2_mask ) ) |
let create default = { default ; l0 = Array . make l0_size nil } |
let set m u byte = let l2_make m = Bytes . make l2_size ( Char . chr m . default ) in if byte = m . default then ( ) else let i = u lsr l0_shift in if m . l0 . ( i ) == nil then m . l0 . ( i ) <- Array . make l1_size snil ; let j = u lsr l1_shift land l1_mask in if m . l0 . ( i ) . ( j ) == snil then m . l0 . ( i ) . ( j ) <- Bytes . unsafe_to_string ( l2_make m ) ; let k = u land l2_mask in Bytes . set ( Bytes . unsafe_of_string m . l0 . ( i ) . ( j ) ) k ( Char . unsafe_chr byte ) |
let size m = match m . l0 with let size = ref ( 3 + 1 + Array . length l0 ) in for i = 0 to Array . length l0 - 1 do match l0 . ( i ) with | [ ] || -> ( ) | l1 -> size := ! size + 1 + Array . length l1 ; for j = 0 to Array . length l1 - 1 do size := ! size + 1 + ( ( String . length l1 . ( j ) * 8 ) / Sys . word_size ) done ; done ; ! size |
let iter_blobs i m = Array . ( iter ( iter i ) ) m . l0 |
let dump_pp pp_v ppf m = let open Uunf_fmt in record [ " default " , int ; " l0 " , pp_v |> array_N |> array ] ppf m . default m . l0 |
let dump = dump_pp pp_v |
let invalid_encode ( ) = invalid_arg " expected ` Await encode " |
let invalid_bounds j l = invalid_arg ( Printf . sprintf " invalid bounds ( index % d , length % d ) " j l ) |
let unsafe_byte s j = Char . code ( Bytes . unsafe_get s j ) |
let unsafe_set_byte s j byte = Bytes . unsafe_set s j ( Char . unsafe_chr byte ) |
let u_bom = Uchar . unsafe_of_int 0xFEFF |
let u_rep = Uchar . unsafe_of_int 0xFFFD |
type encoding = [ ` UTF_8 | ` UTF_16 | ` UTF_16BE | ` UTF_16LE ] |
type decoder_encoding = [ encoding | ` US_ASCII | ` ISO_8859_1 ] |
let encoding_of_string s = match String . uppercase_ascii s with Some ` US_ASCII Some ` ISO_8859_1 |
let malformed s j l = ` Malformed ( Bytes . sub_string s j l ) |
let malformed_pair be hi s j l = let bs1 = Bytes . ( sub s j l ) in let bs0 = Bytes . create 2 in let j0 , j1 = if be then ( 0 , 1 ) else ( 1 , 0 ) in unsafe_set_byte bs0 j0 ( hi lsr 8 ) ; unsafe_set_byte bs0 j1 ( hi land 0xFF ) ; ` Malformed Bytes . ( unsafe_to_string ( cat bs0 bs1 ) ) |
let r_us_ascii s j = let b0 = unsafe_byte s j in if b0 <= 127 then ` Uchar ( Uchar . unsafe_of_int b0 ) else malformed s j 1 |
let r_iso_8859_1 s j = ` Uchar ( Uchar . unsafe_of_int @@ unsafe_byte s j ) |
let utf_8_len = [ | 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 4 ; 4 ; 4 ; 4 ; 4 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ] | |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.