ABS include/util.h /^#define ABS(a) ((a) < 0 ? -(a) : (a))$/ ACK_decomp pld/xln_merge.c /^ACK_decomp(network)$/ ACT_GET pld/pld_int.h /^#define ACT_GET(node) ((node)->PLD_SLOT)$/ ACT_SET pld/pld_int.h /^#define ACT_SET(node) ((act_type_t *) (node)->PLD_/ ADD_DIRECT st/st.c /^#define ADD_DIRECT(table, key, value, hash_val, ne/ AD_accept_match map/bin_area_del.c /^AD_accept_match(new_slack, old_slack, new_area, ol/ AD_alloc_arrival_slots map/bin_area_del.c /^AD_alloc_arrival_slots(node)$/ AD_arrival_to_integer map/bin_area_del.c /^AD_arrival_to_integer(node, arrival)$/ AD_compute_arrivals_area map/bin_area_del.c /^AD_compute_arrivals_area(prim, gate, load_array, i/ AD_compute_interval_network map/bin_area_del.c /^AD_compute_interval_network(network)$/ AD_compute_interval_node map/bin_area_del.c /^AD_compute_interval_node(node)$/ AD_compute_interval_prim map/bin_area_del.c /^AD_compute_interval_prim(prim)$/ AD_do_tree_match map/bin_area_del.c /^AD_do_tree_match(network)$/ AD_find_best_gate map/bin_area_del.c /^AD_find_best_gate(prim)$/ AD_find_best_match map/bin_area_del.c /^AD_find_best_match(node)$/ AD_free_arrival_slots map/bin_area_del.c /^AD_free_arrival_slots(node)$/ AD_get_match_cost map/bin_area_del.c /^AD_get_match_cost(node, prim, gate, required, load/ AD_init_load_req_time map/bin_area_del.c /^AD_init_load_req_time(network)$/ AD_initialize_buckets map/bin_area_del.c /^AD_initialize_buckets(network)$/ AD_integer_to_arrival map/bin_area_del.c /^AD_integer_to_arrival(node, i)$/ AD_load_to_integer_estimate map/bin_area_del.c /^AD_load_to_integer_estimate(node, load)$/ AD_print_arrival_interval map/bin_area_del.c /^AD_print_arrival_interval(node)$/ AD_select_best_match map/bin_area_del.c /^AD_select_best_match(node)$/ AD_update_input_pins map/bin_area_del.c /^AD_update_input_pins(node, gate)$/ AD_update_load_and_req_time map/bin_area_del.c /^AD_update_load_and_req_time(node, load, req_time)$/ ALLOC avl/avl.c /^#define ALLOC(type, num) \\$/ ARRIVAL delay/delay.c /^#define ARRIVAL(time, new_time) \\$/ BALANCE avl/avl.c /^#define BALANCE(node) (HEIGHT((node)->right) - HEI/ BB_dyn_special_cases minimize/ros.c /^BB_dyn_special_cases(BB, p, overexpanded_cube, T, / BB_special_cases minimize/ros.c /^BB_special_cases(BB, p, overexpanded_cube, pNode, / BDD_IS_COMPLEMENT bdd/bdd_int.h /^#define BDD_IS_COMPLEMENT(node) ((int) (node) & 01/ BDD_IS_CONSTANT bdd/bdd_ite.c /^#define BDD_IS_CONSTANT(node) (BDD_REGULAR(node) =/ BDD_NOT bdd/bdd_int.h /^#define BDD_NOT(node) ((bdd_node *) ((int) (node)/ BDD_ONE bdd/bdd_int.h /^#define BDD_ONE(bdd) (bdd)->one$/ BDD_REGULAR bdd/bdd_int.h /^#define BDD_REGULAR(node) ((bdd_node *) ((int) (no/ BDD_ZERO bdd/bdd_int.h /^#define BDD_ZERO(bdd) (BDD_NOT(BDD_ONE(bdd)))$/ BIN map/bin_int.h /^#define BIN(node) ((bin_t *) (node)->BIN_SLOT)$/ BIN_BUCKET map/bin_int.h /^#define BIN_BUCKET(node,load,delay) (&(BIN(node)->/ BUFFER speed/buffer_int.h /^#define BUFFER(node) ((sp_node_t *)(node->BUFFER_S/ CHECK octio/my.h /^#define CHECK(fct) \\$/ CHECK_BIN_BUCKET map/bin_int.h /^#define CHECK_BIN_BUCKET(node,load,delay) {\\$/ COMPARE avl/avl.c /^#define COMPARE(key, nodekey, compare) \\$/ CSPF simplify/simp_int.h /^#define CSPF(node) ((cspf_type_t *) (node)->OBS)$/ CUBELISTSIZE espresso/espresso.h /^#define CUBELISTSIZE(T) (((pcube *) T[1] -/ CreateBag octio/my.h /^#define CreateBag(c, t, s) \\$/ CreateBox octio/my.h /^#define CreateBox(c, t, llx, lly, urx, ury) \\$/ CreateCircle octio/my.h /^#define CreateCircle(c, t, startAng, endAng, inRad/ CreateInst octio/my.h /^#define CreateInst(c, t, xname, xmaster, xview) \\/ CreateInstance octio/my.h /^#define CreateInstance(c, t, xname, xmaster, xview/ CreateLabel octio/my.h /^#define CreateLabel(c, t, s, zx, zy) \\$/ CreateLayer octio/my.h /^#define CreateLayer(c, t, s) \\$/ CreateNet octio/my.h /^#define CreateNet(c, t, s) \\$/ CreateOrModifyBag octio/my.h /^#define CreateOrModifyBag(c, t, s) \\$/ CreateOrModifyLabel octio/my.h /^#define CreateOrModifyLabel(c, t, s) \\$/ CreateOrModifyLayer octio/my.h /^#define CreateOrModifyLayer(c, t, s) \\$/ CreateOrModifyNet octio/my.h /^#define CreateOrModifyNet(c, t, s) \\$/ CreateOrModifyPropInt octio/my.h /^#define CreateOrModifyPropInt(c, t, s, i) \\$/ CreateOrModifyPropReal octio/my.h /^#define CreateOrModifyPropReal(c, t, s, d) \\$/ CreateOrModifyPropStr octio/my.h /^#define CreateOrModifyPropStr(c, t, s, s1) \\$/ CreateOrModifyTerm octio/my.h /^#define CreateOrModifyTerm(c, t, s) \\$/ CreatePath octio/my.h /^#define CreatePath(c, t, w) \\$/ CreatePropInt octio/my.h /^#define CreatePropInt(c, t, s, i) \\$/ CreatePropReal octio/my.h /^#define CreatePropReal(c, t, s, d) \\$/ CreatePropStr octio/my.h /^#define CreatePropStr(c, t, s, s1) \\$/ CreateTerm octio/my.h /^#define CreateTerm(c, t, s) \\$/ DELAY delay/delay_int.h /^#define DELAY(node) ((delay_node_t *) node->DELAY_/ DELAY_NODE_CHECK delay/delay.c /^#define DELAY_NODE_CHECK(network, node, fname) \\$/ DFS_covered_node pld/xln_map_par.c /^DFS_covered_node(node, node_array, flag)$/ D_MAX speed/speed_int.h /^#define D_MAX(a,b) ((double)(a) > (double)(b) ? (d/ D_MIN speed/speed_int.h /^#define D_MIN(a,b) ((double)(a) < (double)(b) ? (d/ EQUAL st/st.c /^#define EQUAL(func, x, y) \\$/ EXEC espresso/espresso.h /^#define EXEC(fct, name, S)\\$/ EXECUTE espresso/espresso.h /^#define EXECUTE(fct,i,S,cost)\\$/ EXEC_S espresso/espresso.h /^#define EXEC_S(fct, name, S)\\$/ EXP pld/pld_int.h /^#define EXP(d,t) ( (t) == 0. ? 0. : exp( -(double)/ FIND_ENTRY st/st.c /^#define FIND_ENTRY(table, hash_val, key, ptr, last/ FLOAT_TO_INT map/bin_fanout.h /^#define FLOAT_TO_INT(x) ((int) ceil(rint(x * 10000/ FP_EQUAL map/map_int.h /^#define FP_EQUAL(a,b) (ABS((a)-(b)) < .0001)$/ FREE avl/avl.c /^#define FREE(obj) \\$/ GETBAR mincov/bin_mincov.c /^#define GETBAR(v) (((v)&1)?((v)-1):((v)+1))$/ GETC io/read_blif.c /^#define GETC(c, fp) \\$/ GETINPUT espresso/espresso.h /^#define GETINPUT(c, pos)\\$/ GETMAX map/bin_int.h /^#define GETMAX(a) MAX((a).rise, (a).fall)$/ GETMIN map/bin_int.h /^#define GETMIN(a) MIN((a).rise, (a).fall)$/ GETOUTPUT espresso/espresso.h /^#define GETOUTPUT(c, pos)\\$/ GETSET espresso/espresso.h /^#define GETSET(family, index) ((family)->data + / GET_DEFAULT delay/com_delay.c /^#define GET_DEFAULT(parm) delay_get_parameter(NIL(/ GET_LEVEL map/bin_fanout.h /^#define GET_LEVEL(level) (((level) < global_inv_ar/ GET_VALUE sim/sim_int.h /^#define GET_VALUE(node) ((int) node->SIM_SLOT)$/ GetByBagName octio/my.h /^#define GetByBagName(c, t, s) \\$/ GetById octio/my.h /^#define GetById(obj, id) \\$/ GetByInstName octio/my.h /^#define GetByInstName(c, t, s) \\$/ GetByLabelName octio/my.h /^#define GetByLabelName(c, t, s) \\$/ GetByLayerName octio/my.h /^#define GetByLayerName(c, t, s) \\$/ GetByNetName octio/my.h /^#define GetByNetName(c, t, s) \\$/ GetByPropName octio/my.h /^#define GetByPropName(c, t, s) \\$/ GetByTermName octio/my.h /^#define GetByTermName(c, t, s) \\$/ GetOrCreateBag octio/my.h /^#define GetOrCreateBag(c, t, s) \\$/ GetOrCreateLabel octio/my.h /^#define GetOrCreateLabel(c, t, s) \\$/ GetOrCreateLayer octio/my.h /^#define GetOrCreateLayer(c, t, s) \\$/ GetOrCreateNet octio/my.h /^#define GetOrCreateNet(c, t, s) \\$/ GetOrCreatePropInt octio/my.h /^#define GetOrCreatePropInt(c, t, s, i) \\$/ GetOrCreatePropReal octio/my.h /^#define GetOrCreatePropReal(c, t, s, d) \\$/ GetOrCreatePropStr octio/my.h /^#define GetOrCreatePropStr(c, t, s, s1) \\$/ GetOrCreateTerm octio/my.h /^#define GetOrCreateTerm(c, t, s) \\$/ HEIGHT avl/avl.c /^#define HEIGHT(node) (node == NIL(avl_node) ? -1 :/ INLABEL espresso/espresso.h /^#define INLABEL(var) PLA->label[cube.first_part/ INLINEset_and espresso/espresso.h /^#define INLINEset_and(r, a, b) (void) set_and(r, / INLINEset_clear espresso/espresso.h /^#define INLINEset_clear(r, size) (void) set_clear(/ INLINEset_copy espresso/espresso.h /^#define INLINEset_copy(r, a) (void) set_copy(r,a)/ INLINEset_diff espresso/espresso.h /^#define INLINEset_diff(r, a, b) (void) set_diff(r/ INLINEset_fill espresso/espresso.h /^#define INLINEset_fill(r, size) (void) set_fill(r/ INLINEset_merge espresso/espresso.h /^#define INLINEset_merge(r, a, b, mask) (void) set_/ INLINEset_ndiff espresso/espresso.h /^#define INLINEset_ndiff(r, a, b, f) (void) set_ndi/ INLINEset_or espresso/espresso.h /^#define INLINEset_or(r, a, b) (void) set_or(r, a,/ INLINEset_xnor espresso/espresso.h /^#define INLINEset_xnor(r, a, b, f) (void) set_xnor/ INLINEset_xor espresso/espresso.h /^#define INLINEset_xor(r, a, b) (void) set_xor(r, / INLINEsetp_disjoint espresso/espresso.h /^#define INLINEsetp_disjoint(a, b, when_false) \\$/ INLINEsetp_equal espresso/espresso.h /^#define INLINEsetp_equal(a, b, when_false) \\$/ INLINEsetp_implies espresso/espresso.h /^#define INLINEsetp_implies(a, b, when_false) \\$/ IS_MAX_LEVEL map/bin_fanout.h /^#define IS_MAX_LEVEL(level) ((level) >= global_inv/ ITE bdd/bdd_ite.c /^ITE(bdd,f,g,h)$/ ITE_constant bdd/bdd_ite.c /^ITE_constant(bdd,f,g,h)$/ KL_up phase/greedy.c /^KL_up(net_phase)$/ LOG_B pld/pld_int.h /^#define LOG_B(base,x) ( log(x)\/log(base) )$/ LOOP espresso/espresso.h /^#define LOOP(set) (set[0] & 0x03ff)$/ LOOPCOPY espresso/espresso.h /^#define LOOPCOPY(set) LOOP(set)$/ LOOPINIT espresso/espresso.h /^#define LOOPINIT(size) ((size <= BPI) ? 1 : WHICH/ LS_ASSERT include/network.h /^#define LS_ASSERT(fct) assert((fct) == LS_OK)$/ MAP map/map_int.h /^#define MAP(node) ((map_t *) (node)->MAP_SLOT)$/ MAP_ARRIVAL map/bin_int.h /^#define MAP_ARRIVAL(node) (MAX(MAP((node))->map_ar/ MAX avl/avl.c /^#define MAX(a,b) ((a) > (b) ? (a) : (b))$/ MAXDELAY map/bin_fanout.h /^#define MAXDELAY(delay) MAX((delay).rise, (delay)./ MAX_ARRIVAL map/bin_int.h /^#define MAX_ARRIVAL(node) (BIN((node))->arrival->m/ MF_ALLOC maxflow/maxflow_int.h /^#define MF_ALLOC(num,type) \\$/ MF_calloc maxflow/mf_input.c /^MF_calloc(a, b)$/ MIN include/util.h /^#define MIN(a,b) ((a) < (b) ? (a) : (b))$/ MIN_AREA map/bin_int.h /^#define MIN_AREA(node) (BIN((node))->arrival->min_/ MIN_ARRIVAL map/bin_int.h /^#define MIN_ARRIVAL(node) (BIN((node))->arrival->m/ MIN_DELAY speed/buffer_int.h /^#define MIN_DELAY(result,t1,t2) / MMalloc util/safe_mem.c /^MMalloc(size)$/ MMfree util/safe_mem.c /^MMfree(obj)$/ MMout_of_memory util/safe_mem.c /^void $/ MMrealloc util/safe_mem.c /^MMrealloc(obj, size)$/ Marr_main array/arr_main.c /^int $/ Mavl_bench1 avl/avl_bench1.c /^main(argc, argv)$/ Mcomb genlib/comb.c /^main(argc, argv)$/ Mdriver lib/driver.c /^main(argc, argv)$/ Mmain mincov/main.c /^int $/ Mmis main/mis.c /^main(argc, argv)$/ Mpermute genlib/permute.c /^main(argc, argv)$/ Mst_bench1 st/st_bench1.c /^main(argc, argv)$/ Mtest-restart util/test-restart.c /^main(argc, argv, environ)$/ NELEM espresso/espresso.h /^#define NELEM(set) (BPI * LOOP(set))$/ NIL avl/avl.c /^#define NIL(type) \\$/ NONNEG map/bin_fanout.h /^#define NONNEG(x) ((x) >= -1.0e-5)$/ NORM pld/pld_int.h /^#define NORM(n) ( (double) n \/ (double) MAX_INT )$/ NRAND pld/pld_int.h /^#define NRAND(a) ( (double) ( a = ( a * 1103515245/ OCTMISCHECK octio/octread.c /^#define OCTMISCHECK(fnc) \\$/ OCT_ASSERT octio/my.h /^#define OCT_ASSERT(fct) \\$/ OCT_ASSERT_DESCR octio/my.h /^#define OCT_ASSERT_DESCR(fct, why) \\$/ OCT_FAIL octio/my.h /^#define OCT_FAIL(fct, why, offending_object) \\$/ OR_literal_order pld/act_map.c /^OR_literal_order(node)$/ OR_pattern pld/act_map.c /^int OR_pattern(root)$/ OUTLABEL espresso/espresso.h /^#define OUTLABEL(pos) PLA->label[cube.first_part/ OpenFacet octio/my.h /^#define OpenFacet(t, c, v, f, m) \\$/ OpenInterface octio/my.h /^#define OpenInterface(t, f, m) \\$/ OpenMaster octio/my.h /^#define OpenMaster(t, i, f, m) \\$/ PLA_labels espresso/cvrin.c /^PLA_labels(PLA)$/ PLA_permute espresso/verify.c /^PLA_permute(PLA1, PLA2)$/ PLA_summary espresso/cvrin.c /^void PLA_summary(PLA)$/ PLA_verify espresso/verify.c /^bool PLA_verify(PLA1, PLA2)$/ POLAR_INV map/bin_fanout.h /^#define POLAR_INV(polarity) (1 - (polarity))$/ POSITIVE_PHASE espresso/espresso.h /^#define POSITIVE_PHASE(pos)\\$/ POW2 espresso/opo.c /^#define POW2(x) (1 << (x))$/ POWER2 espresso/map.c /^#define POWER2(n) (1 << n)$/ PTR_NOT_EQUAL st/st.c /^#define PTR_NOT_EQUAL(table, ptr, user_key)\\$/ PUTINPUT espresso/espresso.h /^#define PUTINPUT(c, pos, value)\\$/ PUTLOOP espresso/espresso.h /^#define PUTLOOP(set, i) (set[0] &= ~0x03ff/ PUTOUTPUT espresso/espresso.h /^#define PUTOUTPUT(c, pos, value)\\$/ PUTSIZE espresso/espresso.h /^#define PUTSIZE(set, size) (set[0] &= 0xffff,/ RAND pld/pld_int.h /^#define RAND(a) ( a = ( a * 1103515245 + 12345 ) &/ REALLOC avl/avl.c /^#define REALLOC(type, obj, num) \\$/ REQUIRED delay/delay.c /^#define REQUIRED(time, new_time) \\$/ RESET espresso/espresso.h /^#define RESET(set, flag) (set[0] &= ~ (flag/ RINT pld/pld_int.h /^#define RINT(a) ( (int) floor( (double) a + 0.5 ) / SAVE pld/pld_int.h /^#define SAVE(ptostring) strcpy(CALLOC(char,strlen/ SET espresso/espresso.h /^#define SET(set, flag) (set[0] |= (flag))/ SETADD map/bin_int.h /^#define SETADD(a,b,c) ((a).rise=(b).rise+(c).rise,/ SETMAX map/bin_int.h /^#define SETMAX(a,b,c) ((a).rise=MAX((b).rise, (c)./ SETMAX2 map/bin_int.h /^#define SETMAX2(a,b) ((a)=((a)>(b))?(a):(b))$/ SETMIN map/bin_int.h /^#define SETMIN(a,b,c) ((a).rise=MIN((b).rise, (c)./ SETMIN2 map/bin_int.h /^#define SETMIN2(a,b) ((a)=((a)<(b))?(a):(b))$/ SETSUB map/bin_int.h /^#define SETSUB(a,b,c) ((a).rise=(b).rise-(c).rise,/ SET_SIZE espresso/espresso.h /^#define SET_SIZE(size) ((size) <= BPI ? 2/ SET_VALUE sim/sim_int.h /^#define SET_VALUE(node, value) (node->SIM_SLOT = / SIM_FLAG simplify/simp_int.h /^#define SIM_FLAG(node) ((sim_flag_t *) ((node)->/ SIZE espresso/espresso.h /^#define SIZE(set) (set[0] >> 16)$/ SOP_VALUE extract/cube.c /^#define SOP_VALUE(x, y) (((x) - 1) * ((y) - 1) - / SORT include/lsort.h /^SORT(list_in, compare, cnt)$/ SORT1 include/lsort.h /^SORT1(list_in, compare)$/ SPEED_DUP_PARAM speed/sp_network.c /^#define SPEED_DUP_PARAM(from,to,p,r) \\$/ STREQ octio/octread.c /^#define STREQ(a, b) (strcmp(a, b) == 0)$/ ST_NUMCMP st/st.c /^#define ST_NUMCMP(x,y) ((x) != (y))$/ ST_NUMHASH st/st.c /^#define ST_NUMHASH(x,size) (ABS((int)x)%(size))$/ ST_PTRHASH st/st.c /^#define ST_PTRHASH(x,size) ((int)((unsigned)(x)>>2/ SWAP pld/pld_int.h /^#define SWAP(type, a, b) {type swapx; swapx = a/ TESTP espresso/espresso.h /^#define TESTP(set, flag) (set[0] & (flag))$/ U genlib/readliblex.c /^# define U(x) x$/ UNGETC io/read_blif.c /^#define UNGETC(c, fp) if (c == '\\n') read_lineno--/ UNIQ include/luniq.h /^UNIQ(list, compare, free_routine)$/ VALUE extract/extract_int.h /^#define VALUE(p) ((value_cell_t *) (p)->user_word/ WEIGHT mincov/mincov_int.h /^#define WEIGHT(weight, col) (weight == NIL(int) ? / WHICH_BIT espresso/espresso.h /^#define WHICH_BIT(element) ((element) & (BPI-/ WHICH_WORD espresso/espresso.h /^#define WHICH_WORD(element) (((element) >> LOG/ XDiamond graphics/XDiamond.c /^XDiamond(display, win, gc, x, y, width, height)$/ XDiamondFilled graphics/XDiamond.c /^XDiamondFilled(display, win, gc, x, y, width, heig/ XEllipseFilled graphics/XEllipse.c /^XEllipseFilled(display, win, gc, x, y, width, heig/ XTriangle graphics/XTriangle.c /^XTriangle(display, win, gc, x, y, width, height)$/ XTriangleFilled graphics/XTriangle.c /^XTriangleFilled(display, win, gc, x, y, width, hei/ abs_covered espresso/unate.c /^abs_covered(A, pick)$/ abs_covered_many espresso/unate.c /^abs_covered_many(A, pick_set)$/ abs_select_restricted espresso/unate.c /^abs_select_restricted(A, restrict)$/ absorb_fanin simplify/simall.c /^absorb_fanin(network, f)$/ absorb_fanin_visited speed/absorb.c /^absorb_fanin_visited( node, table)$/ actReduce pld/act_reduce.c /^actReduce(fn_graph)$/ act_F pld/act_bdd.c /^act_F(F)$/ act_act_free pld/act_map.c /^act_act_free(node)$/ act_break_network pld/act_map.c /^act_break_network(network, table)$/ act_evaluate_map_cost pld/act_map.c /^COST_STRUCT * act_evaluate_map_cost(node, HEURISTI/ act_get_function pld/act_map.c /^act_get_function(network, node, vertex)$/ act_map_network pld/act_map.c /^act_map_network(network, HEURISTIC_NUM, NUM_ITER, / act_quick_phase pld/act_map.c /^act_quick_phase(network, cost_table, HEURISTIC_NUM/ add_inv_network phase/ai.c /^add_inv_network(network)$/ add_inv_node phase/ai.c /^add_inv_node(network, f)$/ add_inverters map/addinv.c /^add_inverters(nodelist, node)$/ add_load_to_node map/bin_util.c /^static void add_load_to_node(node, loadf, best_mat/ add_node_by_name network/append.c /^add_node_by_name(network1, node2)$/ adjust_source_delay map/map_delay.c /^void adjust_source_delay(source_delay, load)$/ all_fanins_positive pld/act_map.c /^int all_fanins_positive(node)$/ all_primes espresso/expand.c /^pcover all_primes(F, R)$/ alloc list/list.c /^#define alloc(type) (type *) malloc(sizeof(type))$/ alloc_bin_tables map/bin_util.c /^static void alloc_bin_tables(node)$/ alloc_buckets map/bin_util.c /^static void alloc_buckets(node)$/ alloc_my_cube pld/xln_k_decomp.c /^alloc_my_cube(cube, support)$/ allocate_pin_params delay/delay.c /^allocate_pin_params(node)$/ and_or_map pld/xln_ufind.c /^and_or_map(network, size)$/ and_with_cofactor espresso/primes.c /^and_with_cofactor(A, cof)$/ apply pld/act_apply.c /^apply(v1, v2, op)$/ applyCleanUp pld/act_apply.c /^applyCleanUp(key, value, arg)$/ applyStep pld/act_apply.c /^ACT_VERTEX_PTR $/ apply_alias command/command.c /^apply_alias(argc, argv)$/ arc_compare map/prim.c /^static int $/ arc_find_or_add map/prim.c /^static int $/ arc_hash map/prim.c /^static int $/ arc_hash_end map/prim.c /^static void $/ arc_hash_init map/prim.c /^arc_hash_init()$/ area_optimization map/bin_area.c /^void area_optimization(network, globals)$/ array_abort array/array.c /^array_abort(i)$/ array_alloc array/array.h /^#define array_alloc(type, number) \\$/ array_append array/array.c /^array_append(array1, array2)$/ array_data array/array.h /^#define array_data(type, array) \\$/ array_do_alloc array/array.c /^array_do_alloc(size, number)$/ array_do_data array/array.c /^array_do_data(array)$/ array_dup array/array.c /^array_dup(old)$/ array_fetch array/array.h /^#define array_fetch(type, a, i) \\$/ array_fetch_last array/array.h /^#define array_fetch_last(array, datum) \\$/ array_free array/array.c /^array_free(array)$/ array_insert array/array.h /^#define array_insert(type, a, i, datum) \\$/ array_insert_last array/array.h /^#define array_insert_last(type, array, datum) \\$/ array_join array/array.c /^array_join(array1, array2)$/ array_n array/array.h /^#define array_n(array) \\$/ array_resize array/array.c /^array_resize(array, new_size)$/ array_sort array/array.c /^array_sort(array, compare)$/ array_uniq array/array.c /^array_uniq(array, compare, free_func)$/ arrival_time_has_changed map/bin_arrival.c /^static int arrival_time_has_changed(table, source_/ arrow graphics/xwindow.c /^arrow(display, win, gc, fromx, fromy, tox, toy, ar/ ascend espresso/setc.c /^int ascend(a, b)$/ assert include/util.h /^#define assert(ex) {\\$/ assignPositions graphics/place.c /^assignPositions(graph, level, maxverts, prevonly, / assign_level speed/speed_util.c /^assign_level(node)$/ assign_levels graphics/level.c /^assign_levels(node)$/ attachLogicFunction octio/octwrite.c /^attachLogicFunction(term, node)$/ attachPolicyProperties octio/octwrite.c /^attachPolicyProperties(facet)$/ attachPolicyTermProperties octio/octwrite.c /^attachPolicyTermProperties(term, direction, termty/ attach_dcnetwork_to_network simplify/cspf.c /^attach_dcnetwork_to_network(network)$/ augmentation maxflow/maxflow.c /^augmentation(graph)$/ avl_check_tree avl/avl.c /^avl_check_tree(tree)$/ avl_count avl/avl.c /^int $/ avl_delete avl/avl.c /^avl_delete(tree, key_p, value_p)$/ avl_find_or_add avl/avl.c /^avl_find_or_add(tree, key, slot_p)$/ avl_first avl/avl.c /^avl_first(tree, key_p, value_p)$/ avl_foreach avl/avl.c /^void $/ avl_foreach_item avl/avl.h /^#define avl_foreach_item(table, gen, dir, key_p, v/ avl_free_gen avl/avl.c /^avl_free_gen(gen)$/ avl_free_table avl/avl.c /^void $/ avl_gen avl/avl.c /^avl_gen(gen, key_p, value_p)$/ avl_init_gen avl/avl.c /^avl_init_gen(tree, dir)$/ avl_init_table avl/avl.c /^avl_init_table(compar)$/ avl_insert avl/avl.c /^avl_insert(tree, key, value)$/ avl_is_member avl/avl.h /^#define avl_is_member(tree, key) avl_lookup(tree, / avl_last avl/avl.c /^avl_last(tree, key_p, value_p)$/ avl_lookup avl/avl.c /^avl_lookup(tree, key, value_p)$/ avl_numcmp avl/avl.c /^int $/ avl_record_gen_backward avl/avl.c /^static void $/ avl_record_gen_forward avl/avl.c /^static void $/ avl_walk_backward avl/avl.c /^static void $/ avl_walk_forward avl/avl.c /^static void $/ balanced_tree decomp/dec_tech.c /^balanced_tree(n, m, node_func, root, nodes, leaves/ bang bdd/bdd_util.c /^#define bang(f) ((BDD_IS_COMPLEMENT(f)) ? '!' : ' / basic_block_node pld/act_map.c /^basic_block_node(A0, A1, SA, B0, B1, SB, S0, S1)$/ bd_comp_exact simplify/filter_util.c /^bd_comp_exact(M, ex_col)$/ bddAlloc bdd/com_bdd.c /^bddAlloc(node)$/ bddDealloc bdd/com_bdd.c /^bddDealloc(node)$/ bdd_alloc_node bdd/bdd_table.c /^bdd_alloc_node(table)$/ bdd_and bdd/bdd_util.c /^bdd_and(f,g,p1,p2) \/* F * G = ITE(F,G,0) *\/$/ bdd_at_node bdd/bdd_util.c /^bdd_at_node(node)$/ bdd_cache_insert bdd/bdd_cache.c /^bdd_cache_insert(table,f,g,h,data)$/ bdd_cache_lookup bdd/bdd_cache.c /^bdd_cache_lookup(table,f,g,h)$/ bdd_cofactor bdd/bdd_co.c /^bdd_cofactor(f,g)$/ bdd_compose bdd/bdd_co.c /^bdd_compose(f,g,h)$/ bdd_constant bdd/bdd_back.c /^bdd_constant(phase,order_list)$/ bdd_construct bdd/bdd_back.c /^bdd_construct(node,order_list,locality)$/ bdd_create_variable bdd/bdd_create.c /^bdd_create_variable(bdd)$/ bdd_dealloc_node bdd/bdd_table.c /^bdd_dealloc_node(table,node)$/ bdd_deref bdd/bdd_ref.c /^bdd_deref(node)$/ bdd_do_cofactor bdd/bdd_co.c /^bdd_do_cofactor(f,g,bdd)$/ bdd_do_compose bdd/bdd_co.c /^bdd_do_compose(f,v,g,bdd)$/ bdd_do_construct bdd/bdd_create.c /^bdd_do_construct(node,bdd,locality)$/ bdd_do_reclaim bdd/bdd_ref.c /^bdd_do_reclaim(n,table)$/ bdd_dup bdd/bdd_util.c /^bdd_dup(f)$/ bdd_else bdd/bdd_util.c /^bdd_else(f)$/ bdd_equal bdd/bdd_util.c /^bdd_equal(f,g)$/ bdd_find_or_add bdd/bdd_table.c /^bdd_find_or_add(table,id,T,E)$/ bdd_free bdd/bdd_util.c /^bdd_free(f)$/ bdd_free_table bdd/bdd_table.c /^bdd_free_table(table)$/ bdd_garbage_collect bdd/bdd_table.c /^bdd_garbage_collect(table)$/ bdd_get_ith_variable bdd/bdd_create.c /^bdd_get_ith_variable(bdd,i)$/ bdd_hash bdd/bdd_int.h /^#define bdd_hash(a,b,c) (((a) << 5) + ((b) << 7) / bdd_init bdd/bdd_init.c /^bdd_init(network,order_list)$/ bdd_init_table bdd/bdd_table.c /^bdd_init_table()$/ bdd_is_tautology bdd/bdd_util.c /^bdd_is_tautology(f,phase)$/ bdd_leq bdd/bdd_util.c /^bdd_leq(f,g,p1,p2) \/* f implies g <=> ITE_const/ bdd_match_order bdd/bdd_back.c /^bdd_match_order(node,order_list)$/ bdd_min bdd/bdd_ite.c /^#define bdd_min(x,y) (((x) < (y)) ? (x) : (y))$/ bdd_node_free bdd/bdd_util.c /^bdd_node_free(n)$/ bdd_not bdd/bdd_util.c /^bdd_not(f)$/ bdd_one bdd/bdd_util.c /^bdd_one(bdd)$/ bdd_or bdd/bdd_util.c /^bdd_or(f,g,p1,p2) \/* F + G = ITE(F,1,G) *\/$/ bdd_print bdd/bdd_util.c /^bdd_print(f)$/ bdd_quit bdd/bdd_init.c /^bdd_quit(bdd)$/ bdd_reclaim bdd/bdd_ref.c /^bdd_reclaim(n,table)$/ bdd_recursive_deref bdd/bdd_ref.c /^bdd_recursive_deref(n,table)$/ bdd_ref bdd/bdd_ref.c /^bdd_ref(node)$/ bdd_register_order bdd/bdd_create.c /^bdd_register_order(bdd,locality)$/ bdd_rehash bdd/bdd_table.c /^bdd_rehash(table)$/ bdd_set_at_node bdd/bdd_util.c /^bdd_set_at_node(node,bdd)$/ bdd_size bdd/bdd_util.c /^bdd_size(f)$/ bdd_size_int bdd/bdd_util.c /^bdd_size_int(n,tab)$/ bdd_table_delete bdd/bdd_verify.c /^bdd_table_delete(key,val,arg)$/ bdd_terminate bdd/bdd_init.c /^bdd_terminate(bdd)$/ bdd_then bdd/bdd_util.c /^bdd_then(f)$/ bdd_top_var bdd/bdd_util.c /^bdd_top_var(f)$/ bdd_verify bdd/bdd_verify.c /^bdd_verify(net1,net2)$/ bdd_xnor bdd/bdd_util.c /^bdd_xnor(f,g) \/* !(F xor G) = ITE(F,G,!G) *\/$/ bdd_xor bdd/bdd_util.c /^bdd_xor(f,g) \/* F xor G = ITE(F,!G,G) *\/$/ bdd_zero bdd/bdd_util.c /^bdd_zero(bdd)$/ bddp bdd/bdd_util.c /^bddp(f,bdd)$/ best_match_is_inverter map/map_int.h /^#define best_match_is_inverter(node) \\$/ best_subcube extract/cube.c /^best_subcube(A)$/ best_subcube_factored extract/cube.c /^best_subcube_factored(A)$/ best_subcube_factored_helper extract/cube.c /^best_subcube_factored_helper(co_rect, rect, state)/ best_subcube_helper extract/cube.c /^best_subcube_helper(co_rect, rect, state)$/ best_subkernel extract/best_subk.c /^best_subkernel(kernel_cube_matrix, row_cost, col_c/ best_subkernel_factor extract/best_subk.c /^best_subkernel_factor(co_rect, rect, state_p)$/ best_subkernel_sop extract/best_subk.c /^best_subkernel_sop(co_rect, rect, state_p)$/ bin_add_pin_to_fanout map/bin_fanout.c /^void bin_add_pin_to_fanout(source, link)$/ bin_alloc map/bin_util.c /^void bin_alloc(node)$/ bin_arrival_init map/bin_arrival.c /^void bin_arrival_init(globals)$/ bin_cleanup_unused_node map/bin_flatten.c /^void bin_cleanup_unused_node(node)$/ bin_delay_area_tree_match map/bin_area_del.c /^bin_delay_area_tree_match(network, library, global/ bin_delay_initialize_pipo map/bin_delay.c /^static void bin_delay_initialize_pipo(network)$/ bin_delay_insert_load map/bin_delay.c /^void bin_delay_insert_load(node, load)$/ bin_delay_tree_match map/bin_delay.c /^network_t *bin_delay_tree_match(network, library, / bin_discretize map/bin_util.c /^static int bin_discretize(r)$/ bin_fanout_cleanup map/bin_fanout.c /^void bin_fanout_cleanup(network)$/ bin_fanout_get_small_inverter map/bin_fanout.c /^lib_gate_t *bin_fanout_get_small_inverter()$/ bin_fanout_init map/bin_fanout.c /^void bin_fanout_init(globals)$/ bin_fanout_power_up map/bin_power.c /^static void bin_fanout_power_up(node_x)$/ bin_fanout_set_minimum_slack map/bin_fanout.c /^void bin_fanout_set_minimum_slack(min)$/ bin_fanout_st_keycmp map/bin_fanout.c /^int bin_fanout_st_keycmp(key1, key2)$/ bin_fanout_st_keyhash map/bin_fanout.c /^int bin_fanout_st_keyhash(key, modulus)$/ bin_fanout_too_complex map/bin_fanout.c /^int bin_fanout_too_complex(x, y)$/ bin_flatten_subnetwork map/bin_flatten.c /^void bin_flatten_subnetwork(node)$/ bin_for_all_nodes_inputs_first map/bin_util.c /^void bin_for_all_nodes_inputs_first(network,fn)$/ bin_for_all_nodes_outputs_first map/bin_util.c /^void bin_for_all_nodes_outputs_first(network,fn)$/ bin_index_to_load map/bin_util.c /^double bin_index_to_load(array, index)$/ bin_init_pi map/bin_delay.c /^void bin_init_pi(node)$/ bin_load_to_index map/bin_util.c /^int bin_load_to_index(node, loadf)$/ bin_load_to_index_heuristic map/bin_util.c /^int bin_load_to_index_heuristic(node, load)$/ bin_load_to_index_insert map/bin_util.c /^int bin_load_to_index_insert(node, load, best_matc/ bin_network_compute_arrival_times map/bin_arrival.c /^void bin_network_compute_arrival_times(network)$/ bin_power_cleanup map/bin_power.c /^static void bin_power_cleanup(network)$/ bin_power_init map/bin_power.c /^static void bin_power_init(network, globals)$/ bin_power_init_links map/bin_power.c /^void bin_power_init_links(network)$/ bin_print_array map/bin_util.c /^void bin_print_array(node)$/ bin_print_buckets map/bin_util.c /^void bin_print_buckets(node)$/ bin_print_gate_stats map/bin_delay.c /^void bin_print_gate_stats(network)$/ bin_print_node map/bin_power.c /^static void bin_print_node(node)$/ bin_print_one_bucket map/bin_util.c /^static void bin_print_one_bucket(name, bucket)$/ bin_propagate_arrival_times_incrementally map/bin_arrival.c /^int bin_propagate_arrival_times_incrementally(netw/ bin_remove_wires map/bin_flatten.c /^void bin_remove_wires(node)$/ bin_required_init map/bin_required.c /^void bin_required_init(globals)$/ bin_required_set_propagate_flag map/bin_required.c /^void bin_required_set_propagate_flag(flag)$/ bin_solution_add mincov/bin_sol.c /^void $/ bin_solution_alloc mincov/bin_sol.c /^bin_solution_alloc(size)$/ bin_solution_del mincov/bin_sol.c /^void $/ bin_solution_dup mincov/bin_sol.c /^bin_solution_dup(sol, size)$/ bin_solution_free mincov/bin_sol.c /^bin_solution_free(sol)$/ binary pld/xln_aux.c /^void binary(value, answer)$/ binate_split_select espresso/cofactor.c /^int binate_split_select(T, cleft, cright, debug_fl/ bit_index espresso/set.c /^int bit_index(a)$/ bit_reverse node/sethack.c /^static unsigned $/ block_copy decomp/partition.c /^block_copy(A, L, R)$/ bound_rect_size_fancy extract/cube.c /^bound_rect_size_fancy(co_rect, rect)$/ bound_rect_size_simple extract/cube.c /^bound_rect_size_simple(co_rect, rect)$/ bp2 bdd/bdd_util.c /^bp2(f,one,t)$/ break_loop maxflow/maxflow.c /^break_loop(graph, node1, node2)$/ bucket_arrival map/bin_delay.c /^static double bucket_arrival(bucket)$/ buf_annotate_trans2 speed/buf_trans2.c /^buf_annotate_trans2(network, fanouts, num_pos, num/ buf_annotate_trans3 speed/buf_recur.c /^static void $/ buf_compare_fanout speed/buf_recur.c /^buf_compare_fanout(ptr1, ptr2)$/ buf_cumulative_cap speed/buf_recur.c /^buf_cumulative_cap(fanouts, num_pos, num_neg, req_/ buf_dump_fanout_data speed/buf_recur.c /^buf_dump_fanout_data(fp, fanouts, n)$/ buf_evaluate_trans2 speed/buf_trans2.c /^int $/ buf_get_gate_version speed/buf_util.c /^buf_get_gate_version(gate, version)$/ buf_implement_trans2 speed/buf_trans2.c /^buf_implement_trans2(network, node, inv_node, fano/ buf_implement_trans3 speed/buf_recur.c /^buf_implement_trans3(network, node, node_inv, fano/ buf_num_fanout speed/buffer_int.h /^#define buf_num_fanout(n) ((n) != NIL(node_t) ? no/ buffer_alloc speed/buf_util.c /^buffer_alloc(node)$/ buffer_free speed/buf_util.c /^buffer_free(node)$/ buffer_inputs map/hackit.c /^buffer_inputs(network, library)$/ buffer_network speed/sp_buffer.c /^buffer_network(network, limit, do_trace, thresh, s/ build_F pld/act_urp.c /^build_F(node)$/ build_complex_case map/bin_fanout.c /^void build_complex_case(source, table, delay_info,/ build_fanin_array simplify/simall.c /^build_fanin_array(f)$/ build_fanout_network map/bin_fanout.c /^void build_fanout_network(source, table, delay_inf/ build_fanout_network_rec map/bin_fanout.c /^static void build_fanout_network_rec(arrival, sour/ build_intersection_matrix mincov/indep.c /^build_intersection_matrix(A)$/ build_network map/treemap.c /^build_network(network)$/ build_network_recur map/treemap.c /^build_network_recur(new_network, node)$/ build_new_fanout map/bin_fanout.c /^static node_t *build_new_fanout(source, slack, fan/ build_new_node octio/octread.c /^build_new_node(node, network, instance)$/ build_parallel_network map/bin_fanout.c /^static void build_parallel_network(arrival, delay_/ cactive espresso/setc.c /^int cactive(a)$/ calc_sizes graphics/xwindow.c /^calc_sizes(win, shape, font, numlines, lines, widt/ cautious_define_cube_size node/cubehack.c /^void $/ cb1_dsharp espresso/sharp.c /^pcover cb1_dsharp(T, c)$/ cb_consensus espresso/essen.c /^pcover cb_consensus(T, c)$/ cb_consensus_dist0 espresso/essen.c /^pcover cb_consensus_dist0(R, p, c)$/ cb_dsharp espresso/sharp.c /^pcover cb_dsharp(c, T)$/ cb_recur_sharp espresso/sharp.c /^pcover cb_recur_sharp(c, T, first, last, level)$/ cb_sharp espresso/sharp.c /^pcover cb_sharp(c, T)$/ cb_unravel espresso/cvrm.c /^static void cb_unravel(c, start, end, startbase, B/ ccommon espresso/setc.c /^bool ccommon(a, b, cof)$/ cdist espresso/setc.c /^int cdist(a, b)$/ cdist0 espresso/setc.c /^bool cdist0(a, b)$/ cdist01 espresso/setc.c /^int cdist01(a, b)$/ cdist0bv minimize/ros.h /^#define cdist0bv(p, q, var) \\$/ cdist0v minimize/ros.c /^cdist0v(p, q, var)$/ change_edge_capacity pld/xln_ULM_util.c /^change_edge_capacity(graph, node, capacity)$/ check maxflow/maxflow.c /^check(graph)$/ check_consistency espresso/verify.c /^bool check_consistency(PLA)$/ check_cube bdd/bdd_co.c /^check_cube(g,bdd)$/ check_equiv espresso/equiv.c /^int check_equiv(f1, f2)$/ check_error network/netchk.c /^check_error(s, node)$/ check_file util/pathsearch.c /^check_file(filename, mode)$/ check_internal_phase genlib/genlib.c /^check_internal_phase(tree, level)$/ check_loop maxflow/maxflow.c /^check_loop(node)$/ check_network map/bin_power.c /^static void check_network(network)$/ check_network_rec map/bin_power.c /^static void check_network_rec(network, table, node/ check_phase phase/phase.c /^check_phase(net_phase)$/ check_pin_is_correct map/bin_power.c /^static void check_pin_is_correct(node, link)$/ check_rect_value extract/greedycol.c /^check_rect_value(A, col_cost, row_cost, rect)$/ check_shell_escape command/command.c /^check_shell_escape(p, status)$/ check_type main/mis.c /^check_type(s)$/ check_uniform graphics/uniform.c /^check_uniform(node)$/ check_universal pld/act_leaf.c /^static int $/ chk_err node/nodecheck.c /^chk_err(s, node)$/ choose_col_seed extract/pingpong.c /^choose_col_seed(A, col_cost)$/ choose_largest_gate map/hackit.c /^choose_largest_gate(library, string)$/ choose_next_col_seed extract/pingpong.c /^choose_next_col_seed(A, col_cost, rect)$/ choose_next_row_seed extract/pingpong.c /^choose_next_row_seed(A, row_cost, rect)$/ choose_row_seed extract/pingpong.c /^choose_row_seed(A, row_cost)$/ choose_smallest_gate map/treemap.c /^choose_smallest_gate(library, string)$/ choose_subcube extract/cube.c /^choose_subcube(A, row_cost, col_cost, option)$/ choose_subkernel extract/best_subk.c /^choose_subkernel(A, row_cost, col_cost, option)$/ clean_master_table octio/octread.c /^clean_master_table()$/ cleanup_converted_data map/bin_power.c /^static void cleanup_converted_data(fanout_info)$/ cleanup_node_if_necessary map/bin_power.c /^static void cleanup_node_if_necessary(node)$/ cleanup_unused_nodes map/bin_flatten.c /^static void cleanup_unused_nodes(node_array)$/ clear_kernel_rect extract/kernel.c /^clear_kernel_rect(A, rect)$/ clear_rect extract/cube.c /^clear_rect(A, rect)$/ close_ROS minimize/ros.c /^close_ROS()$/ close_win graphics/xwindow.c /^close_win(win)$/ clp_est factor/elim.c /^static int $/ cmp_est factor/elim.c /^cmp_est(f)$/ cof_output espresso/cvrm.c /^pcover cof_output(T, i)$/ cofactor espresso/cofactor.c /^pcube *cofactor(T, c)$/ col_value extract/pingpong.c /^col_value(pcol, col_cost)$/ color_free graphics/xwindow.c /^color_free(k, v, a)$/ com_ULM_cover pld/com_pld.c /^com_ULM_cover(network, argc, argv)$/ com_ULM_merge pld/com_pld.c /^com_ULM_merge(network)$/ com__count_nets pld/com_pld.c /^com__count_nets(network)$/ com__estimate_clb pld/com_pld.c /^com__estimate_clb(network, argc, argv)$/ com__is_2ip_and speed/com_speed.c /^com__is_2ip_and(network, argc, argv)$/ com__node_value pld/com_pld.c /^com__node_value(network, argc, argv)$/ com__part_collapse speed/com_speed.c /^com__part_collapse(network, argc, argv)$/ com__print_cutset speed/com_speed.c /^com__print_cutset(network, argc, argv)$/ com__print_fanout speed/com_speed.c /^com__print_fanout(network, argc, argv)$/ com__print_last speed/com_speed.c /^com__print_last(network, argc, argv)$/ com__print_weight speed/com_speed.c /^com__print_weight(network, argc, argv)$/ com__reduce_delay speed/com_speed.c /^com__reduce_delay(network, argc, argv)$/ com__run_maxflow maxflow/com_max.c /^com__run_maxflow(network, argc, argv)$/ com__speed_delay speed/com_speed.c /^com__speed_delay(network, argc, argv)$/ com__speed_plot speed/speed_plot.c /^com__speed_plot(network, argc, argv)$/ com_act_main pld/com_pld.c /^com_act_main(network, argc, argv)$/ com_add_command command/addcom.c /^com_add_command(name, func_fp, changes)$/ com_add_inv phase/com_ph.c /^com_add_inv(network, argc, argv)$/ com_alias command/alias.c /^com_alias(network, argc, argv)$/ com_alias_free command/alias.c /^com_alias_free(value)$/ com_and_or_map pld/com_pld.c /^com_and_or_map(network, argc, argv)$/ com_bdd_cofactor bdd/com_bdd.c /^com_bdd_cofactor(network,argc,argv)$/ com_bdd_compose bdd/com_bdd.c /^com_bdd_compose(network,argc,argv)$/ com_bdd_create bdd/com_bdd.c /^com_bdd_create(network,argc,argv)$/ com_bdd_implies bdd/com_bdd.c /^com_bdd_implies(network,argc,argv)$/ com_bdd_print bdd/com_bdd.c /^com_bdd_print(network,argc,argv)$/ com_bdd_size bdd/com_bdd.c /^com_bdd_size(network,argc,argv)$/ com_bdd_test bdd/com_bdd.c /^com_bdd_test(network)$/ com_bdd_verify bdd/com_bdd.c /^com_bdd_verify(network,argc,argv)$/ com_bdsyn io/com_io.c /^com_bdsyn(old_network, argc, argv)$/ com_best command/commisc.c /^com_best(network, argc, argv)$/ com_buffer map/com_map.c /^com_buffer(network, argc, argv)$/ com_buffer_opt speed/com_speed.c /^com_buffer_opt(network, argc, argv)$/ com_check network/com_network.c /^com_check(network, argc, argv)$/ com_chname io/com_io.c /^com_chname(network, argc, argv)$/ com_cof node/com_node.c /^com_cof(network, argc, argv)$/ com_collapse network/com_network.c /^com_collapse(network, argc, argv)$/ com_command_free command/addcom.c /^com_command_free(value)$/ com_cspf simplify/com_simp.c /^com_cspf(network, argc, argv)$/ com_cube_extract extract/com_ex.c /^com_cube_extract(network, argc, argv)$/ com_decomp decomp/com_dec.c /^com_decomp(network, argc, argv)$/ com_dispatch command/command.c /^com_dispatch(network, argc, argv)$/ com_div node/com_node.c /^com_div(network, argc, argv)$/ com_divide_network pld/com_pld.c /^com_divide_network(network, argc, argv)$/ com_dump_patterns map/com_map.c /^com_dump_patterns(network, argc, argv)$/ com_eat_buffer map/com_map.c /^com_eat_buffer(network, argc, argv)$/ com_echo command/commisc.c /^com_echo(network, argc, argv)$/ com_eliminate factor/com_ft.c /^com_eliminate(network, argc, argv)$/ com_espresso network/com_network.c /^com_espresso(network, argc, argv)$/ com_execute command/command.c /^com_execute(network, command)$/ com_factor factor/com_ft.c /^com_factor(network, argc, argv)$/ com_factor_conv factor/com_ft.c /^com_factor_conv(network, argc, argv)$/ com_free_argv command/alias.c /^com_free_argv(argc, argv)$/ com_gdiv extract/com_ex.c /^com_gdiv(network, argc, argv)$/ com_get_flag command/cmd_set.c /^com_get_flag(flag)$/ com_get_nodes command/get_nodes.c /^com_get_nodes(network, argc, argv)$/ com_get_true_nodes command/get_true_po.c /^com_get_true_nodes(network, argc, argv)$/ com_help command/help.c /^com_help(network, argc, argv)$/ com_infinite_loop command/commisc.c /^com_infinite_loop(network, argc, argv)$/ com_invert node/com_node.c /^com_invert(network, argc, argv)$/ com_karp_decomp pld/com_pld.c /^com_karp_decomp(network, argc, argv)$/ com_kernel_extract extract/com_ex.c /^com_kernel_extract(network, argc, argv)$/ com_map map/com_map.c /^com_map(network, argc, argv)$/ com_map_addinv map/com_map.c /^com_map_addinv(network, argc, argv)$/ com_map_reminv map/com_map.c /^com_map_reminv(network, argc, argv)$/ com_maxflow maxflow/com_max.c /^com_maxflow(network, argc, argv)$/ com_myps simplify/com_simp.c /^com_myps(network, argc, argv)$/ com_open_file command/open_file.c /^com_open_file(filename, mode, real_filename_p, sil/ com_partition pld/com_pld.c /^com_partition(network, argc, argv)$/ com_pf factor/com_ft.c /^com_pf(network, argc, argv)$/ com_pft factor/com_ft.c /^com_pft(network, argc, argv)$/ com_phase_assign phase/com_ph.c /^com_phase_assign(network, argc, argv)$/ com_plot graphics/com_graphics.c /^com_plot(network, argc, argv)$/ com_premap map/com_map.c /^com_premap(network, argc, argv)$/ com_print io/com_io.c /^com_print(network, argc, argv)$/ com_print_altname io/com_io.c /^com_print_altname(network, argc, argv)$/ com_print_delay delay/com_delay.c /^com_print_delay(network, argc, argv)$/ com_print_delay_constraints delay/com_delay.c /^com_print_delay_constraints(network, argc, argv)$/ com_print_exdc simplify/cspf_io.c /^com_print_exdc(network, argc, argv)$/ com_print_factor gcd/com_gcd.c /^com_print_factor(network, argc, argv)$/ com_print_gate map/com_map.c /^com_print_gate(network, argc, argv)$/ com_print_gcd gcd/com_gcd.c /^com_print_gcd(network, argc, argv)$/ com_print_io io/com_io.c /^com_print_io(network, argc, argv)$/ com_print_io_exdc simplify/cspf_io.c /^com_print_io_exdc(network, argc, argv)$/ com_print_kernel extract/com_ex.c /^com_print_kernel(network, argc, argv)$/ com_print_level speed/com_speed.c /^com_print_level(network, argc, argv)$/ com_print_library map/com_map.c /^com_print_library(network, argc, argv)$/ com_print_stats io/com_io.c /^com_print_stats(network, argc, argv)$/ com_print_stats_exdc simplify/cspf_io.c /^com_print_stats_exdc(network, argc, argv)$/ com_pv factor/com_ft.c /^com_pv(network, argc, argv)$/ com_quit command/commisc.c /^com_quit(network, argc, argv)$/ com_read io/com_io.c /^com_read(network, argc, argv)$/ com_read_exdc simplify/cspf_io.c /^com_read_exdc(network, argc, argv)$/ com_read_library map/com_map.c /^com_read_library(network, argc, argv)$/ com_reset_name io/com_io.c /^com_reset_name(network, argc, argv)$/ com_resub resub/com_resub.c /^com_resub(network, argc, argv)$/ com_ripup network/com_network.c /^com_ripup(network, argc, argv)$/ com_save_image command/commisc.c /^com_save_image(network, argc, argv)$/ com_scc node/com_node.c /^com_scc(network, argc, argv)$/ com_set_delay delay/com_delay.c /^com_set_delay(network, argc, argv)$/ com_set_variable command/cmd_set.c /^com_set_variable(network, argc, argv)$/ com_sim node/com_node.c /^com_sim(network, argc, argv)$/ com_sim_verify sim/com_sim.c /^com_sim_verify(network, argc, argv)$/ com_simall simplify/com_simp.c /^com_simall(network, argc, argv)$/ com_simp simplify/com_simp.c /^com_simp(network, argc, argv)$/ com_simplify simplify/com_simp.c /^com_simplify(network, argc, argv)$/ com_simulate sim/com_sim.c /^com_simulate(network, argc, argv)$/ com_source command/source.c /^com_source(network, argc, argv)$/ com_speed_up speed/com_speed.c /^com_speed_up(network, argc, argv)$/ com_sweep network/com_network.c /^com_sweep(network, argc, argv)$/ com_tdecomp decomp/com_dec.c /^com_tdecomp(network, argc, argv)$/ com_test test/example.c /^com_test(network, argc, argv)$/ com_test_mf maxflow/com_max.c /^com_test_mf(network, argc, argv)$/ com_time command/commisc.c /^com_time(network, argc, argv)$/ com_treesize map/com_map.c /^com_treesize(network, argc, argv)$/ com_unalias command/alias.c /^com_unalias(network, argc, argv)$/ com_undo command/undo.c /^com_undo(network, argc, argv)$/ com_unset_variable command/cmd_set.c /^com_unset_variable(network, argc, argv)$/ com_usage command/commisc.c /^com_usage(network, argc, argv)$/ com_verify network/com_network.c /^com_verify(network, argc, argv)$/ com_wd node/com_node.c /^com_wd(network, argc, argv)$/ com_which command/commisc.c /^com_which(network, argc, argv)$/ com_write io/com_io.c /^com_write(network, argc, argv)$/ com_write_exdc simplify/cspf_io.c /^com_write_exdc(network, argc, argv)$/ com_write_slif io/write_slif.c /^com_write_slif(network, argc, argv)$/ combine pld/xln_part.c /^combine(network, size)$/ command_alias_help command/help.c /^command_alias_help(command)$/ comp_perm_fn simplify/cspf.c /^comp_perm_fn(networkptr, accept, method, dctype, f/ comp_ptr pld/xln_ULM_util.c /^int comp_ptr(obj1, obj2)$/ compare array/arr_main.c /^static int $/ compare_cost map/treemap.c /^compare_cost (this_area, this_arrival, match_area,/ compare_count map/treesize.c /^compare_count(x, y)$/ compare_gate_links map/bin_power.c /^static int compare_gate_links(obj1, obj2)$/ compare_int map/bin_util.c /^static int compare_int(obj1, obj2)$/ compare_network map/library.c /^compare_network(net1, net2)$/ compare_node_by_name node/nodemisc.c /^static int $/ compare_rev mincov/bin_mincov.c /^static int $/ compl_cube espresso/compl.c /^static pcover compl_cube(p)$/ compl_d1merge espresso/compl.c /^static void compl_d1merge(L1, R1)$/ compl_lift espresso/compl.c /^static void compl_lift(A1, B1, bcube, var)$/ compl_lift_onset espresso/compl.c /^static void compl_lift_onset(A1, T, bcube, var)$/ compl_lift_onset_complex espresso/compl.c /^static void compl_lift_onset_complex(A1, T, var)$/ compl_merge espresso/compl.c /^static pcover compl_merge(T1, L, R, cl, cr, var, l/ compl_special_cases espresso/compl.c /^static bool compl_special_cases(T, Tbar)$/ complement espresso/compl.c /^pcover complement(T)$/ composite_fanin pld/xln_part.c /^int $/ compute_and_remember_arrival_time map/bin_arrival.c /^static void compute_and_remember_arrival_time(node/ compute_best_fit_inverter map/bin_fanout.c /^static int compute_best_fit_inverter(arrival, dela/ compute_best_match map/bin_delay.c /^void compute_best_match(node)$/ compute_best_number_of_inverters map/map_delay.c /^int compute_best_number_of_inverters(arrival, sour/ compute_cost_array pld/act_map.c /^compute_cost_array(node_array, dup_net, cost_array/ compute_cspf simplify/cspf.c /^compute_cspf(DC, pfanin, node_table2, ANDpi, node_/ compute_cumul_loads map/bin_power.c /^static void compute_cumul_loads(gate_info)$/ compute_default_gate map/map_delay.c /^static lib_gate_t *compute_default_gate()$/ compute_delay delay/delay.c /^compute_delay(node, pin_delay, model)$/ compute_height avl/avl.c /^#define compute_height(node) { \\$/ compute_level map/bin_util.c /^static void compute_level(node)$/ compute_mapped_params delay/delay.c /^compute_mapped_params(node, mode)$/ compute_max_loads map/bin_power.c /^static void compute_max_loads(gate_info)$/ compute_maximum_slack map/bin_fanout.c /^delay_time_t compute_maximum_slack(source, table, / compute_maximum_slack_hash map/bin_fanout.c /^static bin_opt_t compute_maximum_slack_hash(arriva/ compute_maximum_slack_rec map/bin_fanout.c /^static bin_opt_t compute_maximum_slack_rec(arrival/ compute_maximum_value map/map_delay.c /^static double compute_maximum_value(n_elts, a, b, / compute_min_max map/bin_util.c /^static void compute_min_max(table, min, max)$/ compute_min_required map/bin_power.c /^static void compute_min_required(gate_info)$/ compute_minimum_index map/map_delay.c /^static int compute_minimum_index(n_elts, a, b, c)$/ compute_mspf simplify/cspf.c /^compute_mspf(node, fanin, node_table,ANDpi)$/ compute_old_slack map/bin_power.c /^static delay_time_t compute_old_slack(node)$/ compute_output_arrivals map/bin_delay.c /^static void compute_output_arrivals(prim, gate, lo/ compute_own_required_time map/bin_required.c /^static void compute_own_required_time(node)$/ compute_pin_delay map/map_delay.c /^double compute_pin_delay(gate, i, load)$/ compute_pin_required_times map/bin_required.c /^static void compute_pin_required_times(node)$/ compute_po_required_times map/bin_required.c /^void compute_po_required_times(network, required)$/ compute_required_times_globally map/bin_required.c /^void compute_required_times_globally(source_x, sou/ compute_required_times_locally map/bin_required.c /^void compute_required_times_locally(source)$/ compute_required_times_locally_rec map/bin_required.c /^static void compute_required_times_locally_rec(nod/ compute_result_found_in_table map/bin_fanout.c /^static int compute_result_found_in_table(arrival,k/ compute_source_delay map/map_delay.c /^char *compute_source_delay(nin, pin_arrivals, mode/ compute_source_delay_pi map/map_delay.c /^char *compute_source_delay_pi(input_drive)$/ compute_wire_load delay/delay.c /^compute_wire_load(pins)$/ compute_wire_output_arrivals map/bin_delay.c /^static void compute_wire_output_arrivals(load_arra/ consensus espresso/setc.c /^void consensus(r, a, b)$/ construct_cutset maxflow/maxflow.c /^construct_cutset(graph)$/ construct_maxflow_network pld/xln_map_par.c /^construct_maxflow_network()$/ construct_node_from_cube pld/act_map.c /^node_t * construct_node_from_cube(cube, node)$/ convert_data_to_suitable_format map/bin_power.c /^static int convert_data_to_suitable_format(root, n/ copy_array_in_table map/bin_util.c /^static void copy_array_in_table(table, array)$/ copy_bucket_to_map map/bin_delay.c /^static void copy_bucket_to_map(node, bucket)$/ copy_cost espresso/cvrmisc.c /^void copy_cost(s, d)$/ copy_file util/saveimage.c /^copy_file(inFd, outFd, nbytes)$/ copy_list network/network_util.c /^copy_list(list, newlist)$/ copy_map_to_map map/bin_flatten.c /^static void copy_map_to_map(from, to)$/ copy_node network/append.c /^copy_node(network1, node2, name_hack)$/ copy_row decomp/partition.c /^copy_row(A, prow)$/ copy_table_in_array map/bin_util.c /^static void copy_table_in_array(array, table)$/ cost_comp phase/phase_lib.c /^cost_comp(net_phase)$/ cost_fanin pld/xln_part.c /^cost_fanin(po, fanin)$/ cost_of_node pld/act_map.c /^int $/ cost_update pld/act_map.c /^cost_update(node, cost_table, cost_struct)$/ count_intsec_union pld/xln_ULM_util.c /^count_intsec_union(array1, array2, num_intsec, num/ count_it genlib/count.c /^static int $/ count_ones espresso/espresso.h /^#define count_ones(v)\\$/ cov_and_est factor/elim.c /^static int $/ cov_est factor/elim.c /^static int $/ cov_inv_est factor/elim.c /^cov_inv_est(fanout, np, root, cmp_size)$/ cov_leaf_est factor/elim.c /^cov_leaf_est(fanout, np, root, cmp_size)$/ cov_or_est factor/elim.c /^static int $/ cover_cost espresso/cvrmisc.c /^void cover_cost(F, cost)$/ cprint espresso/cvrout.c /^void cprint(T)$/ createGenericMaster octio/octwrite.c /^createGenericMaster(node, name, view)$/ createInterface octio/octwrite.c /^createInterface(facet)$/ create_inverter map/addinv.c /^create_inverter(nodelist, fanin)$/ cspf_alloc simplify/cspf.c /^static void $/ cspf_dc simplify/cspf.c /^cspf_dc(f)$/ cspf_free simplify/cspf.c /^static void $/ cspf_inout_table simplify/cspf.c /^cspf_inout_table(f, il, ol)$/ cube1list espresso/cofactor.c /^pcube *cube1list(A)$/ cube2list espresso/cofactor.c /^pcube *cube2list(A, B)$/ cube3list espresso/cofactor.c /^pcube *cube3list(A, B, C)$/ cube_is_covered espresso/irred.c /^cube_is_covered(T, c)$/ cube_order minimize/dcsimp.c /^int cube_order(p)$/ cube_setup espresso/cubestr.c /^void cube_setup()$/ cubeindex_alloc extract/cubeindex.c /^cubeindex_alloc()$/ cubeindex_free extract/cubeindex.c /^cubeindex_free(table)$/ cubeindex_getcube extract/cubeindex.c /^cubeindex_getcube(table, index)$/ cubeindex_getindex extract/cubeindex.c /^cubeindex_getindex(table, cube)$/ cubelist_partition espresso/cvrm.c /^int cubelist_partition(T, A, B, comp_debug)$/ cubeunlist espresso/cofactor.c /^pcover cubeunlist(A1)$/ cutset maxflow/cutset.c /^cutset(network,node_table)$/ cv_dsharp espresso/sharp.c /^pcover cv_dsharp(A, B)$/ cv_intersect espresso/sharp.c /^pcover cv_intersect(A, B)$/ cv_sharp espresso/sharp.c /^pcover cv_sharp(A, B)$/ d1_order espresso/setc.c /^int d1_order(a, b)$/ d1_rm_equal espresso/contain.c /^int d1_rm_equal(A1, compare)$/ d1merge espresso/contain.c /^pset_family d1merge(A, var)$/ dc_simplify minimize/dcsimp.c /^void dc_simplify(F,D,LKset)$/ dc_special_cases minimize/dcsimp.c /^static bool dc_special_cases(F,D,FD)$/ dcsimp minimize/dcsimp.c /^pcover dcsimp(F,Old_D)$/ debug1_print espresso/cvrout.c /^void debug1_print(T, name, num)$/ debug_print espresso/cvrout.c /^void debug_print(T, name, level)$/ dec_block_partition decomp/partition.c /^dec_block_partition(A, L, R)$/ dec_node_cube decomp/dec_util.c /^dec_node_cube(f, i)$/ dec_node_to_sm decomp/dec_sm.c /^dec_node_to_sm(f)$/ dec_sm_print decomp/dec_sm.c /^dec_sm_print(M)$/ dec_sm_to_node decomp/dec_sm.c /^dec_sm_to_node(M)$/ decomp_and decomp/dec_tech.c /^decomp_and(network, f, and_limit)$/ decomp_and_or decomp/dec_tech.c /^decomp_and_or(network, f)$/ decomp_big_nodes pld/act_map.c /^decomp_big_nodes(network, cost_table, gain, DECOMP/ decomp_disj decomp/disj.c /^decomp_disj(f)$/ decomp_disj_network decomp/decomp.c /^decomp_disj_network(network)$/ decomp_disj_node decomp/decomp.c /^decomp_disj_node(network, f)$/ decomp_good decomp/decomp.c /^decomp_good(f)$/ decomp_good_kernel decomp/dec_util.c /^decomp_good_kernel(f)$/ decomp_good_network decomp/decomp.c /^decomp_good_network(network)$/ decomp_good_node decomp/decomp.c /^decomp_good_node(network, f)$/ decomp_or decomp/dec_tech.c /^decomp_or(network, f, or_limit)$/ decomp_quick decomp/decomp.c /^decomp_quick(f)$/ decomp_quick_kernel decomp/dec_util.c /^decomp_quick_kernel(f)$/ decomp_quick_network decomp/decomp.c /^decomp_quick_network(network) $/ decomp_quick_node decomp/decomp.c /^decomp_quick_node(network, f)$/ decomp_recur decomp/dec_alg.c /^decomp_recur(f, gen_divisor)$/ decomp_tech_network decomp/dec_tech.c /^decomp_tech_network(network, and_limit, or_limit)$/ decomp_usage decomp/com_dec.c /^decomp_usage()$/ define_cube_size node/cubehack.c /^define_cube_size(n)$/ delay_alloc delay/delay.c /^delay_alloc(node)$/ delay_arrival_time delay/delay.c /^delay_arrival_time(node)$/ delay_compute_atime delay/delay.c /^delay_compute_atime(node, model, load)$/ delay_compute_pin_delays map/map_delay.c /^void delay_compute_pin_delays(gate, loads, pin_del/ delay_dup delay/delay.c /^delay_dup(old, new)$/ delay_error delay/delay.c /^delay_error(string)$/ delay_fanout_contribution delay/delay.c /^delay_fanout_contribution(node, pin_num, fanout, m/ delay_force_pininfo delay/delay.c /^delay_force_pininfo(node)$/ delay_free delay/delay.c /^delay_free(node)$/ delay_gate_arrival_times map/map_delay.c /^void delay_gate_arrival_times(nin, arrival_times, / delay_generate_decomposition delay/delay.c /^delay_generate_decomposition(node, mode)$/ delay_get_arrival map/map_delay.c /^delay_time_t delay_get_arrival(node)$/ delay_get_block delay/delay.c /^delay_get_block(pin_delay)$/ delay_get_drive delay/delay.c /^delay_get_drive(pin_delay)$/ delay_get_input_drive map/map_delay.c /^delay_time_t delay_get_input_drive(node)$/ delay_get_load delay/delay.c /^delay_get_load(pin_delay)$/ delay_get_output_load map/map_delay.c /^double delay_get_output_load(node)$/ delay_get_output_required_time map/map_delay.c /^delay_time_t delay_get_output_required_time(node)$/ delay_get_parameter delay/delay.c /^delay_get_parameter(node, param)$/ delay_get_pi_arrival_time delay/delay.c /^int delay_get_pi_arrival_time(node, arrival)$/ delay_get_pi_drive delay/delay.c /^delay_get_pi_drive(node, drive)$/ delay_get_po_load delay/delay.c /^delay_get_po_load(node, load)$/ delay_get_po_required_time delay/delay.c /^delay_get_po_required_time(node, required)$/ delay_giveaway_pin_delay delay/delay.c /^delay_giveaway_pin_delay(network)$/ delay_invalid delay/delay.c /^delay_invalid(node)$/ delay_latest_output delay/delay.c /^delay_latest_output(network, latest_p)$/ delay_load delay/delay.c /^delay_load(node)$/ delay_map_compute_required_times map/map_delay.c /^void $/ delay_map_double_to_phase delay/delay_int.h /^#define delay_map_double_to_phase(x) ((pin_phase_t/ delay_map_simulate delay/mapdelay.c /^delay_map_simulate(nin, pin_arrivals, model, load)/ delay_map_simulate_simple map/map_delay.c /^delay_time_t delay_map_simulate_simple(arrival, so/ delay_node_pin delay/delay.c /^delay_node_pin(node, pin_num, model)$/ delay_print_wire_loads delay/delay.c /^delay_print_wire_loads(fp)$/ delay_required_time delay/delay.c /^delay_required_time(node)$/ delay_set_parameter delay/delay.c /^delay_set_parameter(node, param, value)$/ delay_slack_time delay/delay.c /^delay_slack_time(node)$/ delay_sort delay/com_delay.c /^delay_sort(node1_p, node2_p)$/ delay_trace delay/delay.c /^int $/ delay_tree_match map/bin_delay.c /^network_t *delay_tree_match(network, library, glob/ delete_act pld/act_init.c /^delete_act(vertex, table)$/ delete_from_list network/network_util.c /^delete_from_list(list, node)$/ delvar espresso/pair.c /^pcover delvar(A, paired)$/ derive_dual_classes map/library.c /^derive_dual_classes(library)$/ desc1 espresso/setc.c /^int desc1(a, b)$/ descend espresso/setc.c /^int descend(a, b)$/ dg_alloc graphics/build.c /^dg_alloc(title)$/ dg_calc_sizes graphics/outdev.c /^dg_calc_sizes(win, shape, font, numlines, lines, w/ dg_clipshape graphics/clipshape.c /^dg_clipshape(shape, width, height, fromx, fromy, t/ dg_close graphics/outdev.c /^dg_close(win)$/ dg_create_arc graphics/build.c /^dg_create_arc(from, to)$/ dg_create_node graphics/build.c /^dg_create_node(graph)$/ dg_curve_verts graphics/curve.c /^dg_curve_verts(verts, vcount, nvlist)$/ dg_delete_arc graphics/build.c /^dg_delete_arc(arc)$/ dg_delete_node graphics/build.c /^dg_delete_node(node)$/ dg_draw graphics/draw.c /^dg_draw(window, graph, type, arg)$/ dg_draw_arc graphics/outdev.c /^dg_draw_arc(win, fx, fy, tx, ty, color, style, lab/ dg_draw_node graphics/outdev.c /^dg_draw_node(win, xpos, ypos, shape, color, font, / dg_dump graphics/build.c /^dg_dump(graph)$/ dg_foreach_arc graphics/graphics_int.h /^#define dg_foreach_arc(graph, gen, arc) \\$/ dg_foreach_fanin graphics/graphics_int.h /^#define dg_foreach_fanin(node, gen, arc) \\$/ dg_foreach_fanout graphics/graphics_int.h /^#define dg_foreach_fanout(node, gen, arc) \\$/ dg_foreach_node graphics/graphics_int.h /^#define dg_foreach_node(graph, gen, node) \\$/ dg_free graphics/build.c /^dg_free(graph)$/ dg_get_arc_props graphics/build.c /^dg_get_arc_props(arc, color, style, label)$/ dg_get_node_props graphics/build.c /^dg_get_node_props(node, type, color, shape, font, / dg_kill graphics/draw.c /^dg_kill(win)$/ dg_level graphics/level.c /^dg_level(graph)$/ dg_lsForeachItem graphics/graphics_int.h /^#define dg_lsForeachItem(list, gen, data) \\$/ dg_make_uniform graphics/uniform.c /^dg_make_uniform(graph)$/ dg_old_place graphics/place.c /^dg_old_place(graph)$/ dg_open graphics/outdev.c /^dg_open(window, arg, xlo, ylo, xhi, yhi, label)$/ dg_out_name graphics/mynames.c /^dg_out_name(out)$/ dg_parse_out graphics/mynames.c /^dg_parse_out(name)$/ dg_parse_shape graphics/mynames.c /^dg_parse_shape(name)$/ dg_parse_style graphics/mynames.c /^dg_parse_style(name)$/ dg_parse_type graphics/mynames.c /^dg_parse_type(name)$/ dg_place graphics/place.c /^dg_place(graph)$/ dg_set_arc_props graphics/build.c /^dg_set_arc_props(arc, color, style, label)$/ dg_set_node_props graphics/build.c /^dg_set_node_props(node, type, color, shape, font, / dg_setdev graphics/outdev.c /^dg_setdev(type)$/ dg_shape_name graphics/mynames.c /^dg_shape_name(shape)$/ dg_solvemat graphics/solvemat.c /^dg_solvemat(matrix, vector, size)$/ dg_style_name graphics/mynames.c /^dg_style_name(style)$/ dg_type_name graphics/mynames.c /^dg_type_name(type)$/ dg_update graphics/outdev.c /^dg_update(win)$/ disassemble_fsm espresso/hack.c /^disassemble_fsm(PLA, verbose_mode)$/ discard_pla network/net2pla.c /^discard_pla(PLA)$/ dist_check simplify/filter_util.c /^dist_check(M, p, r, distance)$/ dist_merge espresso/contain.c /^pset_family dist_merge(A, mask)$/ divide_finale node/divide.c /^divide_finale(list, quotient, divisor_ncube, q_sf,/ divide_find_classes node/divide.c /^divide_find_classes(list, fullset)$/ divide_one_phase node/substitute.c /^divide_one_phase(f, g, out, phase)$/ divide_setup_dividend node/divide.c /^divide_setup_dividend(head, sf, divisor_support)$/ divide_setup_divisor node/divide.c /^divide_setup_divisor(sf)$/ divide_single_cube node/divide.c /^divide_single_cube(f, g, r_node)$/ divide_single_literal node/divide.c /^divide_single_literal(f, g, r_node)$/ dll_unlink sparse/sparse_int.h /^#define dll_unlink(p, first, last, next, prev, cou/ do_acyclic_check network/acyclic.c /^static int $/ do_assign io/read_eqn.c /^do_assign(name, expr)$/ do_check_tree avl/avl.c /^do_check_tree(node, compar, error)$/ do_construct bdd/bdd_create.c /^do_construct(node,bdd)$/ do_hash st/st.c /^#define do_hash(key, table)\\$/ do_local_construct bdd/bdd_create.c /^do_local_construct(node,bdd)$/ do_minimize espresso/exact.c /^do_minimize(F, D, R, exact_cover, weighted)$/ do_rebalance avl/avl.c /^do_rebalance(stack_nodep, stack_n)$/ do_sexpr_list io/read_eqn.c /^do_sexpr_list(list, func)$/ do_sf_permute node/nodemisc.c /^static pset_family $/ do_sm_minimum_cover espresso/sminterf.c /^do_sm_minimum_cover(A)$/ do_spline graphics/curve.c /^do_spline(x1, x2, y1, y2, y1_p, y2_p, ap, bp, cp, / do_tree_match map/treemap.c /^do_tree_match(network, library, debug)$/ do_tree_premap map/treemap.c /^do_tree_premap(network, library)$/ do_write_blif io/write_blif.c /^do_write_blif(fp, network, short_flag, netlist_fla/ does_gate_qualify map/bin_delay.c /^static int does_gate_qualify(node, gate, prim)$/ draw_arc graphics/xwindow.c /^draw_arc(win, fx, fy, tx, ty, color, style, label,/ draw_node graphics/xwindow.c /^draw_node(win, xpos, ypos, shape, color, font, num/ dsharp espresso/sharp.c /^pcover dsharp(a, b)$/ dual_network map/library.c /^dual_network(network)$/ dump_cube extract/kernel.c /^dump_cube(fp, cube)$/ dump_fanin node/divide.c /^dump_fanin(fanin, nfanin)$/ dump_fct extract/kernel.c /^dump_fct(fp, fct)$/ dump_irredundant espresso/exact.c /^dump_irredundant(E, Rt, Rp, table)$/ dump_kernel extract/kernel.c /^dump_kernel(fp, kernel)$/ dump_kernel_table extract/kernel.c /^dump_kernel_table()$/ dump_list node/divide.c /^dump_list(list)$/ dump_literal extract/kernel.c /^dump_literal(fp, index)$/ dump_mapped_network map/bin_power.c /^void dump_mapped_network(network)$/ dump_mapped_network_rec map/bin_power.c /^static void dump_mapped_network_rec(visited, node)/ dump_set node/divide.c /^dump_set(fp, setp)$/ dump_subkernel extract/kernel.c /^dump_subkernel(rect)$/ dump_vector sim/com_sim.c /^dump_vector(fp, vec)$/ duplicate_list network/network_util.c /^duplicate_list(list, newlist, newnetwork)$/ dw graphics/place.c /^#define dw(n) ((((dg_node *) n2)->type == DG_DU/ el_valid_val factor/com_ft.c /^el_valid_val(s)$/ element_data_dup phase/phase.c /^element_data_dup(element_data)$/ elim_lowering espresso/expand.c /^void elim_lowering(BB, CC, RAISE, FREESET)$/ eliminate factor/elim.c /^eliminate(network, thresh, limit)$/ end_bdd bdd/com_bdd.c /^end_bdd()$/ end_command command/commisc.c /^end_command()$/ end_decomp decomp/com_dec.c /^end_decomp()$/ end_delay delay/com_delay.c /^end_delay()$/ end_extract extract/com_ex.c /^end_extract()$/ end_factor factor/com_ft.c /^end_factor()$/ end_gcd gcd/com_gcd.c /^end_gcd()$/ end_graphics graphics/com_graphics.c /^end_graphics()$/ end_incompatible pld/xln_k_decomp.c /^end_incompatible()$/ end_intersection pld/xln_k_decomp.c /^end_intersection()$/ end_io io/com_io.c /^end_io()$/ end_lambda_indices pld/xln_k_decomp.c /^end_lambda_indices()$/ end_loop command/source.c /^end_loop(network, lp_lits, lp_time)$/ end_map map/com_map.c /^end_map()$/ end_maxflow maxflow/com_max.c /^end_maxflow()$/ end_mis main/mis_init.c /^end_mis()$/ end_network network/com_network.c /^end_network()$/ end_node node/com_node.c /^end_node()$/ end_octio octio/octio.c /^end_octio()$/ end_p_act pld/act_init.c /^end_p_act()$/ end_phase phase/com_ph.c /^end_phase()$/ end_pld pld/com_pld.c /^end_pld()$/ end_resub resub/com_resub.c /^end_resub() $/ end_sim sim/com_sim.c /^end_sim()$/ end_simplify simplify/com_simp.c /^end_simplify()$/ end_speed speed/com_speed.c /^end_speed() $/ end_test test/end_test.c /^end_test()$/ eq graphics/graphics_int.h /^#define eq(str1, str2) (strcmp((str1), (str2)) == / eqn_output espresso/cvrout.c /^void eqn_output(PLA)$/ equal espresso/espresso.h /^#define equal(a,b) (strcmp(a,b) == 0)$/ equation_setup_file io/read_eqn.c /^equation_setup_file(fp)$/ equation_setup_string io/read_eqn.c /^equation_setup_string(s)$/ error_append error/error.c /^error_append(s)$/ error_cleanup error/error.c /^error_cleanup()$/ error_init error/error.c /^error_init()$/ error_string error/error.c /^error_string()$/ espresso espresso/espresso.c /^pcover espresso(F, D1, R)$/ espresso_read_pla network/pla2net.c /^espresso_read_pla(fp)$/ essen_cube espresso/essen.c /^bool essen_cube(F, D, c)$/ essen_parts espresso/expand.c /^void essen_parts(BB, CC, RAISE, FREESET)$/ essen_raising espresso/expand.c /^void essen_raising(BB, RAISE, FREESET)$/ essential espresso/essen.c /^pcover essential(Fp, Dp)$/ estimate_clb_no pld/xln_ufind.c /^estimate_clb_no(network, size)$/ estimate_net_no pld/xln_ufind.c /^estimate_net_no(network)$/ evaluate_kernel speed/speed_net.c /^static int $/ ex_divide_each_fanout extract/conv.c /^ex_divide_each_fanout(fanout, cubes, newnode, debu/ ex_divide_function_into_network extract/conv.c /^ex_divide_function_into_network(func, fanout, cube/ ex_find_divisor extract/gdivisor.c /^ex_find_divisor(node, level, method)$/ ex_find_divisor_quick extract/qdivisor.c /^ex_find_divisor_quick(node)$/ ex_free_globals extract/conv.c /^ex_free_globals(dup_fcts)$/ ex_is_level0_kernel extract/kernel.c /^ex_is_level0_kernel(A)$/ ex_kernel_gen extract/genkern.c /^ex_kernel_gen(node, func, state)$/ ex_map_index_to_name extract/conv.c /^ex_map_index_to_name(i)$/ ex_network_to_sm extract/conv.c /^ex_network_to_sm(network)$/ ex_node_to_sm extract/conv.c /^ex_node_to_sm(node, M)$/ ex_rect_to_cokernel extract/kernel.c /^ex_rect_to_cokernel(rect)$/ ex_rect_to_kernel extract/kernel.c /^ex_rect_to_kernel(rect)$/ ex_setup_globals extract/conv.c /^ex_setup_globals(network, dup_fcts)$/ ex_setup_globals_single extract/conv.c /^ex_setup_globals_single(node)$/ ex_sm_to_node extract/conv.c /^ex_sm_to_node(func)$/ ex_subkernel_gen extract/genkern.c /^ex_subkernel_gen(node, func, level, state)$/ exact_minimum_cover espresso/unate.c /^pset_family exact_minimum_cover(T)$/ expand espresso/expand.c /^pcover expand(F, R, nonsparse)$/ expand1 espresso/expand.c /^void expand1(BB, CC, RAISE, FREESET, OVEREXPANDED_/ expand1_gasp espresso/gasp.c /^void expand1_gasp(F, D, R, Foriginal, c1index, G)$/ expand_gasp espresso/gasp.c /^pcover expand_gasp(F, D, R, Foriginal)$/ expand_to_largest minimize/dcsimp.c /^expand_to_largest(F, ros)$/ explode espresso/map.c /^void explode(var, z)$/ external_read_oct octio/octread.c /^external_read_oct(network, argc, argv)$/ external_write_oct octio/octwrite.c /^external_write_oct(network, argc, argv)$/ extract_equiv_nodes map/bin_flatten.c /^static void extract_equiv_nodes(node, source, equi/ extract_load_from_slack map/bin_fanout.c /^static double extract_load_from_slack(slack, fanou/ extract_load_values map/bin_util.c /^static int extract_load_values(prim)$/ extract_path network/acyclic.c /^extract_path(visited)$/ extract_result_found_in_table map/bin_fanout.c /^static int extract_result_found_in_table(arrival, / extract_root map/bin_power.c /^static node_t *extract_root(node)$/ extract_valid_gate_links map/bin_power.c /^static void extract_valid_gate_links(gate_info, so/ f_array_insert octio/farray.h /^#define f_array_insert(type, a, i, datum) { \\$/ f_array_insert_last octio/farray.h /^#define f_array_insert_last(type, array, datum) \\$/ factor factor/factor.c /^factor(f)$/ factor_alloc factor/ft_util.c /^factor_alloc(f)$/ factor_best_kernel factor/ft_util.c /^factor_best_kernel(f)$/ factor_best_literal factor/ft_util.c /^factor_best_literal(f, c)$/ factor_count factor/ft_value.c /^factor_count(r, f, stat)$/ factor_dup factor/ft_util.c /^factor_dup(old, new)$/ factor_free factor/ft_util.c /^factor_free(f)$/ factor_general factor/alg_ft.c /^factor_general(f, ck, gen_factor)$/ factor_good factor/factor.c /^factor_good(f)$/ factor_invalid factor/ft_util.c /^factor_invalid(f)$/ factor_nt_free factor/ft_util.c /^factor_nt_free(nodep)$/ factor_nt_to_ft factor/ft_util.c /^factor_nt_to_ft(f, nt)$/ factor_num_literal factor/ft_value.c /^factor_num_literal(f)$/ factor_num_used factor/ft_value.c /^factor_num_used(o, i)$/ factor_print factor/ft_print.c /^factor_print(fp, f)$/ factor_quick factor/factor.c /^factor_quick(f)$/ factor_quick_kernel factor/ft_util.c /^factor_quick_kernel(f)$/ factor_recur factor/alg_ft.c /^factor_recur(f, gen_factor)$/ factor_special factor/alg_ft.c /^factor_special(f, ck, gen_factor)$/ factor_to_nodes factor/ft_util.c /^factor_to_nodes(f)$/ factor_traverse factor/ft_util.c /^factor_traverse(f, func, stat, order)$/ factor_usage factor/com_ft.c /^factor_usage()$/ factored_form octio/octwrite.c /^factored_form(network, orig_node, node, fform)$/ fail include/util.h /^#define fail(why) {\\$/ fancy_lex_order node/sethack.c /^int $/ fanin_add_fanout node/fan.c /^fanin_add_fanout(node)$/ fanin_remove_fanout node/fan.c /^fanin_remove_fanout(node)$/ fanin_remove_single_fanout node/fan.c /^fanin_remove_single_fanout(node, i)$/ fanin_replace_single_fanout node/fan.c /^fanin_replace_single_fanout(node, i)$/ fanout_map_optimal map/bin_power.c /^static void fanout_map_optimal(node_x)$/ fanout_optimization map/bin_power.c /^void fanout_optimization(network, globals)$/ fanout_table_print simplify/simp_dc.c /^fanout_table_print(table)$/ fanout_to_po phase/phase.c /^fanout_to_po(f)$/ fast_cofactor node/cofct.c /^fast_cofactor(node, fanin, phase)$/ fatal espresso/cvrmisc.c /^void fatal(s)$/ fcube_is_covered espresso/irred.c /^fcube_is_covered(T, c, table)$/ fdc_sm_bp_1 simplify/filter_util.c /^fdc_sm_bp_1(M, ex_col)$/ fdc_sm_bp_2 simplify/filter_util.c /^fdc_sm_bp_2(M)$/ fdc_sm_bp_4 simplify/filter_util.c /^fdc_sm_bp_4(M)$/ fdc_sm_bp_6 simplify/filter_util.c /^fdc_sm_bp_6(M, distance)$/ fdc_sm_bp_7 simplify/filter_util.c /^fdc_sm_bp_7(M, distance)$/ feasibly_covered espresso/expand.c /^bool feasibly_covered(BB, c, RAISE, new_lower)$/ feeds_po map/addinv.c /^feeds_po(node)$/ fillin_values delay/delay.c /^fillin_values(pin, newpin)$/ filter_disj_support simplify/dc_filter.c /^filter_disj_support(Mfdc)$/ filter_exact simplify/dc_filter.c /^filter_exact(Mfdc)$/ filter_fdist simplify/dc_filter.c /^filter_fdist(Mfdc, distance)$/ filter_sdist simplify/dc_filter.c /^filter_sdist(Mfdc, distance)$/ filter_size simplify/dc_filter.c /^filter_size(Mfdc)$/ findPlace graphics/place.c /^findPlace(fixed, size, avg, maxverts)$/ find_G pld/xln_k_decomp.c /^find_G( node_to_decomp)$/ find_all_primes espresso/expand.c /^pcover find_all_primes(BB, RAISE, FREESET)$/ find_alphas_and_G pld/xln_k_decomp.c /^find_alphas_and_G(node_to_decomp)$/ find_best_cost espresso/pair.c /^int find_best_cost(pair)$/ find_best_delay map/bin_delay.c /^static int find_best_delay(prim)$/ find_best_div pld/xln_part_dec.c /^find_best_div(div, best_div, size)$/ find_best_match map/treemap.c /^find_best_match(prim)$/ find_class map/library.c /^find_class(library, network)$/ find_correct_ROS minimize/ros.c /^find_correct_ROS(p)$/ find_covers espresso/opo.c /^pset_family find_covers(F, D, select, n)$/ find_dc_inputs espresso/hack.c /^find_dc_inputs(PLA, list, base, maxval, newF, newD/ find_equiv_outputs espresso/equiv.c /^find_equiv_outputs(PLA)$/ find_ex_dc simplify/cspf.c /^find_ex_dc(ponode)$/ find_first_po map/prim.c /^find_first_po(node, po)$/ find_gate map/library.c /^find_gate(library, network)$/ find_inputs espresso/hack.c /^find_inputs(A, PLA, list, base, value, newF, newD)/ find_limits graphics/draw.c /^find_limits(graph, maxlev, minlev, maxvert, minver/ find_match_cost map/treemap.c /^find_match_cost(prim, gate)$/ find_max_col_intersection extract/greedycol.c /^find_max_col_intersection(A, col_cost, rect, row_v/ find_max_row_intersection extract/greedyrow.c /^find_max_row_intersection(A, row_cost, rect, col_v/ find_oc_dyn_special_cases minimize/ros.c /^find_oc_dyn_special_cases(p, overexpanded_cube, T,/ find_oc_special_cases minimize/ros.c /^find_oc_special_cases(p, overexpanded_cube, pNode,/ find_optimal_pairing espresso/pair.c /^void find_optimal_pairing(PLA, strategy)$/ find_or_create_class map/library.c /^find_or_create_class(library, gate)$/ find_or_create_gate map/library.c /^find_or_create_gate(library, network)$/ find_or_create_pattern map/library.c /^find_or_create_pattern(library, network)$/ find_overexpanded_cube minimize/ros.c /^find_overexpanded_cube(p, overexpanded_cube, pNode/ find_overexpanded_cube_dyn minimize/ros.c /^find_overexpanded_cube_dyn(p, overexpanded_cube, T/ find_pairing_cost espresso/pair.c /^int **find_pairing_cost(PLA, strategy)$/ find_phase espresso/opo.c /^pcube find_phase(PLA, first_output, phase1)$/ find_prime_factor gcd/gcd.c /^find_prime_factor(f, cofactor)$/ find_rectangle_fanout extract/misc.c /^find_rectangle_fanout(A, rect)$/ find_rectangle_fanout_cubes extract/misc.c /^find_rectangle_fanout_cubes(A, rect, cubes)$/ find_rightmost avl/avl.c /^find_rightmost(node_p)$/ find_tree pld/xln_ufind.c /^find_tree(node)$/ find_tree_size map/treesize.c /^find_tree_size(node, leaf_table, visited, tree_roo/ find_var pld/act_urp.c /^static int $/ first_fanin factor/com_ft.c /^first_fanin(np)$/ fits graphics/place.c /^fits(map, size, place, maxverts)$/ fix_loop maxflow/maxflow.c /^fix_loop(graph)$/ fmt_cost espresso/cvrmisc.c /^char *fmt_cost(cost)$/ fmt_cube espresso/cvrout.c /^char *fmt_cube(c, out_map, s)$/ fobsdc_sm_bp_1 simplify/cspf_filter.c /^fobsdc_sm_bp_1(M, var)$/ font_free graphics/xwindow.c /^font_free(k, v, a)$/ for pld/xln_lindo.c /^for (numTerm = 0, i = 0; i < coeff->ncols; ++numTe/ force_lower espresso/setc.c /^pset force_lower(xlower, a, b)$/ foreach_active_set espresso/espresso.h /^#define foreach_active_set(R, last, p)\\$/ foreach_fanin include/node.h /^#define foreach_fanin(node, i, p) \\$/ foreach_fanout include/node.h /^#define foreach_fanout(node, gen, p) \\$/ foreach_fanout_pin include/node.h /^#define foreach_fanout_pin(node, gen, p, pin) \\/ foreach_node include/network.h /^#define foreach_node(network, gen, p) \\$/ foreach_output_function espresso/cvrm.c /^foreach_output_function(PLA, func, func1)$/ foreach_polarity map/bin_fanout.h /^#define foreach_polarity(x)for((x)=POLAR_X;(x)F != 0)$/ node_input_phase node/iphase.c /^node_input_phase(node, fanin)$/ node_invalid node/nodeutil.c /^node_invalid(node)$/ node_invert node/invert.c /^node_invert(node)$/ node_is_local map/bin_required.c /^static int node_is_local(node)$/ node_is_madeup_name node/names.c /^node_is_madeup_name(name, value)$/ node_largest_cube_divisor node/node.c /^node_largest_cube_divisor(f)$/ node_lib_process node/libhack.c /^node_lib_process(network)$/ node_literal node/node.c /^node_literal(f, phase)$/ node_literal_count node/node.c /^node_literal_count(node)$/ node_long_name node/names.c /^node_long_name(node)$/ node_minimum_base node/nodemisc.c /^node_minimum_base(node)$/ node_name node/names.c /^node_name(node)$/ node_network node/nodeutil.c /^node_network(node)$/ node_not node/node.c /^node_not(f)$/ node_num_cube node/node.c /^node_num_cube(node)$/ node_num_fanin node/fan.c /^node_num_fanin(node)$/ node_num_fanout node/fan.c /^node_num_fanout(node)$/ node_num_literal node/node.c /^node_num_literal(node)$/ node_oct_name octio/octread.c /^#define node_oct_name(node) (node)->name$/ node_or node/node.c /^node_or(f, g)$/ node_patch_fanin node/fan.c /^int $/ node_print node/print.c /^node_print(fp, node)$/ node_print_internal node/print.c /^node_print_internal(fp, node, phase)$/ node_print_negative node/print.c /^void $/ node_print_rhs node/print.c /^node_print_rhs(fp, node)$/ node_register_daemon node/nodeutil.c /^node_register_daemon(type, func)$/ node_remove_dup_fanin node/nodemisc.c /^node_remove_dup_fanin(node)$/ node_replace node/nodemisc.c /^node_replace(f, r)$/ node_replace_internal node/nodemisc.c /^node_replace_internal(f, fanin, nin, F)$/ node_scc node/node.c /^node_scc(node)$/ node_sf_adjust node/nodemisc.c /^pset_family $/ node_sf_adjust_by_name node/nodemisc.c /^static pset_family $/ node_simplify node/node.c /^node_simplify(node_F, node_D, mode)$/ node_simplify_replace node/node.c /^node_simplify_replace(F, D, mode)$/ node_sort_for_printing node/node.c /^node_sort_for_printing(f)$/ node_substitute node/substitute.c /^node_substitute(f, g, use_complement)$/ node_to_ft factor/ft_util.c /^node_to_ft(f, np)$/ node_value factor/ft_value.c /^int node_value(nodep)$/ node_xnor node/node.c /^node_xnor(f, g)$/ node_xor node/node.c /^node_xor(f, g)$/ nodefanout_print simplify/simp_dc.c /^nodefanout_print(vec)$/ nodeindex_alloc node/nodeindex.c /^nodeindex_alloc()$/ nodeindex_free node/nodeindex.c /^nodeindex_free(table)$/ nodeindex_indexof node/nodeindex.c /^nodeindex_indexof(table, node) $/ nodeindex_insert node/nodeindex.c /^nodeindex_insert(table, node) $/ nodeindex_nodeof node/nodeindex.c /^nodeindex_nodeof(table, index)$/ nodevec_dup node/nodeutil.c /^nodevec_dup(fanin, nin)$/ num_fanins graphics/graphics_int.h /^#define num_fanins(node) lsLength((node)->fanins)$/ num_fanouts graphics/graphics_int.h /^#define num_fanouts(node) lsLength((node)->fanouts/ oct_lib_get_factored_function octio/octwrite.c /^oct_lib_get_factored_function(node)$/ oct_lib_get_gate_cell_and_view octio/octwrite.c /^oct_lib_get_gate_cell_and_view(node, facet, cell, / oct_lib_get_out_pin_name octio/octwrite.c /^oct_lib_get_out_pin_name(node, index)$/ oct_lib_get_pin_name octio/octwrite.c /^oct_lib_get_pin_name(node, index)$/ open_file mincov/main.c /^open_file(filename, mode)$/ open_win graphics/xwindow.c /^open_win(window, arg, xlo, ylo, xhi, yhi, label)$/ opo espresso/opo.c /^pcover opo(phase, T, D, R, first_output)$/ opo_leaf espresso/opo.c /^pset_family opo_leaf(T, select, out1, out2)$/ opo_recur espresso/opo.c /^pset_family opo_recur(T, D, select, offset, first,/ opoall espresso/opo.c /^void opoall(PLA, first_output, last_output, opo_st/ optimize_complex_case map/bin_fanout.c /^delay_time_t optimize_complex_case(table, delay_in/ order_nodes bdd/bdd_order.c /^order_nodes(node_vec, pi_only)$/ output genlib/readliblex.c /^# define output(c) putc(c,yyout)$/ output_phase_setup espresso/opo.c /^output_phase_setup(PLA, first_output)$/ output_symbolic_constraints espresso/cvrout.c /^output_symbolic_constraints(fp, PLA, output_symbol/ overlapping_clear_rect extract/kernel.c /^overlapping_clear_rect(A, rect)$/ overlapping_kernel_extract extract/kernel.c /^overlapping_kernel_extract(value_threshold, use_be/ own_strcmp io/write_slif.c /^own_strcmp(p,q)$/ p_actAlloc pld/act_init.c /^p_actAlloc(node)$/ p_actCreate4Set pld/act_create.c /^p_actCreate4Set(node_vec, node_list, locality, ord/ p_actCreateStep pld/act_create.c /^p_actCreateStep(current_node, level, node_list, lo/ p_actDestroy pld/act_remove.c /^p_actDestroy(act_set_entry_ptr, locality)$/ p_actDup pld/act_init.c /^p_actDup(old, new)$/ p_actFree pld/act_init.c /^p_actFree(node)$/ p_actRemove pld/act_remove.c /^int $/ p_act_construct pld/act_misc.c /^p_act_construct(node, order_list, locality)$/ p_act_node_free pld/act_misc.c /^p_act_node_free(node)$/ p_act_size pld/act_misc.c /^p_act_size(act)$/ p_actfree pld/act_init.c /^p_actfree(node)$/ p_addLists pld/act_reduce.c /^p_addLists(v)$/ p_addPI pld/act_order.c /^p_addPI(key, value, arg)$/ p_alap_order_nodes pld/act_order.c /^p_alap_order_nodes(node_vec)$/ p_applyCreate pld/act_create.c /^p_applyCreate(node, order_list)$/ p_cleanFRTable pld/act_order.c /^p_cleanFRTable(key, value, arg)$/ p_cleanRTable pld/act_order.c /^p_cleanRTable(key, value, arg)$/ p_compare2key pld/act_reduce.c /^p_compare2key(q1, q2)$/ p_dagComplement pld/act_misc.c /^p_dagComplement(u)$/ p_dagCopy pld/act_misc.c /^p_dagCopy(u)$/ p_dagDestroy pld/act_remove.c /^p_dagDestroy(dag)$/ p_fanin_record_sort pld/act_order.c /^p_fanin_record_sort(key1, key2)$/ p_freeTree pld/act_create.c /^p_freeTree(key, value, arg)$/ p_levelAdd pld/act_order.c /^p_levelAdd(node, level_table, root_table)$/ p_maxAdd pld/act_order.c /^p_maxAdd(node, max_table, level_table, root_table)/ p_optimalDag pld/act_create.c /^p_optimalDag(current_node, node_list)$/ p_permute pld/act_create.c /^p_permute(current_node, list, n, best_cost_ptr, be/ p_recFree pld/act_order.c /^p_recFree(node, root_table)$/ p_recOrder pld/act_order.c /^p_recOrder(node, max_table, fanin_table, root_tabl/ p_rootAdd pld/act_order.c /^p_rootAdd(node, root_table)$/ p_rootComplement pld/act_misc.c /^p_rootComplement(u)$/ p_rootCopy pld/act_misc.c /^p_rootCopy(u)$/ p_sort genlib/aoi.c /^static int $/ p_terminalDag pld/act_create.c /^p_terminalDag(value, index_size)$/ p_transitiveFree pld/act_init.c /^p_transitiveFree(node)$/ p_treeNodeDag pld/act_create.c /^p_treeNodeDag(node, tree_table, order_list)$/ pad_file util/saveimage.c /^pad_file(outFd, nbytes)$/ pair_all espresso/pair.c /^pair_all(PLA, pair_strategy)$/ pair_best_cost espresso/pair.c /^ppair pair_best_cost(cost_array_local)$/ pair_free espresso/pair.c /^int pair_free(pair)$/ pair_new espresso/pair.c /^ppair pair_new(n)$/ pair_save espresso/pair.c /^ppair pair_save(pair, n)$/ pairvar espresso/pair.c /^pcover pairvar(A, pair)$/ parallel_inv map/bin_fanout.c /^static bin_opt_t parallel_inv(arrival, delay_info,/ parse_pla espresso/cvrin.c /^void parse_pla(fp, PLA)$/ part_network pld/xln_part.c /^part_network(network, size) $/ partial_collapse pld/xln_map_par.c /^partial_collapse(sink_array, sepset_array)$/ partial_collapse_node pld/xln_map_par.c /^partial_collapse_node(sink, sepset_node_array)$/ partial_scan_lindoFile pld/act_map.c /^partial_scan_lindoFile(lindoFile)$/ partition_ROS minimize/ros.c /^partition_ROS(p, overexpanded_cube, level, T, R)$/ partition_network pld/xln_map_par.c /^partition_network(network_in, n, bincov_heuristics/ patch_constant_cells map/treemap.c /^patch_constant_cells(network)$/ pbv1 espresso/set.c /^char *pbv1(s, n)$/ pc1 espresso/cvrout.c /^char *pc1(c) pcube c;$/ pc2 espresso/cvrout.c /^char *pc2(c) pcube c;$/ pclose util/stub.c /^pclose(fp)$/ phase_assignment espresso/opo.c /^void phase_assignment(PLA, opo_strategy)$/ phase_check_set phase/phase.c /^phase_check_set()$/ phase_check_unset phase/phase.c /^phase_check_unset()$/ phase_count_comp phase/phase.c /^phase_count_comp(np, table, net_phase)$/ phase_dec phase/phase.c /^phase_dec(net_phase, row)$/ phase_do_invert phase/phase.c /^phase_do_invert(net_phase, row)$/ phase_dup phase/phase.c /^phase_dup(net_phase)$/ phase_fanout_setup phase/phase.c /^phase_fanout_setup(rowi, np, table, net_phase, pha/ phase_free phase/phase.c /^phase_free(net_phase)$/ phase_get_best phase/phase.c /^phase_get_best(net_phase)$/ phase_good phase/greedy.c /^phase_good(network)$/ phase_inc phase/phase.c /^phase_inc(net_phase, row)$/ phase_invert phase/phase.c /^phase_invert(net_phase, node_phase)$/ phase_invertible_set phase/phase_lib.c /^phase_invertible_set(row_data)$/ phase_lib_setup phase/phase_lib.c /^phase_lib_setup(network)$/ phase_mark phase/phase.c /^phase_mark(node_phase)$/ phase_node_invert phase/phase_lib.c /^phase_node_invert(np)$/ phase_node_setup phase/phase.c /^phase_node_setup(np, table, net_phase)$/ phase_print phase/phase.c /^phase_print(net_phase)$/ phase_quick phase/greedy.c /^phase_quick(network)$/ phase_random_assign phase/phase.c /^phase_random_assign(net_phase)$/ phase_random_greedy phase/greedy.c /^phase_random_greedy(network, num)$/ phase_record phase/phase_lib.c /^phase_record(network, net_phase)$/ phase_replace phase/phase.c /^phase_replace(old, new)$/ phase_setup phase/phase.c /^phase_setup(network)$/ phase_trace_set phase/phase.c /^phase_trace_set()$/ phase_trace_unset phase/phase.c /^phase_trace_unset()$/ phase_unmark_all phase/phase.c /^phase_unmark_all(net_phase)$/ phase_usage phase/com_ph.c /^phase_usage()$/ phase_value phase/phase_lib.c /^phase_value(node_phase)$/ pi_arrival_time delay/delay.c /^pi_arrival_time(node)$/ ping_pong extract/pingpong.c /^ping_pong(A, row_cost, col_cost)$/ ping_pong_improve extract/pingpong.c /^ping_pong_improve(A, row_cost, col_cost, best_rect/ ping_pong_onepass extract/pingpong.c /^ping_pong_onepass(A, row_cost, col_cost)$/ pla_to_network network/pla2net.c /^pla_to_network(PLA)$/ pla_to_network_single network/pla2net.c /^pla_to_network_single(PLA)$/ pld_decomp_and_or pld/xln_aodecomp.c /^pld_decomp_and_or(network, f, size)$/ pld_log2 pld/xln_aux.c /^int pld_log2(number)$/ pld_order_nodes pld/act_order.c /^pld_order_nodes(node_vec, pi_only)$/ pld_shuffle pld/act_order.c /^pld_shuffle(list)$/ plot_network graphics/com_graphics.c /^plot_network(network, name, action)$/ pls_group espresso/cvrout.c /^void pls_group(PLA, fp)$/ pls_label espresso/cvrout.c /^void pls_label(PLA, fp)$/ pls_output espresso/cvrout.c /^void pls_output(PLA)$/ pm mincov/bin_mincov.c /^pm (mat)$/ po_required_time delay/delay.c /^po_required_time(node, latest)$/ popen util/stub.c /^popen(string, mode)$/ precompute_parameters map/map_delay.c /^static void precompute_parameters(nin, arrival_tim/ preserve_best_area map/bin_delay.c /^static void preserve_best_area(bucket, gate, prim,/ preserve_gate_link map/bin_delay.c /^static void preserve_gate_link(input, node, pin, l/ preserve_selection map/bin_delay.c /^static void preserve_selection(bucket, gate, prim,/ prim_alloc map/prim.c /^prim_alloc()$/ prim_clear_binding map/prim.c /^prim_clear_binding(prim)$/ prim_free map/prim.c /^prim_free(prim)$/ prime bdd/bdd_table.c /^prime(p)$/ primes_consensus espresso/primes.c /^pcover primes_consensus(T)$/ primes_consensus_merge espresso/primes.c /^static pcover $/ primes_consensus_special_cases espresso/primes.c /^static bool $/ print array/arr_main.c /^print(s, a)$/ print_alias command/alias.c /^print_alias(value)$/ print_array pld/xln_ULM_util.c /^void print_array(array, hash_table)$/ print_bool espresso/espresso.h /^#define print_bool(x) ((x) == 0 ? "FALSE" : ((x) =/ print_cost espresso/cvrmisc.c /^char *print_cost(F)$/ print_cube espresso/cvrout.c /^void print_cube(fp, c, out_map)$/ print_delay_time_t map/bin_required.c /^void print_delay_time_t(time_info)$/ print_expanded_cube espresso/cvrout.c /^void print_expanded_cube(fp, c, phase)$/ print_fanin pld/xln_ULM_util.c /^void print_fanin(node)$/ print_function_from_act pld/act_map1.c /^print_function_from_act(vertex, type)$/ print_gate_stat_table map/bin_delay.c /^static void print_gate_stat_table()$/ print_kernel extract/com_ex.c /^print_kernel(kernel, co_kernel, state)$/ print_lev mincov/bin_mincov.c /^print_lev (row_num, p1, p2, p3, p4)$/ print_lib_gate_info map/com_map.c /^print_lib_gate_info(node, print_pins)$/ print_network pld/act_map.c /^int print_network(network, cost_table)$/ print_node map/bin_util.c /^static void print_node(node)$/ print_node_time map/bin_required.c /^void print_node_time(msg, node)$/ print_node_with_string pld/act_map.c /^print_node_with_string(node, name)$/ print_pair espresso/pair.c /^print_pair(pair)$/ print_partition_usage pld/com_pld.c /^print_partition_usage()$/ print_pin_delays delay/delay.c /^print_pin_delays(node, model)$/ print_pin_time map/bin_required.c /^static void print_pin_time(node, link)$/ print_suppressed_node pld/xln_map_par.c /^print_suppressed_node()$/ print_table pld/xln_ULM_util.c /^void print_table(table)$/ print_table_contents map/bin_power.c /^void print_table_contents(table)$/ print_table_entry pld/xln_ULM_util.c /^print_table_entry(key, value, arg)$/ print_time espresso/espresso.h /^#define print_time(t) util_print_time(t)$/ print_trace espresso/cvrmisc.c /^void print_trace(T, name, time)$/ print_vertex pld/act_map.c /^print_vertex(vertex)$/ proc_date main/version.c /^proc_date(datestr)$/ process_constant map/library.c /^process_constant(library, network)$/ process_pattern map/library.c /^process_pattern(library, network)$/ product_node_for_minterm pld/xln_k_decomp.c /^product_node_for_minterm(minterm, node_to_decomp)$/ ps mincov/bin_mincov.c /^ps (set)$/ ps1 espresso/set.c /^char *ps1(a)$/ ptime util/ptime.c /^long $/ put_load_and_slack map/bin_delay.c /^static void put_load_and_slack(node, load, slack)$/ put_load_in_node map/bin_util.c /^static void put_load_in_node(node, load)$/ put_node_names_in_act pld/act_map.c /^void put_node_names_in_act(vertex, list)$/ put_nodes pld/act_map.c /^put_nodes(node, n, order_list)$/ random_order espresso/cvrm.c /^pcover random_order(F)$/ random_simulate lib/driver.c /^random_simulate(npat)$/ read_LINDO_file pld/act_map.c /^read_LINDO_file(filename, variable, iteration_gain/ read_blif io/read_blif.c /^int $/ read_blif_delay io/read_blif.c /^read_blif_delay(network, po_list, fp, word)$/ read_blif_delay_cleanup io/read_blif.c /^read_blif_delay_cleanup(network)$/ read_blif_gate io/read_blif.c /^read_blif_gate(fp, network)$/ read_check_io_list io/read_util.c /^read_check_io_list(network, po_list)$/ read_cover io/read_blif.c /^static int $/ read_cube espresso/cvrin.c /^void read_cube(fp, PLA)$/ read_eqn io/read_eqn.c /^read_eqn(fp)$/ read_eqn_string io/read_eqn.c /^read_eqn_string(s)$/ read_error io/read_util.c /^read_error(s)$/ read_filename_to_netname io/read_util.c /^read_filename_to_netname(network, filename)$/ read_find_or_create_node io/read_util.c /^read_find_or_create_node(network, s)$/ read_hack_outputs io/read_util.c /^read_hack_outputs(network, po_list)$/ read_input_node io/read_blif.c /^read_input_node(fp, network, errmsg)$/ read_node_list io/read_blif.c /^read_node_list(fp, network, list)$/ read_oct octio/octread.c /^read_oct(facet)$/ read_output_node io/read_blif.c /^read_output_node(fp, po_list, errmsg)$/ read_pla espresso/cvrin.c /^int read_pla(fp, needs_dcset, needs_offset, pla_ty/ read_register_filename io/read_util.c /^read_register_filename(fname)$/ read_symbolic espresso/cvrin.c /^int read_symbolic(fp, PLA, word, retval)$/ read_word io/read_blif.c /^int $/ reallocate_graph_node maxflow/mf_input.c /^reallocate_graph_node(graph)$/ reallocate_out_edge maxflow/mf_input.c /^reallocate_out_edge(node)$/ rec_level bdd/bdd_order.c /^rec_level(node, level, factor_table, info_table)$/ rec_max bdd/bdd_order.c /^rec_max(node, max_table, info_table)$/ rec_order bdd/bdd_order.c /^rec_order(node_vec, pi_only, info_table, order_lis/ recompute_arrival_time map/bin_arrival.c /^static int recompute_arrival_time(node)$/ recompute_required_times map/bin_required.c /^static void recompute_required_times(network)$/ recompute_required_times_rec map/bin_required.c /^static void recompute_required_times_rec(table, no/ record_kernel extract/kernel.c /^static int $/ rect_alloc extract/rect.c /^rect_alloc()$/ rect_dup extract/rect.c /^rect_dup(old_rect)$/ rect_free extract/rect.c /^rect_free(rect)$/ recur util/test-restart.c /^recur(cnt)$/ reduce espresso/reduce.c /^pcover reduce(F, D)$/ reduce_cube espresso/reduce.c /^pcube reduce_cube(FD, p)$/ reduce_gasp espresso/gasp.c /^static pcover reduce_gasp(F, D)$/ reduce_loads map/bin_util.c /^static void reduce_loads(node)$/ rehash st/st.c /^static rehash(table)$/ rem_unnec_r_cubes minimize/minimize.c /^rem_unnec_r_cubes(T)$/ remove_duplication map/bin_area.c /^static void remove_duplication(node)$/ remove_other_phase_map map/bin_area.c /^static void remove_other_phase_map(removed, source/ reorder map/prim.c /^static void $/ reorder_rows mincov/bin_mincov.c /^reorder_rows (M)$/ repeated_phase_assignment espresso/opo.c /^void repeated_phase_assignment(PLA)$/ replace_chars_in io/write_slif.c /^replace_chars_in(node_name)$/ replace_node_decomposed pld/xln_k_decomp.c /^replace_node_decomposed(network, node_to_replace)$/ reset_io network/network_util.c /^reset_io(list)$/ rest_is_similar map/bin_fanout.c /^static int rest_is_similar(fanout_info, index)$/ restart_program util/restart.c /^restart_program()$/ restore_complex_case_slack map/bin_fanout.c /^static bin_opt_t restore_complex_case_slack()$/ restore_cube_struct espresso/cubestr.c /^void restore_cube_struct()$/ resub_alge_network resub/aresub.c /^resub_alge_network(network,use_complement)$/ resub_alge_node resub/aresub.c /^resub_alge_node(f,use_complement)$/ resub_bool_network resub/bresub.c /^resub_bool_network(network)$/ resub_bool_node resub/bresub.c /^resub_bool_node(f)$/ resub_usage resub/com_resub.c /^resub_usage()$/ reverse_string pld/xln_aux.c /^reverse_string(string1, string2)$/ rm2_contain espresso/contain.c /^int rm2_contain(A1, B1)$/ rm2_equal espresso/contain.c /^int rm2_equal(A1, B1, E1, compare)$/ rm_contain espresso/contain.c /^int rm_contain(A1)$/ rm_equal espresso/contain.c /^int rm_equal(A1, compare)$/ rm_rev_contain espresso/contain.c /^int rm_rev_contain(A1)$/ rotate_left avl/avl.c /^static $/ rotate_right avl/avl.c /^static $/ row_data_dup phase/phase.c /^row_data_dup(row_data)$/ row_value extract/pingpong.c /^row_value(prow, row_cost)$/ rp mincov/bin_mincov.c /^rp (row)$/ s_sort genlib/aoi.c /^static int $/ same_order bdd/bdd_verify.c /^same_order(list1,list2p)$/ save_complex_case_slack map/bin_fanout.c /^static void save_complex_case_slack(slack)$/ save_cube_struct espresso/cubestr.c /^void save_cube_struct()$/ save_new_slack map/bin_fanout.c /^static int save_new_slack(old_slack, old_area, new/ sccc espresso/reduce.c /^pcube sccc(T)$/ sccc_cube espresso/reduce.c /^pcube sccc_cube(result, p)$/ sccc_merge espresso/reduce.c /^pcube sccc_merge(left, right, cl, cr)$/ sccc_special_cases espresso/reduce.c /^bool sccc_special_cases(T, result)$/ scofactor espresso/cofactor.c /^pcube *scofactor(T, c, var)$/ search_array_index map/bin_util.c /^static int search_array_index(array, value)$/ search_part pld/xln_part.c /^search_part(network, size)$/ select_best_gate map/bin_delay.c /^static void select_best_gate(node)$/ select_best_slack map/bin_power.c /^static int select_best_slack(nodes, result_table, / select_column mincov/mincov.c /^static int $/ select_column_and_update_matrix pld/xln_map_par.c /^select_column_and_update_matrix(matrix)$/ select_essential mincov/mincov.c /^static void $/ select_feasible espresso/expand.c /^void select_feasible(BB, CC, RAISE, FREESET, SUPER/ select_node simplify/simall.c /^select_node(network, table)$/ select_source_gate map/bin_flatten.c /^static node_t *select_source_gate(node, node_array/ set_adjcnt espresso/set.c /^set_adjcnt(a, count, weight)$/ set_and espresso/set.c /^pset set_and(r, a, b)$/ set_andp espresso/set.c /^bool set_andp(r, a, b)$/ set_arrival_time delay/delay.c /^set_arrival_time(node, model)$/ set_clear espresso/set.c /^pset set_clear(r, size)$/ set_copy espresso/set.c /^pset set_copy(r, a)$/ set_diff espresso/set.c /^pset set_diff(r, a, b)$/ set_dist espresso/set.c /^int set_dist(a, b)$/ set_espresso_flags node/cubehack.c /^set_espresso_flags()$/ set_fanout_load delay/delay.c /^set_fanout_load(node, model)$/ set_fill espresso/set.c /^pset set_fill(r, size)$/ set_free espresso/espresso.h /^#define set_free(r) FREE(r)$/ set_full espresso/espresso.h /^#define set_full(size) set_fill(ALLOC(unsigned int/ set_functions genlib/genlib.c /^set_functions(tree, use_nor)$/ set_insert espresso/espresso.h /^#define set_insert(set, e) (set[WHICH_WORD(e)/ set_leaf_inverter_flag map/treemap.c /^set_leaf_inverter_flag(node)$/ set_line_width factor/ft_print.c /^set_line_width()$/ set_mark_act pld/act_map.c /^set_mark_act(PRESENT_ACT)$/ set_merge espresso/set.c /^pset set_merge(r, a, b, mask)$/ set_minimum_slack map/bin_power.c /^static void set_minimum_slack(slack)$/ set_new espresso/espresso.h /^#define set_new(size) set_clear(ALLOC(unsigned int/ set_node_type genlib/nand.c /^set_node_type(tree, type)$/ set_or espresso/set.c /^pset set_or(r, a, b)$/ set_ord espresso/set.c /^int set_ord(a)$/ set_orp espresso/set.c /^bool set_orp(r, a, b)$/ set_pair espresso/pair.c /^void set_pair(PLA)$/ set_pair1 espresso/pair.c /^void set_pair1(PLA, adjust_labels)$/ set_phase espresso/opo.c /^pPLA set_phase(PLA)$/ set_remove espresso/espresso.h /^#define set_remove(set, e) (set[WHICH_WORD(e)/ set_required_time delay/delay.c /^set_required_time(node, latest, model)$/ set_save espresso/espresso.h /^#define set_save(r) set_copy(ALLOC(unsigned int, S/ set_speed_thresh speed/speed_util.c /^set_speed_thresh(network, thresh)$/ set_write espresso/set.c /^void set_write(fp, a)$/ set_xor espresso/set.c /^pset set_xor(r, a, b)$/ setdown_cube espresso/cubestr.c /^void setdown_cube()$/ setp_disjoint espresso/set.c /^bool setp_disjoint(a, b)$/ setp_empty espresso/set.c /^bool setp_empty(a)$/ setp_equal espresso/set.c /^bool setp_equal(a, b)$/ setp_full espresso/set.c /^bool setp_full(a, size)$/ setp_implies espresso/set.c /^bool setp_implies(a, b)$/ setupBB minimize/ros.c /^setupBB(p, overexpanded_cube, pNode, level)$/ setupBB_dyn minimize/ros.c /^setupBB_dyn(p, overexpanded_cube, T, level)$/ setup_BB_CC espresso/expand.c /^void setup_BB_CC(BB, CC)$/ setup_gate_links map/bin_power.c /^static void setup_gate_links(node)$/ sf_active espresso/set.c /^pset_family sf_active(A)$/ sf_addcol espresso/set.c /^pset_family sf_addcol(A, firstcol, n)$/ sf_addset espresso/set.c /^pset_family sf_addset(A, s)$/ sf_and espresso/set.c /^pset sf_and(A)$/ sf_append espresso/set.c /^pset_family sf_append(A, B)$/ sf_bm_print espresso/set.c /^void sf_bm_print(A)$/ sf_bm_read espresso/set.c /^pset_family sf_bm_read(fp)$/ sf_cleanup espresso/set.c /^void sf_cleanup()$/ sf_compress espresso/set.c /^pset_family sf_compress(A, c)$/ sf_contain espresso/contain.c /^pset_family sf_contain(A)$/ sf_copy espresso/set.c /^pset_family sf_copy(R, A)$/ sf_copy_col espresso/set.c /^pset_family sf_copy_col(dst, dstcol, src, srccol)$/ sf_count espresso/set.c /^int *sf_count(A)$/ sf_count_restricted espresso/set.c /^int *sf_count_restricted(A, r)$/ sf_delc espresso/set.c /^pset_family sf_delc(A, first, last)$/ sf_delcol espresso/set.c /^pset_family sf_delcol(A, firstcol, n)$/ sf_delset espresso/set.c /^void sf_delset(A, i)$/ sf_dupl espresso/contain.c /^pset_family sf_dupl(A)$/ sf_free espresso/set.c /^void sf_free(A)$/ sf_inactive espresso/set.c /^pset_family sf_inactive(A)$/ sf_ind_contain espresso/contain.c /^pset_family sf_ind_contain(A, row_indices)$/ sf_ind_unlist espresso/contain.c /^pset_family sf_ind_unlist(A1, totcnt, size, row_in/ sf_join espresso/set.c /^pset_family sf_join(A, B)$/ sf_list espresso/contain.c /^pset *sf_list(A)$/ sf_merge espresso/contain.c /^pset_family sf_merge(A1, B1, E1, totcnt, size)$/ sf_new espresso/set.c /^pset_family sf_new(num, size)$/ sf_or espresso/set.c /^pset sf_or(A)$/ sf_permute espresso/set.c /^pset_family sf_permute(A, permute, npermute)$/ sf_print espresso/set.c /^void sf_print(A)$/ sf_read espresso/set.c /^pset_family sf_read(fp)$/ sf_rev_contain espresso/contain.c /^pset_family sf_rev_contain(A)$/ sf_save espresso/set.c /^pset_family sf_save(A)$/ sf_sort espresso/contain.c /^pset *sf_sort(A, compare)$/ sf_transpose espresso/set.c /^pset_family sf_transpose(A)$/ sf_union espresso/contain.c /^pset_family sf_union(A, B)$/ sf_unlist espresso/contain.c /^pset_family sf_unlist(A1, totcnt, size)$/ sf_write espresso/set.c /^void sf_write(fp, A)$/ shape_width graphics/xwindow.c /^shape_width(shape, width, height)$/ sharp espresso/sharp.c /^pcover sharp(a, b)$/ shuffle bdd/bdd_order.c /^shuffle(list)$/ sigterm command/command.c /^sigterm(sig, code, scp)$/ sim_gen_code sim/codegen.c /^sim_gen_code(fp, network, func_name)$/ sim_verify_codegen sim/codegen.c /^sim_verify_codegen(network1, network2, num, root)$/ sim_verify_interpret sim/interpret.c /^sim_verify_interpret(network1, network2, num)$/ simp_DI simplify/simp_dc.c /^simp_DI(f)$/ simp_accept simplify/simp.c /^simp_accept(f, newf, accept)$/ simp_all_dc simplify/simp_dc.c /^simp_all_dc(f)$/ simp_alloc simplify/simp_daemon.c /^simp_alloc(f)$/ simp_comp espresso/compl.c /^void simp_comp(T, Tnew, Tbar)$/ simp_comp_special_cases espresso/compl.c /^static bool simp_comp_special_cases(T, Tnew, Tbar)/ simp_cspf_dc simplify/simp.c /^simp_cspf_dc(f, il, iol)$/ simp_dc_filter simplify/dc_filter.c /^simp_dc_filter(f, dc, filter)$/ simp_dup simplify/simp_daemon.c /^simp_dup(old, new)$/ simp_fanout_dc simplify/simp_dc.c /^simp_fanout_dc(f)$/ simp_free simplify/simp_daemon.c /^simp_free(f)$/ simp_inout_dc simplify/simp_dc.c /^simp_inout_dc(f, il, iol)$/ simp_invalid simplify/simp_daemon.c /^simp_invalid(f)$/ simp_node_to_sm simplify/simp_sm.c /^simp_node_to_sm(f, dc)$/ simp_nodefanout_vec simplify/simp_dc.c /^simp_nodefanout_vec(f)$/ simp_obsdc_filter simplify/cspf_filter.c /^simp_obsdc_filter(dc, node_table, var, nodepi)$/ simp_obssatdc_filter simplify/cspf_filter.c /^simp_obssatdc_filter(dc, f, var)$/ simp_order simplify/simp_order.c /^simp_order(nodevec)$/ simp_sm_print simplify/simp_sm.c /^simp_sm_print(M)$/ simp_sm_to_node simplify/simp_sm.c /^simp_sm_to_node(M)$/ simp_sub_fanin_dc simplify/simp_dc.c /^simp_sub_fanin_dc(f)$/ simp_table simplify/simp_dc.c /^simp_table(f)$/ simp_tfanin_dc simplify/simp_dc.c /^simp_tfanin_dc(f, il, ol)$/ simp_usage simplify/com_simp.c /^simp_usage(command)$/ simple_print node/print.c /^simple_print(fp, node, phase)$/ simplify espresso/compl.c /^pcover simplify(T)$/ simplify_all simplify/simall.c /^simplify_all(network, method, dctype, accept, filt/ simplify_cspf_node simplify/simp.c /^simplify_cspf_node(f, method, dctype, accept)$/ simplify_cubelist espresso/cofactor.c /^simplify_cubelist(T)$/ simplify_node simplify/simp.c /^simplify_node(f, method, dctype, accept, filter)$/ simplify_special_cases espresso/compl.c /^static bool simplify_special_cases(T, Tnew)$/ simulate_network sim/interpret.c /^simulate_network(network, node_vec, in_value)$/ simulate_node sim/interpret.c /^simulate_node(node)$/ single_cube_order pld/act_map.c /^single_cube_order(node)$/ size_down_inverters map/bin_area.c /^static void size_down_inverters(node)$/ size_sort espresso/cvrm.c /^pcover size_sort(T)$/ size_stamp espresso/cvrmisc.c /^void size_stamp(T, name)$/ skip_line espresso/cvrin.c /^void skip_line(fpin, fpout, echo)$/ sm_alloc_size sparse/matrix.c /^sm_alloc_size(row, col)$/ sm_allocate sparse/matrix.c /^sm_allocate()$/ sm_bin_block_partition mincov/bin_part.c /^sm_bin_block_partition(A, L, R)$/ sm_bin_mincov mincov/bin_mincov.c /^sm_bin_mincov (row_num)$/ sm_block_partition mincov/part.c /^sm_block_partition(A, L, R)$/ sm_cleanup sparse/matrix.c /^sm_cleanup()$/ sm_col_alloc sparse/cols.c /^sm_col_alloc()$/ sm_col_and sparse/cols.c /^sm_col_and(p1, p2)$/ sm_col_compare sparse/cols.c /^int $/ sm_col_contains sparse/cols.c /^int $/ sm_col_count_init simplify/filter_util.c /^sm_col_count_init(size)$/ sm_col_dominance mincov/dominate.c /^int $/ sm_col_dup sparse/cols.c /^sm_col_dup(pcol)$/ sm_col_find sparse/cols.c /^sm_col_find(pcol, row)$/ sm_col_free sparse/cols.c /^sm_col_free(pcol)$/ sm_col_hash sparse/cols.c /^int $/ sm_col_insert sparse/cols.c /^sm_col_insert(pcol, row)$/ sm_col_intersects sparse/cols.c /^int $/ sm_col_print sparse/cols.c /^sm_col_print(fp, pcol)$/ sm_col_remove sparse/cols.c /^sm_col_remove(pcol, row)$/ sm_col_remove_element sparse/cols.c /^sm_col_remove_element(pcol, p)$/ sm_copy_col sparse/matrix.c /^sm_copy_col(dest, dest_col, pcol)$/ sm_copy_row sparse/matrix.c /^sm_copy_row(dest, dest_row, prow)$/ sm_delcol sparse/matrix.c /^void $/ sm_delrow sparse/matrix.c /^void $/ sm_dump sparse/matrix.c /^void $/ sm_dup sparse/matrix.c /^sm_dup(A)$/ sm_element_alloc sparse/sparse_int.h /^#define sm_element_alloc(newobj) \\$/ sm_element_free sparse/sparse_int.h /^#define sm_element_free(e) \\$/ sm_find sparse/matrix.c /^sm_find(A, rownum, colnum)$/ sm_foreach_col include/sparse.h /^#define sm_foreach_col(A, pcol) \\$/ sm_foreach_col_element include/sparse.h /^#define sm_foreach_col_element(pcol, p) \\$/ sm_foreach_row pld/xln_lindo.c /^sm_foreach_row(coeff, row) {$/ sm_foreach_row_element include/sparse.h /^#define sm_foreach_row_element(prow, p) \\$/ sm_free_space sparse/matrix.c /^sm_free_space(A)$/ sm_generate_row pld/xln_map_par.c /^sm_generate_row(solution_array)$/ sm_get include/sparse.h /^#define sm_get(type, x) \\$/ sm_get_col include/sparse.h /^#define sm_get_col(A, colnum) \\$/ sm_get_long_col simplify/filter_util.c /^sm_get_long_col(M, chosen)$/ sm_get_row include/sparse.h /^#define sm_get_row(A, rownum) \\$/ sm_insert sparse/matrix.c /^sm_insert(A, row, col)$/ sm_longest_col sparse/matrix.c /^sm_longest_col(A)$/ sm_longest_row sparse/matrix.c /^sm_longest_row(A)$/ sm_mat_bin_minimum_cover mincov/bin_mincov.c /^sm_mat_bin_minimum_cover (M, weights, heuristic, d/ sm_mat_bin_minimum_cover_greedy pld/xln_map_par.c /^sm_mat_bin_minimum_cover_greedy(matrix, weight, bi/ sm_mat_minimum_cover mincov/bin_mincov.c /^sm_mat_minimum_cover (M, weights, heuristic, debug/ sm_maximal_independent_set mincov/indep.c /^sm_maximal_independent_set(A, weight)$/ sm_mincov mincov/mincov.c /^sm_mincov(A, select, weight, lb, bound, depth, sta/ sm_minimum_cover mincov/mincov.c /^sm_minimum_cover(A, weight, heuristic, debug_level/ sm_ncols simplify/simp_int.h /^#define sm_ncols(M) M->ncols$/ sm_num_elements sparse/matrix.c /^sm_num_elements(A)$/ sm_print sparse/matrix.c /^void $/ sm_put include/sparse.h /^#define sm_put(x, val) \\$/ sm_read sparse/matrix.c /^int $/ sm_read_compressed sparse/matrix.c /^int $/ sm_remove sparse/matrix.c /^sm_remove(A, rownum, colnum)$/ sm_remove_element sparse/matrix.c /^sm_remove_element(A, p)$/ sm_resize sparse/matrix.c /^void $/ sm_row_alloc sparse/rows.c /^sm_row_alloc()$/ sm_row_and sparse/rows.c /^sm_row_and(p1, p2)$/ sm_row_compare sparse/rows.c /^int $/ sm_row_contains sparse/rows.c /^int $/ sm_row_dominance mincov/dominate.c /^int $/ sm_row_dup sparse/rows.c /^sm_row_dup(prow)$/ sm_row_find sparse/rows.c /^sm_row_find(prow, col)$/ sm_row_free sparse/rows.c /^sm_row_free(prow)$/ sm_row_hash sparse/rows.c /^int $/ sm_row_insert sparse/rows.c /^sm_row_insert(prow, col)$/ sm_row_intersects sparse/rows.c /^int $/ sm_row_print sparse/rows.c /^sm_row_print(fp, prow)$/ sm_row_remove sparse/rows.c /^sm_row_remove(prow, col)$/ sm_row_remove_element sparse/rows.c /^sm_row_remove_element(prow, p)$/ sm_write sparse/matrix.c /^void $/ snocomp minimize/minimize.c /^snocomp(F, D1)$/ so_both_do_espresso espresso/cvrm.c /^int so_both_do_espresso(PLA, i)$/ so_both_do_exact espresso/cvrm.c /^int so_both_do_exact(PLA, i)$/ so_both_espresso espresso/cvrm.c /^void so_both_espresso(PLA, strategy)$/ so_both_save espresso/cvrm.c /^int so_both_save(PLA, i)$/ so_do_espresso espresso/cvrm.c /^int so_do_espresso(PLA, i)$/ so_do_exact espresso/cvrm.c /^int so_do_exact(PLA, i)$/ so_espresso espresso/cvrm.c /^void so_espresso(PLA, strategy)$/ so_save espresso/cvrm.c /^int so_save(PLA, i)$/ solution_accept mincov/solution.c /^void $/ solution_add mincov/solution.c /^void $/ solution_alloc mincov/solution.c /^solution_alloc()$/ solution_choose_best mincov/solution.c /^solution_choose_best(best1, best2)$/ solution_dup mincov/solution.c /^solution_dup(sol)$/ solution_free mincov/solution.c /^solution_free(sol)$/ solution_reject mincov/solution.c /^void $/ solve_row bdd/bdd_create.c /^solve_row(node,literals,row,bdd,get_bdd)$/ sort_reduce espresso/cvrm.c /^pcover sort_reduce(T)$/ sorted_insert sparse/sparse_int.h /^#define sorted_insert(type, first, last, count, ne/ source_misrc main/mis.c /^source_misrc(network)$/ sp mincov/bin_mincov.c /^sp (set)$/ sp_already_buffered speed/sp_buffer.c /^sp_already_buffered(table, node)$/ sp_buf_annotate_gate speed/buf_util.c /^sp_buf_annotate_gate(node, model)$/ sp_buf_array_from_list speed/buf_util.c /^sp_buf_array_from_list(buf_list, number_inv, numbe/ sp_buf_compute_req_time speed/buf_delay.c /^sp_buf_compute_req_time(node, model, req_times, ca/ sp_buf_get_crit_fanin speed/buf_util.c /^int $/ sp_buf_get_target speed/sp_buffer.c /^delay_time_t $/ sp_buf_req_time speed/buf_delay.c /^sp_buf_req_time(fo, model, pin, reqp, loadp)$/ sp_buffer_name speed/buf_util.c /^sp_buffer_name(buffer)$/ sp_buffer_recur speed/buf_recur.c /^int $/ sp_buffer_weight speed/sp_buffer.c /^sp_buffer_weight(node, model)$/ sp_compare_buf speed/buf_util.c /^sp_compare_buf(item1, item2)$/ sp_compute speed/buf_delay.c /^sp_compute(phase, req, t)$/ sp_create_noninv_buf_list speed/buf_util.c /^sp_create_noninv_buf_list(buffer_list, limit)$/ sp_get_fanout_set speed/sp_buffer.c /^sp_get_fanout_set(node, node_inv, num_pos, num_neg/ sp_get_gate speed/speed_util.c /^sp_get_gate(class, which)$/ sp_get_input_drive speed/buf_delay.c /^sp_get_input_drive(nodep, model, phase)$/ sp_get_pin_load speed/buf_delay.c /^sp_get_pin_load(node, model)$/ sp_get_versions_of_node speed/buf_recur.c /^sp_get_versions_of_node(node, model, num_gates, a_/ sp_implement_buffer_chain speed/buf_util.c /^sp_implement_buffer_chain(network, node)$/ sp_insert_buf_in_list speed/buf_util.c /^sp_insert_buf_in_list(buffer_list, prev, gate)$/ sp_lib_get_buffer speed/speed_util.c /^sp_lib_get_buffer(lib)$/ sp_lib_get_inv speed/speed_util.c /^sp_lib_get_inv(lib)$/ sp_minimum_slack speed/buf_delay.c /^sp_minimum_slack(network)$/ sp_name_of_impl speed/buf_util.c /^sp_name_of_impl(node)$/ sp_replace_cell_strength speed/buf_replace.c /^sp_replace_cell_strength(network, node, inv_node, / sp_replace_lib_gate speed/buf_util.c /^sp_replace_lib_gate(node, gate, pref_gate)$/ sp_set_inverter speed/buf_util.c /^sp_set_inverter(node, fanin, gate)$/ sp_subtract_delay speed/buf_delay.c /^sp_subtract_delay(phase, block, drive, load, req)$/ sparse_cube_extract extract/cube.c /^sparse_cube_extract(A, value_threshold, use_best_s/ sparse_kernel_extract extract/kernel.c /^sparse_kernel_extract(value_threshold, use_best_su/ specialCreateNet octio/octwrite.c /^specialCreateNet(facet, net, name)$/ specialGetByNetName octio/octwrite.c /^specialGetByNetName(facet, net, name)$/ specialGetOrCreateNet octio/octwrite.c /^specialGetOrCreateNet(facet, net, name)$/ speed_absorb speed/absorb.c /^speed_absorb(f, dist)$/ speed_add_node_to_graph maxflow/cutset.c /^speed_add_node_to_graph(node, cap, store)$/ speed_adjust_phase speed/speed_no.c /^speed_adjust_phase(network)$/ speed_and_decomp speed/speed_and.c /^speed_and_decomp(network, node, model, flag)$/ speed_and_or_decomp speed/speed_or.c /^speed_and_or_decomp(network, node, model)$/ speed_buffer_array_of_nodes speed/sp_buffer.c /^speed_buffer_array_of_nodes(network, nodevec, mode/ speed_buffer_network speed/sp_buffer.c /^speed_buffer_network(network, model, limit, do_tra/ speed_buffer_node speed/sp_buffer.c /^speed_buffer_node(network, node, model, limit, con/ speed_compute_weight speed/weight_util.c /^speed_compute_weight(network, model, coeff, dist, / speed_critical speed/speedup.c /^speed_critical(np)$/ speed_dec_node_cube speed/speed_util.c /^speed_dec_node_cube(f, i)$/ speed_decomp speed/speed_no.c /^speed_decomp( innode, coeff, model, delay_flag)$/ speed_decomp_network speed/speed_net.c /^int $/ speed_del_critical_cubes speed/speed_util.c /^speed_del_critical_cubes(node, thresh)$/ speed_delay_arrival_time speed/speed_delay.c /^void $/ speed_delay_parameters_dup speed/sp_network.c /^speed_delay_parameters_dup(from, to, delay_flag)$/ speed_delay_trace speed/speed_delay.c /^speed_delay_trace(network, model)$/ speed_delete_single_fanin_node speed/speed_util.c /^speed_delete_single_fanin_node(network, node)$/ speed_dump_buffer_list speed/buf_util.c /^speed_dump_buffer_list(fp, buffer_list)$/ speed_free_buffer_list speed/buf_util.c /^speed_free_buffer_list(list)$/ speed_get_stats speed/speed_util.c /^speed_get_stats(network, library, model, delay, ar/ speed_init_decomp speed/speedup.c /^int $/ speed_is_fanout_po speed/speedup.c /^speed_is_fanout_po(node)$/ speed_levelize_crit speed/speed_util.c /^speed_levelize_crit(network)$/ speed_lib_buffers speed/buf_util.c /^speed_lib_buffers(lib, limit, buffer_list)$/ speed_mark_input_cone speed/weight.c /^speed_mark_input_cone(node, area_table, table)$/ speed_network_create_from_node speed/sp_network.c /^speed_network_create_from_node(f, delay_flag)$/ speed_network_delete_node speed/speed_util.c /^speed_network_delete_node(network, node)$/ speed_plot_crit_network speed/speed_plot.c /^speed_plot_crit_network(network, name, action, thr/ speed_plot_use speed/speed_plot.c /^speed_plot_use()$/ speed_print_level speed/speed_util.c /^speed_print_level(network, thresh, crit_only, flag/ speed_rank speed/weight.c /^speed_rank(n, w)$/ speed_replace speed/speedup.c /^speed_replace(network, np, nodes, model)$/ speed_reset_arrival_time speed/speed_delay.c /^speed_reset_arrival_time(node)$/ speed_resub_alge_node speed/speedup.c /^speed_resub_alge_node(network, f, table)$/ speed_scale_value speed/speed_net.c /^speed_scale_value( div, best_data)$/ speed_set_arrival_time speed/speed_delay.c /^void $/ speed_single_level_update speed/speed_delay.c /^speed_single_level_update(node, model, delay)$/ speed_sort2 speed/weight.c /^speed_sort2(n, ra, rb)$/ speed_up_loop speed/speed_loop.c /^speed_up_loop(network, thresh, coeff , dist, model/ speed_up_network speed/speedup.c /^speed_up_network(network, thresh, coeff, dist, mod/ speed_up_node speed/speedup.c /^speed_up_node(network, np, coeff, model, delay_fla/ speed_up_script speed/speed_loop.c /^speed_up_script(network, model, coeff, flag)$/ speed_update_arrival_time speed/speed_delay.c /^speed_update_arrival_time(node, model)$/ speed_update_arrival_time_recur speed/speed_delay.c /^static int $/ speed_update_fanout speed/speed_delay.c /^speed_update_fanout(network, nodevec, fanout_list,/ speed_weight speed/weight.c /^speed_weight(node, dist, model, t_cost, a_cost)$/ speed_weight_bfs speed/weight.c /^speed_weight_bfs(node, dist, table, model, a_array/ speed_weight_count_lit speed/weight.c /^speed_weight_count_lit(key, value, arg)$/ split_F pld/act_urp.c /^split_F(F, b_col, Fl, Fr)$/ split_line command/command.c /^split_line(command, argc, argv)$/ split_network pld/xln_part_dec.c /^split_network(network, size)$/ split_node pld/xln_part_dec.c /^split_node(network, node, size) $/ squeeze_matching pld/xln_map_par.c /^squeeze_matching(row)$/ st_add_direct st/st.c /^st_add_direct(table, key, value)$/ st_copy st/st.c /^st_table *st_copy(old_table)$/ st_count include/st.h /^#define st_count(table) ((table)->num_entries)$/ st_delete st/st.c /^st_delete(table, keyp, value)$/ st_find st/st.c /^st_find(table, key, slot)$/ st_find_or_add st/st.c /^st_find_or_add(table, key, slot)$/ st_foreach st/st.c /^st_foreach(table, func, arg)$/ st_foreach_item include/st.h /^#define st_foreach_item(table, gen, key, value) \\$/ st_free_gen st/st.c /^st_free_gen(gen)$/ st_free_table st/st.c /^st_free_table(table)$/ st_gen st/st.c /^int $/ st_init_gen st/st.c /^st_init_gen(table)$/ st_init_table st/st.c /^st_table *st_init_table(compare, hash)$/ st_init_table_with_params st/st.c /^st_table *st_init_table_with_params(compare, hash,/ st_insert st/st.c /^st_insert(table, key, value)$/ st_is_member include/st.h /^#define st_is_member(table,key) st_lookup(table,ke/ st_lookup st/st.c /^st_lookup(table, key, value)$/ st_numcmp st/st.c /^st_numcmp(x, y)$/ st_numhash st/st.c /^st_numhash(x, size)$/ st_ptrcmp st/st.c /^st_ptrcmp(x, y)$/ st_ptrhash st/st.c /^st_ptrhash(x, size)$/ st_strhash st/st.c /^st_strhash(string, modulus)$/ store_ROS minimize/ros.c /^store_ROS()$/ strchr util/stub.c /^strchr(s, c)$/ strrchr util/stub.c /^strrchr(s, c)$/ super_gasp espresso/gasp.c /^pcover super_gasp(F, D, R, cost)$/ symbolic_hack_labels espresso/hack.c /^symbolic_hack_labels(PLA, list, compress, new_size/ taut_special_cases espresso/irred.c /^taut_special_cases(T)$/ tautology espresso/irred.c /^tautology(T)$/ td_usage decomp/com_dec.c /^td_usage()$/ termFree octio/octread.c /^termFree(terminfo)$/ tmpfile util/tmpfile.c /^tmpfile()$/ totals espresso/cvrmisc.c /^void totals(time, i, T, cost)$/ trace_act pld/act_bdd.c /^trace_act(vertex)$/ trace_path maxflow/maxflow.c /^trace_path(graph, n)$/ transfer_gate_links map/bin_flatten.c /^static void transfer_gate_links(from, to)$/ traverse pld/com_pld.c /^traverse(v, manipulate)$/ tree_equal map/tree.c /^static int $/ tree_init pld/xln_k_decomp.c /^tree_init()$/ tree_map map/treemap.c /^tree_map(network, library, globals)$/ two_cmp pld/act_apply.c /^two_cmp(key1, key2)$/ two_hash pld/act_apply.c /^int $/ unate_act pld/act_leaf.c /^unate_act(F)$/ unate_compl espresso/unate.c /^pset_family unate_compl(A)$/ unate_complement espresso/unate.c /^pset_family unate_complement(A)$/ unate_intersect espresso/unate.c /^pset_family unate_intersect(A, B, largest_only)$/ unate_split_F pld/act_leaf.c /^unate_split_F(F, cover, array)$/ uncof_output espresso/cvrm.c /^pcover uncof_output(T, i)$/ undefine_cube_size node/cubehack.c /^undefine_cube_size()$/ unionop pld/xln_ufind.c /^unionop(node1, node2)$/ uniqNames octio/octread.c /^uniqNames(container, mask)$/ unmark_every_node maxflow/maxflow.c /^unmark_every_node(graph)$/ unpackname octio/octwrite.c /^unpackname(name, cell, view, defaultView)$/ unput genlib/readlib.c /^unput(c)$/ unravel espresso/cvrm.c /^pcover unravel(B, start)$/ unravel_range espresso/cvrm.c /^pcover unravel_range(B, start, end)$/ unused_simp_fanin_dc simplify/simp_dc.c /^unused_simp_fanin_dc(f)$/ update_F pld/act_urp.c /^update_F(F, b_col)$/ update_best extract/pingpong.c /^update_best(rect1, rect2, best_rect)$/ update_cube_literal_matrix extract/cube.c /^update_cube_literal_matrix(A, row_cost, col_cost, / update_win graphics/xwindow.c /^update_win(win)$/ urp_F pld/act_urp.c /^urp_F(F)$/ usage array/arr_main.c /^usage(prog)$/ util_cpu_time util/cpu_time.c /^long $/ util_do_nothing util/stub.c /^util_do_nothing()$/ util_file_search util/pathsearch.c /^util_file_search(file, path, mode)$/ util_getopt util/getopt.c /^int $/ util_getopt_reset util/getopt.c /^util_getopt_reset()$/ util_path_search util/pathsearch.c /^util_path_search(prog)$/ util_pipefork util/pipefork.c /^util_pipefork(argv, toCommand, fromCommand)$/ util_print_cpu_stats util/cpu_stats.c /^util_print_cpu_stats(fp)$/ util_print_time util/prtime.c /^util_print_time(t)$/ util_restart util/restart.c /^util_restart(old, new, interval)$/ util_restart_restore_state util/state.c /^util_restart_restore_state()$/ util_restart_save_state util/state.c /^util_restart_save_state()$/ util_save_image util/saveimage.c /^util_save_image(orig_file_name, save_file_name)$/ util_strsav util/strsav.c /^util_strsav(s)$/ util_tilde_expand util/texpand.c /^util_tilde_expand(fname)$/ val_literal pld/xln_k_decomp.c /^int val_literal(literal)$/ value_cell_alloc extract/value.c /^value_cell_alloc()$/ value_cell_free extract/value.c /^value_cell_free(value_cell)$/ value_cmp_dec factor/ft_value.c /^value_cmp_dec(p1, p2)$/ value_cmp_inc factor/ft_value.c /^value_cmp_inc(p1, p2)$/ value_print factor/ft_value.c /^value_print(fp, np)$/ var_to_canonical bdd/bdd_ite.c /^var_to_canonical(fp,gp,hp,one,topfp,topgp,tophp)$/ var_to_const bdd/bdd_ite.c /^var_to_const(f,gp,hp,one)$/ vemPrint octio/my.h /^#define vemPrint(string) \\$/ verify espresso/verify.c /^bool verify(F, Fold, Dold)$/ verify_cover mincov/bin_mincov.c /^static int $/ verify_estimate map/treemap.c /^int verify_estimate (network, print_stat)$/ verify_indep_set mincov/indep.c /^static int $/ visit_col decomp/partition.c /^visit_col(A, pcol, rows_visited, cols_visited)$/ visit_row decomp/partition.c /^visit_row(A, prow, rows_visited, cols_visited)$/ weight_compute speed/weight.c /^weight_compute(node, model, a_array, d_array, o_ti/ wm mincov/bin_mincov.c /^wm (mat)$/ write_bdnet io/write_bdnet.c /^write_bdnet(fp, network)$/ write_blif io/write_blif.c /^write_blif(fp, network, short_flag, netlist_flag)$/ write_blif_delay io/write_blif.c /^write_blif_delay(fp, network)$/ write_blif_for_bdsyn io/write_blif.c /^write_blif_for_bdsyn(fp, network)$/ write_cover io/write_util.c /^write_cover(fp, p)$/ write_eqn io/write_eqn.c /^write_eqn(fp, network, short_name)$/ write_instance_name io/write_bdnet.c /^write_instance_name(fp, path, viewname, node)$/ write_lif io/write_lif.c /^write_lif(fp, network, sflag)$/ write_oct octio/octwrite.c /^write_oct(network, facet)$/ write_pla io/write_pla.c /^void $/ write_slif io/write_slif.c /^write_slif(fp, network)$/ write_slif_sop io/write_slif.c /^write_slif_sop(fp, node, short_name)$/ write_sop io/write_eqn.c /^write_sop(fp, node, short_name)$/ x_trans graphics/xwindow.c /^#define x_trans(xd, xpos) (((xpos) - xd->xlo + 1) / xl_binary1 pld/xln_aux.c /^void xl_binary1(value, length, string)$/ y_trans graphics/xwindow.c /^#define y_trans(xd, ypos) (xd->maxy - ((ypos) - xd/ yyerror genlib/readlib.c /^yyerror(errmsg)$/ yyinput genlib/readliblex.c /^yyinput(){$/ yylex genlib/readliblex.c /^yylex(){$/ yymore genlib/readliblex.c /^# define yymore() (yymorfg=1)$/ yyoutput genlib/readliblex.c /^yyoutput(c)$/ yyparse genlib/readlib.c /^yyparse() {$/ yyunput genlib/readliblex.c /^yyunput(c)$/ yywrap genlib/readlib.c /^yywrap()$/