| ( * ) [Bap.Std.Bil.Infix] | |
| ( * ) [Bap.Std.Integer] | |
| (!$) [Bap.Std.Bitvector.Int_err] | !$v lifts v to an Or_error monad.
|
| (!) [Bap.Std.Tid] |
infix notation for
from_string_exn
|
| (%$) [Bap.Std.Bil.Infix] | |
| (+) [Bap.Std.Bil.Infix] |
Arithmetic operations
|
| (+) [Bap.Std.Integer] | |
| (++) [Bap.Std.Bitvector] | a ++ n is nsucc a n
|
| (-) [Bap.Std.Bil.Infix] | |
| (-) [Bap.Std.Integer] | |
| (--) [Bap.Std.Bitvector] | a -- n is npred a n
|
| (/$) [Bap.Std.Bil.Infix] | |
| (/) [Bap.Std.Bil.Infix] | |
| (/) [Bap.Std.Integer] | |
| (:=) [Bap.Std.Bil.Infix] | |
| (<$) [Bap.Std.Bil.Infix] | |
| (<) [Bap.Std.Bil.Infix] | |
| (<=$) [Bap.Std.Bil.Infix] | |
| (<=) [Bap.Std.Bil.Infix] | |
| (<>) [Bap.Std.Bil.Infix] | |
| (=) [Bap.Std.Bil.Infix] |
Equality tests
|
| (>$) [Bap.Std.Bil.Infix] | |
| (>) [Bap.Std.Bil.Infix] | |
| (>=$) [Bap.Std.Bil.Infix] | |
| (>=) [Bap.Std.Bil.Infix] | |
| (@.) [Bap.Std.Bitvector] | b1 @. b2 is concat b1 b2
|
| (^!) [Bap.Std.Memory] | m^.n dereferences a byte at address n
|
| (^) [Bap.Std.Memory] | m^n dereferences a byte at address n
|
| (^) [Bap.Std.Bil.Infix] | a ^ b contatenate a and b
|
| (^::) [Bap.Std] | x ^:: xs is a consing operator for sequences
|
| (asr) [Bap.Std.Bil.Infix] | |
| (asr) [Bap.Std.Integer] | |
| (land) [Bap.Std.Bil.Infix] | |
| (land) [Bap.Std.Integer] | |
| (lor) [Bap.Std.Bil.Infix] | |
| (lor) [Bap.Std.Integer] | |
| (lsl) [Bap.Std.Bil.Infix] |
Bit operations
|
| (lsl) [Bap.Std.Integer] | |
| (lsr) [Bap.Std.Bil.Infix] | |
| (lsr) [Bap.Std.Integer] | |
| (lxor) [Bap.Std.Bil.Infix] | |
| (lxor) [Bap.Std.Integer] | |
| (mod) [Bap.Std.Bil.Infix] | |
| (mod) [Bap.Std.Integer] | |
| (~-) [Bap.Std.Integer] |
A common set of infix operators
|
A | |
| abs [Bap.Std.Integer] | |
| add [Bap.Std.Memmap] | add map mem tag adds a new memory region mem tagged with
tag .
|
| add [Bap.Std.Table] | add table mem v returns a new table with added mapping from a
mem region mem to a data value v
|
| add [Bap.Std.Dict] | add map tag x adds new value
|
| add [Bap.Std.Integer] | |
| add [Bap.Std.Trie] | add trie ~key ~data adds data associated with key , if
trie already has some data associated with the key , then
it will be overwritten
|
| add_arg [Bap.Std.Sub.Builder] | |
| add_blk [Bap.Std.Sub.Builder] |
appends an argument
|
| add_def [Bap.Std.Blk.Builder] |
appends a definition
|
| add_elt [Bap.Std.Blk.Builder] |
returns current result
|
| add_jmp [Bap.Std.Blk.Builder] |
appends a phi node
|
| add_phi [Bap.Std.Blk.Builder] |
appends generic element
|
| add_sub [Bap.Std.Program.Builder] | add_sub builder sub appends a subroutine term to the
program.
|
| add_symbol [Bap.Std.Symtab] | add_symbol table name entry blocks extends table with a
new symbol with a given name , entry block and body
blocks .
|
| addr [Bap.Std.Block_accessors] | |
| addr [Bap.Std.Disasm_expert.Basic] |
current position of the disassembler
|
| addr_of_int [Bap.Std.Size] | addr_of_int n return Ok `rn if `rn exists, Error
otherwise.
|
| addr_of_int_exn [Bap.Std.Size] | addr_of_int_exn n the same as addr_of_int , but raises exception
instead of returning Error
|
| addr_of_int_opt [Bap.Std.Size] | addr_of_int_opt n the same as addr_of_int but uses option type
instead of Or_error.t
|
| addr_of_pc [Bap.Std.CPU] | addr_of_pc mem given a memory region, representing some
instruction, return a value to which a PC register is set when
this instruction is executed by CPU.
|
| addr_of_word_size [Bap.Std.Size] | |
| addr_size [Bap.Std.Image] | |
| addr_size [Bap.Std.Arch] | addr_size arch returns an address size for a given arch
|
| after [Bap.Std.Term] | after t ?rev p tid returns all subterms in term p that
occur after a term with a given tid .
|
| ancestors [Bap.Std.Tree] | ancestors tree n returns a sequence of all ancestors of node
n .
|
| append [Bap.Std.Term] | append t ~after:this p c returns the p term with c
appended after this term.
|
| append [Bap.Std.Vector] | append xs x appends x to the end of xs
|
| arch [Bap.Std.Project] | arch project reveals the architecture of a loaded file
|
| arch [Bap.Std.Image] | |
| arg_t [Bap.Std] |
arg
|
| arshift [Bap.Std.Bil] | |
| arshift [Bap.Std.Integer] | |
| asm [Bap.Std.Insn] |
target-specific assembler string representing the instruction
|
| asm [Bap.Std.Disasm_expert.Basic.Insn] | |
| at_least_one [Bap.Std.Table] | |
B | |
| b0 [Bap.Std.Bitvector] | b0 = of_bool false is a zero bit
|
| b1 [Bap.Std.Bitvector] | |
| back [Bap.Std.Disasm_expert.Basic] |
restarts last step.
|
| backward [Bap.Std.Isomorphism] | |
| base [Bap.Std.Var] | base var returns an original variable.
|
| before [Bap.Std.Term] | before t ?rev p tid returns all term that occurs before
defintion with given tid in blk.
|
| bil [Bap.Std.Insn] |
returns BIL program specifying instruction semantics
|
| binop [Bap.Std.Bil] | |
| bit_and [Bap.Std.Bil] | |
| bit_or [Bap.Std.Bil] | |
| bit_xor [Bap.Std.Bil] | |
| bitwidth [Bap.Std.Bitvector] | bitwidth bv return a bit-width, i.e., the amount of bits
|
| blk_t [Bap.Std] |
blk
|
| block [Bap.Std.Disasm] |
start of basic block
|
| blocks [Bap.Std.Disasm_expert.Recursive] | |
| blocks [Bap.Std.Disasm] |
returns a mapping from memory regions to basic blocks.
|
| bool_t [Bap.Std] |
one bit
|
C | |
| cast [Bap.Std.Bil] | |
| cf [Bap.Std.CPU] | |
| cf [Bap.Std.ARM.CPU] | |
| change [Bap.Std.Label] |
updates the label
|
| change [Bap.Std.Term] | change t p id f if p contains subterm with of a given kind
t and identifier id , then apply f to this
subterm.
|
| change [Bap.Std.Table] | change tab mem ~f function f is applied to a set of all memory
regions that intersects with mem .
|
| change [Bap.Std.Dict] | change map tag f changes value.
|
| change [Bap.Std.Trie] | change trie key f if trie has data associated with key then
f will be called with Some data , otherwise it will be called
with None .
|
| children [Bap.Std.Tree] | children tree x returns all immediate successors of node
x .
|
| clone [Bap.Std.Term] | clone term creates an object with a fresh new identifier
that has the same contents as term , i.e., that is
syntactically the same.
|
| code [Bap.Std.Disasm_expert.Basic.Insn] | |
| code [Bap.Std.Reg] |
unique number representig a register
|
| color [Bap.Std] |
Color something with a color
|
| comment [Bap.Std] |
A human readable comment
|
| compare [Bap.Std.Disasm_expert.Basic.Insn] | |
| compare [Bap.Std.Op.Normalized] | |
| compare [Bap.Std.Graphlib] | compare (module G1) (module G2) g1 g2 compares two graphs,
with different implementation but the same node type.
|
| compare [Bap.Std.Seq] | |
| compare_ops [Bap.Std.Op.Normalized] | |
| compare_with [Bap.Std.Memory] | compare_with mem addr compares memory with addr
|
| concat [Bap.Std.Bil] | |
| concat [Bap.Std.Bitvector] | concat b1 b2 concatenates two bitvectors
|
| concat_map [Bap.Std.Term] | concat_map t p ~f substitute subterm c of type t in
parent term p with f c .
|
| cond [Bap.Std.Jmp] | cond jmp returns the jump guard condition
|
| cond [Bap.Std.Graphlib.Ir.Edge] | cond e g computes a condition expression that is
asserted to be true if this branch is taken.
|
| cons [Bap.Std.Seq] | |
| contains [Bap.Std.Memmap] | contains map addr true if there exists such memory region mem ,
that Memory.contains mem addr
|
| contains [Bap.Std.Memory] | contains mem addr returns true if mem contains address addr
|
| count [Bap.Std.Table] | |
| count [Bap.Std.Memory_iterators] | |
| cpsr [Bap.Std.ARM.CPU] | |
| cpuexn [Bap.Std.Bil] | |
| create [Bap.Std.Byteweight.S] | |
| create [Bap.Std.Dwarf.Fbi] | create data tries to create a DWARF reader, from
supplied data .
|
| create [Bap.Std.Dwarf.Data] | create endian sections creates data representation from a assoc list
of sections.
|
| create [Bap.Std.Dwarf.Buffer] | |
| create [Bap.Std.Label] | create () creates a new label with a freshly generated
identifier.
|
| create [Bap.Std.Call] | create ?return ~target () creates a call to the target
subroutine.
|
| create [Bap.Std.Arg] | create ?intent var exp creates an argument.
|
| create [Bap.Std.Phi] | create var label exp creates a phi-node that associates a
variable var with an expression exp .
|
| create [Bap.Std.Jmp] | create ?cond kind creates a jump of given kind
|
| create [Bap.Std.Def] | create ?tid x exp creates definition x := exp
|
| create [Bap.Std.Blk.Builder] | create ~tid ~phis ~defs ~jmp () creates a block builder.
|
| create [Bap.Std.Blk] | create () creates a new empty block.
|
| create [Bap.Std.Sub.Builder] |
appends a block to a subroutine
|
| create [Bap.Std.Sub] | create ?name () creates an empty subroutine with an optional
name.
|
| create [Bap.Std.Program.Builder] | |
| create [Bap.Std.Program] | create ?tid () creates an empty program.
|
| create [Bap.Std.Tid] | create () creates a fresh newly term identifier
|
| create [Bap.Std.ARM.Cond] |
decodes condition value from a word
|
| create [Bap.Std.ARM.Op] |
lifts operand from a basic one
|
| create [Bap.Std.ARM.Reg] |
lifts basic register to a ARM one
|
| create [Bap.Std.ARM.Insn] | create basic_insn lifts ARM instruction from a basic instruction
|
| create [Bap.Std.ABI] |
creates a set of ABI for the provided symbol.
|
| create [Bap.Std.Disasm_expert.Basic] | create ?debug_level ?cpu ~backend target creates a disassembler
for the specified target .
|
| create [Bap.Std.Image] | create ?backend filename creates an image of the file specified
specified by the filename .
|
| create [Bap.Std.Memory] | |
| create [Bap.Std.Graphlib.Callgraph] | |
| create [Bap.Std.Edge] | create x y l creates an edge connecting nodes x and y
labeled with a given label l
|
| create [Bap.Std.Node] | create label creates a new node, and associates it with a
given label .
|
| create [Bap.Std.Graphlib] | create (module G) ~nodes ~edges () creates a graph using
implementation provided by module G .
|
| create [Bap.Std.Vector] | create ?capacity default creates an empty vector with a given
capacity .
|
| create [Bap.Std.Value] | create cons x creates a value using constructor cons and
argument x
|
| create [Bap.Std.Var] | create ?tmp name typ creates a variable with associated
name and type typ .
|
| create [Bap.Std.Trie] | create () creates new empty trie
|
| create_bound [Bap.Std.Symtab] | create_bound syms fn creates a predicate that returns true
for all addresses that belongs to function f .
|
| create_call [Bap.Std.Jmp] | create_call ?cond target transfer control to subroutine
target
|
| create_goto [Bap.Std.Jmp] | create_goto ?cond label local jump
|
| create_int [Bap.Std.Jmp] | create_int ?cond int_number return call interrupt subroutine
|
| create_ret [Bap.Std.Jmp] | create_ret ?cond label return from a procedure
|
D | |
| data [Bap.Std.Dwarf.Buffer] | data pos actual data.
|
| data [Bap.Std.Image] | |
| data [Bap.Std.Dict] | data dict is a sequence of all dict elements
|
| def_t [Bap.Std] |
def
|
| default_path [Bap.Std.Signatures] | |
| defines_var [Bap.Std.Blk] | defines_var blk x true if there exists such phi term or def
term with left hand side equal to x
|
| degree [Bap.Std.Node] | degree ?dir n when in_or_out is `In then returns
the amount of incomming edges, otherwise returns the amount of
outcomming edges.
|
| del_attr [Bap.Std.Term] | del_attr term attr deletes attribute attr from term
|
| depth_first_search [Bap.Std.Graphlib] | depth_first_search (module G) ~init g .
|
| depth_first_visit [Bap.Std.Graphlib] | depth_first_visit (module G) ~init visitor g allows to
specify visiting functions using object.
|
| descendants [Bap.Std.Tree] | descendants tree n returns a set of all descendants of a
given node n .
|
| deserialize [Bap.Std.Var.V1] | |
| dests [Bap.Std.Block_traverse] | dests blk block immediate destinations including unresolved
one.
|
| direct [Bap.Std.Label] | direct label creates a direct label with a given identifier.
|
| disasm [Bap.Std.Project] | disasm project returns results of disassembling
|
| disassemble [Bap.Std] | disassemble ?roots arch mem disassemble provided memory region
mem using best available algorithm and backend for the specified
arch .
|
| disassemble_file [Bap.Std] | disassemble_file ?roots path takes a path to a binary and
disassembles it
|
| disassemble_file_exn [Bap.Std] | disassemble_file ?roots path takes a path to a binary and
disassembles it
|
| disassemble_image [Bap.Std] | disassemble_image image disassemble given image.
|
| div [Bap.Std.Integer] | |
| divide [Bap.Std.Bil] | |
| dom_frontier [Bap.Std.Graphlib] | dom_frontier (module G) g dom_tree calculates dominance
frontiers for all nodes in a graph g .
|
| dominates [Bap.Std.Memmap] | dominates map mem if there is a non empty set of dominators
|
| dominators [Bap.Std.Memmap] | dominators map mem an ordered sequence of all memory regions,
containing mem .
|
| dominators [Bap.Std.Graphlib] | dominators (module G) g entry builds a dominators tree for a
given graph.
|
| dst [Bap.Std.Edge] | dst e returns a destination of an edge e
|
E | |
| edge [Bap.Std.Predicate] | |
| edge [Bap.Std.Node] | edge x y g if graph g has an edge between nodes x and
y then it is returned.
|
| edges [Bap.Std.Graphlib.Ir.Edge] | edges dir e g enumerates all edges occurring before of
after an edge e in graph g
|
| edges [Bap.Std.Graph] | edges g returns all edges of graph g in an unspecified order
|
| edges [Bap.Std.Path] | edges p a sequence of edges from start to finish
|
| edges_rev [Bap.Std.Path] | edges_rev p a reversed sequence from finish to start
|
| elements [Bap.Std.Table] | regions table returns in an ascending order of addresses all
elements mapped in a table
|
| elts [Bap.Std.Blk] | elts ~rev blk return all elements of the blk .
|
| empty [Bap.Std.Memmap] | empty map
|
| empty [Bap.Std.Table] |
creates an empty table
|
| empty [Bap.Std.Graph] | empty is an empty graph
|
| empty [Bap.Std.Dict] |
an empty instance
|
| endian [Bap.Std.Dwarf.Data] | endian data the endianness of data
|
| endian [Bap.Std.Image] | |
| endian [Bap.Std.Memory] |
returns the order of bytes in a word
|
| endian [Bap.Std.Arch] | endian arch returns a word endianness of the arch
|
| entry_of_fn [Bap.Std.Symtab] | entry_of_fn fn returns an entry block of a given function fn
|
| entry_point [Bap.Std.Image] | |
| enum [Bap.Std.Term] | enum ?rev t p enumerate all subterms of type t of the
given term p
|
| enum [Bap.Std.Group] | enum group enumerates all elements of a group, including the
designated one.
|
| enum [Bap.Std.Frontier] | enum f x enumerates frontier of x
|
| eq [Bap.Std.Bil] | |
| equiv [Bap.Std.Partition] | equiv p x y is true of x and y belongs to the same
equivalence class (i.e., to the same group).
|
| errors [Bap.Std.Disasm_expert.Recursive] | |
| errors [Bap.Std.Disasm] |
returns a list of all errors and warnings that occurred during
the disassembling
|
| exists [Bap.Std.Table] | |
| exists [Bap.Std.Memory_iterators] | |
| exists [Bap.Std.Stmt] | exists finder stmt is true iff find finder stmt <> None .
|
| exists [Bap.Std.Exp] | exists finder exp is true if finder finds
something.
|
| exists [Bap.Std.Bil] | exists finder bil returns true if finder finds
something.
|
| exps [Bap.Std.Jmp] | exps jmp returns a sequence of expressions occurring in
different positions of a jump jmp , e.g., in cond ,
target , etc.
|
| extract [Bap.Std.Bil] | |
| extract [Bap.Std.Bitvector] | extract bv ~hi ~lo extracts a subvector from bv , starting
from bit hi and ending with lo .
|
| extract_exn [Bap.Std.Bitvector] | extract_exn bv ~hi ~lo is the same as extract , but will raise
an exception on error.
|
F | |
| filename [Bap.Std.Image] | |
| filename [Bap.Std] |
A name of a file
|
| filter [Bap.Std.Term] | filter t p ~f returns a term p with subterms c for which
f c = false removed.
|
| filter [Bap.Std.Memmap] | filter map f returns a map that contains only those elements
for which f evaluated to true
|
| filter [Bap.Std.Table] |
removes all mappings that do not satisfy the predicate
|
| filter [Bap.Std.Seq] |
for compatibility with Core <= 111.28
|
| filter_map [Bap.Std.Term] | filter_map t p ~f returns term p with all subterms of type
t filter_mapped with function f , i.e., all terms for which
function f returned Some thing are substituted by the
thing , otherwise they're removed from the parent term
|
| filter_map [Bap.Std.Memmap] | filter_map m f creates a new map by applying a function f to
each tag.
|
| filter_map [Bap.Std.Table] | |
| filter_mapi [Bap.Std.Memmap] | filter_mapi is like filter_map but use function also accepts
would assosiated memory region
|
| filter_mapi [Bap.Std.Table] | |
| filtered [Bap.Std.Graphlib] | let module G' = filtered (module G) ?skip_node ?skip_edge ()
creates a new module G' that can be used at any place
instead of G , but that will hide nodes and edges, for which
functions skip_node and skip_edge return true.
|
| filteri [Bap.Std.Table] | |
| find [Bap.Std.Byteweight.Bytes] | |
| find [Bap.Std.Term] | find t p id is Some c if term p has a subterm of type t
such that tid c = id .
|
| find [Bap.Std.Table] | find table mem finds an element mapped to the memory region mem
|
| find [Bap.Std.Dict] | find map tag lookups value
|
| find [Bap.Std.Stmt] | find finder stmt performs a lookup into the Bil statement.
|
| find [Bap.Std.Exp] | find finder exp returns Some thing if finder finds some
thing .
|
| find [Bap.Std.Bil] | find finder bil search in bil using provided finder .
|
| find [Bap.Std.Trie] | find trie key finds data associated with key
|
| find_addr [Bap.Std.Table] | find_addr tab addr finds a memory region that contains a
specified addr
|
| find_by_name [Bap.Std.Symtab] | find_by_name symbols name finds a symbols with a given name
|
| find_by_start [Bap.Std.Symtab] | find_by_start symbols addr finds a symbol that starts from
a given address
|
| find_exn [Bap.Std.Term] | |
| find_if [Bap.Std.Table] | |
| find_if [Bap.Std.Memory_iterators] | |
| find_map [Bap.Std.Table] | |
| find_map [Bap.Std.Memory_iterators] | |
| find_mapi [Bap.Std.Table] | |
| find_var [Bap.Std.Blk] | find_var blk var finds a last definition of a variable var
in a block blk .
|
| finish [Bap.Std.Path] | finish p the last edge of a path p
|
| first [Bap.Std.Term] | first t p returns the first subterm of type t of a given
parent p
|
| first_byte [Bap.Std.Memory] | first_byte m returns first byte of m as a memory
|
| fixpoint [Bap.Std.Stmt] | fixpoint f x applies transformation f until it reaches
fixpoint.
|
| fixpoint [Bap.Std.Exp] | fixpoint f applies transformation f to t until it
reaches a fixpoint, i.e., such point x that
f x = f (f x) .
|
| fixpoint [Bap.Std.Bil] | fixpoint f applies transformation f until fixpoint is
reached.
|
| fns_of_addr [Bap.Std.Symtab] | fns_of_addr symbols addr return a list of functions that
owns addr
|
| fns_of_mem [Bap.Std.Symtab] | fns_of_mem syms mem returns a list of functions that
dominates over provided memory region mem
|
| fold [Bap.Std.Table] | |
| fold [Bap.Std.Memory_iterators] | |
| fold [Bap.Std.Stmt] | |
| fold [Bap.Std.Exp] | fold visitor ~init exp traverse the exp tree with
provided visitor .
|
| fold [Bap.Std.Bil] | fold visitor ~init bil folds visitor over BIL, passing init
value through the tree nodes.
|
| fold_consts [Bap.Std.Exp] | fold_consts performs one step of constant evaluation.
|
| fold_consts [Bap.Std.Bil] | fold_consts evaluate constant expressions.
|
| fold_intersections [Bap.Std.Table] | fold_intersections table mem folds over all regions
intersecting with mem
|
| fold_reachable [Bap.Std.Graphlib] | fold_reachable (module G) ?rev ~init ~f g n applies function
f to all nodes reachable from node g in graph g .
|
| foldi [Bap.Std.Table] | |
| foldi [Bap.Std.Memory_iterators] | |
| for_all [Bap.Std.Table] | |
| for_all [Bap.Std.Memory_iterators] | |
| forward [Bap.Std.Isomorphism] | |
| free_vars [Bap.Std.Phi] | free_vars t returns a set of variables that occur free on
the right hand side of the phi-node.
|
| free_vars [Bap.Std.Jmp] | free_vars jmp returns a set of all variables that are free
in some expression in the jump jmp .
|
| free_vars [Bap.Std.Def] | free_vars def returns a set of free variables, that occurs
on the right hand side of definition def .
|
| free_vars [Bap.Std.Blk] | free_vars blk returns a set of variables that occurs free
in block blk .
|
| free_vars [Bap.Std.Sub] | free_vars sub computes a set of variables that are free in a
given subroutine sub .
|
| free_vars [Bap.Std.Stmt] | free_vars stmt returns a set of all unbound variables, that
occurs in the stmt .
|
| free_vars [Bap.Std.Exp] | free_vars exp returns a set of all unbound variables, that
occurs in the expression exp .
|
| free_vars [Bap.Std.Bil] | free_vars bil returns a set of free variables in program
bil .
|
| from_bigstring [Bap.Std.Elf] | from_bigstring data parses data with optional offset
provided as pos and length as len
|
| from_bigstring [Bap.Std.Project] | from_bigstring arch bigstring is the same as Project.from_string
but accepts a value of type bigstring
|
| from_file [Bap.Std.Project] | from_file filename creates a project from a binary file.
|
| from_image [Bap.Std.Project] | from_image image is like Project.from_file but accepts already
loaded image of a binary file.
|
| from_insn [Bap.Std.Blk] | from_insn insn creates an IR representation of a single
machine instruction insn .
|
| from_mem [Bap.Std.Project] | from_mem arch mem creates a project directly from a memory
object.
|
| from_string [Bap.Std.Project] | from_string arch string creates a memory object from a
provided string and uses Project.from_mem to create a project.
|
| from_string [Bap.Std.Tid] | from_string s parses tid from string.
|
| from_string_exn [Bap.Std.Tid] | from_string_exn s same as from_string_exn but throws
exception on error.
|
| functions [Bap.Std.Dwarf.Fbi] | functions searcher enumerates functions
|
G | |
| ge [Bap.Std.ARM.CPU] | |
| get [Bap.Std.Project] | get project field returns the value of the field if it
exists
|
| get [Bap.Std.Memory] | get word_size mem addr reads memory value from the specified
address.
|
| get [Bap.Std.Vector] | get vec n like nth but raises exception if index is out of
bounds
|
| get [Bap.Std.Value] | get cons extracts a value associated with a constructor cons
(Essentially, performs a pattern match on the specified variant
branch)
|
| get_attr [Bap.Std.Term] | get_attr term attr returns a value of the given attr in
term
|
| get_exn [Bap.Std.Value] | get_exn t v extracts value created with t from the
variant.
|
| gpr [Bap.Std.CPU] |
A set of general purpose registers
|
| group [Bap.Std.Partition] | group p x returns a group of an element x .
|
| groups [Bap.Std.Partition] | groups p returns all partition cells of a partitioning p
|
H | |
| has [Bap.Std.Project] | has project field checks whether field exists or not.
|
| has_attr [Bap.Std.Term] | has_attr term attr is true if term has attribute attr
|
| has_edge [Bap.Std.Node] | has_edge x y g is true iff (x,y) ∈ E.
|
| has_intersections [Bap.Std.Table] | has_intersections tab mem is true iff some portion of mem is
is already mapped in tab .
|
| has_side_effect [Bap.Std.Insn] | has_side_effect is true if instruction may load or store
|
| hash [Bap.Std.Op.Normalized] | |
| hash [Bap.Std.Trie.Token] | |
| hexdump [Bap.Std.Memory] | hexdump t out outputs hexdump (as per hexdump -C ) of the
memory to formatter out
|
| high [Bap.Std.Bil] | |
I | |
| i1 [Bap.Std.Bitvector.Int_err] |
The following lifter will check that their operand has a
corresponding width.
|
| i16 [Bap.Std.Bitvector.Int_err] | |
| i32 [Bap.Std.Bitvector.Int_err] | |
| i4 [Bap.Std.Bitvector.Int_err] | |
| i64 [Bap.Std.Bitvector.Int_err] | |
| i8 [Bap.Std.Bitvector.Int_err] | |
| if_ [Bap.Std.Bil] | |
| indirect [Bap.Std.Label] | indirect exp creates a label that is resolved to an
expression exp
|
| infer_args [Bap.Std.Sub] | |
| init [Bap.Std.Blk.Builder] | init blk creates a builder based on an existing
block.
|
| inputs [Bap.Std.Node] | inputs node graph is incomming edges of a node in graph
|
| insert [Bap.Std.Edge] | insert e g returns a graph g' with a set of edges extended
with edge e .
|
| insert [Bap.Std.Node] | insert n g returns new graph g' that has a set of nodes
N extended with node n .
|
| insn [Bap.Std.Disasm] |
machine instruction
|
| insn_addr [Bap.Std.Disasm] |
address of instruction
|
| insn_at_addr [Bap.Std.Disasm] | insn_at_addr t addr finds instruction to which the addr
belongs.
|
| insn_at_mem [Bap.Std.Disasm] |
performs lookup for an instruction that occupies exactly
the given piece of memory.
|
| insn_of_mem [Bap.Std.Disasm_expert.Basic] | insn_of_mem dis mem performes a disassembly of one instruction
from the given memory region mem .
|
| insns [Bap.Std.Block_accessors] | insns blk returns a list of block instructions
|
| insns [Bap.Std.Disasm_expert.Basic] |
a queue of instructions disassembled in this step
|
| insns [Bap.Std.Disasm] |
returns all instructions that was successfully decoded in an
ascending order of their addresses.
|
| insns_at_mem [Bap.Std.Disasm] | insns_of_mem returns all instructions that occupies memory
regions that have intersections with mem .
|
| int [Bap.Std.Bil] | |
| int [Bap.Std.Bitvector.Int_err] | int w v will be Ok if v has width w
|
| int16 [Bap.Std.Memory.Input] | |
| int32 [Bap.Std.Memory.Input] | |
| int64 [Bap.Std.Memory.Input] | |
| int8 [Bap.Std.Memory.Input] | |
| intent [Bap.Std.Arg] | intent arg returns the argument intent.
|
| intersections [Bap.Std.Memmap] | intersections map mem an ordered sequence of all memory regions,
that intersects with mem .
|
| intersections [Bap.Std.Table] | intersections table mem returns all mappings in a table that
have intersections with mem
|
| intersects [Bap.Std.Memmap] | intersects map mem is true if intersections map mem is not empty
|
| is [Bap.Std.Disasm_expert.Basic.Insn] | |
| is [Bap.Std.Value] | is cons v true if value v was constructed with constructor
cons , i.e., it is true only when is_cons t (create t x)
|
| is_ancestor_of [Bap.Std.Tree] | is_ancestor_of tree child x returns true, if x is one of
the ancestors of a child node.
|
| is_assigned [Bap.Std.Bil] | is_assigned x p is true if there exists such Move
statement, that x occures on the left side of it.
|
| is_bp [Bap.Std.CPU] | |
| is_call [Bap.Std.Insn] | is_call is true for all call instructions
|
| is_cf [Bap.Std.CPU] | |
| is_child_of [Bap.Std.Tree] | is_child_of tree parent child returns true if child is one
of children tree root
|
| is_conditional_jump [Bap.Std.Insn] | is_conditional true for conditional jumps
|
| is_debug [Bap.Std.Image.Symbol] | |
| is_descendant_of [Bap.Std.Tree] | is_descendant_of ~parent tree x is true for all x that
are descendants of a parent node.
|
| is_directed [Bap.Std.Graph] | is_directed is true if graph is a directed graph.
|
| is_empty [Bap.Std.Dict] | is_empty map true if is empty.
|
| is_empty [Bap.Std.Seq] | |
| is_executable [Bap.Std.Image.Segment] | |
| is_flag [Bap.Std.CPU] | |
| is_function [Bap.Std.Image.Symbol] | |
| is_indirect_jump [Bap.Std.Insn] | is_indirect_jump true if it is indirect
|
| is_jump [Bap.Std.Insn] | is_jump true for all jumps
|
| is_mem [Bap.Std.CPU] | |
| is_nf [Bap.Std.CPU] | |
| is_one [Bap.Std.Bitvector] | is_ones bv is true if the least significant bit is equal to one
|
| is_pc [Bap.Std.CPU] | |
| is_reachable [Bap.Std.Graphlib] | is_reachable (module G) ?rev g u v is true if node v is
reachable from node u in graph g .
|
| is_readable [Bap.Std.Image.Segment] | |
| is_referenced [Bap.Std.Stmt] | is_referenced x stmt is true is x is used in the stmt
in any place other then right hand side of the assignment.
|
| is_referenced [Bap.Std.Exp] | is_referenced x exp true if exp contains Var x on one of
its leafs.
|
| is_referenced [Bap.Std.Bil] | is_referenced x p is true if x is referenced in some
expression or statement in program p , before it is
assigned.
|
| is_reg [Bap.Std.CPU] |
Predicates
|
| is_return [Bap.Std.Insn] | is_return true for returns
|
| is_sp [Bap.Std.CPU] | |
| is_ssa [Bap.Std.Sub] | is_ssa sub is true if sub was transformed into an SSA
form.
|
| is_tmp [Bap.Std.Var] | is_tmp true if variable is temporary
|
| is_unconditional_jump [Bap.Std.Insn] | is_unconditional iff is_jump && not is_conditional_jump
|
| is_vf [Bap.Std.CPU] | |
| is_writable [Bap.Std.Image.Segment] | |
| is_zero [Bap.Std.Bitvector] | is_zero bv is true iff all bits are set to zero.
|
| is_zf [Bap.Std.CPU] | |
| ite [Bap.Std.Bil] | |
| iter [Bap.Std.Table] | |
| iter [Bap.Std.Memory_iterators] | |
| iter [Bap.Std.Stmt] | iter visitor stmt iters over a stmt with a visitor.
|
| iter [Bap.Std.Exp] | iter visitor exp iterates over all terms of the exp using
provided visitor.
|
| iter [Bap.Std.Bil] | iter visitor bil apply a visitor for each node of a BIL
forest.
|
| iteri [Bap.Std.Table] | |
| iteri [Bap.Std.Memory_iterators] | |
| itstate [Bap.Std.ARM.CPU] | |
J | |
| jmp [Bap.Std.Graphlib.Ir.Edge] | jmp e returns a jmp term associated with edge e
|
| jmp [Bap.Std.Bil] | jmp t evaluate expression t to absolute address and
transfer control to that address
|
| jmp_t [Bap.Std] |
jmp
|
| jmps [Bap.Std.Graphlib.Ir.Edge] | jmps dir e g enumerates all jumps (including calls,
interrupts, indirects, etc), that occurs before if
dir = `before or after if dir = `after an edge e
|
| jump [Bap.Std.Disasm_expert.Basic] |
jump to the specified memory and continue disassembly in it.
|
K | |
| key_of_first_insns [Bap.Std.Disasm_expert.Basic.Trie] | key_of_first_insns state ~len:n creates a key from first n
instructions stored in the state if state contains such
amount of instructions
|
| key_of_insns [Bap.Std.Insn.Trie] | key_of_insns insns takes a list of instructions and transforms
it to key
|
| kind [Bap.Std.Jmp] | kind jmp evaluates to a kind of jump
|
| kinds [Bap.Std.Disasm_expert.Basic.Insn] | |
L | |
| label [Bap.Std.Edge] | label e returns a label of an edge e
|
| label [Bap.Std.Node] | label n returns a value associated with a node n .
|
| last [Bap.Std.Term] | last t p returns a last subterm of type t of a given
parent p
|
| last [Bap.Std.Disasm_expert.Basic] | last s n returns last n instructions disassembled in this
step.
|
| last_byte [Bap.Std.Memory] | |
| le [Bap.Std.Bil] | |
| leader [Bap.Std.Block_accessors] | leader blk the first instruction
|
| length [Bap.Std.Byteweight.S] | |
| length [Bap.Std.Term] | length t p returns an amount of terms of t class in a
parent term p
|
| length [Bap.Std.Table] | length table returns a number of entries in the table
|
| length [Bap.Std.Memory] | length returns the length of the memory in bytes
|
| length [Bap.Std.Path] |
amount of edges in a path
|
| length [Bap.Std.Trie.Key] | length key return the amount of tokens in a key
|
| length [Bap.Std.Trie] | length trie returns the amount of entries in the trie
|
| let_ [Bap.Std.Bil] | |
| lhs [Bap.Std.Arg] | lhs arg returns a variable associated with the argument.
|
| lhs [Bap.Std.Phi] | lhs phi returns a variable associated with a phi node
|
| lhs [Bap.Std.Def] |
returns the left hand side of a definition
|
| lift [Bap.Std.Target] | lift mem insn lifts provided instruction to BIL.
|
| lift [Bap.Std.Blk] | lift block takes a basic block of assembly instructions and
lifts it to a list of blk terms.
|
| lift [Bap.Std.Sub] | lift entry takes an basic block of assembler instructions,
as an entry and lifts it to the subroutine term.
|
| lift [Bap.Std.Program] | lift symbols takes a table of functions and return a whole
program lifted into IR
|
| lift [Bap.Std.AMD64] | |
| lift [Bap.Std.IA32] | |
| lift [Bap.Std.ARM] | |
| linear_sweep [Bap.Std] | linear_sweep arch mem will perform a linear sweep disassembly on
the specified memory mem
|
| linear_sweep_exn [Bap.Std] | linear_sweep_exn same as linear_sweep , but raises an
exception, instead of returning Or_error monad
|
| link [Bap.Std.Table] | |
| lnot [Bap.Std.Bil.Infix] | |
| lnot [Bap.Std.Integer] | |
| load [Bap.Std.Signatures] | |
| load [Bap.Std.Bil] | |
| logand [Bap.Std.Integer] | |
| logor [Bap.Std.Integer] | |
| logxor [Bap.Std.Integer] | |
| longest_match [Bap.Std.Trie] | longest_match trie k find the value associated with a
longest substring of a key k .
|
| look [Bap.Std.Byteweight.Corpus] | |
| lookup [Bap.Std.Program] | lookup t program id is like find but performs deep
lookup in the whole program for a term with a given id .
|
| lookup [Bap.Std.Memmap] | lookup map addr returns an ordered sequence of all memory
containing the addr
|
| low [Bap.Std.Bil] | |
| lr [Bap.Std.ARM.CPU] | |
| lshift [Bap.Std.Bil] | |
| lshift [Bap.Std.Integer] | |
| lt [Bap.Std.Bil] | |
M | |
| many [Bap.Std.Table] | 0..*
|
| map [Bap.Std.Term] | map t p ~f returns term p with all subterms of type t
mapped with function f
|
| map [Bap.Std.Memmap] | map m f returns a new map with each tag mapped
with function f
|
| map [Bap.Std.Table] | |
| map [Bap.Std.Exp] | map mapper exp maps exp tree using provided mapper .
|
| map [Bap.Std.Bil] | map mapper bil map or transform BIL program.
|
| map_exp [Bap.Std.Phi] | map_exp t ~f applies f to all expressions on the right
hand side of a phi-node t
|
| map_exp [Bap.Std.Jmp] | map_exp jmp ~f applies f to each expression in a jmp ,
e.g., conditions and indirect labels.
|
| map_exp [Bap.Std.Def] | map_exp def f applies f to a rhs of def and returns
an updated definition.
|
| map_exp [Bap.Std.Blk] | map_exp b ~f applies function f for each expression in
block b .
|
| map_lhs [Bap.Std.Blk] | map_lhs blk ~f applies f to every left hand side variable
in def and phi subterms of blk .
|
| map_to_array [Bap.Std.Vector] | map_to_array xs ~f copies data from xs to an array applying
f to each element.
|
| mapi [Bap.Std.Memmap] | mapi m f the same as map , but f is called with two
arguments: mem and tag , where mem is a memory region,
and tag is a tag assosiated with that region.
|
| mapi [Bap.Std.Table] | |
| mark [Bap.Std] |
Mark something as marked
|
| max [Bap.Std.Table] | max tab return the highest binding
|
| max_addr [Bap.Std.Memmap] | max_addr map is a maximum addr mapped in map
|
| max_addr [Bap.Std.Memory] | {max,min}_addr function specify upper and lower bounds of the memory
|
| max_binding [Bap.Std.Memmap] | max_binding map is a maximum binding mapped in map
|
| may_affect_control_flow [Bap.Std.Insn] | may_affect_control_flow is true if it may affect control flow.
|
| may_load [Bap.Std.Insn] | may_load is true if instruction may load data from memory
|
| may_store [Bap.Std.Insn] | may_store is true if instruction may store data to memory
|
| maybe_one [Bap.Std.Table] | 0..1
|
| mem [Bap.Std.CPU] |
Memory
|
| mem [Bap.Std.Table] | mem table mem is true if table contains mem region mem
|
| mem [Bap.Std.Edge] | mem e g is true if e ∈ E.
|
| mem [Bap.Std.Node] | mem n g is true if n is a member of nodes N of graph
g .
|
| mem [Bap.Std.Group] | mem group x checks membership of x in a given group.
|
| mem [Bap.Std.Frontier] | mem f x y is true if y is in a frontier of x
|
| mem [Bap.Std.Dict] | mem map tag checks membership
|
| mem32_t [Bap.Std] | mem32_t size creates a type for memory with 32 -bit addresses
and elements of size size .
|
| mem64_t [Bap.Std] | mem64_t size creates a type for memory with 64 -bit addresses
and elements of size size .
|
| memory [Bap.Std.Block_accessors] | memory blk memory region, occupied by a block
|
| memory [Bap.Std.Project] | memory t returns the memory as an interval tree marked with
arbitrary values.
|
| memory [Bap.Std.Disasm_expert.Basic] |
the memory region we're currently working on
|
| memory [Bap.Std.Image] |
returns memory, annotated with tags
|
| memory_of_fn [Bap.Std.Symtab] | memory_of_fn syms fn returns memory covered by function fn
|
| memory_of_segment [Bap.Std.Image] |
Mappings
|
| memory_of_symbol [Bap.Std.Image] | |
| memref [Bap.Std.Addr] | memref ?disp ?index ?scale base mimics a memory reference syntax
in gas assembler, dis(base,index,scale)
assembler operation.
|
| mems_of_insn [Bap.Std.Disasm] |
returns a sequence of memory regions occupied by the given
instruction.
|
| merge [Bap.Std.ABI] | merge abis create an abi that tries to take best from all
provided abi.
|
| merge [Bap.Std.Memory] | merge m1 m2 takes two memory regions, that either intersects or
share edges (i.e., difference between min_addr of one of the
blocks and max_addr of another is less then or equal to one, and
returns memory blocks that spans memory starting from the address
and ending with address
.
|
| merge_id [Bap.Std.ABI] | |
| min [Bap.Std.Table] | min tab return the lowest binding
|
| min_addr [Bap.Std.Memmap] | min_addr map is a minimum addr mapped in map
|
| min_addr [Bap.Std.Memory] | |
| min_binding [Bap.Std.Memmap] | min_binding map is a minimum binding mapped in map
|
| minus [Bap.Std.Bil] | |
| modulo [Bap.Std.Bil] | |
| modulo [Bap.Std.Integer] | |
| move [Bap.Std.Bil] | move v x evaluate x and assign its value to v
|
| mul [Bap.Std.Integer] | |
N | |
| name [Bap.Std.Sub] | name sub returns a subroutine name
|
| name [Bap.Std.Term] | name t returns a string representation of a term t identity
|
| name [Bap.Std.Tid] | name tid returns a term name: either a string name
with at-prefix, or number identifier.
|
| name [Bap.Std.Insn] |
returns backend specific name of instruction
|
| name [Bap.Std.Disasm_expert.Basic.Insn] | |
| name [Bap.Std.Reg] |
name of a register
|
| name [Bap.Std.Image.Symbol] | |
| name [Bap.Std.Image.Segment] | |
| name [Bap.Std.Value.Tag] | name cons returns a name of a constructor.
|
| name [Bap.Std.Var] | name var returns a name assosiated with variable
|
| name_of_fn [Bap.Std.Symtab] | name_of_fn fn returns symbol name
|
| neg [Bap.Std.Bil] | |
| neg [Bap.Std.Integer] | |
| neq [Bap.Std.Bil] | |
| next [Bap.Std.Byteweight.S] | |
| next [Bap.Std.Term] | next t p id returns a term that preceeds a term with a given
id , if such exists.
|
| next [Bap.Std.Table] | next table elt returns element next to elt , if any
|
| nf [Bap.Std.CPU] | |
| nf [Bap.Std.ARM.CPU] | |
| node [Bap.Std.Predicate] | |
| nodes [Bap.Std.Graph] | nodes g returns all nodes of graph g in an unspecified order
|
| normalize [Bap.Std.Bil.Trie] | normalize ?subst bil normalize BIL.
|
| normalize_negatives [Bap.Std.Exp] | normalize_negatives exp returns an exp where all negative
additions are substituted by subtractions.
|
| normalize_negatives [Bap.Std.Bil] | normalize_negatives p transform x + y to x - abs(y) if y < 0
|
| not [Bap.Std.Bil] | |
| npred [Bap.Std.Bitvector] | npred m n is Fn.apply_n_times ~n pred addr , but more
efficient.
|
| nsucc [Bap.Std.Bitvector] | nsucc m n is Fn.apply_n_times ~n succ m , but more
efficient.
|
| nth [Bap.Std.Term] | nth t p n returns n 'th t -term of parent p .
|
| nth [Bap.Std.Vector] | nth vec n returns n 'th element of vector vec
|
| nth_exn [Bap.Std.Term] | nth_exn t p n same as nth , but raises exception if n is
not a valid position number.
|
| nth_token [Bap.Std.Trie.Key] | nth_token key n the n 'th token of key.
|
| number_of_edges [Bap.Std.Graph] | number_of_edges g returns the size of a graph g .
|
| number_of_groups [Bap.Std.Partition] | number_of_groups p returns the amount of groups in a given
partitioning p .
|
| number_of_nodes [Bap.Std.Graph] | number_of_nodes g returns the order of a graph g
|
O | |
| occurs [Bap.Std.Blk] | occurs blk after:x def if def is occurs after definition
def in blk .
|
| of_array [Bap.Std.Seq] | |
| of_basic [Bap.Std.Insn] |
Creating
The following functions will create
insn instances from a lower
level representation.
|
| of_bigstring [Bap.Std.Image] | of_bigstring ?backend ~data creates an image from the specified
data .
|
| of_binary [Bap.Std.Bitvector] | of_binary ?width endian num creates a bitvector from a string
interpreted as a sequence of bytes in a specified order.
|
| of_bool [Bap.Std.Bitvector] | |
| of_cfg [Bap.Std.Sub] | of_cfg cfg extracts a sub term from a given graph cfg .
|
| of_equiv [Bap.Std.Partition] | of_equiv p n rebuilds a group from an equivalence class
ordinal number.
|
| of_file [Bap.Std.Memory] | |
| of_int [Bap.Std.Dwarf.Leb128] | |
| of_int [Bap.Std.Bitvector] | |
| of_int [Bap.Std.Size] | of_int n return Ok `rn if `rn exists, Error
otherwise.
|
| of_int32 [Bap.Std.Dwarf.Leb128] | |
| of_int32 [Bap.Std.Bitvector] | |
| of_int64 [Bap.Std.Dwarf.Leb128] | |
| of_int64 [Bap.Std.Bitvector] | |
| of_int_exn [Bap.Std.Size] | of_int_exn n the same as of_int , but raises exception
instead of returning Error
|
| of_int_opt [Bap.Std.Size] | of_int_opt n the same as of_int but uses option type
instead of Or_error.t
|
| of_list [Bap.Std.Phi] | of_list var bindings creates a phi-node, that for each pair
of label,exp in the bindings list associates variable var
with expression exp if control flow reaches this point via block
labeled with label .
|
| of_string [Bap.Std.Image] | of_string ?backend ~data creates an image from the specified
data .
|
| of_string [Bap.Std.Arch] | of_string s will try to be clever and to capture all
commonly known synonyms, e.g., of_string "i686" will
work
|
| of_string [Bap.Std.Bitvector] |
Constructors
|
| of_word_size [Bap.Std.Bitvector.Int_err] | of_word_size w creates a lifter for a specified word size
w , i.e.
|
| one [Bap.Std.Table] | 1..1
|
| one [Bap.Std.Integer] | |
| one [Bap.Std.Bitvector] | one width number one with a specified width , is a shortcut for
of_int 1 ~width
|
| ones [Bap.Std.Bitvector] | ones width is a number with a specified width , and all bits
set to 1.
|
| ops [Bap.Std.Insn] |
instruction operands
|
| ops [Bap.Std.Disasm_expert.Basic.Insn] | |
| outputs [Bap.Std.Node] | outputs node graph is outcomming edges of a node in graph
|
P | |
| parent [Bap.Std.Program] | parent t program id is Some p iff find t p id <> None
|
| parent [Bap.Std.Tree] | parent tree n returns an immediate parent of a given node.
|
| passes [Bap.Std.Project] | passes ?library () returns a transitive closure of all
passes registered in the system so far.
|
| passes_exn [Bap.Std.Project] | passes_exn proj is the same as Project.passes , but raises
an exception on error.
|
| pc [Bap.Std.CPU] |
Program counter.
|
| pc [Bap.Std.ARM.CPU] | |
| pc_hi [Bap.Std.Dwarf.Fn] | |
| pc_lo [Bap.Std.Dwarf.Fn] | |
| phi_t [Bap.Std] |
phi
|
| pkg_version [Bap.Std.Config] | |
| plus [Bap.Std.Bil] | |
| pos [Bap.Std.Dwarf.Buffer] | pos buf starting position
|
| postorder_traverse [Bap.Std.Graphlib] |
returns a sequence of nodes in post order
|
| pp [Bap.Std.Byteweight.S] | |
| pp [Bap.Std.Graphlib.Callgraph] | |
| pp [Bap.Std.Path] | pp pp_elt constructs a pretty based on element printer
pp_elt
|
| pp [Bap.Std.Frontier] | pp pp_elt instantiates a pretty-printer for a given
element.
|
| pp [Bap.Std.Tree] | pp pp_elt creates a pretty-printer for a node, based on
element's pretty-printer pp_elt .
|
| pp [Bap.Std.Value.S] | |
| pp [Bap.Std.Trie] | pp pp_val creates a printer for a given value printer
pp_val .
|
| pp [Bap.Std.Seq] | |
| pp_adt [Bap.Std.Insn] | pp_adt prints instruction in ADT format, suitable for reading
by evaluating in many languages, e.g.
|
| pp_adt [Bap.Std.Op] | |
| pp_adt [Bap.Std.Stmt] | |
| pp_adt [Bap.Std.Exp] | |
| pp_bools [Bap.Std.Seq] | |
| pp_chars [Bap.Std.Seq] | |
| pp_floats [Bap.Std.Seq] | |
| pp_ints [Bap.Std.Seq] | |
| pp_seq [Bap.Std.Printable] |
prints a sequence of values of type
t
|
| pp_strings [Bap.Std.Seq] | |
| ppo [Bap.Std.Printable] |
will print to a standard
output_channel , useful for using in
printf , fprintf , etc.
|
| pps [Bap.Std.Printable] |
synonym for
str
|
| pred [Bap.Std.Integer] | |
| pred [Bap.Std.Bitvector] | pred n returns a value preceding n
|
| preds [Bap.Std.Block_traverse] | preds blk block immediate predecessors in unspecified order.
|
| preds [Bap.Std.Disasm_expert.Basic] |
current set of predicates
|
| preds [Bap.Std.Node] | preds node graph returns a sequence of predecessors of a
node in a given graph
|
| prepend [Bap.Std.Term] | prepend t ~before:this p c returns the p with c inserted
before this term.
|
| prev [Bap.Std.Term] | next t p id returns a term that is after a term with a given
id , if such exists.
|
| prev [Bap.Std.Table] | next table elt returns element preceding to elt , if any
|
| program [Bap.Std.Project] | program project returns a program lifted into IR
|
| prune_unreferenced [Bap.Std.Bil] | prune_unreferenced p remove all assignments to variables that
are not used in the program p .
|
| python [Bap.Std] |
A command in python language
|
Q | |
| qf [Bap.Std.ARM.CPU] | |
R | |
| r [Bap.Std.AMD64.CPU] | |
| r [Bap.Std.IA32.CPU] | |
| r0 [Bap.Std.ARM.CPU] | |
| r1 [Bap.Std.ARM.CPU] | |
| r10 [Bap.Std.ARM.CPU] | |
| r11 [Bap.Std.ARM.CPU] | |
| r12 [Bap.Std.ARM.CPU] | |
| r2 [Bap.Std.ARM.CPU] | |
| r3 [Bap.Std.ARM.CPU] | |
| r4 [Bap.Std.ARM.CPU] | |
| r5 [Bap.Std.ARM.CPU] | |
| r6 [Bap.Std.ARM.CPU] | |
| r7 [Bap.Std.ARM.CPU] | |
| r8 [Bap.Std.ARM.CPU] | |
| r9 [Bap.Std.ARM.CPU] | |
| range [Bap.Std.Memory] | range mem a0 a1 returns a view on mem starting from
address a0 and ending at a1 , bounds inclusive
|
| rax [Bap.Std.IA32.CPU] | |
| rbp [Bap.Std.IA32.CPU] | |
| rbx [Bap.Std.IA32.CPU] | |
| rcx [Bap.Std.IA32.CPU] | |
| rdi [Bap.Std.IA32.CPU] | |
| rdx [Bap.Std.IA32.CPU] | |
| read [Bap.Std.Dwarf.Leb128] | |
| reconstruct [Bap.Std.Symtab] | reconstruct ?name ?roots cfg reconstructs symbols using a
whole program cfg .
|
| reg128_t [Bap.Std] |
128-bit width value
|
| reg16_t [Bap.Std] |
16-bit width value
|
| reg256_t [Bap.Std] |
256-bit width value
|
| reg32_t [Bap.Std] |
32-bit width value
|
| reg64_t [Bap.Std] |
64-bit width value
|
| reg8_t [Bap.Std] |
8-bit width value
|
| regions [Bap.Std.Table] | regions table returns in an ascending order of addresses all
memory regions mapped in a table
|
| register [Bap.Std.ABI] |
registers given ABI under the given target
|
| register [Bap.Std.Value.Tag] | |
| register_backend [Bap.Std.Image] | register_backend ~name backend tries to register backend under
the specified name .
|
| register_pass [Bap.Std.Project] | register_pass ?deps name pass registers project transformation,
that doesn't require command line arguments.
|
| register_pass' [Bap.Std.Project] | register_pass ?deps name pass registers pass that doesn't modify
the project effect and is run only for side effect.
|
| register_pass_with_args [Bap.Std.Project] | register_pass_with_args name pass registers pass that
requires command line arguments.
|
| register_pass_with_args' [Bap.Std.Project] | register_pass_with_args' name pass register a pass that
requires arguments for a side effect.
|
| remove [Bap.Std.Phi] | remove def id removes definition with a given id
|
| remove [Bap.Std.Term] | remove t p id returns a term that doesn't contain element
with the given id
|
| remove [Bap.Std.Symtab] | remove table fn removes symbol fn from table
|
| remove [Bap.Std.Memmap] | remove map mem removes all bindings to mem
|
| remove [Bap.Std.Table] |
returns a new table with all mappings from the mem region
mem removed
|
| remove [Bap.Std.Edge] | remove e g returns a graph g' that doesn't contain edge
e .
|
| remove [Bap.Std.Node] | remove n g returns graph g' , with a node n removed from
a set of nodes N .
|
| remove [Bap.Std.Dict] | remove map tag returns a map without a value associated
with tag
|
| remove [Bap.Std.Trie] | remove trie key removes value bound with key if any.
|
| remove_dominators [Bap.Std.Memmap] | remove_dominators map mem removes all bindings that are
dominators to mem
|
| remove_intersections [Bap.Std.Memmap] | remove_intersections map mem removes all bindings that
that intersects with mem
|
| renumber [Bap.Std.Var] | renumber var ver returns a variable, that is identical to
var , but with version equal to ver
|
| result [Bap.Std.Blk.Builder] | |
| result [Bap.Std.Sub.Builder] |
returns current result
|
| result [Bap.Std.Program.Builder] |
fixes the result
|
| return [Bap.Std.Call] |
returns call continuation
|
| rev_map [Bap.Std.Table] | rev_map arity t tab creates a reverse mapping from values of
typeclass t stored in table tab to memory regions.
|
| reverse_postorder_traverse [Bap.Std.Graphlib] |
returns a sequence of nodes in reverse post order.
|
| rhs [Bap.Std.Arg] | rhs arg returns an expression to which argument is
bound.
|
| rhs [Bap.Std.Def] | |
| rip [Bap.Std.IA32.CPU] | |
| rshift [Bap.Std.Bil] | |
| rshift [Bap.Std.Integer] | |
| rsi [Bap.Std.IA32.CPU] | |
| rsp [Bap.Std.IA32.CPU] | |
| run [Bap.Std.Disasm_expert.Recursive] | |
| run [Bap.Std.Disasm_expert.Basic] | run ?stop_on ?invalid ?stopped dis mem ~init ~return ~hit
performs recursive disassembly of specified memory mem .
|
| run_passes [Bap.Std.Project] | run_passes ?library ?argv project folds project over all
registered passes.
|
| run_passes_exn [Bap.Std.Project] | run_passes_exn proj is the same as Project.run_passes , but raises
an exception on error.
|
S | |
| same [Bap.Std.Term] | same x y returns true if x and y represents the same
entity, i.e., Tid.(tid x = tid y)
|
| same [Bap.Std.Value.Tag] | |
| same [Bap.Std.Var] | same x y compares variables ignoring versions, i.e.,
same x y iff equal (base x) (base y)
|
| same_witness [Bap.Std.Value.Tag] | |
| same_witness_exn [Bap.Std.Value.Tag] | |
| save [Bap.Std.Signatures] | |
| sdivide [Bap.Std.Bil] | |
| section [Bap.Std.Dwarf.Data] | section data lookups for a section in data
|
| section [Bap.Std.Image] | |
| section_name [Bap.Std.Elf] | section_name data elf section retrieves name of section
from data
|
| segment [Bap.Std.Image] |
Tags
|
| segment_of_symbol [Bap.Std.Image] | |
| segments [Bap.Std.Image] | |
| select [Bap.Std.Phi] | select phi label takes the value corresponding to a control
flow path marked with label .
|
| select_or_unknown [Bap.Std.Phi] | select_or_unknown phi label is exp if
select phi label = Some exp , otherwise returns a
Bil.unknown expression.
|
| serialize [Bap.Std.Var.V1] | |
| set [Bap.Std.Project] | set project field value sets a field to a give value.
|
| set [Bap.Std.Vector] | set vec n x sets n 'th element of a vector vec to x if
n < length vec then raises exception
|
| set [Bap.Std.Dict] | set map tag x inserts or update
|
| set_attr [Bap.Std.Term] | set_attr term attr value attaches an value to attribute
attr in term
|
| set_name [Bap.Std.Tid] | set_name tid name associates a name with a given
term identifier tid .
|
| sexp_of_t [Bap.Std.Disasm_expert.Basic.Insn] | |
| shell [Bap.Std] |
A command in shell language
|
| shortest_path [Bap.Std.Graphlib] | shortest_path (module G) ?weight ?rev g u v
Find a shortest path from node u to node v .
|
| signed [Bap.Std.Bil] | |
| signed [Bap.Std.Bitvector] | signed t casts t to a signed type, so that any operations
applied on t will be signed
|
| singleton [Bap.Std.Memmap] | singleton a memory map containing only one memory region
|
| singleton [Bap.Std.Table] |
creates a table containing one bindins
|
| size [Bap.Std.Dwarf.Leb128] | size leb return size in bytes of the number stored in LEB128
encoding.
|
| sle [Bap.Std.Bil] | |
| slt [Bap.Std.Bil] | |
| smodulo [Bap.Std.Bil] | |
| sp [Bap.Std.CPU] |
Stack pointer
|
| sp [Bap.Std.ARM.CPU] | |
| span [Bap.Std.Disasm] |
returns a blocks of memory that was visited during the
disassembly.
|
| special [Bap.Std.Bil] | |
| split_after [Bap.Std.Blk] | split_after blk def creates two new blocks, where the first
block contains all defintions up to def inclusive, the
second contains the rest.
|
| split_before [Bap.Std.Blk] | |
| split_bot [Bap.Std.Blk] | split_top blk returns two blocks, where first block shares
the same tid as blk , has all $\Phi$-nodes and definitions
from blk , but has only one destination, namely the second
block.
|
| split_top [Bap.Std.Blk] | split_top blk returns two blocks, where first block shares
the same tid as blk and has all $\Phi$-nodes of blk , but
has only one destination, namely the second block.
|
| split_while [Bap.Std.Blk] | split_while blk ~f splits blk into two block: the first
block holds all definitions for which f p is true and has
the same tid as blk .
|
| spsr [Bap.Std.ARM.CPU] | |
| src [Bap.Std.Edge] | src e returns a source of an edge e
|
| ssa [Bap.Std.Sub] | ssa sub returns sub in SSA form.
|
| start [Bap.Std.Path] | start p the starting edge of a path p
|
| step [Bap.Std.Disasm_expert.Basic] |
continue disassembling from the current point.
|
| stop [Bap.Std.Disasm_expert.Basic] |
stop the disassembly and return the provided value.
|
| store [Bap.Std.Bil] | |
| store_asm [Bap.Std.Disasm_expert.Basic] |
enables storing assembler information
|
| store_kinds [Bap.Std.Disasm_expert.Basic] |
enables storing instruction kinds information
|
| str [Bap.Std.Printable] | str () t is formatted output function that matches "%a"
conversion format specifier in functions, that prints to string,
e.g., sprintf , failwithf , errorf and, suprisingly all
Lwt printing function, including Lwt_io.printf and logging
(or any other function with type ('a,unit,string,...)
formatN`.
|
| string_of_section [Bap.Std.Elf] | string_of_section data section extracts the section data as
string from the provided data
|
| string_of_value [Bap.Std.Bitvector] | |
| strong_components [Bap.Std.Graphlib] | strong_components (module G) g partition graph into strongly
connected components.
|
| sub [Bap.Std.Integer] | |
| sub_t [Bap.Std] |
sub
|
| subroutine_addr [Bap.Std] |
Address of a subroutine entry point
|
| subroutine_name [Bap.Std] |
Name of a subroutine
|
| substitute [Bap.Std.Project] | substitute p region tag value is like
tag_memory, but it will also apply
substitutions in the provided string value, as per OCaml
standard library's Buffer.add_substitute function.
|
| substitute [Bap.Std.Phi] | substitute phi x y substitutes x by y in all right
hand-side expressions of the phi node.
|
| substitute [Bap.Std.Jmp] | substitute jmp x y substitutes x by y in all expressions
that occur in jump jmp expressions.
|
| substitute [Bap.Std.Def] | substitute def x y substitutes x by y in the right hand
side of a definition def
|
| substitute [Bap.Std.Blk] | substitute ?skip blk x y substitutes each occurrence of
expression x with expression y in block blk .
|
| substitute [Bap.Std.Bil] | substitute x y p substitutes each occurrence of expression x by
expression y in program p .
|
| substitute_var [Bap.Std.Bil] | substitute_var x y p substitutes all occurences of variable x
by expression y
|
| succ [Bap.Std.Integer] | |
| succ [Bap.Std.Bitvector] | succ n returns next value after n .
|
| succs [Bap.Std.Block_traverse] | succs blk block immediate successors in the order of
execution, .
|
| succs [Bap.Std.Node] | succs node graph returns a sequence of successors of a
node in a given graph
|
| symbol [Bap.Std.Image] | |
| symbols [Bap.Std.Project] | symbols t returns reconstructed symbol table
|
| symbols [Bap.Std.Image] | |
| symbols_of_segment [Bap.Std.Image] | |
T | |
| tag_memory [Bap.Std.Project] | tag_memory project region tag value tags given region of
memory in project with a given tag and value .
|
| tagname [Bap.Std.Value] | tagname value returns a constructor name of the value
|
| target [Bap.Std.Call] |
returns the target of the call
|
| target_addr [Bap.Std] |
The real virtual address of a target
|
| target_name [Bap.Std] |
Symbolic name of a target
|
| target_of_arch [Bap.Std] | target_of_arch arch returns a module packed into value, that
abstracts target architecture.
|
| terminator [Bap.Std.Block_accessors] | terminator blk last instruction of the block
|
| tid [Bap.Std.Term] | tid entity returns a unique identifier of the entity
|
| tid [Bap.Std.Graphlib.Ir.Edge] | tid e returns a tid of a jmp term that is associated
with an edge e
|
| times [Bap.Std.Bil] | |
| to_addr_size [Bap.Std.Size] | |
| to_bits [Bap.Std.Bitvector] | to_bits x order returns bits of x in a specified order .
|
| to_bits [Bap.Std.Size] | to_bits size returns the number of bits.
|
| to_buffer [Bap.Std.Memory] | to_buffers mem creates a buffer representing the memory mem .
|
| to_bytes [Bap.Std.Bitvector] | to_bytes x order returns bytes of x in a specified order .
|
| to_bytes [Bap.Std.Size] | |
| to_cfg [Bap.Std.Sub] | to_cfg sub builds a graph representation of a subroutine
sub .
|
| to_chars [Bap.Std.Bitvector] | |
| to_dot [Bap.Std.Graphlib] | to_dot (module G) ~filename:"graph.dot" g dumps graph g
using dot format.
|
| to_equiv [Bap.Std.Group] | to_equiv g returns the ordinal number representing the
particular group g
|
| to_float [Bap.Std.Fmm] | |
| to_graph [Bap.Std.Sub] | to_graph sub builds a graph of subroutine sub .
|
| to_graph [Bap.Std.Program] | to_graph program creates a callgraph of a program
|
| to_graph [Bap.Std.Block] | to_graph ?bound entry builds a graph starting with entry and
spanning all reachable blocks.
|
| to_int [Bap.Std.Dwarf.Leb128] | |
| to_int [Bap.Std.Imm] | |
| to_int [Bap.Std.Equiv] | |
| to_int [Bap.Std.Bitvector] |
Conversions to built-in integers
|
| to_int32 [Bap.Std.Dwarf.Leb128] | |
| to_int32 [Bap.Std.Bitvector] | |
| to_int64 [Bap.Std.Dwarf.Leb128] | |
| to_int64 [Bap.Std.Imm] | |
| to_int64 [Bap.Std.Bitvector] | |
| to_sequence [Bap.Std.Term] | to_sequence ?rev t p is a synonym for enum .
|
| to_sequence [Bap.Std.Symtab] | to_sequence symtab returns a sequence of functions
|
| to_sequence [Bap.Std.Memmap] | to_sequence map converts the memmap 'a t to a sequence of
key-value pairs
|
| to_sequence [Bap.Std.Table] | to_sequence tab converts the table t to a
sequence of key-value pairs.
|
| to_sequence [Bap.Std.Frontier] | to_sequence frontier enumerates all elements of a frontier
|
| to_sequence [Bap.Std.Tree] | to_sequence tree enumerates nodes of a tree in an
unspecified order.
|
| to_string [Bap.Std.ABI] | |
| to_string [Bap.Std.Printable] | to_string x returns a human-readable representation of x
|
| to_word [Bap.Std.Imm] | |
| token_hash [Bap.Std.Trie.Key] | hash_token tok efficient hash function for the token type.
|
| top [Bap.Std.Group] | top group returns the top element of a group also known as a
representative element.
|
| train [Bap.Std.Byteweight.S] | |
| typ [Bap.Std.Var] | typ var returns a type assosiated with variable
|
U | |
| uint16 [Bap.Std.Memory.Input] | |
| uint8 [Bap.Std.Memory.Input] | |
| unknown [Bap.Std.Bil] | |
| unop [Bap.Std.Bil] | |
| unsigned [Bap.Std.Bil] | |
| update [Bap.Std.Phi] | update phi label exp associates expression exp with a
control flow path labeled with label .
|
| update [Bap.Std.Term] | update t p c if term p contains a term with id equal to
tid c then return p with this term substituted with p
|
| update [Bap.Std.Edge] | update e l g if edge e exists in graph g then return a
new graph g' in which edge e is associated with label l .
|
| update [Bap.Std.Node] | update n l g if node n is in N then return a graph g
in which node n is associated with label l .
|
| uses_var [Bap.Std.Blk] | uses_var blk x true if variable x is in free_vars blk .
|
V | |
| values [Bap.Std.Phi] | values phi enumerate all possible values.
|
| var [Bap.Std.Bil] | |
| version [Bap.Std.Var] | version v returns a variable version
|
| vf [Bap.Std.CPU] | |
| vf [Bap.Std.ARM.CPU] | |
| view [Bap.Std.Memory] | view word_size ~from ~words mem returns a new memory
that represents the specified region of memory mem .
|
| view [Bap.Std.Graphlib] | view (module G) ~node ~edge ~node_label ~edge_label
creates a proxy module, that will transform back and
forward elements of graph, using corresponding functions.
|
W | |
| walk [Bap.Std.Trie] | walk trie key ~init ~f walks down the tree starting from the
root and ending with the last token of the key.
|
| weight [Bap.Std.Path] | weight p total weight of a path
|
| weight [Bap.Std] |
Give a weight
|
| while_ [Bap.Std.Bil] | |
| with_cond [Bap.Std.Jmp] |
updated jump's guard condition
|
| with_intent [Bap.Std.Arg] | with_intent intent arg updates argument intent
|
| with_kind [Bap.Std.Jmp] | |
| with_lhs [Bap.Std.Phi] | with_lhs phi var updates a left hand side of phi with
var
|
| with_lhs [Bap.Std.Def] |
updates the lhs of definition
|
| with_memory [Bap.Std.Project] | with_memory project updates project memory.
|
| with_name [Bap.Std.Sub] |
updates subroutine name
|
| with_noreturn [Bap.Std.Call] |
marks call as a "noreturn"
|
| with_off [Bap.Std.Dwarf.Buffer] | with_off buf off creates a new buffer that shares data with
buf , but has different starting position equal to pos buf + off
|
| with_pos [Bap.Std.Dwarf.Buffer] | with_pos buf pos creates a new buffer that shares data with
buf , but has different starting position
|
| with_preds [Bap.Std.Disasm_expert.Basic] |
updates the set of predicates, that rules the stop condition.
|
| with_program [Bap.Std.Project] | with_program project program updates a project program
|
| with_return [Bap.Std.Call] |
updates return continuation
|
| with_rhs [Bap.Std.Def] | |
| with_symbols [Bap.Std.Project] | with_symbols project symbols updates project symbols
|
| with_target [Bap.Std.Call] |
updates target
|
| with_unknown_intent [Bap.Std.Arg] |
removes the intent from an argument
|
| word [Bap.Std.Memory.Input] | |
| word_of_addr_size [Bap.Std.Size] | |
| words [Bap.Std.Image] |
Tables
|
| write [Bap.Std.Dwarf.Leb128] | |
Z | |
| zero [Bap.Std.Integer] | |
| zero [Bap.Std.Bitvector] | |
| zf [Bap.Std.CPU] |
Flag registers
|
| zf [Bap.Std.ARM.CPU] |


Forex Today: Focus on trade wars and Brexit remains top priority
by Ross J BurlandHere is what you need to know on Wednesday, November 20:
Trade: A quiet day on the trade war front but there is an immediate focus here. The financial and commodity markets are waiting for further headlines or updates on this front before making their moves one way or the other. The latest was that the US administration had extended Huawei's license to do business with American companies. Yesterday, CNBC reported scepticism from China, especially due to Trump's reluctance to scale back on tariffs. China has reportedly demanded that all tariffs imposed after May be removed immediately while tariffs imposed before that be lifted gradually. US officials are unlikely to bow down to that and hold a different view as to how much a Phase One dal would cover and what portion of the tariffs they should agree to scale back on.
UK Elections: The ITV debate ended with mixed polls. A snap ITV Twitter poll, in fact, put Corbyn in the lead by a huge percentage as follows (29,665 votes):
- 78% Jermy Corbyn won.
- 22% said Johnson won.
YouGov / Sky News snap chat Poll: Who performed best:
- Johnson 51%
- Corbyn 49%
- Excluding don’t knows
- Just over 1,600 respondents
Meanwhile, major polls had the Tory party in with a double-digit lead aha of the event. GBP was bid to 1.2985 on the notion that Johnson has a deal that the Tory party will back on an election victory.
US data: US data showed that the US housing market was indicating ongoing strength - Housing starts rebounded in October rising 3.8% MoM, just coming in below expectations but offset by a downward revision to the fall in September. Housing permits rose 5.0% MoM, beating expectations of an unchanged outcome.
Recap: The RBA minutes, out in yesterday's Asian session, were a little more dovish than expected considering that a November rate cut was, in fact, actively discussed; The Board is waiting for more evidence about the impact of the easing that had already occurred. Market sentiment is that the RBA will likely cut again at forthcoming meetings, at the RBA’s next forecast update in February 2020.


Simple JavaScript Game
For this project learned about manipulating JavaScript objects on the DOM by converting a simple console game I created to an interactive game with graphics.
The game is very simple - simply avoid the alien and make your way back to the spaceship. You can try the game out here: link.


@(words: Seq[Word])(implicit messages: Messages, request: RequestHeader) @base("page-user-words", Some(s"Your Words")) {
| Word | Your Definition | BudDi's Definition |
|---|---|---|
| @word.word | @word.definitions.mkString(", ") | Ask about<EMAIL_ADDRESS>|
Count: @words.length
}


This is the first article heading H3 This is the first section heading H4 This is an article in a section H5 This is the second section heading H4


Data analyst and Economics graduate with strong enterprising attitude seeking a Data Analytics position with an established company. Proficient in Data Wrangling, Visualization, Full Stack Data Analytic Applications, SQL Database Manipulation, Web Scraping, and using Command-Line Interfacing. Began the UCF Data Analytics Bootcamp on 9/11/18 and graduated on 3/14/19. The program required ability to work with diverse teams on demanding time-lines to collect, analyze, and visualize big data. Skill set is an analytical, detail-oriented individual with strong critical thinking and communication skills.
Breakdown of the Men's NCAAB Tournament 2019 using https://www.sports-reference.com/gamelogs. Data was scraped using Chromedriver, Beautiful Soup, and Splinter. Jupyter was used to compile each team's data and to create a clean stat line to be used for head to head data analysis.
GPA : 3.7
Programming Languages/Utilities: Excel, VBA, Python, Pandas in Python, Matplotlib in Python, Python API’s, MySQL, SQLAlchemy, HTML, CSS, ETL, Web Scraping, and MongoDB, Javascript, Plotly, D3.js, Geo-Mapping, Tableau, R, Machine Learning.
(Relevant courses: B ITM 330 Improving Business Performance with Information Technologies (SQL, Access, Excel))
Business: Finance Core Classes (Relevant courses: STA2023 - Statistical Methods I)
Business: Finance Core Classes
GPA : 3.7
Required Programming Languages/Utilities Knowledge: Excel, VBA, Python, Pandas in Python, Matplotlib in Python, Python API’s, MySQL, SQLAlchemy, HTML, CSS, ETL, Web Scraping, and MongoDB, Javascript, Plotly, D3.js, Geo-Mapping, Tableau, R, Machine Learning.
Few things in the universe are as important as numbers. I have always been exceptional in mathematics, working with computers as well as being a hard worker. The better I get with Python and other programming languages; the easier numbers are to understand and work with. Being a baseball nerd, I am constantly analyzing big sets of data.
Over the last 3 years, my knowledge in data analysis has expanded exponentially. My economics degree has also taught me to be an analytical person in everything I do. I like to watch movies and try to analyze them in every way I can. I will always try to make sense out of everything. Something else that I am interested in is finding meaning on the surface as well as any underlying meaning.


{% block title %}
Pinboard bookmarks by {{ account.username }}
{% endblock %}
{% include 'pinboard/includes/account.html' with account=account perms=perms only %}
{% include 'pinboard/includes/annual_bookmark_counts.html' with account=account only %}
{% include 'pinboard/includes/nav_tabs.html' with account=account active='bookmarks' only %}
{% include 'pinboard/includes/bookmark_list.html' with bookmark_list=bookmark_list page_obj=page_obj perms=perms only %}


DATA COMPARISON
2016
2015
2014
2013
2012
2011
2010
2009
GRADUATION RATES
DISTRICT MAP
NEWS »
© HarvestEd 2017.


We are 2 Army Veterans that are skilled in the art of gunsmithing. We are a mobile shop that can build, repair and "decorate" your firearms.
Let us come to you with all your gunsmithing needs.We offer troubleshooting and diagnostics, parts replacement, cleaning, sight adjustment, optics mounting, jewling and more.
Come visit our brick and mortar location where we offer bluing, hydro dipping, cerakoting, wood repair, checkering, manufacturing of ar platforms and more. We also have a range of weapons and ammonution to purchase.
From coming to your home to help with all your firearm needs, to offering a store where you can to peruse and purchase any firearm or ammonution you need, to customizing your favorite weapon, we are a one stop shop for all your firearm needs. Please contact us and let us know how we can help.


What is BookWorm?
BookWorm is a new Online Bookstore.In the age where tablets and ebook readers are taking over we at BookWorm believe that the magic of reading a book is nothing to compare to these gadgets, hence we provide that magic at your very doorstep.BookWorm is all about giving you the happiness and refreshing feeling of reading books that we all deserve.So order a book right now and get lost in it.Happy Reading.
Our Team
We are a bunch of extremely talented and passionate people that want to make a differnce in world of book reading.And we call ourselves The Fsociety
Members Information
* Abdul Raoof(The Leader)
* Sanjay Talreja(The Coder)
* Maaz-ul-Haq(The Coder)
* Ahmed Siddique(The Developer)
* Abdullah Hussein(The Programmer)


|
Assimp
5.0.1, master @ cd42b955
|
Inherits Assimp::IFC::Schema_2x3::IfcReinforcingElement, and ObjectHelper< IfcTendon, 8 >.
Public Member Functions | |
| IfcTendon () | |
Public Attributes | |
| Maybe< IfcPositiveLengthMeasure::Out > | AnchorageSlip |
| IfcAreaMeasure::Out | CrossSectionArea |
| Maybe< IfcText::Out > | Description |
| Maybe< IfcNormalisedRatioMeasure::Out > | FrictionCoefficient |
| IfcGloballyUniqueId::Out | GlobalId |
| Maybe< IfcPositiveLengthMeasure::Out > | MinCurvatureRadius |
| Maybe< IfcLabel::Out > | Name |
| IfcPositiveLengthMeasure::Out | NominalDiameter |
| Maybe< Lazy< IfcObjectPlacement > > | ObjectPlacement |
| Maybe< IfcLabel::Out > | ObjectType |
| Lazy< NotImplemented > | OwnerHistory |
| IfcTendonTypeEnum::Out | PredefinedType |
| Maybe< IfcPressureMeasure::Out > | PreStress |
| Maybe< Lazy< IfcProductRepresentation > > | Representation |
| Maybe< IfcLabel::Out > | SteelGrade |
| Maybe< IfcIdentifier::Out > | Tag |
| Maybe< IfcForceMeasure::Out > | TensionForce |
|
inline |
| Maybe< IfcPositiveLengthMeasure::Out > Assimp::IFC::Schema_2x3::IfcTendon::AnchorageSlip |
| IfcAreaMeasure::Out Assimp::IFC::Schema_2x3::IfcTendon::CrossSectionArea |
|
inherited |
| Maybe< IfcNormalisedRatioMeasure::Out > Assimp::IFC::Schema_2x3::IfcTendon::FrictionCoefficient |
|
inherited |
| Maybe< IfcPositiveLengthMeasure::Out > Assimp::IFC::Schema_2x3::IfcTendon::MinCurvatureRadius |
|
inherited |
| IfcPositiveLengthMeasure::Out Assimp::IFC::Schema_2x3::IfcTendon::NominalDiameter |
|
inherited |
|
inherited |
|
inherited |
| IfcTendonTypeEnum::Out Assimp::IFC::Schema_2x3::IfcTendon::PredefinedType |
| Maybe< IfcPressureMeasure::Out > Assimp::IFC::Schema_2x3::IfcTendon::PreStress |
|
inherited |
|
inherited |
|
inherited |
| Maybe< IfcForceMeasure::Out > Assimp::IFC::Schema_2x3::IfcTendon::TensionForce |


WebSocket API with Web Workers Example
Server:
Connect
User:
Login
Logout
Item Name:
Service Name:
Subscribe
Unsubscribe
Commands:
Incoming Messages:


STRUCTURE AND POINTERS To access members of structure with structure variable, we used the dot . operator. But when we have a pointer of structure type, we use arrow -> to access structure members. Example : struct student { int id; char name[30]; float percentage; }; Void main() { int i; struct student record1 = {1, "Raju", 90.5}; struct student *ptr; ptr = &record1; printf("Records of STUDENT1: \n"); printf(" Id is: %d \n", ptr->id); //prints 1 printf(" Name is: %s \n", ptr->name); //prints ”Raju” printf(" Percentage is: %f \n\n", ptr->percentage); //prints 90.5 } Prev Next


Actually you don’t need gem for this, here is the step to install Bootstrap 3 in RoR
- Download Bootstrap
- Copy:
bootstrap/dist/css/bootstrap.css and bootstrap/dist/css/bootstrap.min.css
To: vendor/assets/stylesheets
- Copy:
bootstrap/dist/js/bootstrap.js and bootstrap/dist/js/bootstrap.min.js
To: vendor/assets/javascripts
- Update: app/assets/stylesheets/application.css by adding:
- Update: app/assets/javascripts/application.jsby adding:
With this you can update bootstrap any time you want, don’t need to wait gem to be updated. Also with this approach assets pipeline will use minified versions in production.
(Source: http://stackoverflow.com/questions/18371318/installing-bootstrap-3-on-rails-app)


Loading situation, please wait...
Rate Limit Exceeded
<assembly
xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">
<id>brms</id>
<formats>
<format>zip</format>
</formats>
<includeBaseDirectory>false</includeBaseDirectory>
</assembly>
Resubmitted by 'xyz' at 'datetime': Successful
No situations found.
Finding situations, please wait...
| ! |
Type |
Status |
Subject |
Timestamp |
Description |
|
|
Rate Limit Exceeded |
Open |
{urn:namespace}ImportantService|VeryImportantOperation |
08/20/2013 @ 5:22:47 |
Some description of the Situation goes here in this column so that it can be read by the user. |
|
|
SLA Violation |
In Progress |
{urn:namespace}ServiceA|OperationB |
08/19/2013 @ 14:33:47 |
Some description of the Situation goes here in this column so that it can be read by the user. |
|
SLA Violation |
Reopened |
{urn:namespace}ServiceA|OperationB |
08/19/2013 @ 14:35:47 |
Some description of the Situation goes here in this column so that it can be read by the user. |
|
Rate Limit Approaching |
Closed |
{urn:namespace}SomeService|AnotherOperation |
08/15/2013 @ 12:11:42 |
Some description of the Situation goes here in this column so that it can be read by the user. |


You now have:
Looking for more Web App layouts? Check out our layouts collection. You can also preview them live.
This is another card.
License
Everything in this repo is BSD style license unless otherwise specified.
Copyright (c) 2015 The Polymer Authors. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
- Neither the name of Google Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

Users
This is the users section
Resume file
Seongmo Kang
Objective
I am looking to join an Image Processing Software Engineer. I am self-motivated, self-start person and I have strong commitment to task. I adapt well in the fast-paced collaborative environment. I am a team-oriented, self-driven person with a keen technical mind and an eye for detail.
Summary
- A lot of experience in C programming development.
- Strong background in signal, image and video processing.
- Strong understanding of image processing algorithms and camera image signal processing chain.
- Excellent communication, interpersonal and problem solving skill.
- In depth understanding of Java design patterns like Data Access Object, MVC and Singleton.*
- Experience designing embedded systems and knowledge of various communication protocols (I2C, SPI, UART)*
- Quick learner with ability to implement new skills in a short period of time
- Experience with schematic capture and PCB layout*
Technical Skills
Work Experience
- Ziontech Inc.
- Kookmin Univ.
- Designing filter in order to remove MR sounds with using Matlab.
- Kookmin Univ.
- Analyzing License Plate program using Raspberry Pi, Pi_Cam, Linux, OpenCV
- Getting Popularity Award in Capstone Design Contest.
Education
Kookmin University (2011-2017) Bachelor of Electronical EngineeringArmy
Signal Corpsman (March 2012 – December 2013)
Repubilc of Korea KangWondo
- Signal Support Systems Specialist.
- Human Resources Specialist.
Contact
This is the contact section


We build the technology that allows people to invest through tax wrappers like ISAs and pensions. Our software is the driving force behind investment and advice firms of all sizes.
With our custody service and investment technology, financial advisers and wealth managers can aspire to own more of the value chain, by operating their own platform; one that better serves the needs of their clients, and more fully integrates with the rest of their business.
And thanks to our pioneering API, fintechs can get to market more quickly and cheaply than ever before - creating the ambitious products and services that could help millions of people to better manage their money.
{{ partial "casestudies" .Params }}


"Are You Ready to Drink the Rainbow?"
Welcome to the LaCroix Hydration Club, brought to you by Twin Hammers…And That Pamplemousse! "What's this all about?" you ask?
For one, IT'S ABOUT SPIRIT! Any veteran Sunbreaker knows that a key to tourney success is sharing in a super dope Spirit Challenge with opposing teams after each game (they may be opponents on the field but they're friends in our hearts!)
For another, it's about taking your hydration seriously!
At the heart of the LaCroix Hydration Club—and our spirit challenge— is the creation and consumption of the Rainbow of Hydration! Spirit Winners begin their journey to total hydration by going on a treasure hunt slash obstacle course. Their goal? To find their very own Spirit Flavor (some people have spirit animals; our people have Spirit Flavors). Our Spirit Winners embark on this journey by turning over a disc—this will unlock their Flavor Team.
The Spirit Winners will search for the LaCroix Hydration Club members that matches their given flavor—this club member will be their Flavor Spirit Guide. The Flavor Spirit Guide will then gift the Spirit Winner with a bottle of flavor—the first step in creating their Spirit Flavor.
Now comes the obstacle course! Spirit Winners must first knock down a wall of cans with a disc. When successful, they'll discover the cup in which they will create their Spirit Flavor.
Next, Spirit Winners will proceed to locate a can of Pure LaCroix, searching for the cherished item in a bucket of empty cans. To make things even more interesting, they must retrieve the can using only their mouths.
The Spirit Winners are now almost ready to create their very own spirit flavors!
But first... They will need to pass a whipped cream flip contest. (Naturally.)
Once successful, the Spirit Winners will proceed to the finish line where—at last—they will Create and Hydrate with their very own LACROIX SPIRIT FLAVOR.
Winners will not only be gifted with a goodie bag of hydration-related items, they'll also receive the ultimate prize—TOTAL HYDRATION!


Meson design rationale: A proposal for a better cross platform build system
This document is the original design description for Meson. The syntax listed here does not necessarily correspond to the current status of Meson.
A software developer's most important tool is the editor. If you talk to coders about the editors they use, you are usually met with massive enthusiasm and praise. You will hear how Emacs is the greatest thing ever or how vi is so elegant or how Eclipse's integration features make you so much more productive. You can sense the enthusiasm and affection that the people feel towards these programs.
The second most important tool, even more important than the compiler, is the build system.
Those are pretty much universally despised.
The most positive statement on build systems you can usually get (and it might require some coaxing) is something along the lines of well, it's a terrible system, but all other options are even worse. It is easy to see why this is the case. For starters, commonly used free build systems have obtuse syntaxes. They use for the most part global variables that are set in random locations so you can never really be sure what a given line of code does. They do strange and unpredictable things at every turn.
Let's illustrate this with a simple example. Suppose we want to run a program built with GNU Autotools under gdb. The instinctive thing to do is to just run gdb programname
. The problem is that this may or may not work. In some cases the executable file is a binary whereas at other times it is a wrapper shell script that invokes the real binary which resides in a hidden subdirectory. Gdb invocation fails if the binary is a script but succeeds if it is not. The user has to remember the type of each one of his executables (which is an implementation detail of the build system) just to be able to debug them. Several other such pain points can be found in this blog post.
Given these idiosyncrasies it is no wonder that most people don't want to have anything to do with build systems. They'll just copypaste code that works (somewhat) in one place to another and hope for the best. They actively go out of their way not to understand the system because the mere thought of it is repulsive. Doing this also provides a kind of inverse job security. If you don't know tool X, there's less chance of finding yourself responsible for its use in your organisation. Instead you get to work on more enjoyable things.
This leads to a vicious circle. Since people avoid the tools and don't want to deal with them, very few work on improving them. The result is apathy and stagnation.
Can we do better?
At its core, building C and C++ code is not a terribly difficult task. In fact, writing a text editor is a lot more complicated and takes more effort. Yet we have lots of very high quality editors but only few build systems with questionable quality and usability.
So, in the grand tradition of own-itch-scratching, I decided to run a scientific experiment. The purpose of this experiment was to explore what would it take to build a "good" build system. What kind of syntax would suit this problem? What sort of problems would this application need to solve? What sort of solutions would be the most appropriate?
To get things started, here is a list of requirements any modern cross-platform build system needs to provide.
###1. Must be simple to use###
One of the great virtues of Python is the fact that it is very readable. It is easy to see what a given block of code does. It is concise, clear and easy to understand. The proposed build system must be syntactically and semantically clean. Side effects, global state and interrelations must be kept at a minimum or, if possible, eliminated entirely.
###2. Must do the right thing by default###
Most builds are done by developers working on the code. Therefore the defaults must be tailored towards that use case. As an example the system shall build objects without optimization and with debug information. It shall make binaries that can be run directly from the build directory without linker tricks, shell scripts or magic environment variables.
###3. Must enforce established best practices###
There really is no reason to compile source code without the equivalent of -Wall
. So enable it by default. A different kind of best practice is the total separation of source and build directories. All build artifacts must be stored in the build directory. Writing stray files in the source directory is not permitted under any circumstances.
###4. Must have native support for platforms that are in common use###
A lot of free software projects can be used on non-free platforms such as Windows or OSX. The system must provide native support for the tools of choice on those platforms. In practice this means native support for Visual Studio and XCode. Having said IDEs invoke external builder binaries does not count as native support.
###5. Must not add complexity due to obsolete platforms###
Work on this build system started during the Christmas holidays of 2012. This provides a natural hard cutoff line of 2012/12/24. Any platform, tool or library that was not in active use at that time is explicitly not supported. These include unixes such as IRIX, SunOS, OSF-1, Ubuntu versions older than 12/10, GCC versions older than 4.7 and so on. If these old versions happen to work, great. If they don't, not a single line of code will be added to the system to work around their bugs.
###6. Must be fast###
Running the configuration step on a moderate sized project must not take more than five seconds. Running the compile command on a fully up to date tree of 1000 source files must not take more than 0.1 seconds.
###7. Must provide easy to use support for modern sw development features###
An example is precompiled headers. Currently no free software build system provides native support for them. Other examples could include easy integration of Valgrind and unit tests, test coverage reporting and so on.
###8. Must allow override of default values###
Sometimes you just have to compile files with only given compiler flags and no others, or install files in weird places. The system must allow the user to do this if he really wants to.
Overview of the solution
Going over these requirements it becomes quite apparent that the only viable approach is roughly the same as taken by CMake: having a domain specific language to declare the build system. Out of this declaration a configuration is generated for the backend build system. This can be a Makefile, Visual Studio or XCode project or anything else.
The difference between the proposed DSL and existing ones is that the new one is declarative. It also tries to work on a higher level of abstraction than existing systems. As an example, using external libraries in current build systems means manually extracting and passing around compiler flags and linker flags. In the proposed system the user just declares that a given build target uses a given external dependency. The build system then takes care of passing all flags and settings to their proper locations. This means that the user can focus on his own code rather than marshalling command line arguments from one place to another.
A DSL is more work than the approach taken by SCons, which is to provide the system as a Python library. However it allows us to make the syntax more expressive and prevent certain types of bugs by e.g. making certain objects truly immutable. The end result is again the same: less work for the user.
The backend for Unix requires a bit more thought. The default choice would be Make. However it is extremely slow. It is not uncommon on large code bases for Make to take several minutes just to determine that nothing needs to be done. Instead of Make we use Ninja, which is extremely fast. The backend code is abstracted away from the core, so other backends can be added with relatively little effort.
Sample code
Enough design talk, let's get to the code. Before looking at the examples we would like to emphasize that this is not in any way the final code. It is proof of concept code that works in the system as it currently exists (February 2013), but may change at any time.
Let's start simple. Here is the code to compile a single executable binary.
project('compile one', 'c')
executable('program', 'prog.c')<
This is about as simple as one can get. First you declare the project name and the languages it uses. Then you specify the binary to build and its sources. The build system will do all the rest. It will add proper suffixes (e.g. '.exe' on Windows), set the default compiler flags and so on.
Usually programs have more than one source file. Listing them all in the function call can become unwieldy. That is why the system supports keyword arguments. They look like this.
project('compile several', 'c')
sources = ['main.c', 'file1.c', 'file2.c', 'file3.c']
executable('program', sources : sourcelist)
External depencencies are simple to use.
project('external lib', 'c') libdep = find_dep('extlibrary', required : true) sources = ['main.c', 'file1.c', 'file2.c', 'file3.c'] executable('program', sources : sourcelist, dep : libdep)
In other build systems you have to manually add the compile and link flags from external dependencies to targets. In this system you just declare that extlibrary is mandatory and that the generated program uses that. The build system does all the plumbing for you.
Here's a slightly more complicated definition. It should still be understandable.
project('build library', 'c') foolib = shared_library('foobar', sources : 'foobar.c',\ install : true) exe = executable('testfoobar', 'tester.c', link : foolib) add_test('test library', exe)
First we build a shared library named foobar. It is marked installable, so running ninja install
installs it to the library directory (the system knows which one so the user does not have to care). Then we build a test executable which is linked against the library. It will no tbe installed, but instead it is added to the list of unit tests, which can be run with the command ninja test
.
Above we mentioned precompiled headers as a feature not supported by other build systems. Here's how you would use them.
project('pch demo', 'cxx')
executable('myapp', 'myapp.cpp', pch : 'pch/myapp.hh')
The main reason other build systems can not provide pch support this easily is because they don't enforce certain best practices. Due to the way include paths work, it is impossible to provide pch support that always works with both in-source and out-of-source builds. Mandating separate build and source directories makes this and many other problems a lot easier.
Get the code
The code for this experiment can be found at the Meson repository. It should be noted that it is not a build system. It is only a proposal for one. It does not work reliably yet. You probably should not use it as the build system of your project.
All that said I hope that this experiment will eventually turn into a full blown build system. For that I need your help. Comments and especially patches are more than welcome.
The results of the search are


Class DataSourceCollection
Collection of entities, represented as complex sql.
- Orm\Object
- Orm\BaseDibiCollection implements Orm\IEntityCollection
- Orm\DataSourceCollection
Namespace: Orm
Package: Orm
Subpackage: Mappers\Collection
Author: Petr Procházka
See: DibiDataSource with subselects
See: DibiDataSourceX without subselects For mysql is prefer DibiDataSourceX which works without subselects. <code> $collection = $dibiMapper->dataSource('SELECT * FROM [tableName] WHERE [foo] = %s', $foo); </code>
Located at Mappers/Collection/DataSourceCollection.php
Package: Orm
Subpackage: Mappers\Collection
Author: Petr Procházka
See: DibiDataSource with subselects
See: DibiDataSourceX without subselects For mysql is prefer DibiDataSourceX which works without subselects. <code> $collection = $dibiMapper->dataSource('SELECT * FROM [tableName] WHERE [foo] = %s', $foo); </code>
Located at Mappers/Collection/DataSourceCollection.php
final public
|
|
final public
integer
|
|
public
|
|
final public
string
|
|
final public
DibiDataSource
|
|
protected
|
|
final public
integer
|
__callStatic(),
__get(),
__isset(),
__set(),
__unset()
|
ASC,
DESC
|
$findBy,
$tableAlias,
$where
|


Insert product
Name
Name cannot be empty
Likes
Likes must be an integer
Dislikes
Disikes must be an integer
Insert


Join T-dolls and get to the IWS-2000 Tile!
New Gamea,a,a,fa,sd,fa,sdf,asd,f,asd,fa,sdf,a,wef,awe,fa,wef,aw,ef,awe
How to play: Use your arrow keys to move the tiles.
When two tiles touch, they merge into one based on the current arithmetic operation!
Press Number Key (1-4) to change operation.
Created by MerHS Based on 1024 by Veewo Studio and conceptually similar to Threes by Asher Vollmer.
T-doll Images: Copyrightⓒ SUNBORN Network Technology Co., Ltd. All Rights Reserved.


First, you will need to create an account. To do this click Register and enter your email, a username, and password.
Once you have created your account you will need to verify your email address by clicking the link in the confirmation email you were sent.
This link should then bring you back to the site and log you into your account.
Now that you have made your account with CoCoTemp you will need to construct your iButton sensor.
In order to do this, you will need to get an iButton, a reader, a shield, and optionally an iButton keyfob.
The shield is needed to protect the iButton from the weather itself. It makes sure that the button is a consistent temperature by protecting it from the sun, but also gives the button access to the air.
You have multiple options for the shield. You can purchase a professional radiation shield online or you could create your own improvised shield at home. If you opt to build your own you can refer to our tutorial video below on how to do so; you will just need your iButton, a disposable cup(styrofoam or plastic), some string, an adhesive, and either your reader or keyfob to hold the iButton.
Here are some links to purchase some of the items you may need.
Note: iButton’s are not waterproof and when you set up your iButton you must make sure it is adequately protected from the rain.
If you do not wish to create your own shield or need something more durable than a plastic cup then you can contact CoCoTemp for one of our experimental flat-mailable shields.
If you are planning to build your own shield you can refer to this tutorial video.
To create and manage sites, make sure that you are signed in to your account. When you are ready to create a site go to My Sites.
Next, you will want to click on Create a new site.
From here you will need to give your site a name and designate its location. You can set your site's location by clicking on the interactive map, or by entering the latitude, longitude, and elevation.
The next step is to give it a quick description. This way you will be able to tell which site it is in case you have many sites.
The final section of information to be entered is the GLOBE site survey. The survey asks for information about the location such as the height of the sensor, any obstacles, and other valuable information. You are not required to answer all of the questions, but if you do then it will help others when comparing weather data.
Now that you have created a site, you will be able to assign devices to it. This is done by clicking Add a device.
This will take you to a new page where you will be able to select a site and type of device via a drop-down menu. You will also want to put in the manufacturer/serial number so that you can tell the devices apart.
Note: the default device type is iButton. If you have a different type of temperature recording device make sure to change this.
Once you have created a site and a device you can select them from My Sites to view information about them such as the metadata and what devices are assigned to the site. When viewing a site you will also see a graph displaying current data that has been uploaded. The site's location on the map will be visible on the side of the page. To delete a device, just select the device and select delete.
If you plan to use the CoCo iTemp desktop application to extract and/or upload data from your iButton you will need to install it. This can be downloaded by clicking here. In order to run the application you must have Java installed; this can be downloaded here. You will also need to download the appropriate one-wire drivers here so the application can read data from the iButton.
To obtain iButton data you will need to plug the device into your computer's USB port via the reader. This must be done before starting the application or it will not detect the iButton. Next, start up the CoCo iTemp application and log into your account. Select the iButton from the dashboard, and the iButton's associated site will appear. If the iButton does not have a site associated with it you can click the 'Assign Site' button to associate it with one of your sites. Once selected you can have your iButton start collecting data by clicking on the 'Mission' button. Next, you can start a new mission by clicking on the 'New Mission' button. You can stop a mission by clicking on the 'Stop Mission' button. On the mission page, you can also click on the 'Read Data' button to download the data from your iButton to a local file. This data can then be manually uploaded to the site if you prefer to do it this way.
To upload data, make sure that you have your iButton selected and ensure that it has a site assigned to it. You can then click on the 'Upload' button and it will upload your data to the desired site. Another way to upload data to a site is to go to the Upload Data page. Here you can select the file that was generated by clicking on 'Read Data' from the iButton and the specific site that you would like to upload the data to. You can also add notes to your upload on this page.
If you are using a different kind of software to obtain your data then make sure that the file you are using to upload is formatted as shown below. A good way to easily make sure of this is to open up your file in Microsoft Excel or a similar software and check that it is formatted as shown below. If you have a file that is not a CSV file that you wish to use, create an Excel file like the example and then save the file as a CSV by going to 'save file as' and then changing the file extension type to .csv rather than .xlsx.
Note: Currently an internet connection is needed in order to use the CoCo iTemp Application.
After successfully uploading your data to your site, you can finally view the uploaded data. You can find your site by using the map on the dashboard to click on the site's marker and then on its name. Alternatively, you can click on the 'My Sites' tab on the sidebar in order to see all of your sites and devices. From here you can click on the site you want to see data for and you will be brought to a page displaying its data.
If you want to compare data between sites, you will want to go to the Microclimate Data page. Once there you can use the 'Filters' tab on the right side of the screen to load NOAA sites based on custom filters.
You can also find CoCo Temp sites using the Microclimate Comparison Tool.
Once you have all of the desired sites loaded you can click on them and then click on 'Add to Graph'. If you want to remove something from the graph then re-click it on the map and click 'Remove from Graph'. Once you select a site, its data will appear on the graph below as well as in tables in the filter tab on the right.
When using the graphs you can temporarily hide the data by clicking on the data's name in the legend on the right side. Note: The yellow lines on the graph are there to indicate large drops or rises in temperature, which could help locate any suspect data.


{% extends "base.html" %} {% block title %}{{ paper.title }}{% endblock %} {% block footer_class %}fixed{% endblock %} {% block content %}
This paper doesn't have LaTeX source code, so it can't be rendered as a web page.
Take a look at the original PDF instead.