1:\\n junctions[v] = Junction(Vertex.get_vertex_id(), v)\\n edges.add(Edge(super_block, junctions[v]))\\n\\n for edge in edges:\\n self.add_vertex(edge.successor())\\n self.add_edge(edge)\\n\\n return scc_to_super_block, junctions\\n\\n def __add_edges(self, induced_subgraph, strong_components, scc_to_super_block, junctions):\\n for super_block in scc_to_super_block.values():\\n v = super_block[0]\\n if not isinstance(v.program_point, Vertex):\\n (pred_edge,) = induced_subgraph.predecessors(v)\\n predecessor = junctions[pred_edge.predecessor()]\\n self.add_edge(Edge(predecessor, super_block))\\n else:\\n for pred_edge in induced_subgraph.predecessors(v):\\n predecessor = scc_to_super_block[strong_components[pred_edge.predecessor()]]\\n self.add_edge(Edge(predecessor, super_block))\\n\\n def super_blocks(self):\\n for v in self:\\n if isinstance(v, SuperBlock):\\n yield v\\n\\n def junctions(self):\\n for v in self:\\n if isinstance(v, Junction):\\n yield v\\n\\n def dotify(self):\\n data = []\\n for v in self:\\n data.append(v.dotify())\\n for e in self.successors(v):\\n data.append(e.dotify())\\n filename = '{}.{}.super.dot'.format(self.program.basename, self.name)\\n dot.generate(filename, data)\\n\\n\\nclass SyntaxTree(Tree):\\n def __init__(self, g: FlowGraph):\\n Tree.__init__(self)\\n self.g = g\\n self._cache = {}\\n self._post_dominance_frontier = DominanceFrontiers(g, g.post_dominator_tree())\\n self._root = self.__make_sequence_subtree(g.entry, g.exit, True)\\n\\n def __make_sequence_subtree(self, source: Vertex, target: Vertex, inclusive: bool):\\n seq = Sequence(Vertex.get_vertex_id())\\n self.add_vertex(seq)\\n\\n walker = source\\n while walker != target:\\n if len(self.g.predecessors(walker)) > 1 and len(self._post_dominance_frontier[walker]) > 1:\\n if walker != source:\\n if walker not in self._cache:\\n subroot = self.__make_sequence_subtree(walker, target, False)\\n self._cache[walker] = subroot\\n else:\\n subroot = self._cache[walker]\\n self.add_edge(Edge(seq, subroot))\\n walker = target\\n else:\\n self.add_vertex(walker)\\n self.add_edge(Edge(seq, walker))\\n if len(self.g.successors(walker)) == 1:\\n print(self.g.name, source, target, walker)\\n (e,) = self.g.successors(walker)\\n walker = e.successor()\\n else:\\n self.add_edge(Edge(seq, self.__make_alternative_subtree(walker)))\\n (dominator_e,) = self.g.post_dominator_tree().predecessors(walker)\\n walker = dominator_e.predecessor()\\n\\n if inclusive:\\n self.add_vertex(target)\\n self.add_edge(Edge(seq, target))\\n\\n return seq\\n\\n def __make_alternative_subtree(self, branch: Vertex):\\n alt = Alternative(Vertex.get_vertex_id())\\n self.add_vertex(alt)\\n\\n (dominator_e,) = self.g.post_dominator_tree().predecessors(branch)\\n for e in self.g.successors(branch):\\n seq = self.__make_sequence_subtree(e.successor(), dominator_e.predecessor(), False)\\n self.add_edge(Edge(alt, seq))\\n\\n return alt\\n\\n def dotify(self):\\n data = []\\n for v in self:\\n data.append(v.dotify())\\n for e in self.successors(v):\\n data.append(e.dotify())\\n filename = '{}.{}.ast.dot'.format(self.g.program, self.g.name)\\n dot.generate(filename, data)\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.5726937055587769,\n \"alphanum_fraction\": 0.578228771686554,\n \"avg_line_length\": 35.621620178222656,\n \"blob_id\": \"2c181ac72f70477799533d8f9777b392c628c006\",\n \"content_id\": \"3b582c3c0eaae9c5040db9cd50e4ce633277ac4f\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 2710,\n \"license_type\": \"no_license\",\n \"max_line_length\": 131,\n \"num_lines\": 74,\n \"path\": \"/tools/super_block_calculations.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import argparse\\nimport os\\nimport shutil\\nimport sys\\nimport threading\\nimport timeit\\n\\nfrom calculations import calculations\\nfrom graphs import graph\\nfrom system import program, database\\nfrom utils import messages\\n\\n\\ndef main(**kwargs):\\n prog = program.IO.read(kwargs['filename'])\\n prog.cleanup()\\n with database.Database(kwargs['database']) as db:\\n for subprogram in prog:\\n subprogram.cfg.dotify()\\n ppg = graph.ProgramPointGraph.create_from_control_flow_graph(subprogram.cfg)\\n ppg.dotify()\\n\\n for i in range(0, kwargs['repeat']):\\n lnt = graph.LoopNests(ppg)\\n lnt.dotify()\\n\\n ilp_for_ppg = calculations.create_ilp_for_program_point_graph(ppg, lnt, db)\\n ilp_for_ppg.solve('{}{}.ppg.ilp'.format(prog.basename(), ppg.name))\\n\\n start = timeit.default_timer()\\n super_graph = graph.SuperBlockGraph(lnt)\\n super_graph.dotify()\\n end = timeit.default_timer()\\n\\n ilp_for_super = calculations.create_ilp_for_super_block_graph(super_graph, lnt, db)\\n ilp_for_super.solve('{}{}.super.ilp'.format(prog.basename(), ppg.name))\\n ilp_for_super.add_to_construction_time(end - start)\\n\\n messages.verbose_message('>>>>>', ppg.name, \\\"PASSED\\\" if ilp_for_ppg.wcet == ilp_for_super.wcet else \\\"FAILED \\\" * 10)\\n messages.verbose_message(ilp_for_ppg)\\n messages.verbose_message(ilp_for_super, new_lines=2)\\n\\n\\ndef parse_the_command_line():\\n parser = argparse.ArgumentParser(description='Do WCET calculation using super blocks')\\n\\n parser.add_argument('--filename',\\n help='read the program from this file',\\n required=True)\\n\\n parser.add_argument('--database',\\n help='use the WCET data in this file',\\n required=True)\\n\\n parser.add_argument('--repeat',\\n type=int,\\n help='repeat the calculation this many times',\\n default=1,\\n metavar='')\\n\\n parser.add_argument('--folded',\\n action='store_true',\\n help='fold super blocks before constraint solving',\\n default=False)\\n\\n return parser.parse_args()\\n\\n\\nif __name__ == '__main__':\\n assert sys.version_info >= (3, 0), 'Script requires Python 3.0 or greater to run'\\n assert shutil.which('lp_solve', mode=os.X_OK), 'Script requires lp_solve to be in your path'\\n threading.stack_size(2 ** 26)\\n sys.setrecursionlimit(2 ** 20)\\n main(**vars(parse_the_command_line()))\\n\"\n },\n {\n \"alpha_fraction\": 0.5562784671783447,\n \"alphanum_fraction\": 0.5731945633888245,\n \"avg_line_length\": 17.297618865966797,\n \"blob_id\": \"77bab687c82aafde5d466ca32344d830ba33764b\",\n \"content_id\": \"36350a7c4acc5bb4a4e4b08b79aeb62bbcb2d9f5\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 1537,\n \"license_type\": \"no_license\",\n \"max_line_length\": 77,\n \"num_lines\": 84,\n \"path\": \"/benchmarks/matrix_count/matrix_count.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Matrix count taken from MDH suite and modified\\n * by Adam Betts to consume a test vector supplied on the command line.\\n *\\n * For this program, the test vector consists of 400 integers since there is\\n * a 20*20 matrix to be initialised. The program does the following:\\n * 1) It counts the number of positive numbers in the matrix.\\n * 2) It sums the positive numbers.\\n * 3) It counts the number of negative numbers in the matrix.\\n * 4) It sums the negative numbers.\\n */\\n\\n#define UPPERLIMIT 5\\ntypedef int matrix[UPPERLIMIT][UPPERLIMIT];\\n\\nint Postotal;\\nint Negtotal;\\nint Poscnt;\\nint Negcnt;\\n\\nvoid\\nmatrix_count (matrix A)\\n{\\n int i, j;\\n int Ptotal = 0;\\n int Ntotal = 0;\\n int Pcnt = 0;\\n int Ncnt = 0;\\n\\n for (i = 0; i < UPPERLIMIT; ++i)\\n {\\n for (j = 0; j < UPPERLIMIT; ++j)\\n {\\n if (A[i][j] < 0)\\n {\\n Ntotal += A[i][j];\\n Ncnt++;\\n }\\n else\\n {\\n Ptotal += A[i][j];\\n Pcnt++;\\n }\\n }\\n }\\n\\n Postotal = Ptotal;\\n Poscnt = Pcnt;\\n Negtotal = Ntotal;\\n Negcnt = Ncnt;\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n int i, j, k;\\n matrix A;\\n\\n /*\\n * There is a matrix with X*X dimensions that needs to be filled up.\\n * This many values need to be passed on the command-line as a consequence.\\n */\\n if (argc != UPPERLIMIT * UPPERLIMIT + 1)\\n {\\n return 1;\\n }\\n\\n /*\\n * Initialise matrix A.\\n */\\n k = 0;\\n for (i = 0; i < UPPERLIMIT; ++i)\\n {\\n for (j = 0; j < UPPERLIMIT; ++j)\\n {\\n A[i][j] = atoi (argv[k + 1]);\\n k++;\\n }\\n }\\n\\n matrix_count (A);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.5741574764251709,\n \"alphanum_fraction\": 0.5761358737945557,\n \"avg_line_length\": 50.417545318603516,\n \"blob_id\": \"1f5d58003dd9a73c7b7d12b621b623c9ee99032f\",\n \"content_id\": \"f8b46a8daae33edb2ba68aefbd60509a8c5d0adf\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 14658,\n \"license_type\": \"no_license\",\n \"max_line_length\": 147,\n \"num_lines\": 285,\n \"path\": \"/GPUTimingAnalysis/src/IPGs.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from DirectedGraphs import DirectedGraph, dummyVertexID\\nfrom Vertices import HeaderVertex, Ipoint\\nfrom Edges import IPGEdge\\nimport Debug\\n\\nedgeID = 1\\n\\nclass IPG (DirectedGraph):\\n def __init__(self, icfg, lnt=None):\\n DirectedGraph.__init__(self)\\n self.__branchDivergence = False\\n self.__branchDivergentEdges = []\\n self.__entryID = dummyVertexID\\n self.__exitID = dummyVertexID\\n self.__icfg = icfg\\n self.__lnt = lnt\\n self.__ipointIDToVertex = {}\\n self.__auxiliaryData = _AuxiliaryData()\\n self.__visited = {}\\n self.__initialise()\\n self.__doDepthFirstSearch(self.__icfg.getEntryID())\\n self.__addEdgesUsingLNT()\\n self.__setEntryAndExit()\\n self.setName(icfg.getName())\\n del self.__visited\\n \\n def updateWithBranchDivergentPaths (self):\\n self.__branchDivergence = True\\n for level, vertices in self.__lnt.levelIterator():\\n for v in vertices:\\n if isinstance(v, HeaderVertex):\\n headerID = v.getHeaderID()\\n if not self.__lnt.isSelfLoopHeader(headerID):\\n if not isinstance(v, Ipoint):\\n self.__auxiliaryData.vertexToReachable[headerID][headerID] = [headerID]\\n self.__auxiliaryData.headerID = headerID\\n self.__solveDFF(headerID)\\n self.__collapseInnerLoops(headerID)\\n \\n def getIpointVertex (self, ipointID):\\n assert ipointID in self.__ipointIDToVertex, \\\"Unable to find Ipoint with trace ID 0x%04X\\\" % ipointID\\n return self.__ipointIDToVertex[ipointID]\\n \\n def getEntryID (self):\\n assert self.__entryID != dummyVertexID, \\\"Entry to IPG not found\\\"\\n return self.__entryID\\n \\n def getExitID (self):\\n assert self.__exitID != dummyVertexID, \\\"Exit to IPG not found\\\"\\n return self.__exitID\\n \\n def isBranchDivergentEdge (self, predID, succID):\\n return (predID, succID) in self.__branchDivergentEdges\\n \\n def __initialise (self):\\n for v in self.__icfg:\\n vertexID = v.getVertexID()\\n self.__visited[vertexID] = False\\n self.__auxiliaryData.vertexToReachable[vertexID] = {} \\n # Ipoint actions\\n if self.__icfg.isIpoint(vertexID):\\n ipointv = Ipoint(vertexID, v.getIpointID())\\n self.vertices[vertexID] = ipointv\\n self.__ipointIDToVertex[v.getIpointID()] = ipointv\\n if self.__lnt.isLoopHeader(vertexID):\\n self.__auxiliaryData.ipointToHeader[vertexID] = vertexID\\n else:\\n headerv = self.__lnt.getInternalHeaderVertex(self.__lnt.getVertex(vertexID).getParentID())\\n self.__auxiliaryData.ipointToHeader[vertexID] = headerv.getHeaderID()\\n # Header actions\\n if self.__lnt.isLoopHeader(vertexID):\\n # Ignore self loops\\n if not self.__lnt.isSelfLoopHeader(vertexID):\\n self.__auxiliaryData.headerToIpoints[vertexID] = self.__lnt.getIpointsInLoopBody(vertexID)\\n self.__auxiliaryData.headerToReachable[vertexID] = {}\\n self.__auxiliaryData.headerToTopSorts[vertexID] = []\\n self.__auxiliaryData.headerToIterationEdges[vertexID] = [] \\n \\n def __doDepthFirstSearch (self, vertexID):\\n self.__visited[vertexID] = True\\n v = self.__icfg.getVertex(vertexID)\\n for succID in v.getSuccessorIDs():\\n if self.__visited[succID] == False:\\n self.__doDepthFirstSearch(succID)\\n # Get the root of the LNT\\n rootv = self.__lnt.getInternalHeaderVertex(self.__lnt.getRootID())\\n if vertexID != rootv.getHeaderID():\\n treev = self.__lnt.getVertex(vertexID)\\n headerv = self.__lnt.getInternalHeaderVertex(treev.getParentID())\\n headerID = headerv.getHeaderID()\\n # Insert the vertex visited at the front of the topological sort for the loop\\n # in which it is contained\\n self.__auxiliaryData.headerToTopSorts[headerID].insert(0, vertexID)\\n if self.__lnt.isLoopHeader(vertexID):\\n outerHeaderv = self.__lnt.getInternalHeaderVertex(headerv.getParentID())\\n outerHeaderID = outerHeaderv.getHeaderID()\\n self.__auxiliaryData.headerToTopSorts[outerHeaderID].insert(0, vertexID)\\n else:\\n self.__auxiliaryData.headerToTopSorts[vertexID].insert(0, vertexID)\\n \\n def __addEdgesUsingLNT (self):\\n for level, vertices in self.__lnt.levelIterator():\\n for v in vertices:\\n if isinstance(v, HeaderVertex):\\n headerID = v.getHeaderID()\\n if not self.__lnt.isSelfLoopHeader(headerID):\\n if not isinstance(v, Ipoint):\\n self.__auxiliaryData.vertexToReachable[headerID][headerID] = [headerID]\\n self.__auxiliaryData.headerID = headerID\\n self.__solveDFF(headerID)\\n self.__collapseInnerLoops(headerID)\\n \\n def __solveDFF (self, headerID):\\n Debug.debugMessage(\\\"Building IPG in CFG* loop %s\\\" % headerID, 5)\\n self.__auxiliaryData.changed = True\\n self.__auxiliaryData.iteration = 0\\n \\n while self.__auxiliaryData.changed:\\n self.__auxiliaryData.changed = False\\n self.__auxiliaryData.iteration += 1\\n \\n for vertexID in self.__auxiliaryData.headerToTopSorts[headerID]:\\n v = self.__icfg.getVertex(vertexID)\\n for predID in v.getPredecessorIDs():\\n analyseEdge = False\\n \\n if vertexID == headerID:\\n if self.__lnt.isLoopBackEdge(predID, headerID) and self.__auxiliaryData.iteration > 1:\\n analyseEdge = True\\n elif not self.__lnt.isLoopHeader(vertexID):\\n analyseEdge = True\\n elif not self.__lnt.isLoopBackEdge(predID, vertexID):\\n analyseEdge = True\\n \\n if analyseEdge:\\n Debug.debugMessage(\\\"Iteration %s, edge %s => %s\\\" \\n % (self.__auxiliaryData.iteration, predID, vertexID), 15)\\n if self.__icfg.isIpoint(predID):\\n self.__update(predID, vertexID, headerID, predID)\\n else:\\n for keyID in self.__auxiliaryData.vertexToReachable[predID].keys():\\n if self.__icfg.isIpoint(keyID):\\n self.__update(keyID, vertexID, headerID, predID)\\n \\n if self.__auxiliaryData.iteration == 1 and headerID in self.__auxiliaryData.vertexToReachable[predID]:\\n self.__updateLoopReachability(headerID, vertexID, predID)\\n \\n def __update (self, ipointID, vertexID, headerID, predID):\\n ipointv = self.getVertex(ipointID)\\n \\n if self.__icfg.isIpoint(vertexID):\\n if not ipointv.hasSuccessor(vertexID):\\n self.__auxiliaryData.changed = True\\n self.__addEdge(ipointID, vertexID)\\n if ipointID != predID:\\n self.__updateEdgeLabel(ipointID, vertexID,\\n self.__auxiliaryData.vertexToReachable[predID][ipointID])\\n \\n if self.__auxiliaryData.iteration == 2:\\n self.__setIterationEdge(ipointID, vertexID)\\n elif ipointID != predID:\\n self.__updateEdgeLabel(ipointID, vertexID,\\n self.__auxiliaryData.vertexToReachable[predID][ipointID])\\n else:\\n if self.__lnt.isLoopHeader(vertexID) and not self.__lnt.isSelfLoopHeader(vertexID) and vertexID != headerID:\\n self.__updateLoopExits(vertexID, ipointID, predID)\\n self.__addLoopEntryEdges(ipointID, vertexID, predID)\\n else:\\n if ipointID not in self.__auxiliaryData.vertexToReachable[vertexID]:\\n self.__auxiliaryData.changed = True\\n self.__auxiliaryData.vertexToReachable[vertexID][ipointID] = [vertexID]\\n if ipointID != predID:\\n self.__auxiliaryData.vertexToReachable[vertexID][ipointID].extend(self.__auxiliaryData.vertexToReachable[predID][ipointID])\\n elif ipointID != predID:\\n self.__updateAndTestForIteration(self.__auxiliaryData.vertexToReachable[vertexID][ipointID], \\n self.__auxiliaryData.vertexToReachable[predID][ipointID])\\n \\n def __updateAndTestForIteration (self, oldSet, extraElements):\\n oldsize = len(set(oldSet))\\n oldSet.extend(extraElements)\\n newsize = len(set(oldSet))\\n if oldsize != newsize:\\n self.__auxiliaryData.changed = True\\n \\n def __updateLoopReachability (self, headerID, predID, vertexID):\\n if self.__icfg.isIpoint(vertexID):\\n if vertexID not in self.__auxiliaryData.headerToReachable[headerID]:\\n self.__auxiliaryData.changed = True\\n self.__auxiliaryData.headerToReachable[headerID][vertexID].extend(self.__auxiliaryData.vertexToReachable[predID][headerID])\\n else:\\n pass\\n \\n def __updateLoopExits (self, headerID, keyID, predID):\\n for exitID in self.__lnt.getLoopExits(headerID):\\n if headerID in self.__auxiliaryData.vertexToReachable[exitID]:\\n if keyID not in self.__auxiliaryData.vertexToReachable[exitID]:\\n self.__auxiliaryData.changed = True\\n self.__auxiliaryData.vertexToReachable[exitID][keyID] = []\\n if keyID != predID:\\n self.__auxiliaryData.vertexToReachable[exitID][keyID].extend(self.__auxiliaryData.vertexToReachable[predID][keyID])\\n self.__auxiliaryData.vertexToReachable[exitID][keyID].extend(self.__auxiliaryData.vertexToReachable[exitID][headerID])\\n elif keyID != predID:\\n self.__updateAndTestForIteration(self.__auxiliaryData.vertexToReachable[exitID][keyID], \\n self.__auxiliaryData.vertexToReachable[predID][keyID])\\n \\n def __addLoopEntryEdges (self, sourceID, headerID, predID):\\n sourcev = self.getVertex(sourceID)\\n for destinationID in self.__auxiliaryData.headerToReachable[headerID].keys():\\n if not sourcev.hasSuccessor(destinationID):\\n self.__auxiliaryData.changed = True\\n self.__addEdge(sourceID, destinationID)\\n if sourceID != predID:\\n self.__updateEdgeLabel(sourceID, destinationID,\\n self.__auxiliaryData.vertexToReachable[predID][sourceID])\\n self.__updateEdgeLabel(sourceID, destinationID, \\n self.__auxiliaryData.headerToReachable[headerID][destinationID])\\n if self.__auxiliaryData.iteration == 2:\\n self.__setIterationEdge(sourceID, destinationID) \\n elif self.__auxiliaryData.iteration == 2:\\n self.__setIterationEdge(sourceID, destinationID)\\n \\n def __addEdge (self, predID, succID):\\n global edgeID\\n Debug.debugMessage(\\\"Adding IPG Edge %s => %s\\\" % (predID, succID), 10)\\n predv = self.getVertex(predID)\\n succv = self.getVertex(succID)\\n predv.addIpointSuccessor (succv.getIpointID(), succID)\\n succe = IPGEdge(succID, edgeID)\\n prede = IPGEdge(predID, edgeID)\\n predv.addSuccessorEdge(succe)\\n succv.addPredecessorEdge(prede) \\n edgeID += 1\\n if self.__branchDivergence:\\n self.__branchDivergentEdges.append((predID, succID))\\n \\n def __setIterationEdge (self, predID, succID):\\n predv = self.getVertex(predID)\\n succv = self.getVertex(succID)\\n succe = predv.getSuccessorEdge(succID)\\n prede = succv.getPredecessorEdge(predID)\\n succe.setIterationEdge()\\n prede.setIterationEdge()\\n \\n def __updateEdgeLabel (self, predID, succID, extraElements):\\n predv = self.getVertex(predID)\\n succv = self.getVertex(succID)\\n succe = predv.getSuccessorEdge(succID)\\n prede = succv.getPredecessorEdge(predID)\\n size1 = succe.getEdgeLabelSize()\\n size2 = prede.getEdgeLabelSize()\\n assert size1 == size2, \\\"Discrepancy between size of edge labels for %s => %s. Found both %s and %s\\\" % (predID, succID, size1, size2)\\n succe.addToEdgeLabel(extraElements)\\n prede.addToEdgeLabel(extraElements)\\n succe.addToEdgeLabel([predID, succID])\\n prede.addToEdgeLabel([predID, succID])\\n newSize = succe.getEdgeLabelSize()\\n if newSize != size1:\\n self.__auxiliaryData.changed = True\\n \\n def __collapseInnerLoops (self, headerID):\\n headerv = self.__lnt.getVertex(self.__lnt.getVertex(headerID).getParentID())\\n for succID in headerv.getSuccessorIDs():\\n if self.__lnt.isLoopHeader(succID) and not self.__lnt.isSelfLoopHeader(succID):\\n ipoints = self.__auxiliaryData.headerToIpoints[succID]\\n self.__auxiliaryData.headerToIpoints[headerID].extend(ipoints)\\n for ipointID in ipoints:\\n self.__auxiliaryData.ipointToHeader[ipointID] = headerID\\n \\n def __setEntryAndExit (self):\\n entryv = self.vertices[self.__icfg.getEntryID()]\\n self.__entryID = entryv.getVertexID()\\n assert entryv.numberOfPredecessors() == 1, \\\"Entry vertex %s of IPG has multiple predecessors\\\" % self.__entryID\\n for predID in entryv.getPredecessorIDs():\\n self.__exitID = predID\\n\\nclass _AuxiliaryData ():\\n def __init__(self):\\n self.changed = False\\n self.iteration = 0\\n self.vertexToReachable = {}\\n self.headerToReachable = {}\\n self.headerToTopSorts = {}\\n self.headerToIterationEdges = {}\\n self.headerToIpoints = {}\\n self.ipointToHeader = {}\\n \"\n },\n {\n \"alpha_fraction\": 0.5279361605644226,\n \"alphanum_fraction\": 0.5427594184875488,\n \"avg_line_length\": 15.528302192687988,\n \"blob_id\": \"0c4b43ca0ad4e40a558efed7f16514995ae355ff\",\n \"content_id\": \"dea0079a3c1fa87b410c83f2da1155a2acb0a3fb\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 877,\n \"license_type\": \"no_license\",\n \"max_line_length\": 75,\n \"num_lines\": 53,\n \"path\": \"/benchmarks/insertsort/insertsort.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Insert sort taken from MDH suite and modified by Adam Betts to consume a\\n * test vector supplied on the command line.\\n *\\n * For this program, the test vector is a list of integers to be sorted.\\n * Note that the size of the array is determined by the number of arguments\\n * given to the program, i.e. argc - 1.\\n */\\n\\nvoid\\ninsertsort (int ARRAY_SIZE, int a[])\\n{\\n int i, j, key;\\n\\n for (j = 1; j < ARRAY_SIZE; j++)\\n {\\n key = a[j];\\n i = j - 1;\\n\\n while (a[i] > key && i >= 0)\\n {\\n a[i+1] = a[i];\\n i--;\\n }\\n\\n a[i+1] = key;\\n }\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int ARRAY_SIZE = argc - 1;\\n int TV[ARRAY_SIZE];\\n int i;\\n\\n /*\\n * At least one integer value must be supplied\\n */\\n if (argc == 1)\\n {\\n return 1;\\n }\\n\\n for (i = 0; i < argc - 1; i++)\\n {\\n TV[i] = atoi (argv[i + 1]);\\n }\\n\\n insertsort (ARRAY_SIZE, TV);\\n\\n return 0;\\n}\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.3553571403026581,\n \"alphanum_fraction\": 0.4537946283817291,\n \"avg_line_length\": 33.1984748840332,\n \"blob_id\": \"211f53187fe452ada2412cd28d26342eeb208f52\",\n \"content_id\": \"5f067699294ff73932894935c2dfe79bfb752eeb\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 8960,\n \"license_type\": \"no_license\",\n \"max_line_length\": 112,\n \"num_lines\": 262,\n \"path\": \"/DaikonPathInformation/benchmarks/fastDiscreteCosineTransform.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/* MDH WCET BENCHMARK SUITE. */\\n/* 2012/09/28, Jan Gustafsson \\n * Changes:\\n * - main() declared as int.\\n * - Unused variables removed.\\n */\\n// *********************************************************************************************************\\n// * FDCT.C *\\n// * *\\n// * Forward Discrete Cosine Transform * \\n// * Used on 8x8 image blocks * \\n// * to reassemble blocks in order to ease quantization compressing image information on the more *\\n// * significant frequency components *\\n// * * \\n// * Expected Result -> short int block[64]= { 699,164,-51,-16, 31,-15,-19, 8, *\\n// * 71, 14,-61, -2,-11,-12, 7, 12, *\\n// * -58,-55, 13, 28,-20, -7, 14,-18, *\\n// * 29, 22, 3, 3,-11, 7, 11,-22, *\\n// * -1,-28,-27, 10, 0, -7, 11, 6, *\\n// * 7, 6, 21, 21,-10, -8, 2,-14, *\\n// * 1, -7,-15,-15,-10, 15, 16,-10, *\\n// * 0, -1, 0, 15, 4,-13, -5, 4 }; *\\n// * *\\n// * Exadecimal results: Block -> 02bb00a4 ffcdfff0 001ffff1 ffed0008 0047000e ffc3fffe 000bfff4 0007000c *\\n// * ffc6ffc9 000d001c ffecfff9 000effee 001d0016 00030003 fff50007 000bffea *\\n// * ffffffe4 ffe5000a 0000fff9 000b0006 00070006 00150015 fff6fff8 0002fff2 *\\n// * 0001fff9 fff1fff1 fff6000f 0010fff6 0000ffff 0000000f 0004fff3 fffb0004 *\\n// * * \\n// * Number of clock cycles (with these inputs) -> 2132 * \\n// *********************************************************************************************************\\n\\n// Cosine Transform Coefficients\\n#define W1 2841 /* 2048*sqrt(2)*cos(1*pi/16) */\\n#define W2 2676 /* 2048*sqrt(2)*cos(2*pi/16) */\\n#define W3 2408 /* 2048*sqrt(2)*cos(3*pi/16) */\\n#define W5 1609 /* 2048*sqrt(2)*cos(5*pi/16) */\\n#define W6 1108 /* 2048*sqrt(2)*cos(6*pi/16) */\\n#define W7 565 /* 2048*sqrt(2)*cos(7*pi/16) */\\n\\n// Other FDCT Parameters\\n#define CONST_BITS 13\\n#define PASS1_BITS 2\\n\\n#define TEST_VECTOR_LENGTH 64\\n\\nint \\nfastDiscreteCosineTransform (short int *blk, int lx)\\n{\\n#ifdef CBMC\\n//==========> fastdiscretecosinetransform : header 6\\nint __count_6_5 = 0;\\nint __count_6_5_L = 0; //Loop counter\\n//==========> fastdiscretecosinetransform : header 3\\nint __count_3_2 = 0;\\nint __count_3_2_L = 0; //Loop counter\\n//==========> fastdiscretecosinetransform : header 1\\nint __count_7 = 0;\\nint __count_3_4 = 0;\\n#endif\\n\\n int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;\\n int tmp10, tmp11, tmp12, tmp13;\\n int z1, z2, z3, z4, z5;\\n int i;\\n short int *block;\\n\\n int constant;\\n\\n /* Pass 1: process rows. */\\n /* Note results are scaled up by sqrt(8) compared to a true DCT; */\\n /* furthermore, we scale the results by 2**PASS1_BITS. */\\n\\n block=blk;\\n\\n #ifdef CBMC\\n __count_3_2_L = 0;\\n #endif\\n for (i=0; i<8; i++) // 3\\n {\\n #ifdef CBMC\\n __count_3_2_L++;\\n __count_3_2++;\\n #endif\\n tmp0 = block[0] + block[7];\\n tmp7 = block[0] - block[7];\\n tmp1 = block[1] + block[6];\\n tmp6 = block[1] - block[6];\\n tmp2 = block[2] + block[5];\\n tmp5 = block[2] - block[5];\\n tmp3 = block[3] + block[4];\\n tmp4 = block[3] - block[4];\\n\\n tmp10 = tmp0 + tmp3;\\n tmp13 = tmp0 - tmp3;\\n tmp11 = tmp1 + tmp2;\\n tmp12 = tmp1 - tmp2;\\n\\n block[0] = ((tmp10+tmp11) << PASS1_BITS);\\n block[4] = ((tmp10-tmp11) << PASS1_BITS);\\n\\n constant= 4433;\\n z1 = (tmp12 + tmp13) * constant;\\n constant= 6270;\\n block[2] = (z1 + (tmp13 * constant)) >> (CONST_BITS-PASS1_BITS);\\n constant= -15137;\\n block[6] = (z1 + (tmp12 * constant)) >> (CONST_BITS-PASS1_BITS);\\n\\n z1 = tmp4 + tmp7;\\n z2 = tmp5 + tmp6;\\n z3 = tmp4 + tmp6;\\n z4 = tmp5 + tmp7;\\n constant= 9633;\\n z5 = ((z3 + z4) * constant); /* sqrt(2) * c3 */\\n\\n constant= 2446;\\n tmp4 = (tmp4 * constant); /* sqrt(2) * (-c1+c3+c5-c7) */\\n constant= 16819;\\n tmp5 = (tmp5 * constant); /* sqrt(2) * ( c1+c3-c5+c7) */\\n constant= 25172;\\n tmp6 = (tmp6 * constant); /* sqrt(2) * ( c1+c3+c5-c7) */\\n constant= 12299;\\n tmp7 = (tmp7 * constant); /* sqrt(2) * ( c1+c3-c5-c7) */\\n constant= -7373;\\n z1 = (z1 * constant); /* sqrt(2) * (c7-c3) */\\n constant= -20995;\\n z2 = (z2 * constant); /* sqrt(2) * (-c1-c3) */\\n constant= -16069;\\n z3 = (z3 * constant); /* sqrt(2) * (-c3-c5) */\\n constant= -3196;\\n z4 = (z4 * constant); /* sqrt(2) * (c5-c3) */\\n\\n z3 += z5;\\n z4 += z5;\\n\\n block[7] = (tmp4 + z1 + z3) >> (CONST_BITS-PASS1_BITS);\\n block[5] = (tmp5 + z2 + z4) >> (CONST_BITS-PASS1_BITS);\\n block[3] = (tmp6 + z2 + z3) >> (CONST_BITS-PASS1_BITS);\\n block[1] = (tmp7 + z1 + z4) >> (CONST_BITS-PASS1_BITS);\\n\\n /* advance to next row */\\n block += lx;\\n }\\n #ifdef CBMC\\n assert(__count_3_2_L <= 9); // Loop counter property\\n __count_3_4++;\\n #endif\\n\\n /* Pass 2: process columns. */\\n\\n block=blk;\\n\\n #ifdef CBMC\\n __count_6_5_L = 0;\\n #endif\\n for (i = 0; i<8; i++) // 6\\n {\\n #ifdef CBMC\\n __count_6_5_L++;\\n __count_6_5++;\\n #endif\\n tmp0 = block[0] + block[7*lx];\\n tmp7 = block[0] - block[7*lx];\\n tmp1 = block[lx] + block[6*lx];\\n tmp6 = block[lx]- block[6*lx];\\n tmp2 = block[2*lx] + block[5*lx];\\n tmp5 = block[2*lx] - block[5*lx];\\n tmp3 = block[3*lx] + block[4*lx];\\n tmp4 = block[3*lx] - block[4*lx];\\n \\n tmp10 = tmp0 + tmp3;\\n tmp13 = tmp0 - tmp3;\\n tmp11 = tmp1 + tmp2;\\n tmp12 = tmp1 - tmp2;\\n\\n block[0] = (tmp10 + tmp11) >> (PASS1_BITS+3);\\n block[4*lx] = (tmp10 - tmp11) >> (PASS1_BITS+3);\\n\\n constant = 4433;\\n z1 = ((tmp12 + tmp13) * constant);\\n constant= 6270;\\n block[2*lx] = (z1 + (tmp13 * constant)) >> (CONST_BITS+PASS1_BITS+3);\\n constant=-15137;\\n block[6*lx] = (z1 + (tmp12 * constant)) >> (CONST_BITS+PASS1_BITS+3);\\n\\n z1 = tmp4 + tmp7;\\n z2 = tmp5 + tmp6;\\n z3 = tmp4 + tmp6;\\n z4 = tmp5 + tmp7;\\n constant=9633;\\n z5 = ((z3 + z4) * constant); /* sqrt(2) * c3 */\\n\\n constant=2446;\\n tmp4 = (tmp4 * constant); /* sqrt(2) * (-c1+c3+c5-c7) */\\n constant=16819;\\n tmp5 = (tmp5 * constant); /* sqrt(2) * ( c1+c3-c5+c7) */\\n constant=25172;\\n tmp6 = (tmp6 * constant); /* sqrt(2) * ( c1+c3+c5-c7) */\\n constant=12299;\\n tmp7 = (tmp7 * constant); /* sqrt(2) * ( c1+c3-c5-c7) */\\n constant=-7373;\\n z1 = (z1 * constant); /* sqrt(2) * (c7-c3) */\\n constant= -20995;\\n z2 = (z2 * constant); /* sqrt(2) * (-c1-c3) */\\n constant=-16069;\\n z3 = (z3 * constant); /* sqrt(2) * (-c3-c5) */\\n constant=-3196;\\n z4 = (z4 * constant); /* sqrt(2) * (c5-c3) */\\n\\n z3 += z5;\\n z4 += z5;\\n\\n block[7*lx] = (tmp4 + z1 + z3) >> (CONST_BITS+PASS1_BITS+3);\\n block[5*lx] = (tmp5 + z2 + z4) >> (CONST_BITS+PASS1_BITS+3);\\n block[3*lx] = (tmp6 + z2 + z3) >> (CONST_BITS+PASS1_BITS+3);\\n block[lx] = (tmp7 + z1 + z4) >> (CONST_BITS+PASS1_BITS+3);\\n\\n /* advance to next column */\\n block++;\\n }\\n \\n #ifdef CBMC\\n assert(__count_6_5_L <= 9); // Loop counter property\\n __count_7++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_3_2 >= 8); // Lower capacity constraint\\nassert(__count_3_2 <= 8); // Upper capacity constraint\\nassert(__count_3_4 >= 1); // Lower capacity constraint\\nassert(__count_3_4 <= 1); // Upper capacity constraint\\nassert(__count_6_5 >= 8); // Lower capacity constraint\\nassert(__count_6_5 <= 8); // Upper capacity constraint\\nassert(__count_7 >= 1); // Lower capacity constraint\\nassert(__count_7 <= 1); // Upper capacity constraint\\n#endif\\n\\n return lx + block[0];\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n /*\\n * At least as many integers as the test vector length\\n */\\n if (argc != TEST_VECTOR_LENGTH + 1)\\n {\\n return 1;\\n }\\n \\n short int block[64];\\n int i;\\n for (i = 0; i < argc - 1; ++i)\\n {\\n block[i] = (short int) atoi (argv[i + 1]);\\n }\\n\\n int val = fastDiscreteCosineTransform (block, 8);\\n printf(\\\"%d\\\", val);\\n \\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.4846450686454773,\n \"alphanum_fraction\": 0.48884040117263794,\n \"avg_line_length\": 47.43902587890625,\n \"blob_id\": \"e0862be916e67bc6301cc50213ca193c711f1c83\",\n \"content_id\": \"fa12f89547f9432734ffa4bd6485c426fa3eaf43\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 5959,\n \"license_type\": \"no_license\",\n \"max_line_length\": 129,\n \"num_lines\": 123,\n \"path\": \"/tools/system/database.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import sqlite3\\nimport collections\\n\\nfrom graphs import graph\\n\\n\\nclass Table:\\n def __init__(self, name, key, *args):\\n self._name = name\\n self._key = key\\n self._columns = collections.OrderedDict()\\n for column_name, data_type in args:\\n self._columns[column_name] = data_type\\n\\n @property\\n def name(self):\\n return self._name\\n\\n def key(self, index):\\n return self._key[index]\\n\\n def __iter__(self):\\n for column_name, data_type in self._columns.items():\\n yield column_name, data_type\\n\\n\\nclass Database:\\n def __init__(self, filename):\\n self.__filename = filename\\n self._wcet_table = Table('wcets',\\n ['source_id', 'destination_id'],\\n ('source_id', 'int'), ('destination_id', 'int'), ('value', 'int'))\\n self._wfreq_table = Table('wfreqs',\\n ['source_id', 'destination_id'],\\n ('source_id', 'int'), ('destination_id', 'int'), ('value', 'int'))\\n self._instrumentation_table = Table('instrumentation',\\n ['source_id', 'destination_id'],\\n ('source_id', 'int'), ('destination_id', 'int'), ('value', 'int'))\\n self._tables = [self._wcet_table, self._wfreq_table, self._instrumentation_table]\\n\\n def __enter__(self):\\n self.__connection = sqlite3.connect(self.__filename)\\n self.__cursor = self.__connection.cursor()\\n return self\\n\\n def __exit__(self, exception_type, exception_value, traceback):\\n self.__connection.commit()\\n self.__connection.close()\\n\\n def reset(self):\\n for table in self._tables:\\n self.__cursor.execute('DROP TABLE if exists {}'.format(table.name))\\n self.__cursor.execute('CREATE TABLE {} ({})'.format(table.name,\\n ', '.join(['{} {}'.format(key, value) for key, value in table])))\\n\\n def add_wcet(self, program_point: graph.Vertex or graph.Edge, wcet: int):\\n if isinstance(program_point, graph.Vertex):\\n row = [program_point.id_, 0, wcet]\\n else:\\n assert isinstance(program_point, graph.Edge)\\n row = [program_point.predecessor().id_, program_point.successor().id_, wcet]\\n self.__cursor.execute('INSERT INTO {} VALUES (?, ?, ?)'.format(self._wcet_table.name), row)\\n\\n def add_wfreq(self, program_point: graph.Vertex or graph.Edge, wfreq: int):\\n if isinstance(program_point, graph.Vertex):\\n row = [program_point.id_, 0, wfreq]\\n else:\\n assert isinstance(program_point, graph.Edge)\\n row = [program_point.predecessor().id_, program_point.successor().id_, wfreq]\\n self.__cursor.execute('INSERT INTO {} VALUES (?, ?, ?)'.format(self._wfreq_table.name), row)\\n\\n def set_instrumentation(self, program_point: graph.Vertex or graph.Edge):\\n if isinstance(program_point, graph.Vertex):\\n row = [program_point.id_, 0, 1]\\n else:\\n assert isinstance(program_point, graph.Edge)\\n row = [program_point.predecessor().id_, program_point.successor().id_, 1]\\n self.__cursor.execute('INSERT INTO {} VALUES (?, ?, ?)'.format(self._instrumentation_table.name), row)\\n\\n def get_wcet(self, program_point: graph.Vertex or graph.Edge):\\n if isinstance(program_point, graph.Vertex):\\n key = [program_point.id_, 0]\\n else:\\n assert isinstance(program_point, graph.Edge)\\n key = [program_point.predecessor().id_, program_point.successor().id_]\\n query = \\\"SELECT * from {} where {}='{}' and {}='{}'\\\".format(self._wcet_table.name,\\n self._wcet_table.key(0),\\n key[0],\\n self._wcet_table.key(1),\\n key[1])\\n self.__cursor.execute(query)\\n (row,) = self.__cursor.fetchall()\\n return row[2]\\n\\n def get_wfreq(self, program_point: graph.Vertex or graph.Edge):\\n if isinstance(program_point, graph.Vertex):\\n key = [program_point.id_, 0]\\n else:\\n assert isinstance(program_point, graph.Edge)\\n key = [program_point.predecessor().id_, program_point.successor().id_]\\n query = \\\"SELECT * from {} where {}='{}' and {}='{}'\\\".format(self._wfreq_table.name,\\n self._wfreq_table.key(0),\\n key[0],\\n self._wfreq_table.key(1),\\n key[1])\\n self.__cursor.execute(query)\\n (row,) = self.__cursor.fetchall()\\n return row[2]\\n\\n def is_instrumentation(self, program_point: graph.Vertex or graph.Edge):\\n if isinstance(program_point, graph.Vertex):\\n key = [program_point.id_, 0]\\n else:\\n assert isinstance(program_point, graph.Edge)\\n key = [program_point.predecessor().id_, program_point.successor().id_]\\n query = \\\"SELECT * from {} where {}='{}' and {}='{}'\\\".format(self._instrumentation_table.name,\\n self._instrumentation_table.key(0),\\n key[0],\\n self._instrumentation_table.key(1),\\n key[1])\\n self.__cursor.execute(query)\\n rows = self.__cursor.fetchall()\\n return len(rows) != 0\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.5748792290687561,\n \"alphanum_fraction\": 0.5789552927017212,\n \"avg_line_length\": 34.97282791137695,\n \"blob_id\": \"90b94138e65067b631928f77dbdbecaf0678100f\",\n \"content_id\": \"10a731eac95d7de8ef25ea8db92a1cad03e13b6f\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 6624,\n \"license_type\": \"no_license\",\n \"max_line_length\": 95,\n \"num_lines\": 184,\n \"path\": \"/GPUTimingAnalysis/src/ParseCFGs.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import shlex\\nimport CFGs, Debug\\n\\nvertexID = 0\\nPCPrefix = \\\"PC=0x\\\"\\nbraOP = \\\"bra\\\"\\ncallOP = \\\"call\\\"\\ncallpOP = \\\"callp\\\"\\nretOP = \\\"ret\\\"\\nretpOP = \\\"retp\\\"\\nexitOP = \\\"exit\\\"\\nbreakOP = \\\"break\\\"\\npredicated = \\\"@%p\\\"\\n\\ndef getAddress (string):\\n return int(string[len(\\\"PC=\\\"):], 0)\\n\\ndef getBasicBlockWithLabel (cfg, label):\\n for bb in cfg:\\n firstAddr, firstInstr = bb.getFirstInstruction()\\n if firstInstr.containsLabel(label):\\n return bb\\n assert False, \\\"Unable to find basic block with label '%s'\\\" % label\\n \\ndef getBasicBlockWithNextAddress (cfg, addr):\\n # Prioritise finding the block whose first address is\\n # 8 bytes away from the last instruction of the current block\\n for bb in cfg:\\n firstAddr, firstInstr = bb.getFirstInstruction()\\n if firstAddr == addr + 8:\\n return bb\\n for bb in cfg:\\n firstAddr, firstInstr = bb.getFirstInstruction()\\n if firstAddr == addr + 4:\\n return bb\\n assert False, \\\"Unable to find basic block with next address of %s\\\" % addr\\n \\ndef addEdgeToBasicBlockWithNextAddress (cfg, bb, lastAddr):\\n succ = getBasicBlockWithNextAddress(cfg, lastAddr)\\n bb.addSuccessor(succ.getVertexID())\\n succ.addPredecessor(bb.getVertexID())\\n \\ndef addEdges (cfg):\\n import re\\n for bb in cfg:\\n lastAddr, lastInstr = bb.getLastInstruction()\\n lastStr = lastInstr.getString()\\n if braOP in lastStr:\\n lexemes = shlex.split(lastStr)\\n # Add successor with label\\n label = lexemes[-1]\\n succ = getBasicBlockWithLabel(cfg, label)\\n bb.addSuccessor(succ.getVertexID())\\n succ.addPredecessor(bb.getVertexID())\\n # The regular expression pattern matches predicated instructions\\n match = re.search(r'@\\\\!?%p', lastStr)\\n if match:\\n # Add successor with next address\\n addEdgeToBasicBlockWithNextAddress(cfg, bb, lastAddr)\\n elif callOP in lastStr or callpOP in lastStr:\\n lexemes = shlex.split(lastStr)\\n label = lexemes[-1]\\n succ = getBasicBlockWithLabel(cfg, label)\\n bb.addSuccessor(succ.getVertexID())\\n succ.addPredecessor(bb.getVertexID())\\n # Add successor with next address\\n addEdgeToBasicBlockWithNextAddress(cfg, bb, lastAddr)\\n elif exitOP not in lastStr:\\n addEdgeToBasicBlockWithNextAddress(cfg, bb, lastAddr)\\n \\ndef createBasicBlocks (cfg, instructions):\\n global vertexID\\n leaders = []\\n branch = False\\n # First identify the leaders\\n for instr in instructions:\\n if instr == instructions[0] \\\\\\n or instr.getString().startswith(CFGs.Instruction.labelPrefix) \\\\\\n or branch:\\n leaders.append(instr)\\n branch = False\\n if braOP in instr.getString() \\\\\\n or retOP in instr.getString() \\\\\\n or retpOP in instr.getString() \\\\\\n or callOP in instr.getString() \\\\\\n or callpOP in instr.getString() \\\\\\n or breakOP in instr.getString():\\n branch = True\\n \\n # Now create the basic blocks\\n bb = None\\n for instr in instructions:\\n if instr in leaders:\\n bb = CFGs.BasicBlock(vertexID)\\n vertexID += 1\\n cfg.addVertex(bb)\\n bb.addInstruction(instr)\\n else:\\n assert bb, \\\"Basic block is currently null\\\"\\n bb.addInstruction(instr)\\n \\ndef setEntryAndExit (cfg):\\n withoutPred = []\\n withoutSucc = []\\n for bb in cfg:\\n if bb.numberOfSuccessors() == 0:\\n withoutSucc.append(bb.getVertexID())\\n elif bb.numberOfSuccessors() == 1:\\n if bb.hasSuccessor(bb.getVertexID()):\\n withoutSucc.append(bb.getVertexID())\\n if bb.numberOfPredecessors() == 0:\\n withoutPred.append(bb.getVertexID())\\n elif bb.numberOfPredecessors() == 1:\\n if bb.hasPredecessor(bb.getVertexID()):\\n withoutPred.append(bb.getVertexID())\\n \\n if len(withoutPred) == 0:\\n Debug.exitMessage(\\\"CFG '%s' does not an entry point\\\" % cfg.getName())\\n elif len(withoutPred) > 1:\\n debugStr = \\\"\\\"\\n for bbID in withoutPred:\\n bb = cfg.getVertex(bbID)\\n debugStr += bb.__str__()\\n Debug.exitMessage(\\\"CFG '%s' has too many entry points: %s\\\" % (cfg.getName(), debugStr))\\n else:\\n cfg.setEntryID(withoutPred[0])\\n \\n if len(withoutSucc) == 0:\\n Debug.exitMessage(\\\"CFG '%s' does not an exit point\\\" % cfg.getName())\\n elif len(withoutSucc) > 1:\\n debugStr = \\\"\\\"\\n for bbID in withoutSucc:\\n bb = cfg.getVertex(bbID)\\n debugStr += bb.__str__()\\n Debug.exitMessage(\\\"CFG '%s' has too many exit points: %s\\\" % (cfg.getName(), debugStr))\\n else:\\n cfg.setExitID(withoutSucc[0]) \\n \\ndef getInstructionString (lexemes):\\n return ' '.join(lexemes)\\n \\ndef analyseLine (line, instructions, labels):\\n lexemes = shlex.split(line)\\n if len(lexemes) > 0:\\n PCIndex = 2\\n startInstrIndex = 4\\n if lexemes[PCIndex].startswith(PCPrefix):\\n address = getAddress(lexemes[PCIndex])\\n instrString = getInstructionString(lexemes[startInstrIndex:]) \\n if labels:\\n labelString = getInstructionString(labels)\\n instrString = labelString + \\\" \\\" + instrString\\n labels[:] = []\\n instruction = CFGs.Instruction (address, instrString)\\n instructions.append(instruction)\\n else:\\n labels.append(lexemes[-1])\\n \\ndef createProgram (cfgLines):\\n program = CFGs.Program()\\n cfg = None\\n analyse = False\\n instructions = []\\n labels = []\\n for line in cfgLines:\\n if \\\"Summary of basic blocks for\\\" in line:\\n analyse = False\\n assert cfg \\n assert instructions \\n createBasicBlocks(cfg, instructions)\\n addEdges(cfg)\\n setEntryAndExit(cfg)\\n instructions = [] \\n if analyse:\\n analyseLine(line, instructions, labels) \\n if \\\"Printing basic blocks for function\\\" in line:\\n analyse = True\\n lexemes = shlex.split(line)\\n functionName = lexemes[-1][:-1]\\n cfg = CFGs.CFG()\\n cfg.setName(functionName)\\n program.addCFG(cfg)\\n Debug.debugMessage(\\\"Found new CFG '%s'\\\" % functionName, 1)\\n return program \\n\"\n },\n {\n \"alpha_fraction\": 0.44450289011001587,\n \"alphanum_fraction\": 0.5165702104568481,\n \"avg_line_length\": 20.541501998901367,\n \"blob_id\": \"397756f9059a22a5a3669edfc168219f6719b864\",\n \"content_id\": \"47393d29c3ff8ae49759ac63a126b50d5ffaf0bf\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 5703,\n \"license_type\": \"no_license\",\n \"max_line_length\": 76,\n \"num_lines\": 253,\n \"path\": \"/DaikonPathInformation/benchmarks/quadraticroots.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\r\\n * Root computation of a quadratic equation (qurt) taken from MDH suite and\\r\\n * modified by Adam Betts to consume a test vector supplied on the command line.\\r\\n *\\r\\n * For this program, the test vector is the 3 integer coefficients of a\\r\\n * polynomial ax^2 + bx + c where a /= 0\\r\\n */\\r\\n\\r\\ndouble\\r\\nfabs (double n)\\r\\n{\\r\\n if (n >= 0)\\r\\n {\\r\\n return n;\\r\\n }\\r\\n else\\r\\n {\\r\\n return -n;\\r\\n }\\r\\n}\\r\\n\\r\\ndouble\\r\\nsqrt (double val)\\r\\n{\\r\\n#ifdef CBMC\\r\\n//==========> sqrt : header 8\\r\\nint __count_4_7 = 0;\\r\\nint __count_5_6 = 0;\\r\\nint __count_5_7 = 0;\\r\\nint __count_8_4 = 0; //Loop counter\\r\\n//==========> sqrt : header 1\\r\\nint __count_9 = 0;\\r\\nint __count_2_9 = 0;\\r\\nint __count_8_9 = 0;\\r\\n#endif\\r\\n double x = val / 10;\\r\\n double dx;\\r\\n double diff;\\r\\n double min_tol = 0.00001;\\r\\n int i;\\r\\n int flag = 0;\\r\\n\\r\\n if (val == 0)\\r\\n {\\r\\n x = 0;\\r\\n #ifdef CBMC\\r\\n __count_2_9++;\\r\\n #endif\\r\\n }\\r\\n else\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_8_4 = 0;\\r\\n #endif\\r\\n for (i = 1; i < 20; i++) // 8\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_8_4++;\\r\\n #endif\\r\\n if (!flag)\\r\\n {\\r\\n dx = (val - (x * x)) / (2.0 * x);\\r\\n x = x + dx;\\r\\n diff = val - (x * x);\\r\\n if (fabs (diff) <= min_tol)\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_5_6++;\\r\\n #endif\\r\\n flag = 1;\\r\\n }\\r\\n #ifdef CBMC\\r\\n else __count_5_7++;\\r\\n #endif\\r\\n }\\r\\n else\\r\\n {\\r\\n x = x;\\r\\n #ifdef CBMC\\r\\n __count_4_7++;\\r\\n #endif\\r\\n }\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_8_4 <= 20); // Loop counter property\\r\\n __count_8_9++;\\r\\n #endif\\r\\n }\\r\\n #ifdef CBMC\\r\\n __count_9++;\\r\\n #endif\\r\\n\\r\\n#ifdef CBMC\\r\\n\\r\\nassert(__count_9 >= 1); // Lower capacity constraint\\r\\nassert(__count_9 <= 1); // Upper capacity constraint\\r\\nassert(__count_2_9 == 0); // Dead code\\r\\n//assert(__count_4_7 >= 11); // Lower capacity constraint\\r\\nassert(__count_4_7 <= 15); // Upper capacity constraint\\r\\n//assert(__count_5_6 >= 1); // Lower capacity constraint\\r\\nassert(__count_5_6 <= 1); // Upper capacity constraint\\r\\nassert(__count_5_7 >= 3); // Lower capacity constraint\\r\\n//assert(__count_5_7 <= 7); // Upper capacity constraint\\r\\nassert(__count_8_9 >= 1); // Lower capacity constraint\\r\\nassert(__count_8_9 <= 1); // Upper capacity constraint\\r\\n#endif\\r\\n return x;\\r\\n}\\r\\n\\r\\nvoid\\r\\nquadraticroots (double a[])\\r\\n{\\r\\n#ifdef CBMC\\r\\n//==========> quadraticroots : header 10\\r\\nint __count_18 = 0;\\r\\nint __count_10_17 = 0;\\r\\nint __count_12_13 = 0;\\r\\nint __count_14_15 = 0;\\r\\nint __count_16_18 = 0;\\r\\n#endif\\r\\n double x1[2];\\r\\n double x2[2];\\r\\n double d;\\r\\n double w1;\\r\\n double w2;\\r\\n\\r\\n if (a[0] == 0.0) // 10\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_10_17++;\\r\\n __count_18++;\\r\\n #endif\\r\\n\\r\\n#ifdef CBMC\\r\\nassert(__count_14_15 == 0); // Dead code\\r\\n//assert(__count_10_17 == 0); // Dead code\\r\\nassert(__count_18 >= 1); // Lower capacity constraint\\r\\nassert(__count_18 <= 1); // Upper capacity constraint\\r\\nassert(__count_16_18 <= 1); // Upper capacity constraint\\r\\nassert(__count_12_13 <= 1); // Upper capacity constraint\\r\\nassert(__count_12_13 > 0 ==> __count_18 > 0); // Execution dependence\\r\\nassert(__count_16_18 > 0 ==> __count_18 > 0); // Execution dependence\\r\\n#endif\\r\\n\\r\\n return 999;\\r\\n }\\r\\n\\r\\n d = a[1] * a[1] - 4 * a[0] * a[2];\\r\\n w1 = 2.0 * a[0];\\r\\n w2 = sqrt (fabs (d));\\r\\n\\r\\n if (d > 0.0) // 12\\r\\n {\\r\\n\\r\\n x1[0] = (-a[1] + w2) / w1;\\r\\n x1[1] = 0.0;\\r\\n x2[0] = (-a[1] - w2) / w1;\\r\\n x2[1] = 0.0;\\r\\n #ifdef CBMC\\r\\n __count_12_13++;\\r\\n __count_18++;\\r\\n #endif\\r\\n\\r\\n#ifdef CBMC\\r\\nassert(__count_14_15 == 0); // Dead code\\r\\n//assert(__count_10_17 == 0); // Dead code\\r\\nassert(__count_18 >= 1); // Lower capacity constraint\\r\\nassert(__count_18 <= 1); // Upper capacity constraint\\r\\nassert(__count_16_18 <= 1); // Upper capacity constraint\\r\\nassert(__count_12_13 <= 1); // Upper capacity constraint\\r\\nassert(__count_12_13 > 0 ==> __count_18 > 0); // Execution dependence\\r\\nassert(__count_16_18 > 0 ==> __count_18 > 0); // Execution dependence\\r\\n#endif\\r\\n\\r\\n return 0;\\r\\n }\\r\\n else if (d == 0.0)\\r\\n {\\r\\n x1[0] = -a[1] / w1;\\r\\n x1[1] = 0.0;\\r\\n x2[0] = x1[0];\\r\\n x2[1] = 0.0;\\r\\n #ifdef CBMC\\r\\n __count_14_15++;\\r\\n __count_18++;\\r\\n #endif\\r\\n\\r\\n#ifdef CBMC\\r\\nassert(__count_14_15 == 0); // Dead code\\r\\n//assert(__count_10_17 == 0); // Dead code\\r\\nassert(__count_18 >= 1); // Lower capacity constraint\\r\\nassert(__count_18 <= 1); // Upper capacity constraint\\r\\nassert(__count_16_18 <= 1); // Upper capacity constraint\\r\\nassert(__count_12_13 <= 1); // Upper capacity constraint\\r\\nassert(__count_12_13 > 0 ==> __count_18 > 0); // Execution dependence\\r\\nassert(__count_16_18 > 0 ==> __count_18 > 0); // Execution dependence\\r\\n#endif\\r\\n\\r\\n return 0;\\r\\n }\\r\\n else\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_16_18++;\\r\\n #endif\\r\\n w2 /= w1;\\r\\n x1[0] = -a[1] / w1;\\r\\n x1[1] = w2;\\r\\n x2[0] = x1[0];\\r\\n x2[1] = -w2;\\r\\n #ifdef CBMC\\r\\n __count_18++;\\r\\n #endif\\r\\n\\r\\n#ifdef CBMC\\r\\nassert(__count_14_15 == 0); // Dead code\\r\\n//assert(__count_10_17 == 0); // Dead code\\r\\nassert(__count_18 >= 1); // Lower capacity constraint\\r\\nassert(__count_18 <= 1); // Upper capacity constraint\\r\\nassert(__count_16_18 <= 1); // Upper capacity constraint\\r\\nassert(__count_12_13 <= 1); // Upper capacity constraint\\r\\nassert(__count_12_13 > 0 ==> __count_18 > 0); // Execution dependence\\r\\nassert(__count_16_18 > 0 ==> __count_18 > 0); // Execution dependence\\r\\n#endif\\r\\n return 0;\\r\\n }\\r\\n}\\r\\n\\r\\nint\\r\\nmain (int argc, char *argv[])\\r\\n{\\r\\n double a[3];\\r\\n /*\\r\\n * Three integers must be supplied\\r\\n */\\r\\n if (argc != 4)\\r\\n {\\r\\n return 1;\\r\\n }\\r\\n if (*argv[1] == '0')\\r\\n {\\r\\n return 1;\\r\\n }\\r\\n\\r\\n a[0] = atoi (argv[1]);\\r\\n a[1] = atoi (argv[2]);\\r\\n a[2] = atoi (argv[3]);\\r\\n\\r\\n quadraticroots(a);\\r\\n printf(\\\"%lf\\\", a[0]);\\r\\n\\r\\n return 0;\\r\\n}\\r\\n\"\n },\n {\n \"alpha_fraction\": 0.3378088176250458,\n \"alphanum_fraction\": 0.39849624037742615,\n \"avg_line_length\": 12.546875,\n \"blob_id\": \"ff5d9363df469f82cb6e87d36436d1c9a2b04a32\",\n \"content_id\": \"bcc5c99e473c384d471cf8e3275d77025ef23725\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 1862,\n \"license_type\": \"no_license\",\n \"max_line_length\": 76,\n \"num_lines\": 128,\n \"path\": \"/benchmarks/qurt/qurt.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\r\\n * Root computation of a quadratic equation (qurt) taken from MDH suite and\\r\\n * modified by Adam Betts to consume a test vector supplied on the command line.\\r\\n *\\r\\n * For this program, the test vector is the 3 integer coefficients of a\\r\\n * polynomial ax^2 + bx + c where a /= 0\\r\\n */\\r\\n\\r\\ndouble\\r\\nfabs (double n)\\r\\n{\\r\\n if (n >= 0)\\r\\n {\\r\\n return n;\\r\\n }\\r\\n else\\r\\n {\\r\\n return -n;\\r\\n }\\r\\n}\\r\\n\\r\\ndouble\\r\\nsqrt (double val)\\r\\n{\\r\\n double x = val / 10;\\r\\n double dx;\\r\\n double diff;\\r\\n double min_tol = 0.00001;\\r\\n int i;\\r\\n int flag = 0;\\r\\n\\r\\n if (val == 0)\\r\\n {\\r\\n x = 0;\\r\\n }\\r\\n else\\r\\n {\\r\\n for (i = 1; i < 20; i++)\\r\\n {\\r\\n if (!flag)\\r\\n {\\r\\n dx = (val - (x * x)) / (2.0 * x);\\r\\n x = x + dx;\\r\\n diff = val - (x * x);\\r\\n if (fabs (diff) <= min_tol)\\r\\n {\\r\\n flag = 1;\\r\\n }\\r\\n }\\r\\n else\\r\\n {\\r\\n x = x;\\r\\n }\\r\\n }\\r\\n }\\r\\n return x;\\r\\n}\\r\\n\\r\\nint\\r\\nqurt (double a[])\\r\\n{\\r\\n double x1[2];\\r\\n double x2[2];\\r\\n double d;\\r\\n double w1;\\r\\n double w2;\\r\\n\\r\\n if (a[0] == 0.0)\\r\\n {\\r\\n return 999;\\r\\n }\\r\\n\\r\\n d = a[1] * a[1] - 4 * a[0] * a[2];\\r\\n w1 = 2.0 * a[0];\\r\\n w2 = sqrt (fabs (d));\\r\\n\\r\\n if (d > 0.0)\\r\\n {\\r\\n x1[0] = (-a[1] + w2) / w1;\\r\\n x1[1] = 0.0;\\r\\n x2[0] = (-a[1] - w2) / w1;\\r\\n x2[1] = 0.0;\\r\\n return 0;\\r\\n }\\r\\n else if (d == 0.0)\\r\\n {\\r\\n x1[0] = -a[1] / w1;\\r\\n x1[1] = 0.0;\\r\\n x2[0] = x1[0];\\r\\n x2[1] = 0.0;\\r\\n return 0;\\r\\n }\\r\\n else\\r\\n {\\r\\n w2 /= w1;\\r\\n x1[0] = -a[1] / w1;\\r\\n x1[1] = w2;\\r\\n x2[0] = x1[0];\\r\\n x2[1] = -w2;\\r\\n return 0;\\r\\n }\\r\\n}\\r\\n\\r\\nint\\r\\nmain (int argc, char *argv[])\\r\\n{\\r\\n double a[3];\\r\\n\\r\\n /*\\r\\n * Three integers must be supplied\\r\\n */\\r\\n if (argc != 4)\\r\\n {\\r\\n return 1;\\r\\n }\\r\\n if (*argv[1] == '0')\\r\\n {\\r\\n return 1;\\r\\n }\\r\\n\\r\\n a[0] = atoi (argv[1]);\\r\\n a[1] = atoi (argv[2]);\\r\\n a[2] = atoi (argv[3]);\\r\\n\\r\\n qurt(a);\\r\\n\\r\\n return 0;\\r\\n}\\r\\n\"\n },\n {\n \"alpha_fraction\": 0.7505205869674683,\n \"alphanum_fraction\": 0.768846333026886,\n \"avg_line_length\": 62.18421173095703,\n \"blob_id\": \"b82ad469e41bbd6a0a3fda1ff171d165d4a18a88\",\n \"content_id\": \"3bed69275cb2a481583c53ebaf558ea9b3a27d16\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Shell\",\n \"length_bytes\": 2401,\n \"license_type\": \"no_license\",\n \"max_line_length\": 94,\n \"num_lines\": 38,\n \"path\": \"/DaikonPathInformation/benchmarks/CBMC.bash\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"python ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc adpcm.c \\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc binary_search.c \\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc bubblesort.c \\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc compress.c\\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc crc.c\\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc edn.c \\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc fastDiscreteCosineTransform.c \\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc fft.c \\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc insertsort.c \\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc LUdecomposition.c\\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc matrix_inverse.c\\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc embedded.c \\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc quicksort.c \\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc quadraticroots.c\\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc select.c\\npython ../src/RunCBMC.py --CBMC /home/adam/CBMC/cbmc squareroot.c\\npython ../src/ToolGem5.py adpcm m5out/adpcm.trace*\\npython ../src/ToolGem5.py binary_search m5out/binary_search.trace*\\npython ../src/ToolGem5.py bubblesort m5out/bubblesort.trace*\\npython ../src/ToolGem5.py matrix_count m5out/matrix_count.trace*\\npython ../src/ToolGem5.py compress m5out/compress.trace*\\npython ../src/ToolGem5.py cover m5out/cover.trace*\\npython ../src/ToolGem5.py crc m5out/crc.trace*\\npython ../src/ToolGem5.py edn m5out/edn.trace*\\npython ../src/ToolGem5.py fastDiscreteCosineTransform m5out/fastDiscreteCosineTransform.trace*\\npython ../src/ToolGem5.py fft m5out/fft.trace*\\npython ../src/ToolGem5.py insertsort m5out/insertsort.trace*\\npython ../src/ToolGem5.py janne_complex m5out/janne_complex.trace*\\npython ../src/ToolGem5.py lcdnum m5out/lcdnum.trace*\\npython ../src/ToolGem5.py LUdecomposition m5out/LUdecomposition.trace*\\npython ../src/ToolGem5.py matrix_inverse m5out/matrix_inverse.trace*\\npython ../src/ToolGem5.py matrixmultiply m5out/matrixmultiply.trace*\\npython ../src/ToolGem5.py embedded m5out/embedded.trace*\\npython ../src/ToolGem5.py quicksort m5out/quicksort.trace*\\npython ../src/ToolGem5.py quadraticroots m5out/quadraticroots.trace*\\npython ../src/ToolGem5.py select m5out/select.trace*\\npython ../src/ToolGem5.py squareroot m5out/squareroot.trace*\\npython ../src/ToolGem5.py statistics m5out/statistics.trace*\\n\"\n },\n {\n \"alpha_fraction\": 0.5342960357666016,\n \"alphanum_fraction\": 0.5415162444114685,\n \"avg_line_length\": 33.5,\n \"blob_id\": \"8479fd42ee5c13043cc98bb722275cea9d56e97f\",\n \"content_id\": \"83a7dfedc7073b3d929115a6e77022dd55f43b20\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 277,\n \"license_type\": \"no_license\",\n \"max_line_length\": 58,\n \"num_lines\": 8,\n \"path\": \"/DaikonPathInformation/src/config.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"\\nclass Arguments:\\n \\\"\\\"\\\"Globals and arguments passed on the command line\\\"\\\"\\\"\\n \\n m5_trace_directory = \\\"m5out\\\"\\n GCC = \\\"arm-linux-gnueabi-gcc\\\"\\n objdump = \\\"arm-linux-gnueabi-objdump\\\"\\n basename = None\\n basepath = None\\n\"\n },\n {\n \"alpha_fraction\": 0.47685524821281433,\n \"alphanum_fraction\": 0.5077149271965027,\n \"avg_line_length\": 13.465909004211426,\n \"blob_id\": \"bd16eedf7a8af1421808e682e9a8a9c86c169650\",\n \"content_id\": \"d535ff8350ddbe4e356ea9d8b9b1264e919cf5b1\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 1361,\n \"license_type\": \"no_license\",\n \"max_line_length\": 69,\n \"num_lines\": 88,\n \"path\": \"/DaikonPathInformation/benchmarks/prime.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\r\\n * Prime program taken from MDH suite and modified by Adam Betts\\r\\n * to consume a test vector supplied on the command line.\\r\\n *\\r\\n * For this program, the test vector is a single element. The program\\r\\n * determines if it is prime or not.\\r\\n */\\r\\n\\r\\nunsigned char\\r\\ndivides (unsigned int n, unsigned int m)\\r\\n{\\r\\n return m % n == 0;\\r\\n}\\r\\n\\r\\nunsigned char\\r\\neven (unsigned int n)\\r\\n{\\r\\n return divides (2, n);\\r\\n}\\r\\n\\r\\nunsigned char\\r\\nprime (unsigned int n)\\r\\n{\\r\\n #ifdef CBMC\\r\\n int __count_3_11 = 0;\\r\\n int __count_7_11 = 0;\\r\\n int __count_8_9 = 0;\\r\\n int __count_9_10 = 0;\\r\\n int __count_L9 = 0;\\r\\n #endif\\r\\n int i;\\r\\n\\r\\n if (even (n))\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_3_11++;\\r\\n #endif\\r\\n return n == 2;\\r\\n }\\r\\n\\r\\n for (i = 3; \\r\\n #ifdef CBMC\\r\\n __count_L9++,\\r\\n #endif\\r\\n i * i <= n; i += 2)\\r\\n {\\r\\n if (divides (i, n))\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_7_11++;\\r\\n #endif\\r\\n return 0;\\r\\n }\\r\\n #ifdef CBMC\\r\\n __count_8_9++;\\r\\n #endif\\r\\n }\\r\\n #ifdef CBMC\\r\\n __count_9_10++;\\r\\n #endif\\r\\n return n > 1;\\r\\n}\\r\\n\\r\\nint\\r\\nmain (int argc, char *argv[])\\r\\n{\\r\\n unsigned char answer;\\r\\n unsigned int number;\\r\\n \\r\\n /*\\r\\n * One integer must be supplied\\r\\n */\\r\\n if (argc != 2)\\r\\n {\\r\\n return 1;\\r\\n }\\r\\n \\r\\n number = atoi(argv[1]);\\r\\n if (number < 2)\\r\\n {\\r\\n return 1;\\r\\n }\\r\\n\\r\\n answer = prime (number);\\r\\n printf(\\\"%c\\\", answer); \\r\\n\\r\\n return 0;\\r\\n}\\r\\n\"\n },\n {\n \"alpha_fraction\": 0.5429610013961792,\n \"alphanum_fraction\": 0.5484987497329712,\n \"avg_line_length\": 50.25,\n \"blob_id\": \"4702f95a20d1c08ac4ae20349664ff7fe33d3f41\",\n \"content_id\": \"55fcefe7fddecc76f630cbfafdb00a47c646dcda\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 34671,\n \"license_type\": \"no_license\",\n \"max_line_length\": 159,\n \"num_lines\": 676,\n \"path\": \"/DaikonPathInformation/src/calculations.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import directed_graphs\\nimport vertices\\nimport edges\\nimport config\\nimport debug\\nimport os\\nimport timeit\\nimport subprocess\\nimport re\\nimport decimal\\nimport shlex\\n\\ndef getNewLine (num=1):\\n return \\\"\\\\n\\\" * num \\n\\nclass WCETCalculation:\\n def __init__ (self, program, data):\\n self.__VanillaContextIDToWCET = {}\\n self.__ExtraContextIDToWCET = {}\\n contextg = program.getContextGraph()\\n dfs = directed_graphs.DepthFirstSearch(contextg, contextg.getRootID())\\n for vertexID in dfs.getPostorder():\\n contextv = contextg.getVertex(vertexID)\\n functionName = contextv.getName()\\n pathg = program.getPathInfoGraph(functionName)\\n if pathg.isExecutedFunction():\\n debug.verbose_message(\\\"Doing WCET calculation on %s\\\" % functionName, __name__)\\n lnt = program.getLNT(functionName)\\n cfg = program.getCFG(functionName)\\n ilp1 = CreateCFGILPVanilla(data, self.__VanillaContextIDToWCET, contextv, cfg, lnt, pathg)\\n ilp1WCET, ilp1SolvingTime = ilp1.solve()\\n debug.verbose_message(\\\"ILP(vanilla):: WCET(%s)=%s (SOLVE TIME=%.5f)\\\" % (functionName, ilp1WCET, ilp1SolvingTime), __name__)\\n self.__VanillaContextIDToWCET[contextv.vertexID] = ilp1WCET\\n if not pathg.executionDependencies() and not pathg.mutualInclusionPairs() and not pathg.mutualExclusionPairs():\\n ilp2 = CreateCFGILPExtra(data, self.__ExtraContextIDToWCET, contextv, cfg, lnt, pathg)\\n ilp2WCET, ilp2SolvingTime = ilp2.solve()\\n self.__ExtraContextIDToWCET[contextv.vertexID] = ilp2WCET\\n debug.verbose_message(\\\"ILP(extra):: WCET(%s)=%s (SOLVE TIME=%.5f)\\\" % (functionName, ilp2WCET, ilp2SolvingTime), __name__)\\n else:\\n clp2 = CreateCFGCLPExtra(data, self.__ExtraContextIDToWCET, contextv, cfg, lnt, pathg)\\n clp2WCET, clp2SolvingTime = clp2.solve()\\n self.__ExtraContextIDToWCET[contextv.vertexID] = clp2WCET\\n debug.verbose_message(\\\"CLP(extra):: WCET(%s)=%s (SOLVE TIME=%.5f)\\\" % (functionName, clp2WCET, clp2SolvingTime), __name__)\\n else:\\n debug.verbose_message(\\\"%s did not execute\\\" % functionName, __name__)\\n self.__VanillaContextIDToWCET[contextv.vertexID] = 0\\n self.__ExtraContextIDToWCET[contextv.vertexID] = 0\\n \\nclass ECLIPSE:\\n fileExtensions = ['.res', '.vanilla', '.extra']\\n conjunct = \\\",\\\" + getNewLine()\\n clauseSep = \\\":-\\\"\\n domainSep = \\\" #:: \\\"\\n equals = \\\" #= \\\"\\n fileSuffix = \\\"ecl\\\"\\n gt = \\\" #> \\\"\\n gtOrEqual = \\\" #>= \\\"\\n implies = \\\" => \\\"\\n lt = \\\" #< \\\"\\n ltOrEqual = \\\" #=< \\\"\\n multiply = \\\"*\\\"\\n plus = \\\" + \\\"\\n terminator = \\\".\\\"\\n \\n @staticmethod\\n def getComment (comment):\\n return \\\"% \\\" + comment + getNewLine()\\n \\n @staticmethod\\n def getEdgeCountVariable (sourceID, destinationID):\\n return \\\"E_%d_%d\\\" % (sourceID, destinationID)\\n \\n @staticmethod\\n def getVertexCountVariable (vertexID):\\n return \\\"V_%d\\\" % (vertexID)\\n \\n @staticmethod\\n def getVertexWCETVariable (vertexID):\\n return \\\"W_%d\\\" % (vertexID)\\n \\n @staticmethod\\n def getTempList (suffix):\\n return \\\"VARS%d\\\" % suffix\\n \\nclass CLP:\\n WCET = \\\"WCET\\\"\\n PWCET = \\\"PWCET\\\"\\n BB_TIMES = \\\"BB_TIMES\\\"\\n BB_COUNTS = \\\"BB_COUNTS\\\"\\n EDGE_COUNTS = \\\"EDGE_COUNTS\\\"\\n OUTPUT_PREDICATE_HEAD = \\\"print_results\\\"\\n \\n def __init__ (self):\\n self._filename = None\\n self._wcet = 0\\n self._solvingTime = 0\\n self._lines = []\\n self.__addRequiredPackages()\\n self.__goal = \\\"solve(%s)\\\" % (CLP.WCET)\\n self._lines.append(\\\"%s%s%s\\\" % (self.__goal, ECLIPSE.clauseSep, getNewLine()))\\n \\n def __addRequiredPackages (self):\\n self._lines.append(ECLIPSE.getComment(\\\"Packages\\\"))\\n libs = ['ic', 'branch_and_bound', 'lists', 'util']\\n for lib in libs:\\n self._lines.append(\\\"%s%s(%s)%s%s\\\" % (ECLIPSE.clauseSep, 'lib', lib, ECLIPSE.terminator, getNewLine()))\\n self._lines.append(getNewLine())\\n \\n def solve (self):\\n with open(self._filename, 'w') as clpFile:\\n for line in self._lines:\\n clpFile.write(line) \\n debug.debug_message(\\\"Solving CLP in %s\\\" % self._filename, 10)\\n command = 'jeclipse -b %s -e \\\"%s.\\\"' % (self._filename, self.__goal) \\n debug.verbose_message(\\\"Running command '%s'\\\" % command, __name__)\\n start = timeit.default_timer()\\n proc = subprocess.Popen(command, shell=True, executable=\\\"/bin/bash\\\")\\n returnCode = proc.wait()\\n self._solvingTime = (timeit.default_timer() - start)\\n if returnCode != 0:\\n debug.warning_message(\\\"Running '%s' failed\\\" % command)\\n return self._wcet, self._solvingTime\\n else:\\n with open(self._filename + '.res') as f:\\n for line in f:\\n if re.match(r'%s' % CLP.WCET, line):\\n values = re.findall(r'[0-9]+', line)\\n assert len(values) == 1, \\\"Unable to find WCET value in CLP output file\\\"\\n self._wcet = int(values[0])\\n assert self._wcet\\n assert self._solvingTime\\n return self._wcet, self._solvingTime\\n \\n def _addOutputPredicates (self):\\n fileHandle = \\\"F\\\" \\n self._lines.append('%s(%s,%s,%s) %s' % (CLP.OUTPUT_PREDICATE_HEAD, CLP.BB_COUNTS, CLP.EDGE_COUNTS, CLP.WCET, ECLIPSE.clauseSep))\\n self._lines.append(getNewLine())\\n self._lines.append('open(\\\"%s\\\",%s,%s)%s' % (os.path.basename(self._filename) + \\\".res\\\", \\\"write\\\", fileHandle, ECLIPSE.conjunct))\\n self._lines.append('print_list(%s,\\\"%s: \\\",%s)%s' % (fileHandle, CLP.BB_COUNTS, CLP.BB_COUNTS, ECLIPSE.conjunct))\\n self._lines.append('print_list(%s,\\\"%s: \\\",%s)%s' % (fileHandle, CLP.EDGE_COUNTS, CLP.EDGE_COUNTS, ECLIPSE.conjunct))\\n self._lines.append('write(%s, \\\"%s: \\\")%s' % (fileHandle, CLP.WCET, ECLIPSE.conjunct))\\n self._lines.append('write(%s,%s)%s' % (fileHandle, CLP.WCET, ECLIPSE.conjunct))\\n self._lines.append('nl(%s)%s' % (fileHandle, ECLIPSE.conjunct))\\n self._lines.append('close(%s)%s' % (fileHandle, ECLIPSE.terminator))\\n self._lines.append(getNewLine(2))\\n \\n self._lines.append('print_list(_,_,[])%s' % (ECLIPSE.terminator))\\n self._lines.append(getNewLine())\\n self._lines.append('print_list(%s,Name,[H|T])%s' % (fileHandle, ECLIPSE.clauseSep))\\n self._lines.append(getNewLine())\\n self._lines.append('write(%s,Name)%s' % (fileHandle, ECLIPSE.conjunct))\\n self._lines.append('write(%s,H)%s' % (fileHandle, ECLIPSE.conjunct))\\n self._lines.append('print_list1(%s,T)%s' % (fileHandle, ECLIPSE.conjunct))\\n self._lines.append('nl(%s)%s' % (fileHandle, ECLIPSE.terminator))\\n self._lines.append(getNewLine(2))\\n \\n self._lines.append('print_list1(_,[])%s' % (ECLIPSE.terminator))\\n self._lines.append(getNewLine())\\n self._lines.append('print_list1(%s,[H|T])%s' % (fileHandle, ECLIPSE.clauseSep))\\n self._lines.append(getNewLine())\\n self._lines.append('write(%s,\\\",\\\")%s' % (fileHandle, ECLIPSE.conjunct))\\n self._lines.append('write(%s,H)%s' % (fileHandle, ECLIPSE.conjunct))\\n self._lines.append('print_list1(%s,T)%s' % (fileHandle, ECLIPSE.terminator))\\n self._lines.append(getNewLine(2))\\n \\nclass CreateCFGCLP (CLP):\\n def __init__ (self):\\n CLP.__init__(self)\\n\\n def _addVariables (self, cfg):\\n self._lines.append(ECLIPSE.getComment(\\\"Declarations\\\"))\\n bbCounts = []\\n bbTimes = []\\n edgeCounts = []\\n for v in cfg:\\n bbCounts.append(ECLIPSE.getVertexCountVariable(v.vertexID))\\n bbTimes.append(ECLIPSE.getVertexWCETVariable(v.vertexID))\\n for succID in v.getSuccessorIDs():\\n edgeCounts.append(ECLIPSE.getEdgeCountVariable(v.vertexID, succID))\\n self._lines.append(\\\"%s = [%s]%s\\\" % (CLP.BB_COUNTS, ','.join(var for var in bbCounts), ECLIPSE.conjunct))\\n self._lines.append(\\\"%s = [%s]%s\\\" % (CLP.BB_TIMES, ','.join(var for var in bbTimes), ECLIPSE.conjunct))\\n self._lines.append(\\\"%s = [%s]%s\\\" % (CLP.EDGE_COUNTS, ','.join(var for var in edgeCounts), ECLIPSE.conjunct))\\n self._lines.append(getNewLine())\\n \\n def _addObjectiveFunction (self, cfg):\\n self._lines.append(ECLIPSE.getComment(\\\"Objective function\\\"))\\n rhs = \\\"\\\"\\n count = 1\\n for v in cfg:\\n rhs += \\\"%s%s%s\\\" % (ECLIPSE.getVertexCountVariable(v.vertexID), ECLIPSE.multiply, ECLIPSE.getVertexWCETVariable(v.vertexID))\\n if count < cfg.numOfvertices():\\n rhs += ECLIPSE.plus\\n count += 1\\n self._lines.append(\\\"%s%s%s%s\\\" % (CLP.WCET, ECLIPSE.equals, rhs, ECLIPSE.conjunct))\\n self._lines.append(getNewLine()) \\n \\n def _addExecutionTimeDomains (self, data, contextWCETs, contextv, cfg):\\n self._lines.append(ECLIPSE.getComment(\\\"timing constraints\\\"))\\n for v in cfg:\\n wcet = data.getExecutionTime(cfg.getName(), v.getOriginalVertexID())\\n if cfg.isCallSite(v.vertexID):\\n calleeContextID = contextv.getSuccessorWithCallSite(v.vertexID)\\n calleeContextWCET = contextWCETs[calleeContextID]\\n wcet += calleeContextWCET\\n self._lines.append(\\\"%s%s%d%s\\\" % \\\\\\n (ECLIPSE.getVertexWCETVariable(v.vertexID), ECLIPSE.equals, wcet, ECLIPSE.conjunct))\\n self._lines.append(getNewLine()) \\n \\n def _addStructuralConstraints (self, cfg):\\n self._lines.append(ECLIPSE.getComment(\\\"Structural constraints\\\"))\\n for v in cfg:\\n self._lines.append(ECLIPSE.getComment(\\\"Vertex %d\\\" % v.vertexID))\\n # Flow out to successor edges\\n rhs = \\\"\\\"\\n count = 1\\n for predID in v.getPredecessorIDs():\\n rhs += ECLIPSE.getEdgeCountVariable(predID, v.vertexID)\\n if count < v.numberOfPredecessors():\\n rhs += ECLIPSE.plus\\n count += 1\\n self._lines.append(\\\"%s%s%s%s\\\" % (ECLIPSE.getVertexCountVariable(v.vertexID), ECLIPSE.equals, rhs, ECLIPSE.conjunct))\\n # Flow in/out through predecessor/successor edges\\n lhs = \\\"\\\"\\n count = 1\\n for succID in v.getSuccessorIDs():\\n lhs += ECLIPSE.getEdgeCountVariable(v.vertexID, succID)\\n if count < v.numberOfSuccessors():\\n lhs += ECLIPSE.plus\\n count += 1\\n rhs = \\\"\\\"\\n count = 1\\n for predID in v.getPredecessorIDs():\\n rhs += ECLIPSE.getEdgeCountVariable(predID, v.vertexID)\\n if count < v.numberOfPredecessors():\\n rhs += ECLIPSE.plus\\n count += 1\\n self._lines.append(\\\"%s%s%s%s\\\" % (lhs, ECLIPSE.equals, rhs, ECLIPSE.conjunct))\\n self._lines.append(getNewLine())\\n \\n def _addRelativeCapacityConstraints (self, cfg, lnt, pathg):\\n self._lines.append(ECLIPSE.getComment(\\\"Relative capacity constraints\\\"))\\n for level, the_vertices in lnt.levelIterator(True):\\n for treev in the_vertices:\\n if isinstance(treev, vertices.HeaderVertex):\\n headerID = treev.getHeaderID()\\n self._lines.append(ECLIPSE.getComment(\\\"Capacity constraints on header %d\\\" % treev.getHeaderID())) \\n if treev.vertexID == lnt.getRootID():\\n self._lines.append(\\\"%s%s%d%s\\\" % (ECLIPSE.getEdgeCountVariable(cfg.getExitID(), cfg.getEntryID()), ECLIPSE.equals, 1, ECLIPSE.conjunct))\\n else:\\n relativeBound = 0\\n for programPoint in pathg.getLoopMonitoredProgramPoints(headerID):\\n pathv = pathg.getProgramPointVertex(programPoint)\\n succe = pathv.getSuccessoredges(edges.PathInformationEdgeType.LOOP_BOUNDS)[0]\\n relativeBound = max(relativeBound, succe.relative)\\n v = cfg.getVertex(headerID)\\n loopBody = lnt.getLoopBody(headerID)\\n forwardSuccIDs = []\\n for succID in v.getSuccessorIDs():\\n if succID in loopBody:\\n forwardSuccIDs.append((headerID, succID))\\n lhs = \\\"\\\"\\n count = 1\\n for edge in forwardSuccIDs:\\n lhs += ECLIPSE.getEdgeCountVariable(edge[0], edge[1])\\n if count < len(forwardSuccIDs):\\n lhs += ECLIPSE.plus\\n count += 1\\n forwardPredIDs = []\\n for prede in v.getPredecessoredges():\\n if not lnt.isLoopBackEdge(prede.vertexID, headerID):\\n forwardPredIDs.append((prede.vertexID, headerID))\\n rhs = \\\"\\\"\\n count = 1\\n for edge in forwardPredIDs:\\n rhs += \\\"%d%s%s\\\" % (relativeBound, ECLIPSE.multiply, ECLIPSE.getEdgeCountVariable(edge[0], edge[1]))\\n if count < len(forwardPredIDs):\\n rhs += ECLIPSE.plus\\n count += 1\\n self._lines.append(\\\"%s%s%s%s\\\" % (lhs, ECLIPSE.ltOrEqual, rhs, ECLIPSE.conjunct))\\n self._lines.append(getNewLine()) \\n \\n def __getUpperBound (self, lnt, vertexID, headerID, headerToUpperCapacityBound):\\n if lnt.isLoopHeader(vertexID):\\n return headerToUpperCapacityBound[vertexID]\\n return headerToUpperCapacityBound[headerID]\\n \\n def _addExecutionCountDomains (self, cfg, lnt, pathg, addPathInformation):\\n self._lines.append(ECLIPSE.getComment(\\\"Execution count domains\\\"))\\n headerToUpperCapacityBound = {}\\n for headerID in lnt.getHeaderIDs():\\n upperCapacityBound = 0\\n for programPoint in pathg.getLoopMonitoredProgramPoints(headerID):\\n pathv = pathg.getProgramPointVertex(programPoint)\\n succe = pathv.getSuccessoredges(edges.PathInformationEdgeType.LOOP_BOUNDS)[0]\\n upperCapacityBound = max(upperCapacityBound, succe.upper)\\n headerToUpperCapacityBound[headerID] = upperCapacityBound\\n headerToUpperCapacityBound[cfg.getEntryID()] = 1\\n \\n # First add domains for basic blocks\\n for v in cfg: \\n vertexID = v.vertexID\\n treev = lnt.getVertex(vertexID)\\n headerv = lnt.getVertex(treev.getParentID())\\n headerID = headerv.getHeaderID()\\n lowerCapacityBound = 0\\n upperCapacityBound = 0\\n if not addPathInformation:\\n lowerCapacityBound = 0\\n upperCapacityBound = self.__getUpperBound(lnt, vertexID, headerID, headerToUpperCapacityBound)\\n else:\\n pathv = pathg.isMonitoredVertex(vertexID)\\n if pathv:\\n succe = pathv.getSuccessoredges(edges.PathInformationEdgeType.CAPACITY_BOUNDS)[0]\\n lowerCapacityBound = succe.lower\\n upperCapacityBound = succe.upper\\n else:\\n upperCapacityBound = self.__getUpperBound(lnt, vertexID, headerID, headerToUpperCapacityBound) \\n line = \\\"%s%s[%d.%d]%s\\\" % (ECLIPSE.getVertexCountVariable(vertexID), ECLIPSE.domainSep, lowerCapacityBound, upperCapacityBound, ECLIPSE.conjunct)\\n self._lines.append(line) \\n \\n # Now add domains for edges\\n for v in cfg: \\n vertexID = v.vertexID\\n treev1 = lnt.getVertex(vertexID)\\n headerv1 = lnt.getVertex(treev1.getParentID()) \\n headerBound1 = self.__getUpperBound(lnt, vertexID, headerv1.getHeaderID(), headerToUpperCapacityBound)\\n for succID in v.getSuccessorIDs(): \\n treev2 = lnt.getVertex(succID)\\n headerv2 = lnt.getVertex(treev2.getParentID()) \\n headerBound2 = self.__getUpperBound(lnt, succID, headerv2.getHeaderID(), headerToUpperCapacityBound)\\n lowerCapacityBound = 0\\n upperCapacityBound = 0 \\n upperCapacityBound = max(headerBound1, headerBound2)\\n if addPathInformation:\\n pathv = pathg.isMonitoredEdge(vertexID, succID)\\n if pathv:\\n succe = pathv.getSuccessoredges(edges.PathInformationEdgeType.CAPACITY_BOUNDS)[0]\\n lowerCapacityBound = succe.lower\\n upperCapacityBound = succe.upper\\n line = \\\"%s%s[%d.%d]%s\\\" % \\\\\\n (ECLIPSE.getEdgeCountVariable(vertexID, succID), ECLIPSE.domainSep, lowerCapacityBound, upperCapacityBound, ECLIPSE.conjunct)\\n self._lines.append(line)\\n self._lines.append(getNewLine()) \\n \\n def _addEpilogue (self):\\n self._lines.append(\\\"%s%s%d%s%s%s\\\" % (CLP.PWCET, ECLIPSE.equals, -1, ECLIPSE.multiply, CLP.WCET, ECLIPSE.conjunct))\\n self._lines.append(\\\"append(%s,%s,%s)%s\\\" % (CLP.EDGE_COUNTS, CLP.BB_COUNTS, ECLIPSE.getTempList(0), ECLIPSE.conjunct))\\n self._lines.append(\\\"append(%s,%s,%s)%s\\\" % (CLP.BB_TIMES, ECLIPSE.getTempList(0), ECLIPSE.getTempList(1), ECLIPSE.conjunct))\\n self._lines.append(\\\"time(bb_min(search(%s,0,input_order,indomain_max,complete,[]),%s,bb_options{}))%s\\\" % \\\\\\n (ECLIPSE.getTempList(1), CLP.PWCET, ECLIPSE.conjunct))\\n self._lines.append(\\\"%s(%s, %s, %s)%s\\\" % \\\\\\n (CLP.OUTPUT_PREDICATE_HEAD, CLP.BB_COUNTS, CLP.EDGE_COUNTS, CLP.WCET, ECLIPSE.terminator))\\n self._lines.append(getNewLine(2))\\n\\nclass CreateCFGCLPVanilla (CreateCFGCLP):\\n def __init__ (self, data, contextWCETs, contextv, cfg, lnt, pathg):\\n CreateCFGCLP.__init__(self)\\n self._filename = \\\"%s.%s.context%s.%s.%s.vanilla\\\" % (config.Arguments.basepath + os.sep + config.Arguments.basename, \\n contextv.getName(), \\n contextv.vertexID, \\n \\\"cfg\\\", \\n ECLIPSE.fileSuffix)\\n self._addVariables(cfg)\\n self._addObjectiveFunction(cfg)\\n self._addExecutionTimeDomains(data, contextWCETs, contextv, cfg)\\n self._addStructuralConstraints(cfg)\\n self._addRelativeCapacityConstraints(cfg, lnt, pathg)\\n self._addExecutionCountDomains(cfg, lnt, pathg, False)\\n self._addEpilogue()\\n self._addOutputPredicates()\\n\\nclass CreateCFGCLPExtra (CreateCFGCLP):\\n def __init__ (self, data, contextWCETs, contextv, cfg, lnt, pathg):\\n CreateCFGCLP.__init__(self)\\n self._filename = \\\"%s.%s.context%s.%s.%s.extra\\\" % (config.Arguments.basepath + os.sep + config.Arguments.basename, \\n contextv.getName(), \\n contextv.vertexID, \\n \\\"cfg\\\", \\n ECLIPSE.fileSuffix)\\n self._addVariables(cfg)\\n self._addObjectiveFunction(cfg)\\n self._addExecutionTimeDomains(data, contextWCETs, contextv, cfg)\\n self._addStructuralConstraints(cfg)\\n self._addRelativeCapacityConstraints(cfg, lnt, pathg)\\n self._addExecutionCountDomains(cfg, lnt, pathg, True)\\n self._addInfeasiblePathConstraints(cfg, lnt, pathg)\\n self._addEpilogue()\\n self._addOutputPredicates()\\n\\n def _addInfeasiblePathConstraints (self, cfg, lnt, pathg):\\n self._lines.append(ECLIPSE.getComment(\\\"Infeasible path constraints\\\"))\\n for pathv in pathg:\\n succe = pathv.getSuccessoredges(edges.PathInformationEdgeType.CAPACITY_BOUNDS)[0]\\n if succe.upper > 0:\\n programPoint = pathv.getProgramPoint()\\n if isinstance(programPoint, tuple):\\n countVariable1 = ECLIPSE.getEdgeCountVariable(programPoint[0], programPoint[1])\\n else:\\n countVariable1 = ECLIPSE.getVertexCountVariable(programPoint)\\n for succe in pathv.getSuccessoredges(edges.PathInformationEdgeType.INCLUSION):\\n succv = pathg.getVertex(succe.vertexID)\\n succProgramPoint = succv.getProgramPoint()\\n if isinstance(succProgramPoint, tuple):\\n countVariable2 = ECLIPSE.getEdgeCountVariable(succProgramPoint[0], succProgramPoint[1])\\n else:\\n countVariable2 = ECLIPSE.getVertexCountVariable(succProgramPoint)\\n self._lines.append(\\\"%s%s0%s%s%s0%s\\\" % \\\\\\n (countVariable1, ECLIPSE.gt, ECLIPSE.implies, countVariable2, ECLIPSE.gt, ECLIPSE.conjunct))\\n for succe in pathv.getSuccessoredges(edges.PathInformationEdgeType.EXCLUSION):\\n succv = pathg.getVertex(succe.vertexID)\\n succProgramPoint = succv.getProgramPoint()\\n if isinstance(succProgramPoint, tuple):\\n countVariable2 = ECLIPSE.getEdgeCountVariable(succProgramPoint[0], succProgramPoint[1])\\n else:\\n countVariable2 = ECLIPSE.getVertexCountVariable(succProgramPoint)\\n self._lines.append(\\\"%s%s0%s%s%s0%s\\\" % \\\\\\n (countVariable1, ECLIPSE.gt, ECLIPSE.implies, countVariable2, ECLIPSE.equals, ECLIPSE.conjunct))\\n self._lines.append(getNewLine())\\n \\nclass LpSolve:\\n comma = \\\",\\\"\\n dummyPrefix = \\\"d_\\\"\\n edgePrefix = \\\"e_\\\"\\n equals = \\\" = \\\"\\n fileSuffix = \\\"ilp\\\"\\n gt = \\\" > \\\"\\n gtOrEqual = \\\" >= \\\"\\n int_ = \\\"int\\\"\\n lt = \\\" < \\\"\\n ltOrEqual = \\\" <= \\\"\\n max_ = \\\"max: \\\"\\n plus = \\\" + \\\"\\n semiColon = \\\";\\\"\\n vertexPrefix = \\\"v_\\\"\\n \\n @staticmethod\\n def getDummyVariable (edgeID, index=0):\\n if index:\\n return \\\"%s%s_%d\\\" % (LpSolve.dummyPrefix, edgeID, index)\\n return \\\"%s%d\\\" % (LpSolve.dummyPrefix, edgeID)\\n \\n @staticmethod\\n def getEdgeVariable (sourceID, destinationID, index=0):\\n if index:\\n return \\\"%s%d_%d_%d\\\" % (LpSolve.edgePrefix, sourceID, destinationID, index)\\n return \\\"%s%d_%d\\\" % (LpSolve.edgePrefix, sourceID, destinationID)\\n \\n @staticmethod\\n def getVertexVariable (vertexID, index=0):\\n if index:\\n return \\\"%s%s_%d\\\" % (LpSolve.vertexPrefix, vertexID, index)\\n return \\\"%s%d\\\" % (LpSolve.vertexPrefix, vertexID)\\n \\n @staticmethod\\n def getComment (comment):\\n return \\\"// \\\" + comment + \\\"\\\\n\\\"\\n \\nclass ILP ():\\n def __init__ (self):\\n self._wcet = 0\\n self._solvingTime = 0\\n self._variableToExecutionCount = {}\\n self._constraints = []\\n self._variables = set([])\\n self._filename = None\\n \\n def solve (self):\\n assert self._filename, \\\"ILP filename has not been set\\\"\\n debug.debug_message(\\\"Solving ILP for %s\\\" % self._filename, 10)\\n command = \\\"lp_solve %s -S1 -time\\\" % self._filename \\n start = timeit.default_timer()\\n proc = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, executable=\\\"/bin/bash\\\")\\n returnCode = proc.wait()\\n self._solvingTime = (timeit.default_timer() - start)\\n if returnCode != 0:\\n debug.warning_message(\\\"Running '%s' failed\\\" % command)\\n return self._wcet, self._solvingTime\\n for line in proc.stdout.readlines():\\n if line.startswith(\\\"Value of objective function\\\"):\\n lexemes = shlex.split(line)\\n self._wcet = long(decimal.Decimal(lexemes[-1])) \\n assert self._wcet\\n assert self._solvingTime\\n for line in proc.stderr.readlines():\\n if line.startswith(\\\"CPU Time for Parsing\\\"):\\n lexemes = shlex.split(line)\\n time = lexemes[5][:-1]\\n #self.solvingTime -= float(time)\\n return self._wcet, self._solvingTime\\n \\nclass CreateCFGILP (ILP): \\n def _createStructuralConstraints (self, cfg):\\n for v in cfg:\\n vertexID = v.vertexID\\n comment = LpSolve.getComment(\\\"Basic block = %d\\\" % vertexID)\\n self._constraints.append(comment)\\n self._variables.add(LpSolve.getVertexVariable(vertexID))\\n constraint1 = LpSolve.getVertexVariable(vertexID)\\n constraint1 += LpSolve.equals\\n num = 1\\n for succe in v.getSuccessoredges():\\n succID = succe.vertexID \\n self._variables.add(LpSolve.getEdgeVariable(vertexID, succID))\\n constraint1 += LpSolve.getEdgeVariable(vertexID, succID)\\n if num < v.numberOfSuccessors():\\n constraint1 += LpSolve.plus\\n num += 1\\n constraint1 += LpSolve.semiColon\\n constraint1 += getNewLine() \\n self._constraints.append(constraint1)\\n \\n constraint2 = \\\"\\\"\\n num = 1\\n for succe in v.getSuccessoredges():\\n succID = succe.vertexID \\n constraint2 += LpSolve.getEdgeVariable(vertexID, succID)\\n if num < v.numberOfSuccessors():\\n constraint2 += LpSolve.plus\\n num += 1\\n constraint2 += LpSolve.equals\\n num = 1\\n for prede in v.getPredecessoredges():\\n predID = prede.vertexID \\n constraint2 += LpSolve.getEdgeVariable(predID, vertexID)\\n if num < v.numberOfPredecessors():\\n constraint2 += LpSolve.plus\\n num += 1\\n constraint2 += LpSolve.semiColon\\n constraint2 += getNewLine(2) \\n self._constraints.append(constraint2)\\n \\n def _createExecutionCountConstraints (self, cfg, lnt, pathg):\\n for level, the_vertices in lnt.levelIterator(True):\\n for treev in the_vertices:\\n if isinstance(treev, vertices.HeaderVertex):\\n headerID = treev.getHeaderID()\\n if treev.vertexID == lnt.getRootID():\\n comment = LpSolve.getComment(\\\"Upper capacity constraint on header %d\\\" % cfg.getEntryID())\\n self._constraints.append(comment)\\n constraint = LpSolve.getVertexVariable(cfg.getEntryID())\\n constraint += LpSolve.ltOrEqual\\n constraint += str(1)\\n constraint += LpSolve.semiColon\\n constraint += getNewLine(2)\\n self._constraints.append(constraint)\\n else:\\n comment = LpSolve.getComment(\\\"Relative capacity constraint on header %d\\\" % headerID)\\n self._constraints.append(comment)\\n relativeBound = 0\\n for programPoint in pathg.getLoopMonitoredProgramPoints(headerID):\\n pathv = pathg.getProgramPointVertex(programPoint)\\n succe = pathv.getSuccessoredges(edges.PathInformationEdgeType.LOOP_BOUNDS)[0]\\n relativeBound = max(relativeBound, succe.relative)\\n # edges entering the loop\\n loopBody = lnt.getLoopBody(headerID)\\n v = cfg.getVertex(headerID)\\n forwardSuccIDs = []\\n for succID in v.getSuccessorIDs():\\n if succID in loopBody:\\n forwardSuccIDs.append((headerID, succID))\\n constraint = \\\"\\\" \\n count = 1 \\n for edge in forwardSuccIDs:\\n constraint += \\\"%s\\\" % LpSolve.getEdgeVariable(edge[0], edge[1])\\n if count < len(forwardSuccIDs):\\n constraint += LpSolve.plus\\n count += 1\\n # Pre-header edges\\n forwardPredIDs = []\\n for prede in v.getPredecessoredges():\\n if not lnt.isLoopBackEdge(prede.vertexID, headerID):\\n forwardPredIDs.append((prede.vertexID, headerID))\\n constraint += LpSolve.ltOrEqual \\n count = 1\\n for edge in forwardPredIDs:\\n constraint += \\\"%d %s\\\" % (relativeBound, LpSolve.getEdgeVariable(edge[0], edge[1]))\\n if count < len(forwardPredIDs):\\n constraint += LpSolve.plus\\n count += 1\\n constraint += LpSolve.semiColon\\n constraint += getNewLine(2)\\n self._constraints.append(constraint)\\n \\n def _createObjectiveFunction (self, data, contextWCETs, contextv, cfg):\\n constraint = LpSolve.max_\\n num = 1\\n for var in self._variables:\\n if var.startswith(LpSolve.vertexPrefix):\\n lIndex = var.find('_')\\n basicBlockID = int(var[lIndex+1:])\\n wcet = data.getExecutionTime(cfg.getName(), basicBlockID)\\n if cfg.isCallSite(basicBlockID):\\n calleeContextID = contextv.getSuccessorWithCallSite(basicBlockID)\\n calleeContextWCET = contextWCETs[calleeContextID]\\n wcet += calleeContextWCET\\n constraint += \\\"%d %s\\\" % (wcet, var)\\n else:\\n constraint += \\\"%d %s\\\" % (0, var)\\n if num < len(self._variables):\\n constraint += LpSolve.plus\\n if num % 10 == 0:\\n constraint += getNewLine()\\n num += 1\\n constraint += LpSolve.semiColon \\n constraint += getNewLine(2)\\n self._constraints.insert(0, constraint) \\n \\n def _createIntegerConstraint (self):\\n constraint = LpSolve.int_ + \\\" \\\"\\n num = 1\\n for var in self._variables:\\n constraint += var\\n if num < len(self._variables):\\n constraint += LpSolve.comma\\n num += 1\\n constraint += LpSolve.semiColon + getNewLine()\\n self._constraints.append(constraint)\\n \\n def _outputConstraints (self):\\n with open(self._filename, 'w') as ilpFile:\\n for constraint in self._constraints:\\n ilpFile.write(constraint)\\n\\nclass CreateCFGILPVanilla (CreateCFGILP):\\n def __init__ (self, data, contextWCETs, contextv, cfg, lnt, pathg):\\n CreateCFGILP.__init__(self)\\n self._filename = \\\"%s.%s.context%s.%s.%s.vanilla\\\" % (config.Arguments.basepath + os.sep + config.Arguments.basename, \\n contextv.getName(), \\n contextv.vertexID, \\n \\\"cfg\\\", \\n LpSolve.fileSuffix)\\n self._createStructuralConstraints(cfg)\\n self._createExecutionCountConstraints(cfg, lnt, pathg)\\n self._createIntegerConstraint()\\n self._createObjectiveFunction(data, contextWCETs, contextv, cfg)\\n self._outputConstraints()\\n \\nclass CreateCFGILPExtra (CreateCFGILP):\\n def __init__ (self, data, contextWCETs, contextv, cfg, lnt, pathg):\\n CreateCFGILP.__init__(self)\\n self._filename = \\\"%s.%s.context%s.%s.%s.extra\\\" % (config.Arguments.basepath + os.sep + config.Arguments.basename, \\n contextv.getName(), \\n contextv.vertexID, \\n \\\"cfg\\\", \\n LpSolve.fileSuffix)\\n self._createStructuralConstraints(cfg)\\n self._createExecutionCountConstraints(cfg, lnt, pathg)\\n self._createLowerAndUpperBoundConstraints(cfg, pathg)\\n self._createIntegerConstraint()\\n self._createObjectiveFunction(data, contextWCETs, contextv, cfg)\\n self._outputConstraints()\\n \\n def _createLowerAndUpperBoundConstraints (self, cfg, pathg):\\n comment = LpSolve.getComment(\\\"Infeasible path constraints\\\")\\n self._constraints.append(comment)\\n for pathv in pathg:\\n programPoint = pathv.getProgramPoint()\\n if isinstance(programPoint, tuple):\\n constraint1 = LpSolve.getEdgeVariable(programPoint[0], programPoint[1])\\n else:\\n constraint1 = LpSolve.getVertexVariable(programPoint)\\n succe = pathv.getSuccessoredges(edges.PathInformationEdgeType.CAPACITY_BOUNDS)[0]\\n constraint1 += LpSolve.gtOrEqual\\n constraint1 += str(succe.lower)\\n constraint1 += LpSolve.semiColon;\\n constraint1 += getNewLine()\\n self._constraints.append(constraint1)\\n if isinstance(programPoint, tuple):\\n constraint2 = LpSolve.getEdgeVariable(programPoint[0], programPoint[1])\\n else:\\n constraint2 = LpSolve.getVertexVariable(programPoint)\\n constraint2 += LpSolve.ltOrEqual\\n constraint2 += str(succe.upper)\\n constraint2 += LpSolve.semiColon;\\n constraint2 += getNewLine(2)\\n self._constraints.append(constraint2) \\n \\n \\n\"\n },\n {\n \"alpha_fraction\": 0.4096066653728485,\n \"alphanum_fraction\": 0.4527231454849243,\n \"avg_line_length\": 13.85393238067627,\n \"blob_id\": \"4418e59e5abd6d1d240a25673e3c3dfddbe64b57\",\n \"content_id\": \"fbdb1db9b036f8fb5dc11f8d07ea0023701a8f74\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 2644,\n \"license_type\": \"no_license\",\n \"max_line_length\": 75,\n \"num_lines\": 178,\n \"path\": \"/DaikonPathInformation/benchmarks/mergesort.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Merge sort which consumes a\\n * test vector supplied on the command line.\\n *\\n * For this program, the test vector is a list of integers to be sorted.\\n * Note that the size of the array is determined by the number of arguments\\n * given to the program, i.e. argc - 1.\\n */\\n\\nint\\nmerge (int ARRAY_SIZE, int a[], int b[], int l, int r, int u)\\n{\\n #ifdef CBMC\\n int __count_13_15 = 0;\\n int __count_14_15 = 0;\\n int __count_16_20 = 0;\\n int __count_18_20 = 0;\\n int __count_20_19 = 0;\\n int __count_23_22 = 0;\\n int __count_26_25 = 0;\\n int __count_L26 = 0;\\n int __count_L23 = 0;\\n int __count_L20 = 0;\\n int __count_L16 = 0;\\n #endif\\n\\n int i = l;\\n int j = r;\\n int k = l;\\n\\n while (\\n #ifdef CBMC\\n __count_L16++,\\n #endif\\n i < r && j < u)\\n {\\n if (a[i] <= a[j])\\n {\\n b[k] = a[i];\\n i++;\\n #ifdef CBMC\\n __count_13_15++;\\n #endif\\n }\\n else\\n {\\n b[k] = a[j];\\n j++;\\n #ifdef CBMC\\n __count_14_15++;\\n #endif\\n }\\n k++;\\n }\\n\\n // TODO: check\\n #ifdef CBMC\\n if(i < r) {\\n __count_18_20++;\\n }\\n else {\\n __count_16_20++;\\n }\\n #endif\\n\\n while (\\n #ifdef CBMC\\n __count_L20++,\\n #endif\\n i < r)\\n {\\n #ifdef CBMC\\n __count_20_19++;\\n #endif\\n b[k] = a[i];\\n i++;\\n k++;\\n }\\n while (\\n #ifdef CBMC\\n __count_L23++,\\n #endif\\n j < u)\\n {\\n #ifdef CBMC\\n __count_23_22++;\\n #endif\\n b[k] = a[j];\\n j++;\\n k++;\\n }\\n for (k = l; \\n #ifdef CBMC\\n __count_L26++,\\n #endif\\n k < u; k++)\\n {\\n #ifdef CBMC\\n __count_26_25++;\\n #endif\\n a[k] = b[k];\\n }\\n}\\n\\nint\\nmergesort (int ARRAY_SIZE, int a[])\\n{\\n #ifdef CBMC\\n int __count_3_5 = 0;\\n int __count_4_5 = 0;\\n int __count_L9 = 0;\\n int __count_L7 = 0;\\n #endif\\n\\n int k = 1;\\n int u;\\n int i;\\n int b[ARRAY_SIZE];\\n\\n while (\\n #ifdef CBMC\\n __count_L9++,\\n #endif\\n k < ARRAY_SIZE)\\n {\\n i = 1;\\n while (\\n #ifdef CBMC\\n __count_L7++,\\n #endif\\n i + k <= ARRAY_SIZE)\\n {\\n u = i + k * 2;\\n if (u > ARRAY_SIZE)\\n {\\n u = ARRAY_SIZE + 1;\\n #ifdef CBMC\\n __count_4_5++;\\n #endif\\n }\\n #ifdef CBMC\\n else __count_3_5++;\\n #endif\\n merge (ARRAY_SIZE, a, b, i, i + k, u);\\n i = i + k * 2;\\n }\\n k = k * 2;\\n }\\n \\n return a[0];\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int ARRAY_SIZE = argc - 1;\\n int TV[ARRAY_SIZE];\\n int i;\\n\\n /*\\n * At least one integer value must be supplied\\n */\\n if (argc == 1)\\n {\\n return 1;\\n }\\n\\n for (i = 0; i < argc - 1; ++i)\\n {\\n TV[i] = atoi (argv[i + 1]);\\n }\\n\\n int val = mergesort (ARRAY_SIZE, TV);\\n \\n printf(\\\"%d\\\", val);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.5870108008384705,\n \"alphanum_fraction\": 0.5936719179153442,\n \"avg_line_length\": 28.774999618530273,\n \"blob_id\": \"7636324c243f19d7b6f1adac430b8ceedc7fd5b0\",\n \"content_id\": \"2873ade6a4223792dc8deb4944c8951f7bec9937\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 1201,\n \"license_type\": \"no_license\",\n \"max_line_length\": 93,\n \"num_lines\": 40,\n \"path\": \"/DaikonPathInformation/src/edges.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"dummyID = 0\\n\\nclass Edge (): \\n def __init__ (self, vertexID, edgeID=None): \\n self.vertexID = vertexID\\n if edgeID is None:\\n self.edgeID = dummyID\\n else:\\n self.edgeID = edgeID\\n \\nclass CallGraphEdge(Edge):\\n def __init__ (self, vertexID):\\n Edge.__init__(self, vertexID)\\n self.call_sites = set()\\n \\nclass PathInformationEdgeType:\\n INCLUSION = 0\\n EXCLUSION = 1\\n LOOP_BOUNDS = 2\\n CAPACITY_BOUNDS = 3\\n \\nclass PathInformationEdge (Edge): \\n def __init__ (self, vertexID, infoType):\\n Edge.__init__(self, vertexID)\\n self.__infoType = infoType\\n \\n def getInformationType (self):\\n return self.__infoType\\n \\nclass LoopBoundEdge (PathInformationEdge):\\n def __init__ (self, vertexID):\\n PathInformationEdge.__init__(self, vertexID, PathInformationEdgeType.LOOP_BOUNDS)\\n self.relative = 0\\n self.upper = 0\\n \\nclass CapacityBoundEdge (PathInformationEdge):\\n def __init__ (self, vertexID):\\n PathInformationEdge.__init__(self, vertexID, PathInformationEdgeType.CAPACITY_BOUNDS)\\n self.lower = sys.maxint\\n self.upper = 0\\n \\n \\n\"\n },\n {\n \"alpha_fraction\": 0.5595207214355469,\n \"alphanum_fraction\": 0.561582088470459,\n \"avg_line_length\": 36.11483383178711,\n \"blob_id\": \"bcf74075e5ed5ecd37da8ec5eec25b63866370c8\",\n \"content_id\": \"25a7c610205d2ef3283bfc5e4a598b6064c3d23e\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 7762,\n \"license_type\": \"no_license\",\n \"max_line_length\": 158,\n \"num_lines\": 209,\n \"path\": \"/GPUTimingAnalysis/src/CFGs.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from DirectedGraphs import dummyVertexID, DirectedGraph\\nfrom Vertices import Vertex, Ipoint\\n\\n# Class to mode instructions inside basic blocks\\nclass Instruction (): \\n labelPrefix = \\\"$L\\\"\\n \\n def __init__ (self, address, instrString):\\n self.address = address\\n self.instrString = instrString\\n \\n def getAddress (self):\\n return self.address\\n \\n def getString (self):\\n return self.instrString\\n \\n def containsLabel (self, label):\\n import shlex\\n lexemes = shlex.split(self.instrString)\\n if lexemes[0].startswith(Instruction.labelPrefix):\\n assert lexemes[0].endswith(':'), \\\"Instruction '%s' does not contain a valid label\\\" % self\\n return label == lexemes[0][:-1]\\n return False\\n \\n def __str__(self):\\n return hex(self.address) + \\\" : \\\" + self.instrString\\n\\nclass BasicBlock (Vertex):\\n def __init__ (self, vertexID):\\n Vertex.__init__(self, vertexID)\\n self.instructions = {}\\n \\n def addInstruction (self, instr):\\n address = instr.getAddress()\\n assert address not in self.instructions, \\\"Basic block \\\" + str(self._vertexID) + \\\" already has instruction with address \\\" + str(address)\\n self.instructions[address] = instr\\n \\n def getFirstInstruction (self):\\n return sorted(self.instructions.iteritems())[0]\\n \\n def getLastInstruction (self):\\n return sorted(self.instructions.iteritems())[len(self.instructions) - 1]\\n \\n def numberOfInstructions (self):\\n return len(self.instructions)\\n \\n def getInstructions (self):\\n return sorted(self.instructions.iteritems())\\n \\n def __str__ (self):\\n string = \\\"Vertex ID = \\\" + str(self._vertexID) + \\\"\\\\n\\\"\\n string += \\\"\\\\t\\\" + Vertex.predecessorStr(self)\\n string += \\\"\\\\t\\\" + Vertex.successorStr(self)\\n string += \\\"\\\\t\\\" + 40 * \\\"=\\\" + \\\"\\\\n\\\" \\n for address, instr in sorted(self.instructions.iteritems()):\\n string += \\\"\\\\t\\\" + instr.__str__() + \\\"\\\\n\\\" \\n string += \\\"\\\\t\\\" + 40 * \\\"=\\\" + \\\"\\\\n\\\" \\n return string\\n \\nclass CFG (DirectedGraph): \\n def __init__ (self):\\n DirectedGraph.__init__(self)\\n self._entryID = dummyVertexID\\n self._exitID = dummyVertexID\\n \\n def getReverseCFG (self):\\n reverseg = CFG()\\n # Add vertices\\n for v in self:\\n copyv = None\\n if isinstance(v, BasicBlock):\\n copyv = BasicBlock(v.getVertexID())\\n else:\\n assert isinstance(v, Ipoint)\\n copyv = Ipoint(v.getVertexID(), v.getIpointID())\\n reverseg.addVertex(copyv)\\n \\n # Add edges\\n for v in self:\\n predID = v.getVertexID()\\n predv = reverseg.getVertex(predID)\\n for succID in v.getSuccessorIDs():\\n succv = reverseg.getVertex(succID)\\n predv.addPredecessor(succID)\\n succv.addSuccessor(predID)\\n \\n # Set the entry and exit IDs\\n reverseg.setEntryID(self.getExitID())\\n reverseg.setExitID(self.getExitID())\\n return reverseg\\n \\n def addVertex (self, bb):\\n bbID = bb.getVertexID()\\n assert bbID not in self.vertices, \\\\\\n \\\"Adding basic block %d which is already in graph\\\" % bbID\\n self.vertices[bbID] = bb\\n \\n def getVertex (self, bbID):\\n return DirectedGraph.getVertex(self, bbID)\\n \\n def getEntryID (self):\\n assert self._entryID != dummyVertexID, \\\"Entry ID not set\\\" \\n return self._entryID\\n \\n def setEntryID (self, entryID=None):\\n if entryID is None:\\n for bb in self.vertices.values():\\n if bb.numberOfPredecessors() == 0:\\n bbID = bb.getVertexID()\\n assert self._entryID == dummyVertexID, \\\"The entry ID has already been set to %s. Found another entry candidate %s\\\" % (self._entryID, bbID)\\n self._entryID = bbID\\n assert self._entryID != dummyVertexID, \\\"Unable to find a vertex without predecessors to set as the entry\\\"\\n else:\\n assert entryID in self.vertices, \\\"Cannot find vertex \\\" + str(entryID) + \\\" in vertices\\\"\\n assert entryID > dummyVertexID, \\\"Entry ID \\\" + str(entryID) + \\\" is not positive\\\"\\n self._entryID = entryID\\n \\n def getExitID (self):\\n assert self._exitID != dummyVertexID, \\\"Exit ID not set\\\" \\n return self._exitID\\n \\n def setExitID (self, exitID=None):\\n if exitID is None:\\n for bb in self.vertices.values():\\n if bb.numberOfSuccessors() == 0:\\n bbID = bb.getVertexID()\\n assert self._exitID == dummyVertexID, \\\"The exit ID has already been set to %s. Found another entry candidate %s\\\" % (self._entryID, bbID)\\n self._exitID = bbID\\n assert self._exitID != dummyVertexID, \\\"Unable to find a vertex without successors to set as the entry\\\"\\n else:\\n assert exitID in self.vertices, \\\"Cannot find vertex \\\" + str(exitID) + \\\" in vertices\\\"\\n assert exitID > dummyVertexID, \\\"Exit ID \\\" + str(exitID) + \\\" is not positive\\\"\\n self._exitID = exitID\\n \\n def addExitEntryEdge (self):\\n\\n assert self._exitID != dummyVertexID, \\\"Exit ID not set\\\"\\n entryv = self.getVertex(self._entryID)\\n exitv = self.getVertex(self._exitID)\\n entryv.addPredecessor(self._exitID)\\n exitv.addSuccessor(self._entryID)\\n \\n def __str__ (self):\\n string = \\\"*\\\" * 20 + \\\" CFG Output \\\" + \\\"*\\\" * 20 + \\\"\\\\n\\\" + \\\\\\n \\\"Entry ID = %s\\\\n\\\" % str(self._entryID) + \\\\\\n \\\"Exit ID = %s\\\\n\\\" % str(self._exitID) + \\\"\\\\n\\\"\\n for bb in self.vertices.values():\\n string += bb.__str__()\\n return string\\n \\nclass Program():\\n def __init__(self):\\n self.__cfgs = []\\n self.__icfgs = []\\n self.__ipgs = []\\n self.__lnts = []\\n self.__hwmts = {}\\n self.__wcets = {}\\n \\n def getIPGWithEntryIpointID (self, ipointID):\\n for ipg in self.__ipgs:\\n startv = ipg.getVertex(ipg.getEntryID())\\n if startv.getIpointID() == ipointID:\\n return ipg\\n assert False, \\\"Unable to find IPG whose entry Ipoint ID is %d\\\" % ipointID\\n \\n def updateHWMT (self, functionName, time):\\n if functionName not in self.__hwmts:\\n self.__hwmts[functionName] = time\\n else:\\n if time > self.__hwmts[functionName]:\\n self.__hwmts[functionName] = time\\n \\n def getHWMT (self, functionName):\\n assert functionName in self.__hwmts, \\\"Unable to find a HWMT value for %s\\\" % (functionName)\\n return self.__hwmts[functionName]\\n \\n def updateWCET (self, functionName, time):\\n assert functionName not in self.__wcets, \\\"Already have a WCET value for %s which is %d\\\" % (functionName, time)\\n self.__wcets[functionName] = time\\n \\n def getWCET (self, functionName):\\n assert functionName in self.__wcets, \\\"Unable to find a WCET value for %s\\\" % (functionName)\\n return self.__wcets[functionName]\\n \\n def addCFG (self, cfg):\\n self.__cfgs.append(cfg)\\n \\n def addICFG (self, icfg):\\n self.__icfgs.append(icfg)\\n \\n def addIPG (self, ipg):\\n self.__ipgs.append(ipg)\\n \\n def addLNT (self, lnt):\\n self.__lnts.append(lnt)\\n \\n def getCFGs (self):\\n return self.__cfgs.__iter__() \\n\\n def getICFGs (self):\\n return self.__icfgs.__iter__() \\n\\n def getIPGs (self):\\n return self.__ipgs.__iter__() \\n \\n def getLNTs (self):\\n return self.__lnts.__iter__() \\n \"\n },\n {\n \"alpha_fraction\": 0.4417192041873932,\n \"alphanum_fraction\": 0.5431581735610962,\n \"avg_line_length\": 24.408727645874023,\n \"blob_id\": \"48028c4e2f5beb957e7a362aabbf9868912c27b0\",\n \"content_id\": \"2fe78d7ae77720ed3593bb6bdba7c923e4c7a994\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 47743,\n \"license_type\": \"no_license\",\n \"max_line_length\": 83,\n \"num_lines\": 1879,\n \"path\": \"/DaikonPathInformation/benchmarks/cover.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Cover taken from MDH suite and modified by Adam Betts to consume a\\n * test vector supplied on the command line. Note that the three original functions\\n * 'swi10', 'swi50', 'swi120' have all been merged into the single 'cover' function\\n * because they each have a loop with a fixed number of iterations, and the paths\\n * followed through each do not depend on input or a particular calling order\\n *\\n * For this program, a one-element test vector is expected.\\n */\\n \\nint \\nswi120 (int c)\\n{\\n #ifdef CBMC\\n//==========> swi120 : header 126\\nint __count_3_4 = 0;\\nint __count_3_5 = 0;\\nint __count_3_6 = 0;\\nint __count_3_7 = 0;\\nint __count_3_9 = 0;\\nint __count_3_12 = 0;\\nint __count_3_13 = 0;\\nint __count_3_14 = 0;\\nint __count_3_17 = 0;\\nint __count_3_20 = 0;\\nint __count_3_21 = 0;\\nint __count_3_22 = 0;\\nint __count_3_25 = 0;\\nint __count_3_28 = 0;\\nint __count_3_29 = 0;\\nint __count_3_30 = 0;\\nint __count_3_33 = 0;\\nint __count_3_36 = 0;\\nint __count_3_37 = 0;\\nint __count_3_38 = 0;\\nint __count_3_41 = 0;\\nint __count_3_44 = 0;\\nint __count_3_45 = 0;\\nint __count_3_46 = 0;\\nint __count_3_49 = 0;\\nint __count_3_52 = 0;\\nint __count_3_53 = 0;\\nint __count_3_54 = 0;\\nint __count_3_57 = 0;\\nint __count_3_60 = 0;\\nint __count_3_61 = 0;\\nint __count_3_62 = 0;\\nint __count_3_65 = 0;\\nint __count_3_68 = 0;\\nint __count_3_69 = 0;\\nint __count_3_70 = 0;\\nint __count_3_73 = 0;\\nint __count_3_76 = 0;\\nint __count_3_77 = 0;\\nint __count_3_78 = 0;\\nint __count_3_81 = 0;\\nint __count_3_84 = 0;\\nint __count_3_85 = 0;\\nint __count_3_86 = 0;\\nint __count_3_89 = 0;\\nint __count_3_92 = 0;\\nint __count_3_93 = 0;\\nint __count_3_94 = 0;\\nint __count_3_97 = 0;\\nint __count_3_100 = 0;\\nint __count_3_101 = 0;\\nint __count_3_102 = 0;\\nint __count_3_105 = 0;\\nint __count_3_108 = 0;\\nint __count_3_109 = 0;\\nint __count_3_110 = 0;\\nint __count_3_113 = 0;\\nint __count_3_116 = 0;\\nint __count_3_117 = 0;\\nint __count_3_118 = 0;\\nint __count_3_121 = 0;\\nint __count_8_125 = 0;\\nint __count_10_125 = 0;\\nint __count_11_125 = 0;\\nint __count_15_125 = 0;\\nint __count_16_125 = 0;\\nint __count_18_125 = 0;\\nint __count_19_125 = 0;\\nint __count_23_125 = 0;\\nint __count_24_125 = 0;\\nint __count_26_125 = 0;\\nint __count_27_125 = 0;\\nint __count_31_125 = 0;\\nint __count_32_125 = 0;\\nint __count_34_125 = 0;\\nint __count_35_125 = 0;\\nint __count_39_125 = 0;\\nint __count_40_125 = 0;\\nint __count_42_125 = 0;\\nint __count_43_125 = 0;\\nint __count_47_125 = 0;\\nint __count_48_125 = 0;\\nint __count_50_125 = 0;\\nint __count_51_125 = 0;\\nint __count_55_125 = 0;\\nint __count_56_125 = 0;\\nint __count_58_125 = 0;\\nint __count_59_125 = 0;\\nint __count_63_125 = 0;\\nint __count_64_125 = 0;\\nint __count_66_125 = 0;\\nint __count_67_125 = 0;\\nint __count_71_125 = 0;\\nint __count_72_125 = 0;\\nint __count_74_125 = 0;\\nint __count_75_125 = 0;\\nint __count_79_125 = 0;\\nint __count_80_125 = 0;\\nint __count_82_125 = 0;\\nint __count_83_125 = 0;\\nint __count_87_125 = 0;\\nint __count_88_125 = 0;\\nint __count_90_125 = 0;\\nint __count_91_125 = 0;\\nint __count_95_125 = 0;\\nint __count_96_125 = 0;\\nint __count_98_125 = 0;\\nint __count_99_125 = 0;\\nint __count_103_125 = 0;\\nint __count_104_125 = 0;\\nint __count_106_125 = 0;\\nint __count_107_125 = 0;\\nint __count_111_125 = 0;\\nint __count_112_125 = 0;\\nint __count_114_125 = 0;\\nint __count_115_125 = 0;\\nint __count_119_125 = 0;\\nint __count_120_125 = 0;\\nint __count_122_125 = 0;\\nint __count_123_125 = 0;\\nint __count_124_125 = 0;\\nint __count_126_2 = 0; //Loop counter\\n//==========> swi120 : header 1\\nint __count_127 = 0;\\nint __count_126_127 = 0;\\n#endif\\n\\n int i;\\n \\n for (i = 0; i < 120; i++)\\n {\\n #ifdef CBMC\\n __count_126_2++;\\n #endif\\n switch (i)\\n {\\n case 0:\\n #ifdef CBMC\\n __count_3_4++;\\n #endif\\n c++;\\n break;\\n case 1:\\n #ifdef CBMC\\n __count_3_5++;\\n #endif\\n c++;\\n break;\\n case 2:\\n #ifdef CBMC\\n __count_3_6++;\\n #endif\\n c++;\\n break;\\n case 3:\\n #ifdef CBMC\\n __count_3_7++;\\n #endif\\n c++;\\n break;\\n case 4:\\n #ifdef CBMC\\n __count_8_125++;\\n #endif\\n c++;\\n break;\\n case 5:\\n #ifdef CBMC\\n __count_3_9++;\\n #endif\\n c++;\\n break;\\n case 6:\\n #ifdef CBMC\\n __count_10_125++;\\n #endif\\n c++;\\n break;\\n case 7:\\n #ifdef CBMC\\n __count_11_125++;\\n #endif\\n c++;\\n break;\\n case 8:\\n #ifdef CBMC\\n __count_3_12++;\\n #endif\\n c++;\\n break;\\n case 9:\\n #ifdef CBMC\\n __count_3_13++;\\n #endif\\n c++;\\n break;\\n case 10:\\n #ifdef CBMC\\n __count_3_14++;\\n #endif\\n c++;\\n break;\\n case 11:\\n #ifdef CBMC\\n __count_15_125++;\\n #endif\\n c++;\\n break;\\n case 12:\\n #ifdef CBMC\\n __count_16_125++;\\n #endif\\n c++;\\n break;\\n case 13:\\n #ifdef CBMC\\n __count_3_17++;\\n #endif\\n c++;\\n break;\\n case 14:\\n #ifdef CBMC\\n __count_18_125++;\\n #endif\\n c++;\\n break;\\n case 15:\\n #ifdef CBMC\\n __count_19_125++;\\n #endif\\n c++;\\n break;\\n case 16:\\n #ifdef CBMC\\n __count_3_20++;\\n #endif\\n c++;\\n break;\\n case 17:\\n #ifdef CBMC\\n __count_3_21++;\\n #endif\\n c++;\\n break;\\n case 18:\\n #ifdef CBMC\\n __count_3_22++;\\n #endif\\n c++;\\n break;\\n case 19:\\n #ifdef CBMC\\n __count_23_125++;\\n #endif\\n c++;\\n break;\\n case 20:\\n #ifdef CBMC\\n __count_24_125++;\\n #endif\\n c++;\\n break;\\n case 21:\\n #ifdef CBMC\\n __count_3_25++;\\n #endif\\n c++;\\n break;\\n case 22:\\n #ifdef CBMC\\n __count_26_125++;\\n #endif\\n c++;\\n break;\\n case 23:\\n #ifdef CBMC\\n __count_27_125++;\\n #endif\\n c++;\\n break;\\n case 24:\\n #ifdef CBMC\\n __count_3_28++;\\n #endif\\n c++;\\n break;\\n case 25:\\n #ifdef CBMC\\n __count_3_29++;\\n #endif\\n c++;\\n break;\\n case 26:\\n #ifdef CBMC\\n __count_3_30++;\\n #endif\\n c++;\\n break;\\n case 27:\\n #ifdef CBMC\\n __count_31_125++;\\n #endif\\n c++;\\n break;\\n case 28:\\n #ifdef CBMC\\n __count_32_125++;\\n #endif\\n c++;\\n break;\\n case 29:\\n #ifdef CBMC\\n __count_3_33++;\\n #endif\\n c++;\\n break;\\n case 30:\\n #ifdef CBMC\\n __count_34_125++;\\n #endif\\n c++;\\n break;\\n case 31:\\n #ifdef CBMC\\n __count_35_125++;\\n #endif\\n c++;\\n break;\\n case 32:\\n #ifdef CBMC\\n __count_3_36++;\\n #endif\\n c++;\\n break;\\n case 33:\\n #ifdef CBMC\\n __count_3_37++;\\n #endif\\n c++;\\n break;\\n case 34:\\n #ifdef CBMC\\n __count_3_38++;\\n #endif\\n c++;\\n break;\\n case 35:\\n #ifdef CBMC\\n __count_39_125++;\\n #endif\\n c++;\\n break;\\n case 36:\\n #ifdef CBMC\\n __count_40_125++;\\n #endif\\n c++;\\n break;\\n case 37:\\n #ifdef CBMC\\n __count_3_41++;\\n #endif\\n c++;\\n break;\\n case 38:\\n #ifdef CBMC\\n __count_42_125++;\\n #endif\\n c++;\\n break;\\n case 39:\\n #ifdef CBMC\\n __count_43_125++;\\n #endif\\n c++;\\n break;\\n case 40:\\n #ifdef CBMC\\n __count_3_44++;\\n #endif\\n c++;\\n break;\\n case 41:\\n #ifdef CBMC\\n __count_3_45++;\\n #endif\\n c++;\\n break;\\n case 42:\\n #ifdef CBMC\\n __count_3_46++;\\n #endif\\n c++;\\n break;\\n case 43:\\n #ifdef CBMC\\n __count_47_125++;\\n #endif\\n c++;\\n break;\\n case 44:\\n #ifdef CBMC\\n __count_48_125++;\\n #endif\\n c++;\\n break;\\n case 45:\\n #ifdef CBMC\\n __count_3_49++;\\n #endif\\n c++;\\n break;\\n case 46:\\n #ifdef CBMC\\n __count_50_125++;\\n #endif\\n c++;\\n break;\\n case 47:\\n #ifdef CBMC\\n __count_51_125++;\\n #endif\\n c++;\\n break;\\n case 48:\\n #ifdef CBMC\\n __count_3_52++;\\n #endif\\n c++;\\n break;\\n case 49:\\n #ifdef CBMC\\n __count_3_53++;\\n #endif\\n c++;\\n break;\\n case 50:\\n #ifdef CBMC\\n __count_3_54++;\\n #endif\\n c++;\\n break;\\n case 51:\\n #ifdef CBMC\\n __count_55_125++;\\n #endif\\n c++;\\n break;\\n case 52:\\n #ifdef CBMC\\n __count_56_125++;\\n #endif\\n c++;\\n break;\\n case 53:\\n #ifdef CBMC\\n __count_3_57++;\\n #endif\\n c++;\\n break;\\n case 54:\\n #ifdef CBMC\\n __count_58_125++;\\n #endif\\n c++;\\n break;\\n case 55:\\n #ifdef CBMC\\n __count_59_125++;\\n #endif\\n c++;\\n break;\\n case 56:\\n #ifdef CBMC\\n __count_3_60++;\\n #endif\\n c++;\\n break;\\n case 57:\\n #ifdef CBMC\\n __count_3_61++;\\n #endif\\n c++;\\n break;\\n case 58:\\n #ifdef CBMC\\n __count_3_62++;\\n #endif\\n c++;\\n break;\\n case 59:\\n #ifdef CBMC\\n __count_63_125++;\\n #endif\\n c++;\\n break;\\n case 60:\\n #ifdef CBMC\\n __count_64_125++;\\n #endif\\n c++;\\n break;\\n case 61:\\n #ifdef CBMC\\n __count_3_65++;\\n #endif\\n c++;\\n break;\\n case 62:\\n #ifdef CBMC\\n __count_66_125++;\\n #endif\\n c++;\\n break;\\n case 63:\\n #ifdef CBMC\\n __count_67_125++;\\n #endif\\n c++;\\n break;\\n case 64:\\n #ifdef CBMC\\n __count_3_68++;\\n #endif\\n c++;\\n break;\\n case 65:\\n #ifdef CBMC\\n __count_3_69++;\\n #endif\\n c++;\\n break;\\n case 66:\\n #ifdef CBMC\\n __count_3_70++;\\n #endif\\n c++;\\n break;\\n case 67:\\n #ifdef CBMC\\n __count_71_125++;\\n #endif\\n c++;\\n break;\\n case 68:\\n #ifdef CBMC\\n __count_72_125++;\\n #endif\\n c++;\\n break;\\n case 69:\\n #ifdef CBMC\\n __count_3_73++;\\n #endif\\n c++;\\n break;\\n case 70:\\n #ifdef CBMC\\n __count_74_125++;\\n #endif\\n c++;\\n break;\\n case 71:\\n #ifdef CBMC\\n __count_75_125++;\\n #endif\\n c++;\\n break;\\n case 72:\\n #ifdef CBMC\\n __count_3_76++;\\n #endif\\n c++;\\n break;\\n case 73:\\n #ifdef CBMC\\n __count_3_77++;\\n #endif\\n c++;\\n break;\\n case 74:\\n #ifdef CBMC\\n __count_3_78++;\\n #endif\\n c++;\\n break;\\n case 75:\\n #ifdef CBMC\\n __count_79_125++;\\n #endif\\n c++;\\n break;\\n case 76:\\n #ifdef CBMC\\n __count_80_125++;\\n #endif\\n c++;\\n break;\\n case 77:\\n #ifdef CBMC\\n __count_3_81++;\\n #endif\\n c++;\\n break;\\n case 78:\\n #ifdef CBMC\\n __count_82_125++;\\n #endif\\n c++;\\n break;\\n case 79:\\n #ifdef CBMC\\n __count_83_125++;\\n #endif\\n c++;\\n break;\\n case 80:\\n #ifdef CBMC\\n __count_3_84++;\\n #endif\\n c++;\\n break;\\n case 81:\\n #ifdef CBMC\\n __count_3_85++;\\n #endif\\n c++;\\n break;\\n case 82:\\n #ifdef CBMC\\n __count_3_86++;\\n #endif\\n c++;\\n break;\\n case 83:\\n #ifdef CBMC\\n __count_87_125++;\\n #endif\\n c++;\\n break;\\n case 84:\\n #ifdef CBMC\\n __count_88_125++;\\n #endif\\n c++;\\n break;\\n case 85:\\n #ifdef CBMC\\n __count_3_89++;\\n #endif\\n c++;\\n break;\\n case 86:\\n #ifdef CBMC\\n __count_90_125++;\\n #endif\\n c++;\\n break;\\n case 87:\\n #ifdef CBMC\\n __count_91_125++;\\n #endif\\n c++;\\n break;\\n case 88:\\n #ifdef CBMC\\n __count_3_92++;\\n #endif\\n c++;\\n break;\\n case 89:\\n #ifdef CBMC\\n __count_3_93++;\\n #endif\\n c++;\\n break;\\n case 90:\\n #ifdef CBMC\\n __count_3_94++;\\n #endif\\n c++;\\n break;\\n case 91:\\n #ifdef CBMC\\n __count_95_125++;\\n #endif\\n c++;\\n break;\\n case 92:\\n #ifdef CBMC\\n __count_96_125++;\\n #endif\\n c++;\\n break;\\n case 93:\\n #ifdef CBMC\\n __count_3_97++;\\n #endif\\n c++;\\n break;\\n case 94:\\n #ifdef CBMC\\n __count_98_125++;\\n #endif\\n c++;\\n break;\\n case 95:\\n #ifdef CBMC\\n __count_99_125++;\\n #endif\\n c++;\\n break;\\n case 96:\\n #ifdef CBMC\\n __count_3_100++;\\n #endif\\n c++;\\n break;\\n case 97:\\n #ifdef CBMC\\n __count_3_101++;\\n #endif\\n c++;\\n break;\\n case 98:\\n #ifdef CBMC\\n __count_3_102++;\\n #endif\\n c++;\\n break;\\n case 99:\\n #ifdef CBMC\\n __count_103_125++; \\n #endif\\n c++;\\n break;\\n case 100:\\n #ifdef CBMC\\n __count_104_125++;\\n #endif\\n c++;\\n break;\\n case 101:\\n #ifdef CBMC\\n __count_3_105++;\\n #endif\\n c++;\\n break;\\n case 102:\\n #ifdef CBMC\\n __count_106_125++;\\n #endif\\n c++;\\n break;\\n case 103:\\n #ifdef CBMC\\n __count_107_125++;\\n #endif\\n c++;\\n break;\\n case 104:\\n #ifdef CBMC\\n __count_3_108++;\\n #endif\\n c++;\\n break;\\n case 105:\\n #ifdef CBMC\\n __count_3_109++;\\n #endif\\n c++;\\n break;\\n case 106:\\n #ifdef CBMC\\n __count_3_110++;\\n #endif\\n c++;\\n break;\\n case 107:\\n #ifdef CBMC\\n __count_111_125++;\\n #endif\\n c++;\\n break;\\n case 108:\\n #ifdef CBMC\\n __count_112_125++;\\n #endif\\n c++;\\n break;\\n case 109:\\n #ifdef CBMC\\n __count_3_113++;\\n #endif\\n c++;\\n break;\\n case 110:\\n #ifdef CBMC\\n __count_114_125++;\\n #endif\\n c++;\\n break;\\n case 111:\\n #ifdef CBMC\\n __count_115_125++;\\n #endif\\n c++;\\n break;\\n case 112:\\n #ifdef CBMC\\n __count_3_116++;\\n #endif\\n c++;\\n break;\\n case 113:\\n #ifdef CBMC\\n __count_3_117++;\\n #endif\\n c++;\\n break;\\n case 114:\\n #ifdef CBMC\\n __count_3_118++;\\n #endif\\n c++;\\n break;\\n case 115:\\n #ifdef CBMC\\n __count_119_125++;\\n #endif\\n c++;\\n break;\\n case 116:\\n #ifdef CBMC\\n __count_120_125++;\\n #endif\\n c++;\\n break;\\n case 117:\\n #ifdef CBMC\\n __count_3_121++;\\n #endif\\n c++;\\n break;\\n case 118:\\n #ifdef CBMC\\n __count_122_125++;\\n #endif\\n c++;\\n break;\\n case 119:\\n #ifdef CBMC\\n __count_123_125++;\\n #endif\\n c++;\\n break;\\n default:\\n #ifdef CBMC\\n __count_124_125++;\\n #endif\\n c--;\\n break;\\n }\\n }\\n \\n #ifdef CBMC\\n __count_126_127++;\\n __count_127++;\\n #endif\\n \\n #ifdef CBMC\\nassert(__count_126_2 <= 121); // Loop counter property\\nassert(__count_127 >= 1); // Lower capacity constraint\\nassert(__count_127 <= 1); // Upper capacity constraint\\nassert(__count_3_4 >= 1); // Lower capacity constraint\\nassert(__count_3_4 <= 1); // Upper capacity constraint\\nassert(__count_3_5 >= 1); // Lower capacity constraint\\nassert(__count_3_5 <= 1); // Upper capacity constraint\\nassert(__count_3_6 >= 1); // Lower capacity constraint\\nassert(__count_3_6 <= 1); // Upper capacity constraint\\nassert(__count_3_7 >= 1); // Lower capacity constraint\\nassert(__count_3_7 <= 1); // Upper capacity constraint\\nassert(__count_3_9 >= 1); // Lower capacity constraint\\nassert(__count_3_9 <= 1); // Upper capacity constraint\\nassert(__count_3_12 >= 1); // Lower capacity constraint\\nassert(__count_3_12 <= 1); // Upper capacity constraint\\nassert(__count_3_13 >= 1); // Lower capacity constraint\\nassert(__count_3_13 <= 1); // Upper capacity constraint\\nassert(__count_3_14 >= 1); // Lower capacity constraint\\nassert(__count_3_14 <= 1); // Upper capacity constraint\\nassert(__count_3_17 >= 1); // Lower capacity constraint\\nassert(__count_3_17 <= 1); // Upper capacity constraint\\nassert(__count_3_20 >= 1); // Lower capacity constraint\\nassert(__count_3_20 <= 1); // Upper capacity constraint\\nassert(__count_3_21 >= 1); // Lower capacity constraint\\nassert(__count_3_21 <= 1); // Upper capacity constraint\\nassert(__count_3_22 >= 1); // Lower capacity constraint\\nassert(__count_3_22 <= 1); // Upper capacity constraint\\nassert(__count_3_25 >= 1); // Lower capacity constraint\\nassert(__count_3_25 <= 1); // Upper capacity constraint\\nassert(__count_3_28 >= 1); // Lower capacity constraint\\nassert(__count_3_28 <= 1); // Upper capacity constraint\\nassert(__count_3_29 >= 1); // Lower capacity constraint\\nassert(__count_3_29 <= 1); // Upper capacity constraint\\nassert(__count_3_30 >= 1); // Lower capacity constraint\\nassert(__count_3_30 <= 1); // Upper capacity constraint\\nassert(__count_3_33 >= 1); // Lower capacity constraint\\nassert(__count_3_33 <= 1); // Upper capacity constraint\\nassert(__count_3_36 >= 1); // Lower capacity constraint\\nassert(__count_3_36 <= 1); // Upper capacity constraint\\nassert(__count_3_37 >= 1); // Lower capacity constraint\\nassert(__count_3_37 <= 1); // Upper capacity constraint\\nassert(__count_3_38 >= 1); // Lower capacity constraint\\nassert(__count_3_38 <= 1); // Upper capacity constraint\\nassert(__count_3_41 >= 1); // Lower capacity constraint\\nassert(__count_3_41 <= 1); // Upper capacity constraint\\nassert(__count_3_44 >= 1); // Lower capacity constraint\\nassert(__count_3_44 <= 1); // Upper capacity constraint\\nassert(__count_3_45 >= 1); // Lower capacity constraint\\nassert(__count_3_45 <= 1); // Upper capacity constraint\\nassert(__count_3_46 >= 1); // Lower capacity constraint\\nassert(__count_3_46 <= 1); // Upper capacity constraint\\nassert(__count_3_49 >= 1); // Lower capacity constraint\\nassert(__count_3_49 <= 1); // Upper capacity constraint\\nassert(__count_3_52 >= 1); // Lower capacity constraint\\nassert(__count_3_52 <= 1); // Upper capacity constraint\\nassert(__count_3_53 >= 1); // Lower capacity constraint\\nassert(__count_3_53 <= 1); // Upper capacity constraint\\nassert(__count_3_54 >= 1); // Lower capacity constraint\\nassert(__count_3_54 <= 1); // Upper capacity constraint\\nassert(__count_3_57 >= 1); // Lower capacity constraint\\nassert(__count_3_57 <= 1); // Upper capacity constraint\\nassert(__count_3_60 >= 1); // Lower capacity constraint\\nassert(__count_3_60 <= 1); // Upper capacity constraint\\nassert(__count_3_61 >= 1); // Lower capacity constraint\\nassert(__count_3_61 <= 1); // Upper capacity constraint\\nassert(__count_3_62 >= 1); // Lower capacity constraint\\nassert(__count_3_62 <= 1); // Upper capacity constraint\\nassert(__count_3_65 >= 1); // Lower capacity constraint\\nassert(__count_3_65 <= 1); // Upper capacity constraint\\nassert(__count_3_68 >= 1); // Lower capacity constraint\\nassert(__count_3_68 <= 1); // Upper capacity constraint\\nassert(__count_3_69 >= 1); // Lower capacity constraint\\nassert(__count_3_69 <= 1); // Upper capacity constraint\\nassert(__count_3_70 >= 1); // Lower capacity constraint\\nassert(__count_3_70 <= 1); // Upper capacity constraint\\nassert(__count_3_73 >= 1); // Lower capacity constraint\\nassert(__count_3_73 <= 1); // Upper capacity constraint\\nassert(__count_3_76 >= 1); // Lower capacity constraint\\nassert(__count_3_76 <= 1); // Upper capacity constraint\\nassert(__count_3_77 >= 1); // Lower capacity constraint\\nassert(__count_3_77 <= 1); // Upper capacity constraint\\nassert(__count_3_78 >= 1); // Lower capacity constraint\\nassert(__count_3_78 <= 1); // Upper capacity constraint\\nassert(__count_3_81 >= 1); // Lower capacity constraint\\nassert(__count_3_81 <= 1); // Upper capacity constraint\\nassert(__count_3_84 >= 1); // Lower capacity constraint\\nassert(__count_3_84 <= 1); // Upper capacity constraint\\nassert(__count_3_85 >= 1); // Lower capacity constraint\\nassert(__count_3_85 <= 1); // Upper capacity constraint\\nassert(__count_3_86 >= 1); // Lower capacity constraint\\nassert(__count_3_86 <= 1); // Upper capacity constraint\\nassert(__count_3_89 >= 1); // Lower capacity constraint\\nassert(__count_3_89 <= 1); // Upper capacity constraint\\nassert(__count_3_92 >= 1); // Lower capacity constraint\\nassert(__count_3_92 <= 1); // Upper capacity constraint\\nassert(__count_3_93 >= 1); // Lower capacity constraint\\nassert(__count_3_93 <= 1); // Upper capacity constraint\\nassert(__count_3_94 >= 1); // Lower capacity constraint\\nassert(__count_3_94 <= 1); // Upper capacity constraint\\nassert(__count_3_97 >= 1); // Lower capacity constraint\\nassert(__count_3_97 <= 1); // Upper capacity constraint\\nassert(__count_3_100 >= 1); // Lower capacity constraint\\nassert(__count_3_100 <= 1); // Upper capacity constraint\\nassert(__count_3_101 >= 1); // Lower capacity constraint\\nassert(__count_3_101 <= 1); // Upper capacity constraint\\nassert(__count_3_102 >= 1); // Lower capacity constraint\\nassert(__count_3_102 <= 1); // Upper capacity constraint\\nassert(__count_3_105 >= 1); // Lower capacity constraint\\nassert(__count_3_105 <= 1); // Upper capacity constraint\\nassert(__count_3_108 >= 1); // Lower capacity constraint\\nassert(__count_3_108 <= 1); // Upper capacity constraint\\nassert(__count_3_109 >= 1); // Lower capacity constraint\\nassert(__count_3_109 <= 1); // Upper capacity constraint\\nassert(__count_3_110 >= 1); // Lower capacity constraint\\nassert(__count_3_110 <= 1); // Upper capacity constraint\\nassert(__count_3_113 >= 1); // Lower capacity constraint\\nassert(__count_3_113 <= 1); // Upper capacity constraint\\nassert(__count_3_116 >= 1); // Lower capacity constraint\\nassert(__count_3_116 <= 1); // Upper capacity constraint\\nassert(__count_3_117 >= 1); // Lower capacity constraint\\nassert(__count_3_117 <= 1); // Upper capacity constraint\\nassert(__count_3_118 >= 1); // Lower capacity constraint\\nassert(__count_3_118 <= 1); // Upper capacity constraint\\nassert(__count_3_121 >= 1); // Lower capacity constraint\\nassert(__count_3_121 <= 1); // Upper capacity constraint\\nassert(__count_8_125 >= 1); // Lower capacity constraint\\nassert(__count_8_125 <= 1); // Upper capacity constraint\\nassert(__count_10_125 >= 1); // Lower capacity constraint\\nassert(__count_10_125 <= 1); // Upper capacity constraint\\nassert(__count_11_125 >= 1); // Lower capacity constraint\\nassert(__count_11_125 <= 1); // Upper capacity constraint\\nassert(__count_15_125 >= 1); // Lower capacity constraint\\nassert(__count_15_125 <= 1); // Upper capacity constraint\\nassert(__count_16_125 >= 1); // Lower capacity constraint\\nassert(__count_16_125 <= 1); // Upper capacity constraint\\nassert(__count_18_125 >= 1); // Lower capacity constraint\\nassert(__count_18_125 <= 1); // Upper capacity constraint\\nassert(__count_19_125 >= 1); // Lower capacity constraint\\nassert(__count_19_125 <= 1); // Upper capacity constraint\\nassert(__count_23_125 >= 1); // Lower capacity constraint\\nassert(__count_23_125 <= 1); // Upper capacity constraint\\nassert(__count_24_125 >= 1); // Lower capacity constraint\\nassert(__count_24_125 <= 1); // Upper capacity constraint\\nassert(__count_26_125 >= 1); // Lower capacity constraint\\nassert(__count_26_125 <= 1); // Upper capacity constraint\\nassert(__count_27_125 >= 1); // Lower capacity constraint\\nassert(__count_27_125 <= 1); // Upper capacity constraint\\nassert(__count_31_125 >= 1); // Lower capacity constraint\\nassert(__count_31_125 <= 1); // Upper capacity constraint\\nassert(__count_32_125 >= 1); // Lower capacity constraint\\nassert(__count_32_125 <= 1); // Upper capacity constraint\\nassert(__count_34_125 >= 1); // Lower capacity constraint\\nassert(__count_34_125 <= 1); // Upper capacity constraint\\nassert(__count_35_125 >= 1); // Lower capacity constraint\\nassert(__count_35_125 <= 1); // Upper capacity constraint\\nassert(__count_39_125 >= 1); // Lower capacity constraint\\nassert(__count_39_125 <= 1); // Upper capacity constraint\\nassert(__count_40_125 >= 1); // Lower capacity constraint\\nassert(__count_40_125 <= 1); // Upper capacity constraint\\nassert(__count_42_125 >= 1); // Lower capacity constraint\\nassert(__count_42_125 <= 1); // Upper capacity constraint\\nassert(__count_43_125 >= 1); // Lower capacity constraint\\nassert(__count_43_125 <= 1); // Upper capacity constraint\\nassert(__count_47_125 >= 1); // Lower capacity constraint\\nassert(__count_47_125 <= 1); // Upper capacity constraint\\nassert(__count_48_125 >= 1); // Lower capacity constraint\\nassert(__count_48_125 <= 1); // Upper capacity constraint\\nassert(__count_50_125 >= 1); // Lower capacity constraint\\nassert(__count_50_125 <= 1); // Upper capacity constraint\\nassert(__count_51_125 >= 1); // Lower capacity constraint\\nassert(__count_51_125 <= 1); // Upper capacity constraint\\nassert(__count_55_125 >= 1); // Lower capacity constraint\\nassert(__count_55_125 <= 1); // Upper capacity constraint\\nassert(__count_56_125 >= 1); // Lower capacity constraint\\nassert(__count_56_125 <= 1); // Upper capacity constraint\\nassert(__count_58_125 >= 1); // Lower capacity constraint\\nassert(__count_58_125 <= 1); // Upper capacity constraint\\nassert(__count_59_125 >= 1); // Lower capacity constraint\\nassert(__count_59_125 <= 1); // Upper capacity constraint\\nassert(__count_63_125 >= 1); // Lower capacity constraint\\nassert(__count_63_125 <= 1); // Upper capacity constraint\\nassert(__count_64_125 >= 1); // Lower capacity constraint\\nassert(__count_64_125 <= 1); // Upper capacity constraint\\nassert(__count_66_125 >= 1); // Lower capacity constraint\\nassert(__count_66_125 <= 1); // Upper capacity constraint\\nassert(__count_67_125 >= 1); // Lower capacity constraint\\nassert(__count_67_125 <= 1); // Upper capacity constraint\\nassert(__count_71_125 >= 1); // Lower capacity constraint\\nassert(__count_71_125 <= 1); // Upper capacity constraint\\nassert(__count_72_125 >= 1); // Lower capacity constraint\\nassert(__count_72_125 <= 1); // Upper capacity constraint\\nassert(__count_74_125 >= 1); // Lower capacity constraint\\nassert(__count_74_125 <= 1); // Upper capacity constraint\\nassert(__count_75_125 >= 1); // Lower capacity constraint\\nassert(__count_75_125 <= 1); // Upper capacity constraint\\nassert(__count_79_125 >= 1); // Lower capacity constraint\\nassert(__count_79_125 <= 1); // Upper capacity constraint\\nassert(__count_80_125 >= 1); // Lower capacity constraint\\nassert(__count_80_125 <= 1); // Upper capacity constraint\\nassert(__count_82_125 >= 1); // Lower capacity constraint\\nassert(__count_82_125 <= 1); // Upper capacity constraint\\nassert(__count_83_125 >= 1); // Lower capacity constraint\\nassert(__count_83_125 <= 1); // Upper capacity constraint\\nassert(__count_87_125 >= 1); // Lower capacity constraint\\nassert(__count_87_125 <= 1); // Upper capacity constraint\\nassert(__count_88_125 >= 1); // Lower capacity constraint\\nassert(__count_88_125 <= 1); // Upper capacity constraint\\nassert(__count_90_125 >= 1); // Lower capacity constraint\\nassert(__count_90_125 <= 1); // Upper capacity constraint\\nassert(__count_91_125 >= 1); // Lower capacity constraint\\nassert(__count_91_125 <= 1); // Upper capacity constraint\\nassert(__count_95_125 >= 1); // Lower capacity constraint\\nassert(__count_95_125 <= 1); // Upper capacity constraint\\nassert(__count_96_125 >= 1); // Lower capacity constraint\\nassert(__count_96_125 <= 1); // Upper capacity constraint\\nassert(__count_98_125 >= 1); // Lower capacity constraint\\nassert(__count_98_125 <= 1); // Upper capacity constraint\\nassert(__count_99_125 >= 1); // Lower capacity constraint\\nassert(__count_99_125 <= 1); // Upper capacity constraint\\nassert(__count_103_125 >= 1); // Lower capacity constraint\\nassert(__count_103_125 <= 1); // Upper capacity constraint\\nassert(__count_104_125 >= 1); // Lower capacity constraint\\nassert(__count_104_125 <= 1); // Upper capacity constraint\\nassert(__count_106_125 >= 1); // Lower capacity constraint\\nassert(__count_106_125 <= 1); // Upper capacity constraint\\nassert(__count_107_125 >= 1); // Lower capacity constraint\\nassert(__count_107_125 <= 1); // Upper capacity constraint\\nassert(__count_111_125 >= 1); // Lower capacity constraint\\nassert(__count_111_125 <= 1); // Upper capacity constraint\\nassert(__count_112_125 >= 1); // Lower capacity constraint\\nassert(__count_112_125 <= 1); // Upper capacity constraint\\nassert(__count_114_125 >= 1); // Lower capacity constraint\\nassert(__count_114_125 <= 1); // Upper capacity constraint\\nassert(__count_115_125 >= 1); // Lower capacity constraint\\nassert(__count_115_125 <= 1); // Upper capacity constraint\\nassert(__count_119_125 >= 1); // Lower capacity constraint\\nassert(__count_119_125 <= 1); // Upper capacity constraint\\nassert(__count_120_125 >= 1); // Lower capacity constraint\\nassert(__count_120_125 <= 1); // Upper capacity constraint\\nassert(__count_122_125 >= 1); // Lower capacity constraint\\nassert(__count_122_125 <= 1); // Upper capacity constraint\\nassert(__count_123_125 >= 1); // Lower capacity constraint\\nassert(__count_123_125 <= 1); // Upper capacity constraint\\nassert(__count_124_125 == 0); // Dead code\\nassert(__count_126_127 >= 1); // Lower capacity constraint\\nassert(__count_126_127 <= 1); // Upper capacity constraint\\n #endif\\n \\n return c;\\n} \\n\\nint \\nswi50 (int c)\\n{\\n#ifdef CBMC\\n//==========> swi50 : header 193\\nint __count_129_191 = 0;\\nint __count_130_131 = 0;\\nint __count_130_136 = 0;\\nint __count_130_137 = 0;\\nint __count_130_138 = 0;\\nint __count_130_139 = 0;\\nint __count_130_144 = 0;\\nint __count_130_145 = 0;\\nint __count_130_146 = 0;\\nint __count_130_147 = 0;\\nint __count_130_152 = 0;\\nint __count_130_153 = 0;\\nint __count_130_154 = 0;\\nint __count_130_155 = 0;\\nint __count_130_160 = 0;\\nint __count_130_161 = 0;\\nint __count_130_162 = 0;\\nint __count_130_163 = 0;\\nint __count_130_168 = 0;\\nint __count_130_169 = 0;\\nint __count_130_170 = 0;\\nint __count_130_171 = 0;\\nint __count_130_176 = 0;\\nint __count_130_177 = 0;\\nint __count_130_178 = 0;\\nint __count_130_179 = 0;\\nint __count_130_184 = 0;\\nint __count_130_185 = 0;\\nint __count_130_186 = 0;\\nint __count_130_187 = 0;\\nint __count_132_192 = 0;\\nint __count_133_192 = 0;\\nint __count_134_192 = 0;\\nint __count_135_192 = 0;\\nint __count_140_192 = 0;\\nint __count_141_192 = 0;\\nint __count_142_192 = 0;\\nint __count_143_192 = 0;\\nint __count_148_192 = 0;\\nint __count_149_192 = 0;\\nint __count_150_192 = 0;\\nint __count_151_192 = 0;\\nint __count_156_192 = 0;\\nint __count_157_192 = 0;\\nint __count_158_192 = 0;\\nint __count_159_192 = 0;\\nint __count_164_192 = 0;\\nint __count_165_192 = 0;\\nint __count_166_192 = 0;\\nint __count_167_192 = 0;\\nint __count_172_192 = 0;\\nint __count_173_192 = 0;\\nint __count_174_192 = 0;\\nint __count_175_192 = 0;\\nint __count_180_192 = 0;\\nint __count_181_192 = 0;\\nint __count_182_192 = 0;\\nint __count_183_192 = 0;\\nint __count_188_192 = 0;\\nint __count_189_192 = 0;\\nint __count_190_192 = 0;\\nint __count_193_129 = 0; //Loop counter\\n//==========> swi50 : header 128\\nint __count_194 = 0;\\nint __count_193_194 = 0;\\n#endif\\n\\n int i;\\n\\n for (i = 0; i < 50; i++)\\n {\\n #ifdef CBMC\\n __count_193_129++;\\n #endif \\n switch (i)\\n {\\n case 0:\\n #ifdef CBMC\\n __count_130_131++;\\n #endif\\n c++;\\n break;\\n case 1:\\n #ifdef CBMC\\n __count_132_192++;\\n #endif\\n c++;\\n break;\\n case 2:\\n #ifdef CBMC\\n __count_133_192++;\\n #endif\\n c++;\\n break;\\n case 3:\\n #ifdef CBMC\\n __count_134_192++;\\n #endif\\n c++;\\n break;\\n case 4:\\n #ifdef CBMC\\n __count_135_192++;\\n #endif\\n c++;\\n break;\\n case 5:\\n #ifdef CBMC\\n __count_130_136++;\\n #endif\\n c++;\\n break;\\n case 6:\\n #ifdef CBMC\\n __count_130_137++;\\n #endif\\n c++;\\n break;\\n case 7:\\n #ifdef CBMC\\n __count_130_138++;\\n #endif\\n c++;\\n break;\\n case 8:\\n #ifdef CBMC\\n __count_130_139++;\\n #endif\\n c++;\\n break;\\n case 9:\\n #ifdef CBMC\\n __count_140_192++;\\n #endif\\n c++;\\n break;\\n case 10:\\n #ifdef CBMC\\n __count_141_192++;\\n #endif\\n c++;\\n break;\\n case 11:\\n #ifdef CBMC\\n __count_142_192++;\\n #endif\\n c++;\\n break;\\n case 12:\\n #ifdef CBMC\\n __count_143_192++;\\n #endif\\n c++;\\n break;\\n case 13:\\n #ifdef CBMC\\n __count_130_144++;\\n #endif\\n c++;\\n break;\\n case 14:\\n #ifdef CBMC\\n __count_130_145++;\\n #endif\\n c++;\\n break;\\n case 15:\\n #ifdef CBMC\\n __count_130_146++;\\n #endif\\n c++;\\n break;\\n case 16:\\n #ifdef CBMC\\n __count_130_147++;\\n #endif\\n c++;\\n break;\\n case 17:\\n #ifdef CBMC\\n __count_148_192++;\\n #endif\\n c++;\\n break;\\n case 18:\\n #ifdef CBMC\\n __count_149_192++;\\n #endif\\n c++;\\n break;\\n case 19:\\n #ifdef CBMC\\n __count_150_192++;\\n #endif\\n c++;\\n break;\\n case 20:\\n #ifdef CBMC\\n __count_151_192++;\\n #endif\\n c++;\\n break;\\n case 21:\\n #ifdef CBMC\\n __count_130_152++;\\n #endif\\n c++;\\n break;\\n case 22:\\n #ifdef CBMC\\n __count_130_153++;\\n #endif\\n c++;\\n break;\\n case 23:\\n #ifdef CBMC\\n __count_130_154++;\\n #endif\\n c++;\\n break;\\n case 24:\\n #ifdef CBMC\\n __count_130_155++;\\n #endif\\n c++;\\n break;\\n case 25:\\n #ifdef CBMC\\n __count_156_192++;\\n #endif\\n c++;\\n break;\\n case 26:\\n #ifdef CBMC\\n __count_157_192++;\\n #endif\\n c++;\\n break;\\n case 27:\\n #ifdef CBMC\\n __count_158_192++;\\n #endif\\n c++;\\n break;\\n case 28:\\n #ifdef CBMC\\n __count_159_192++;\\n #endif\\n c++;\\n break;\\n case 29:\\n #ifdef CBMC\\n __count_130_160++;\\n #endif\\n c++;\\n break;\\n case 30:\\n #ifdef CBMC\\n __count_130_161++;\\n #endif\\n c++;\\n break;\\n case 31:\\n #ifdef CBMC\\n __count_130_162++;\\n #endif\\n c++;\\n break;\\n case 32:\\n #ifdef CBMC\\n __count_130_163++;\\n #endif\\n c++;\\n break;\\n case 33:\\n #ifdef CBMC\\n __count_164_192++;\\n #endif\\n c++;\\n break;\\n case 34:\\n #ifdef CBMC\\n __count_165_192++;\\n #endif\\n c++;\\n break;\\n case 35:\\n #ifdef CBMC\\n __count_166_192++;\\n #endif\\n c++;\\n break;\\n case 36:\\n #ifdef CBMC\\n __count_167_192++;\\n #endif\\n c++;\\n break;\\n case 37:\\n #ifdef CBMC\\n __count_130_168++;\\n #endif\\n c++;\\n break;\\n case 38:\\n #ifdef CBMC\\n __count_130_169++;\\n #endif\\n c++;\\n break;\\n case 39:\\n #ifdef CBMC\\n __count_130_170++;\\n #endif\\n c++;\\n break;\\n case 40:\\n #ifdef CBMC\\n __count_130_171++;\\n #endif\\n c++;\\n break;\\n case 41:\\n #ifdef CBMC\\n __count_172_192++;\\n #endif\\n c++;\\n break;\\n case 42:\\n #ifdef CBMC\\n __count_173_192++;\\n #endif\\n c++;\\n break;\\n case 43:\\n #ifdef CBMC\\n __count_174_192++;\\n #endif\\n c++;\\n break;\\n case 44:\\n #ifdef CBMC\\n __count_175_192++;\\n #endif\\n c++;\\n break;\\n case 45:\\n #ifdef CBMC\\n __count_130_176++;\\n #endif\\n c++;\\n break;\\n case 46:\\n #ifdef CBMC\\n __count_130_177++;\\n #endif\\n c++;\\n break;\\n case 47:\\n #ifdef CBMC\\n __count_130_178++;\\n #endif\\n c++;\\n break;\\n case 48:\\n #ifdef CBMC\\n __count_130_179++;\\n #endif\\n c++;\\n break;\\n case 49:\\n #ifdef CBMC\\n __count_180_192++;\\n #endif\\n c++;\\n break;\\n case 50:\\n #ifdef CBMC\\n __count_181_192++;\\n #endif\\n c++;\\n break;\\n case 51:\\n #ifdef CBMC\\n __count_182_192++;\\n #endif\\n c++;\\n break;\\n case 52:\\n #ifdef CBMC\\n __count_183_192++;\\n #endif\\n c++;\\n break;\\n case 53:\\n #ifdef CBMC\\n __count_130_184++;\\n #endif\\n c++;\\n break;\\n case 54:\\n #ifdef CBMC\\n __count_130_185++;\\n #endif\\n c++;\\n break;\\n case 55:\\n #ifdef CBMC\\n __count_130_186++;\\n #endif\\n c++;\\n break;\\n case 56:\\n #ifdef CBMC\\n __count_130_187++;\\n #endif\\n c++;\\n break;\\n case 57:\\n #ifdef CBMC\\n __count_188_192++;\\n #endif\\n c++;\\n break;\\n case 58:\\n #ifdef CBMC\\n __count_189_192++;\\n #endif\\n c++;\\n break;\\n case 59:\\n #ifdef CBMC\\n __count_190_192++;\\n #endif\\n c++;\\n break;\\n default:\\n #ifdef CBMC\\n __count_129_191++;\\n #endif\\n c--;\\n break;\\n }\\n }\\n \\n #ifdef CBMC\\n __count_193_194++;\\n __count_194++;\\n #endif\\n \\n#ifdef CBMC\\nassert(__count_193_129 <= 51); // Loop counter property\\nassert(__count_129_191 == 0); // Dead code\\nassert(__count_130_131 >= 1); // Lower capacity constraint\\nassert(__count_130_131 <= 1); // Upper capacity constraint\\nassert(__count_130_136 >= 1); // Lower capacity constraint\\nassert(__count_130_136 <= 1); // Upper capacity constraint\\nassert(__count_130_137 >= 1); // Lower capacity constraint\\nassert(__count_130_137 <= 1); // Upper capacity constraint\\nassert(__count_130_138 >= 1); // Lower capacity constraint\\nassert(__count_130_138 <= 1); // Upper capacity constraint\\nassert(__count_130_139 >= 1); // Lower capacity constraint\\nassert(__count_130_139 <= 1); // Upper capacity constraint\\nassert(__count_133_192 >= 1); // Lower capacity constraint\\nassert(__count_133_192 <= 1); // Upper capacity constraint\\nassert(__count_130_144 >= 1); // Lower capacity constraint\\nassert(__count_130_144 <= 1); // Upper capacity constraint\\nassert(__count_130_145 >= 1); // Lower capacity constraint\\nassert(__count_130_145 <= 1); // Upper capacity constraint\\nassert(__count_130_146 >= 1); // Lower capacity constraint\\nassert(__count_130_146 <= 1); // Upper capacity constraint\\nassert(__count_130_147 >= 1); // Lower capacity constraint\\nassert(__count_130_147 <= 1); // Upper capacity constraint\\nassert(__count_130_152 >= 1); // Lower capacity constraint\\nassert(__count_130_152 <= 1); // Upper capacity constraint\\nassert(__count_130_153 >= 1); // Lower capacity constraint\\nassert(__count_130_153 <= 1); // Upper capacity constraint\\nassert(__count_130_154 >= 1); // Lower capacity constraint\\nassert(__count_130_154 <= 1); // Upper capacity constraint\\nassert(__count_130_155 >= 1); // Lower capacity constraint\\nassert(__count_130_155 <= 1); // Upper capacity constraint\\nassert(__count_130_160 >= 1); // Lower capacity constraint\\nassert(__count_130_160 <= 1); // Upper capacity constraint\\nassert(__count_130_161 >= 1); // Lower capacity constraint\\nassert(__count_130_161 <= 1); // Upper capacity constraint\\nassert(__count_130_162 >= 1); // Lower capacity constraint\\nassert(__count_130_162 <= 1); // Upper capacity constraint\\nassert(__count_130_163 >= 1); // Lower capacity constraint\\nassert(__count_130_163 <= 1); // Upper capacity constraint\\nassert(__count_130_168 >= 1); // Lower capacity constraint\\nassert(__count_130_168 <= 1); // Upper capacity constraint\\nassert(__count_130_169 >= 1); // Lower capacity constraint\\nassert(__count_130_169 <= 1); // Upper capacity constraint\\nassert(__count_130_170 >= 1); // Lower capacity constraint\\nassert(__count_130_170 <= 1); // Upper capacity constraint\\nassert(__count_130_171 >= 1); // Lower capacity constraint\\nassert(__count_130_171 <= 1); // Upper capacity constraint\\nassert(__count_130_176 >= 1); // Lower capacity constraint\\nassert(__count_130_176 <= 1); // Upper capacity constraint\\nassert(__count_130_177 >= 1); // Lower capacity constraint\\nassert(__count_130_177 <= 1); // Upper capacity constraint\\nassert(__count_130_178 >= 1); // Lower capacity constraint\\nassert(__count_130_178 <= 1); // Upper capacity constraint\\nassert(__count_130_179 >= 1); // Lower capacity constraint\\nassert(__count_130_179 <= 1); // Upper capacity constraint\\nassert(__count_130_184 == 0); // Dead code\\nassert(__count_130_185 == 0); // Dead code\\nassert(__count_130_186 == 0); // Dead code\\nassert(__count_130_187 == 0); // Dead code\\nassert(__count_132_192 >= 1); // Lower capacity constraint\\nassert(__count_132_192 <= 1); // Upper capacity constraint\\nassert(__count_194 >= 1); // Lower capacity constraint\\nassert(__count_194 <= 1); // Upper capacity constraint\\nassert(__count_134_192 >= 1); // Lower capacity constraint\\nassert(__count_134_192 <= 1); // Upper capacity constraint\\nassert(__count_135_192 >= 1); // Lower capacity constraint\\nassert(__count_135_192 <= 1); // Upper capacity constraint\\nassert(__count_140_192 >= 1); // Lower capacity constraint\\nassert(__count_140_192 <= 1); // Upper capacity constraint\\nassert(__count_141_192 >= 1); // Lower capacity constraint\\nassert(__count_141_192 <= 1); // Upper capacity constraint\\nassert(__count_142_192 >= 1); // Lower capacity constraint\\nassert(__count_142_192 <= 1); // Upper capacity constraint\\nassert(__count_143_192 >= 1); // Lower capacity constraint\\nassert(__count_143_192 <= 1); // Upper capacity constraint\\nassert(__count_148_192 >= 1); // Lower capacity constraint\\nassert(__count_148_192 <= 1); // Upper capacity constraint\\nassert(__count_149_192 >= 1); // Lower capacity constraint\\nassert(__count_149_192 <= 1); // Upper capacity constraint\\nassert(__count_150_192 >= 1); // Lower capacity constraint\\nassert(__count_150_192 <= 1); // Upper capacity constraint\\nassert(__count_151_192 >= 1); // Lower capacity constraint\\nassert(__count_151_192 <= 1); // Upper capacity constraint\\nassert(__count_156_192 >= 1); // Lower capacity constraint\\nassert(__count_156_192 <= 1); // Upper capacity constraint\\nassert(__count_157_192 >= 1); // Lower capacity constraint\\nassert(__count_157_192 <= 1); // Upper capacity constraint\\nassert(__count_158_192 >= 1); // Lower capacity constraint\\nassert(__count_158_192 <= 1); // Upper capacity constraint\\nassert(__count_159_192 >= 1); // Lower capacity constraint\\nassert(__count_159_192 <= 1); // Upper capacity constraint\\nassert(__count_164_192 >= 1); // Lower capacity constraint\\nassert(__count_164_192 <= 1); // Upper capacity constraint\\nassert(__count_165_192 >= 1); // Lower capacity constraint\\nassert(__count_165_192 <= 1); // Upper capacity constraint\\nassert(__count_166_192 >= 1); // Lower capacity constraint\\nassert(__count_166_192 <= 1); // Upper capacity constraint\\nassert(__count_167_192 >= 1); // Lower capacity constraint\\nassert(__count_167_192 <= 1); // Upper capacity constraint\\nassert(__count_172_192 >= 1); // Lower capacity constraint\\nassert(__count_172_192 <= 1); // Upper capacity constraint\\nassert(__count_173_192 >= 1); // Lower capacity constraint\\nassert(__count_173_192 <= 1); // Upper capacity constraint\\nassert(__count_174_192 >= 1); // Lower capacity constraint\\nassert(__count_174_192 <= 1); // Upper capacity constraint\\nassert(__count_175_192 >= 1); // Lower capacity constraint\\nassert(__count_175_192 <= 1); // Upper capacity constraint\\nassert(__count_180_192 >= 1); // Lower capacity constraint\\nassert(__count_180_192 <= 1); // Upper capacity constraint\\nassert(__count_181_192 == 0); // Dead code\\nassert(__count_182_192 == 0); // Dead code\\nassert(__count_183_192 == 0); // Dead code\\nassert(__count_188_192 == 0); // Dead code\\nassert(__count_189_192 == 0); // Dead code\\nassert(__count_190_192 == 0); // Dead code\\nassert(__count_193_194 >= 1); // Lower capacity constraint\\nassert(__count_193_194 <= 1); // Upper capacity constraint\\n#endif\\n \\n return c;\\n} \\n\\nint \\nswi10 (int c)\\n{\\n#ifdef CBMC\\n//==========> swi10 : header 214\\nint __count_200_212 = 0;\\nint __count_201_202 = 0;\\nint __count_201_203 = 0;\\nint __count_201_204 = 0;\\nint __count_201_207 = 0;\\nint __count_201_208 = 0;\\nint __count_201_209 = 0;\\nint __count_201_210 = 0;\\nint __count_201_211 = 0;\\nint __count_205_213 = 0;\\nint __count_206_213 = 0;\\nint __count_214_200 = 0; //Loop counter\\n//==========> swi10 : header 199\\nint __count_215 = 0;\\nint __count_214_215 = 0;\\n#endif\\n\\n int i;\\n \\n for (i = 0; i < 10; i++)\\n {\\n #ifdef CBMC\\n __count_214_200++;\\n #endif\\n switch (i)\\n {\\n case 0:\\n #ifdef CBMC\\n __count_201_202++;\\n #endif\\n c++;\\n break;\\n case 1:\\n #ifdef CBMC\\n __count_201_203++;\\n #endif\\n c++;\\n break;\\n case 2:\\n #ifdef CBMC\\n __count_201_204++;\\n #endif\\n c++;\\n break;\\n case 3:\\n #ifdef CBMC\\n __count_205_213++;\\n #endif\\n c++;\\n break;\\n case 4:\\n #ifdef CBMC\\n __count_206_213++;\\n #endif\\n c++;\\n break;\\n case 5:\\n #ifdef CBMC\\n __count_201_207++;\\n #endif\\n c++;\\n break;\\n case 6:\\n #ifdef CBMC\\n __count_201_208++;\\n #endif\\n c++;\\n break;\\n case 7:\\n #ifdef CBMC\\n __count_201_209++;\\n #endif\\n c++;\\n break;\\n case 8:\\n #ifdef CBMC\\n __count_201_210++;\\n #endif\\n c++;\\n break;\\n case 9:\\n #ifdef CBMC\\n __count_201_211++;\\n #endif\\n c++;\\n break;\\n default:\\n #ifdef CBMC\\n __count_200_212++; \\n #endif\\n c--;\\n break;\\n }\\n }\\n \\n #ifdef CBMC\\n __count_214_215++;\\n __count_215++;\\n #endif\\n \\n#ifdef CBMC\\nassert(__count_214_200 <= 11); // Loop counter property\\nassert(__count_200_212 == 0); // Dead code\\nassert(__count_201_202 >= 1); // Lower capacity constraint\\nassert(__count_201_202 <= 1); // Upper capacity constraint\\nassert(__count_201_203 >= 1); // Lower capacity constraint\\nassert(__count_201_203 <= 1); // Upper capacity constraint\\nassert(__count_201_204 >= 1); // Lower capacity constraint\\nassert(__count_201_204 <= 1); // Upper capacity constraint\\nassert(__count_201_207 >= 1); // Lower capacity constraint\\nassert(__count_201_207 <= 1); // Upper capacity constraint\\nassert(__count_201_208 >= 1); // Lower capacity constraint\\nassert(__count_201_208 <= 1); // Upper capacity constraint\\nassert(__count_201_209 >= 1); // Lower capacity constraint\\nassert(__count_201_209 <= 1); // Upper capacity constraint\\nassert(__count_201_210 >= 1); // Lower capacity constraint\\nassert(__count_201_210 <= 1); // Upper capacity constraint\\nassert(__count_201_211 >= 1); // Lower capacity constraint\\nassert(__count_201_211 <= 1); // Upper capacity constraint\\nassert(__count_205_213 >= 1); // Lower capacity constraint\\nassert(__count_205_213 <= 1); // Upper capacity constraint\\nassert(__count_206_213 >= 1); // Lower capacity constraint\\nassert(__count_206_213 <= 1); // Upper capacity constraint\\nassert(__count_215 >= 1); // Lower capacity constraint\\nassert(__count_215 <= 1); // Upper capacity constraint\\nassert(__count_214_215 >= 1); // Lower capacity constraint\\nassert(__count_214_215 <= 1); // Upper capacity constraint\\n#endif\\n \\n return c;\\n}\\n\\nint\\ncover (int c)\\n{\\n c = swi10(c);\\n c = swi50(c);\\n c = swi120(c);\\n\\n return c;\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n volatile int cnt;\\n\\n /*\\n * One integer value must be supplied\\n */\\n if (argc != 2)\\n {\\n return 1;\\n }\\n\\n cnt = atoi (argv[1]);\\n int val = cover(cnt);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.6822262406349182,\n \"alphanum_fraction\": 0.6858168840408325,\n \"avg_line_length\": 38.78571319580078,\n \"blob_id\": \"b8585c0398f0cd61e6ca741ffbd2c590f171de51\",\n \"content_id\": \"e29bb82b0aaf006613cf94e182be0b04c5504aec\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 557,\n \"license_type\": \"no_license\",\n \"max_line_length\": 68,\n \"num_lines\": 14,\n \"path\": \"/DaikonPathInformation/src/utils.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import itertools\\n\\ndef enum(*sequential, **named):\\n enums = dict(zip(sequential, range(len(sequential))), **named)\\n reverse = dict((value, key) for key, value in enums.iteritems())\\n forward = dict((key, value) for key, value in enums.iteritems())\\n enums['reverse_mapping'] = reverse\\n enums['forward_mapping'] = forward\\n return type('Enum', (), enums)\\n\\ndef peekahead_iterator(iterable, window=1):\\n items, nexts = itertools.tee(iterable, 2)\\n nexts = itertools.islice(nexts, window, None)\\n return itertools.izip_longest(items, nexts)\\n\"\n },\n {\n \"alpha_fraction\": 0.4651339054107666,\n \"alphanum_fraction\": 0.49595755338668823,\n \"avg_line_length\": 16.748878479003906,\n \"blob_id\": \"23eb84375a7347d4ed47fce98989381b3d402d7d\",\n \"content_id\": \"0814ce9d76d41f2c7e03333d8bfb5a038d41b65a\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 3958,\n \"license_type\": \"no_license\",\n \"max_line_length\": 100,\n \"num_lines\": 223,\n \"path\": \"/benchmarks/quantileEstimation/quantileEstimation.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Takes an input vector of doubles and calculates an estimate of the 0.5 quantile (i.e. the median)\\n * \\n * The algorithm is an adapted version of the 'Single-Pass Estimation of Arbitrary Quantiles'\\n * algorithm found on pages 435-438 in the book \\\"Numerical Recipes The Art Of Scientific Computing\\\"\\n * Third Edition by William H. Press et al\\n */\\n\\n#define nbuf 1000\\n#define nq 251\\n\\nint nt = 0;\\nint nd = 0;\\n\\ndouble pval[nq];\\ndouble dbuf[nbuf];\\ndouble qile[nq];\\n\\ndouble q0 = 1.0e99;\\ndouble qm = -1.0e99;\\n\\ndouble minDoub(double a, double b) {\\n\\tif(a < b) {return a;}\\n\\telse {return b;}\\n}\\n\\ndouble maxDoub(double a, double b) {\\n\\tif(a > b) {return a;}\\n\\telse {return b;}\\n}\\n\\nint merge (int ARRAY_SIZE, double a[], double b[], int l, int r, int u)\\n{\\n int i = l;\\n int j = r;\\n int k = l;\\n\\n while (i < r && j < u)\\n {\\n if (a[i] <= a[j])\\n {\\n b[k] = a[i];\\n i++;\\n }\\n else\\n {\\n b[k] = a[j];\\n j++;\\n }\\n k++;\\n }\\n while (i < r)\\n {\\n b[k] = a[i];\\n i++;\\n k++;\\n }\\n while (j < u)\\n {\\n b[k] = a[j];\\n j++;\\n k++;\\n }\\n for (k = l; k < u; k++)\\n {\\n a[k] = b[k];\\n }\\n}\\n\\nvoid mergesort (int ARRAY_SIZE, double a[])\\n{\\n int k = 1;\\n int u;\\n int i;\\n double b[ARRAY_SIZE];\\n\\n while (k < ARRAY_SIZE)\\n {\\n i = 1;\\n while (i + k <= ARRAY_SIZE)\\n {\\n u = i + k * 2;\\n if (u > ARRAY_SIZE)\\n {\\n u = ARRAY_SIZE + 1;\\n }\\n merge (ARRAY_SIZE, a, b, i, i + k, u);\\n i = i + k * 2;\\n }\\n k = k * 2;\\n }\\n}\\n\\nvoid initialise() {\\n\\tint i;\\n\\tfor (i = 0; i < nq; i++) {\\n\\t\\tqile[i] = 0.0;\\n\\t}\\n\\n\\tfor (i = 85; i <= 165; i++) {\\n\\t\\tpval[i] = (i - 75.0) / 100.0;\\n\\t}\\n\\n\\tfor (i = 84; i >= 0; i--) {\\n\\t\\tpval[i] = 0.87191909 * pval[i+1];\\n\\t\\tpval[250 - i] = 1.0 - pval[i];\\n\\t}\\n}\\n\\nvoid update() {\\n\\tint jd = 0, jq = 0, iq;\\n\\tdouble target, told = 0.0, tnew = 0.0;\\n\\tdouble qold, qnew;\\n\\tdouble newqile[nq];\\n\\t\\n\\tmergesort(nd, dbuf);\\n\\tqold = qnew = qile[0] = newqile[0] = q0;\\n\\tqile[nq-1] = newqile[nq-1] = qm;\\n\\n\\tpval[0] = minDoub(0.5 / (nt + nd), 0.5 * pval[1]);\\n\\tpval[nq-1] = maxDoub(1.0 - 0.5 / (nt + nd), 0.5 * (1.0 + pval[nq - 2]));\\n\\n\\tfor(iq = 1; iq < nq - 1; iq++) {\\n\\t\\ttarget = (nt + nd) * pval[iq];\\n\\t\\tif (tnew < target) {\\n\\t\\t\\tfor (;;) {\\n\\t\\t\\t\\tif (jq < nq && (jd >= nd || qile[jq] < dbuf[jd])) {\\n\\t\\t\\t\\t\\tqnew = qile[jq];\\n\\t\\t\\t\\t\\ttnew = jd + nt * pval[jq++];\\n\\t\\t\\t\\t\\tif (tnew >= target) break;\\n\\t\\t\\t\\t} else {\\n\\t\\t\\t\\t\\tqnew = dbuf[jd];\\n\\t\\t\\t\\t\\ttnew = told;\\n\\t\\t\\t\\t\\tif (qile[jq] > qile[jq-1]) {\\n\\t\\t\\t\\t\\t\\ttnew += nt * (pval[jq] - pval[jq-1]) * (qnew - qold) / (qile[jq] - qile[jq-1]);\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tjd++;\\n\\t\\t\\t\\t\\tif (tnew >= target) break;\\n\\t\\t\\t\\t\\ttold = tnew++;\\n\\t\\t\\t\\t\\tqold = qnew;\\n\\t\\t\\t\\t\\tif (tnew >= target) break;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\ttold = tnew;\\n\\t\\t\\t\\tqold = qnew;\\n\\t\\t\\t}\\t\\t\\t\\n\\t\\t}\\n\\t\\tif (tnew == told) {\\n\\t\\t\\tnewqile[iq] = 0.5 * (qold + qnew);\\n\\t\\t} else {\\n\\t\\t\\tnewqile[iq] = qold + (qnew - qold) * (target - told) / (tnew - told);\\n\\t\\t}\\n\\t\\ttold = tnew;\\n\\t\\tqold = qnew;\\n\\t}\\n\\tint i;\\n\\tfor(i = 0; i < nq; i++) {\\n\\t\\tqile[i] = newqile[i];\\n\\t}\\n\\tnt += nd;\\n\\tnd = 0;\\n}\\n\\ndouble report(double p) {\\n\\tdouble q;\\n\\tif (nd > 0) update();\\n\\n\\tint jl = 0;\\n\\tint jh = nq - 1;\\n\\tint j;\\n\\n\\twhile (jh - jl > 1) {\\n\\t\\tj = (jh + jl) >> 1;\\n\\t\\tif (p > pval[j]) {jl = j;}\\n\\t\\telse {jh = j;}\\n\\t}\\n\\tj = jl;\\n\\tq = qile[j] + (qile[j+1] - qile[j]) * (p - pval[j]) / (pval[j+1] - pval[j]);\\n\\treturn maxDoub(qile[0], minDoub(qile[nq-1], q));\\n}\\n\\nvoid add(double datum) {\\n\\tdbuf[nd++] = datum;\\n\\tif (datum < q0) {q0 = datum;}\\n\\tif (datum > qm) {qm = datum;}\\n\\tif (nd == nbuf) update();\\n}\\n\\ndouble quantileEstimation(double a[], int ARRAY_SIZE, double quantile) {\\n\\tint i;\\t\\n\\n\\tinitialise();\\n\\tfor (i = 0; i < ARRAY_SIZE; i++) {\\n\\t\\tadd(a[i]);\\n\\t}\\n\\n\\treturn report(quantile);\\n}\\n\\nint main (int argc, char *argv[])\\n{\\n\\tconst int ARRAY_SIZE = argc - 1;\\n\\tdouble TV[ARRAY_SIZE];\\n\\tint i;\\n\\n\\t/*\\n\\t * At least one integer value must be supplied\\n\\t */\\n\\tif (argc == 1)\\n\\t{\\n\\t\\treturn 1;\\n\\t}\\n\\n\\tfor (i = 0; i < argc - 1; i++)\\n\\t{\\n\\t\\tTV[i] = atoi (argv[i + 1]);\\n\\t}\\n\\n\\tdouble quantileEstimate = quantileEstimation(TV, ARRAY_SIZE, 0.5);\\n\\n\\tprintf(\\\"%lf\\\\n\\\", quantileEstimate);\\n\\n\\treturn 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.5848317742347717,\n \"alphanum_fraction\": 0.5873242020606995,\n \"avg_line_length\": 34.980770111083984,\n \"blob_id\": \"6f519d2a45467079b6858780f3cf7b4bcadce4a6\",\n \"content_id\": \"3cf05d956742b12f2cedc4b926b6d93e0a63646a\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 5617,\n \"license_type\": \"no_license\",\n \"max_line_length\": 124,\n \"num_lines\": 156,\n \"path\": \"/GPUTimingAnalysis/src/Vertices.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from Edges import Edge\\nfrom DirectedGraphs import dummyVertexID\\nimport Debug\\n\\nclass Vertex ():\\n def __init__ (self, vertexID):\\n self._vertexID = vertexID\\n self._predecessors = {}\\n self._successors = {}\\n \\n def getVertexID (self):\\n return self._vertexID\\n \\n def addPredecessor (self, predID, edgeID=None):\\n assert predID not in self._predecessors, \\\"Vertex %d already has predecessor %d\\\" % (self._vertexID, predID)\\n e = Edge(predID, edgeID)\\n self._predecessors[predID] = e\\n \\n def addPredecessorEdge (self, prede):\\n predID = prede.getVertexID()\\n assert predID not in self._predecessors, \\\"Vertex %d already has predecessor %d\\\" % (self._vertexID, predID)\\n self._predecessors[predID] = prede\\n \\n def removePredecessor (self, predID):\\n assert predID in self._predecessors, \\\"Cannot remove %d as it is not in predecessor of %d\\\" % (predID, self._vertexID)\\n del self._predecessors[predID]\\n \\n def getPredecessorIDs (self):\\n return self._predecessors.keys()\\n \\n def getPredecessorEdges (self):\\n return self._predecessors.values()\\n \\n def numberOfPredecessors (self):\\n return len(self._predecessors)\\n \\n def hasPredecessor (self, predID):\\n return predID in self._predecessors.keys()\\n \\n def getPredecessorEdge (self, predID):\\n assert predID in self._predecessors, \\\"Vertex %d is not a predecessor of %d\\\" % (predID, self._vertexID)\\n return self._predecessors[predID]\\n \\n def addSuccessor (self, succID,edgeID=None):\\n assert succID not in self._successors, \\\"Vertex %d already has successor %d\\\" % (self._vertexID, succID)\\n e = Edge(succID, edgeID)\\n self._successors[succID] = e\\n \\n def addSuccessorEdge (self, succe):\\n succID = succe.getVertexID()\\n assert succID not in self._successors, \\\"Vertex %d already has successor %d\\\" % (self._vertexID, succID)\\n self._successors[succID] = succe\\n \\n def removeSuccessor (self, succID):\\n assert succID in self._successors, \\\"Cannot remove %d as it is not in _successors of %d\\\" % (succID, self._vertexID)\\n del self._successors[succID]\\n \\n def getSuccessorIDs (self):\\n return self._successors.keys()\\n \\n def getSuccessorEdges (self):\\n return self._successors.values()\\n \\n def numberOfSuccessors (self):\\n return len(self._successors)\\n \\n def hasSuccessor (self, succID):\\n return succID in self._successors.keys()\\n \\n def getSuccessorEdge (self, succID):\\n assert succID in self._successors, \\\"Vertex %d is not a successor of %d\\\" % (succID, self._vertexID)\\n return self._successors[succID]\\n \\n def predecessorStr (self):\\n string = \\\"pred = {\\\"\\n count = 1\\n for predID in sorted(self._predecessors.keys()):\\n string += str(predID)\\n if count < len(self._predecessors):\\n string += \\\",\\\"\\n count = count + 1\\n string += \\\"}\\\\n\\\"\\n return string\\n \\n def successorStr (self): \\n string = \\\"succ = {\\\"\\n count = 1\\n for succID in sorted(self._successors.keys()):\\n string += str(succID)\\n if count < len(self._successors):\\n string += \\\",\\\"\\n count = count + 1\\n string += \\\"}\\\\n\\\"\\n return string\\n \\nclass TreeVertex (Vertex):\\n def __init__ (self, vertexID):\\n Vertex.__init__(self, vertexID)\\n self.__parentID = dummyVertexID\\n self.__level = -1\\n \\n def setParentID (self, parentID):\\n self.__parentID = parentID\\n \\n def getParentID (self):\\n assert self.__parentID != dummyVertexID, \\\"Parent ID of %d has not been set\\\" % self.parentID\\n return self.__parentID\\n \\n def setLevel (self, level):\\n assert level >= 0, \\\"The level of a vertex cannot be less than 0. You gave %d\\\" % level\\n self.__level = level\\n \\n def getLevel (self):\\n return self.__level \\n \\n def __str__ (self):\\n if self.__parentID == dummyVertexID:\\n return \\\"parent(%d) = <>\\\\n\\\" % self._vertexID\\n else:\\n return \\\"parent(%d) = %d\\\\n\\\" % (self._vertexID, self.__parentID)\\n \\nclass HeaderVertex (TreeVertex):\\n def __init__ (self, vertexID, headerID):\\n TreeVertex.__init__(self, vertexID)\\n self.headerID = headerID\\n \\n def getHeaderID (self):\\n return self.headerID\\n \\n def __str__ (self):\\n return TreeVertex.__str__(self)[:-1] + \\\" (\\\" + \\\"*\\\" * 3 + \\\" HEADER \\\" + \\\"*\\\" * 3 + \\\")\\\\n\\\" \\n \\nclass Ipoint (Vertex):\\n def __init__ (self, vertexID, IpointID):\\n Vertex.__init__(self, vertexID)\\n self.__IpointID = IpointID\\n self.__succIpointIDToVertexID = {}\\n \\n def getIpointID (self):\\n return self.__IpointID\\n \\n def addIpointSuccessor (self, succIpointID, succID):\\n self.__succIpointIDToVertexID[succIpointID] = succID\\n \\n def getIpointSuccessor (self, succIpointID):\\n if succIpointID not in self.__succIpointIDToVertexID:\\n Debug.debugMessage(\\\"Unable to find successor of %s with Ipoint ID 0x%04X\\\" % (self._vertexID, succIpointID), 1)\\n return None\\n return self.__succIpointIDToVertexID[succIpointID]\\n \\n def __str__ (self):\\n string = \\\"Vertex ID = \\\" + str(self._vertexID) + \\\"\\\\n\\\"\\n string += \\\"\\\\tIpoint ID = \\\" + str(self.__IpointID) + \\\"\\\\n\\\"\\n string += \\\"\\\\t\\\" + Vertex.predecessorStr(self)\\n string += \\\"\\\\t\\\" + Vertex.successorStr(self) \\n return string\\n \"\n },\n {\n \"alpha_fraction\": 0.601837694644928,\n \"alphanum_fraction\": 0.603675365447998,\n \"avg_line_length\": 39.8125,\n \"blob_id\": \"8bca9b99d754c951a0b39de48ee521ade1682985\",\n \"content_id\": \"edaed0bf9767a65e4a6a01d7c947e649bd96e787\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 3265,\n \"license_type\": \"no_license\",\n \"max_line_length\": 165,\n \"num_lines\": 80,\n \"path\": \"/DaikonPathInformation/src/tool_super_blocks.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#!/usr/bin/env python\\n\\nfrom __future__ import print_function\\n\\nimport program_input_output\\nimport debug\\nimport traces\\nimport calculations\\nimport config\\nimport argparse\\nimport os\\n\\ndef count_program_points(program):\\n superg_program_points = 0\\n cfg_program_points = 0\\n for cfg in program.cfgs.values():\\n pathg = cfg.get_super_block_cfg()\\n superg_program_points += len(pathg.getMonitoredProgramPoints())\\n cfg_program_points += min(cfg.number_of_vertices(), cfg.number_of_edges())\\n print(config.Arguments.program, \\\"[Super block program points = %d\\\" % superg_program_points, \\\"CFG program points = %d]\\\" % cfg_program_points)\\n return program\\n\\ndef the_command_line():\\n parser = argparse.ArgumentParser(description=\\\"Compute super block cfgs\\\")\\n \\n parser.add_argument(\\\"program_file\\\",\\n help=\\\"a file containing program information (with '.txt' extension)\\\")\\n \\n parser.add_argument(\\\"-d\\\",\\n \\\"--debug\\\",\\n type=int,\\n help=\\\"debug mode\\\",\\n default=0)\\n \\n parser.add_argument(\\\"-u\\\",\\n \\\"--udraw\\\",\\n action=\\\"store_true\\\",\\n help=\\\"generate uDrawGraph files\\\",\\n default=False)\\n\\n parser.add_argument(\\\"--generate-traces\\\",\\n type=int,\\n help=\\\"generate traces for the given program\\\",\\n default=0,\\n metavar=\\\"\\\")\\n \\n parser.add_argument(\\\"--parse-trace\\\",\\n help=\\\"parse this trace file\\\",\\n metavar=\\\"\\\")\\n \\n parser.add_argument(\\\"-v\\\",\\n \\\"--verbose\\\",\\n action=\\\"store_true\\\",\\n help=\\\"be verbose\\\",\\n default=False)\\n \\n parser.parse_args(namespace=config.Arguments)\\n \\n config.Arguments.basename = os.path.splitext(os.path.basename(config.Arguments.program_file))[0]\\n config.Arguments.basepath = os.path.abspath(os.path.dirname(config.Arguments.program_file))\\n \\n config.Arguments.program_file = os.path.abspath(config.Arguments.program_file)\\n if not config.Arguments.program_file.endswith(\\\".txt\\\"):\\n debug.exit_message(\\\"Please pass a program file with a '%s' suffix\\\" % \\\".txt\\\")\\n \\n if config.Arguments.parse_trace is not None:\\n config.Arguments.parse_trace = os.path.abspath(config.Arguments.parse_trace)\\n assert os.path.exists(config.Arguments.parse_trace), \\\"Trace file '%s' does not exist\\\" % config.Arguments.parse_trace\\n assert os.path.getmtime(config.Arguments.program_file) <= os.path.getmtime(config.Arguments.parse_trace), \\\"Program file modified AFTER trace file generation\\\"\\n \\nif __name__ == \\\"__main__\\\":\\n the_command_line()\\n program = program_input_output.read_file(config.Arguments.program_file)\\n count_program_points(program)\\n if config.Arguments.generate_traces > 0:\\n traces.Generatetraces(program, config.Arguments.traces)\\n elif config.Arguments.parse_trace:\\n data = traces.Parsetraces(config.Arguments.tracefile, program)\\n program.output()\\n calculations.WCETCalculation(program, data)\\n\"\n },\n {\n \"alpha_fraction\": 0.5750617980957031,\n \"alphanum_fraction\": 0.5807135105133057,\n \"avg_line_length\": 45.60082244873047,\n \"blob_id\": \"7a50e742a524956e9aef59952e8a11c5b1866719\",\n \"content_id\": \"556aceaa0f2d02eb86db226b3214ef319f5092d3\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 11324,\n \"license_type\": \"no_license\",\n \"max_line_length\": 142,\n \"num_lines\": 243,\n \"path\": \"/DaikonPathInformation/src/tool_Gem5.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#!/usr/bin/env python\\n\\nimport config\\nimport debug\\nimport timing\\nimport calculations\\nimport traces\\nimport testing\\nimport arm\\nimport program_input_output\\nimport argparse\\nimport subprocess\\nimport sys\\nimport os\\nimport re\\nimport distutils.spawn\\n\\ndef do_analysis(program): \\n time1 = timing.log(\\\"TRACE PARSING RUN #1 (NO INLINING)\\\")\\n data = traces.Gem5Parser(program, config.Arguments.gem5_traces)\\n debug.verbose_message(\\\"HWMT = %d\\\" % data.getLongestTime(), __name__) \\n calculations.WCETCalculation(program, data)\\n program.output()\\n program.generateAllUDrawFiles()\\n\\n if program.getCallGraph().numOfvertices() > 1 and config.Arguments.inline:\\n program.inlineCalls()\\n time2 = timing.log(\\\"TRACE PARSING RUN #2 (INLINED PROGRAM)\\\")\\n data = traces.Gem5Parser(program, config.Arguments.gem5_traces)\\n debug.verbose_message(\\\"HWMT = %d\\\" % data.getLongestTime(), __name__)\\n calculations.WCETCalculation(program, data)\\n program.output()\\n program.generateAllUDrawFiles(\\\"inlined\\\")\\n \\ndef set_gem5_variables():\\n # Need a gem5 environment variable \\n gem5_home = \\\"GEM5_HOME\\\"\\n try:\\n config.Arguments.gem5_basepath = os.environ[gem5_home]\\n if not os.path.exists(os.path.abspath(config.Arguments.gem5_basepath)):\\n debug.exit_message(\\\"Your gem5 base directory '%s' does not exist\\\" % config.Arguments.gem5_basepath)\\n config.Arguments.gem5_simulator = config.Arguments.gem5_basepath + os.sep + \\\"build\\\" + os.sep + \\\"ARM\\\" + os.sep + \\\"gem5.opt\\\"\\n if not os.path.exists(config.Arguments.gem5_simulator):\\n debug.exit_message(\\n\\\"\\\"\\\"Unable to find '%s' in your gem5 distribution, which is the optimised arm \\nconfiguration of gem5. Ensure that you have built this version using \\n'scons arm/build/gem5.opt' in '%s'\\\"\\\"\\\" \\\\\\n% (config.Arguments.gem5_simulator, config.Arguments.gem5_basepath))\\n config.Arguments.gem5_config = config.Arguments.gem5_basepath + os.sep + \\\"configs\\\" + os.sep + \\\"example\\\" + os.sep + \\\"se.py\\\"\\n if not os.path.exists(config.Arguments.gem5_config):\\n debug.exit_message(\\\"The gem5 configuration file '%s' does not exist\\\" % config.Arguments.gem5_config)\\n except KeyError:\\n debug.exit_message (\\\"You need to set environment variable '%s' to simulate the program using gem5\\\" % gem5_home)\\n \\ndef check_trace_files():\\n files = []\\n for trace_file in config.Arguments.gem5_traces:\\n trace_file = os.path.abspath(trace_file)\\n if not re.match(r'.*%s\\\\.trace\\\\.[0-9]+' % config.Arguments.basename, trace_file):\\n debug.exitMessage(\\\"The file '%s' is not a valid gem5 trace for '%s'\\\" % (trace_file, config.Arguments.basename)) \\n if not os.path.isfile(trace_file):\\n debug.exitMessage(\\\"The argument '%s' is not a valid file\\\" % trace_file) \\n files.append(trace_file)\\n config.Arguments.gem5_traces = files\\n\\ndef disassemble_program(binary):\\n debug.verbose_message(\\\"Disassembling program\\\", __name__)\\n disassembly_filename = binary + \\\".dis\\\"\\n with open(disassembly_filename, 'w') as disassembly:\\n cmd = \\\"%s %s -d\\\" % (config.Arguments.objdump, binary)\\n proc = subprocess.Popen(cmd, \\n shell=True, \\n stdout=disassembly, \\n stderr=sys.stderr) \\n returncode = proc.wait()\\n if returncode:\\n debug.exit_message(\\\"Disassembling '%s' failed\\\" % binary) \\n return disassembly_filename\\n \\ndef compile_program(program):\\n debug.verbose_message(\\\"Compiling program\\\", __name__)\\n optimisation = \\\"\\\"\\n extraFlags = \\\"\\\"\\n if config.Arguments.flags:\\n for flag in config.Arguments.flags:\\n extraFlags += \\\"-%s \\\" % flag\\n if re.match(r'O[0-3]+', flag):\\n optimisation = flag\\n binary = program[:-2] + optimisation\\n cmd = \\\"%s -fno-stack-protector -static %s %s -o %s\\\" % (config.Arguments.GCC, extraFlags, program, binary)\\n debug.debug_message(\\\"Compiling with command '%s'\\\" % cmd, 1)\\n proc = subprocess.Popen(cmd, \\n shell=True, \\n stdout=sys.stdout, \\n stderr=sys.stderr) \\n returncode = proc.wait()\\n if returncode:\\n debug.exit_message(\\\"Compiling '%s' with '%s' failed\\\" % (program, cmd))\\n return binary\\n \\ndef get_binary_and_program():\\n file_ext = os.path.splitext(config.Arguments.program_file)[1]\\n if file_ext:\\n if file_ext == '.c':\\n if not distutils.spawn.find_executable(config.Arguments.GCC):\\n debug.exit_message(\\\"Unable to find arm GCC cross compiler '%s' on your path\\\" % config.Arguments.GCC)\\n if not distutils.spawn.find_executable(config.Arguments.objdump):\\n debug.exit_message(\\\"Unable to find arm GCC object dump facility '%s' on your path\\\" % config.Arguments.objdump)\\n if not config.Arguments.root:\\n debug.exit_message(\\\"To compile and analyse a C file, you must supply a root function via -r.\\\")\\n binary = compile_program(config.Arguments.program_file)\\n disassembly = disassemble_program(binary)\\n program = arm.Disassembler(disassembly, config.Arguments.root).program\\n program_input_output.write_disassembled_program_to_file(program, disassembly)\\n return binary, program\\n else:\\n debug.exit_message(\\\"Unable to compile '%s' because its extension is not '%s'\\\" % (config.Arguments.program_file, '.c'))\\n else:\\n binary = config.Arguments.program_file\\n config.Arguments.program_file = binary + \\\".txt\\\"\\n if not os.access(binary, os.X_OK):\\n debug.exit_message(\\\"The argument '%s' does not have execute permissions\\\" % binary)\\n if not os.path.exists(config.Arguments.program_file):\\n debug.exit_message(\\\"Expected to find file with program information in '%s' but it is not there\\\" % config.Arguments.program_file)\\n program = program_input_output.read_file(config.Arguments.program_file)\\n return binary, program\\n\\ndef the_command_line():\\n def comma_separated_list(the_list):\\n try:\\n return the_list.split(',')\\n except:\\n raise argparse.ArgumentTypeError(\\\"Invalid compiler flags\\\")\\n \\n parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter,\\n description=\\\"Run C programs on gem5 and analyse traces\\\")\\n \\n parser.add_argument(\\\"program_file\\\",\\n help=\\\"either a program to compile (with '.c.' extension) or a pre-compiled binary\\\")\\n \\n parser.add_argument(\\\"gem5_traces\\\", \\n nargs='*',\\n help=\\\"previous gem5 runs\\\")\\n \\n parser.add_argument(\\\"-C\\\",\\n \\\"--compile\\\",\\n action=\\\"store_true\\\",\\n help=\\\"only compile program\\\",\\n default=False)\\n\\n parser.add_argument(\\\"--compiler-flags\\\",\\n type=comma_separated_list,\\n help=\\\"flags to be passed to the compiler\\\",\\n dest=\\\"flags\\\",\\n metavar=\\\"\\\")\\n \\n parser.add_argument(\\\"-d\\\",\\n \\\"--debug\\\",\\n action=\\\"store\\\",\\n type=int,\\n help=\\\"debug mode\\\",\\n metavar=\\\"\\\",\\n default=0)\\n \\n parser.add_argument(\\\"--exclusive-size\\\",\\n action=\\\"store\\\",\\n type=int,\\n help=\\\"size of subsets of mutually exclusive basic blocks to compute\\\",\\n metavar=\\\"\\\")\\n \\n parser.add_argument(\\\"-G\\\",\\n \\\"--ga\\\",\\n action=\\\"store_true\\\",\\n help=\\\"use a genetic algorithm to generate test vectors\\\",\\n default=False)\\n \\n parser.add_argument(\\\"-I\\\",\\n \\\"--inline\\\",\\n action=\\\"store_true\\\",\\n help=\\\"do analysis with fully inlined program where applicable\\\",\\n default=False)\\n \\n parser.add_argument(\\\"-r\\\",\\n \\\"--root\\\",\\n action=\\\"store\\\",\\n help=\\\"the function that is the entry point of the analysis. [This should not be 'main']\\\",\\n metavar=\\\"\\\")\\n \\n parser.add_argument(\\\"-T\\\",\\n \\\"--number-of-tests\\\",\\n action=\\\"store\\\",\\n type=int,\\n dest=\\\"tests\\\",\\n help=\\\"the number of times to run the application\\\",\\n metavar=\\\"\\\",\\n default=1)\\n \\n parser.add_argument(\\\"-u\\\",\\n \\\"--udraw\\\",\\n action=\\\"store_true\\\",\\n help=\\\"generate uDrawGraph files\\\",\\n default=False)\\n \\n parser.add_argument(\\\"-v\\\",\\n \\\"--verbose\\\",\\n action=\\\"store_true\\\",\\n help=\\\"be verbose\\\",\\n default=False)\\n \\n parser.parse_args(namespace=config.Arguments)\\n \\n config.Arguments.basename = os.path.splitext(os.path.basename(config.Arguments.program_file))[0]\\n config.Arguments.basepath = os.path.abspath(os.path.dirname(config.Arguments.program_file))\\n \\n config.Arguments.program_file = os.path.abspath(config.Arguments.program_file)\\n if not os.path.exists(config.Arguments.program_file):\\n debug.exit_message(\\\"The first command-line argument must be a file: '%s' does not exist.\\\" % config.Arguments.program_file)\\n elif not os.path.isfile(config.Arguments.program_file):\\n debug.exit_message(\\\"The first command-line argument must be a file: '%s' is not a file\\\" % config.Arguments.program_file)\\n \\n config.Arguments.test_specification_file = os.path.splitext(config.Arguments.program_file)[0] + '.test'\\n if not os.path.exists(config.Arguments.test_specification_file ):\\n debug.exit_message(\\\"Expected to find the test specification file '%s' but it is not there\\\" % config.Arguments.test_specification_file)\\n\\nif __name__ == \\\"__main__\\\": \\n the_command_line()\\n debug.verbose_message(\\\"%s Analysing program '%s' %s\\\" % ('*' * 10, config.Arguments.program_file, '*' * 10), __name__)\\n time1 = timing.log(\\\"COMPILING BEGIN\\\")\\n binary, program = get_binary_and_program()\\n time2 = timing.log(\\\"COMPILING END\\\")\\n if config.Arguments.compile:\\n debug.exit_message(\\\"DONE\\\")\\n if config.Arguments.gem5_traces:\\n check_trace_files()\\n else:\\n set_gem5_variables()\\n if config.Arguments.ga:\\n debug.verbose_message(\\\"Using GA to generate test vectors\\\", __name__)\\n config.Arguments.gem5_traces.extend(testing.runGAGem5(binary))\\n else:\\n debug.verbose_message(\\\"Running program on gem5 with %d tests\\\" % config.Arguments.tests, __name__)\\n config.Arguments.gem5_traces.extend(testing.run_gem5(binary))\\n do_analysis(program)\\n\"\n },\n {\n \"alpha_fraction\": 0.3892455995082855,\n \"alphanum_fraction\": 0.4069020748138428,\n \"avg_line_length\": 13.404623985290527,\n \"blob_id\": \"afa3c33a190d5305784dd8599aca39ac5bedc618\",\n \"content_id\": \"286bca6852a259eaa87f40faf60506c3ce187ebf\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 2492,\n \"license_type\": \"no_license\",\n \"max_line_length\": 75,\n \"num_lines\": 173,\n \"path\": \"/benchmarks/heapsort/heapsort.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Heap sort which consumes a\\n * test vector supplied on the command line.\\n *\\n * For this program, the test vector is a list of integers to be sorted.\\n * Note that the size of the array is determined by the number of arguments\\n * given to the program, i.e. argc - 1.\\n */\\n\\nvoid\\nheapbubble (int ARRAY_SIZE, int a[], int pos)\\n{\\n int z = 0;\\n int max = 0;\\n int tmp = 0;\\n int left = 0;\\n int right = 0;\\n\\n z = pos;\\n for (;;)\\n {\\n left = 2 * z + 1;\\n right = left + 1;\\n\\n if (left >= ARRAY_SIZE)\\n {\\n return;\\n }\\n else if (right >= ARRAY_SIZE)\\n {\\n max = left;\\n }\\n else if (a[left] > a[right])\\n {\\n max = left;\\n }\\n else\\n {\\n max = right;\\n }\\n if (a[z] > a[max])\\n {\\n return;\\n }\\n\\n tmp = a[z];\\n a[z] = a[max];\\n a[max] = tmp;\\n z = max;\\n }\\n}\\n\\nvoid\\nheapsort (int ARRAY_SIZE, int a[])\\n{\\n int i;\\n int tmp;\\n int z;\\n int max;\\n int tmp2;\\n int left;\\n int right;\\n\\n for (i = ARRAY_SIZE / 2; i >= 0; --i)\\n {\\n max = 0;\\n tmp2 = 0;\\n left = 0;\\n right = 0;\\n z = i;\\n \\n for (;;)\\n {\\n left = 2 * z + 1;\\n right = left + 1;\\n\\n if (left >= ARRAY_SIZE)\\n {\\n break;\\n }\\n else if (right >= ARRAY_SIZE)\\n {\\n max = left;\\n }\\n else if (a[left] > a[right])\\n {\\n max = left;\\n }\\n else\\n {\\n max = right;\\n }\\n if (a[z] > a[max])\\n {\\n break;\\n }\\n\\n tmp2 = a[z];\\n a[z] = a[max];\\n a[max] = tmp2;\\n z = max;\\n }\\n } \\n\\n for (i = ARRAY_SIZE - 1; i > 0; i--)\\n {\\n tmp = a[0];\\n a[0] = a[i];\\n a[i] = tmp;\\n max = 0;\\n tmp2 = 0;\\n left = 0;\\n right = 0;\\n z = 0;\\n \\n for (;;)\\n {\\n left = 2 * z + 1;\\n right = left + 1;\\n\\n if (left >= ARRAY_SIZE)\\n {\\n break;\\n }\\n else if (right >= ARRAY_SIZE)\\n {\\n max = left;\\n }\\n else if (a[left] > a[right])\\n {\\n max = left;\\n }\\n else\\n {\\n max = right;\\n }\\n if (a[z] > a[max])\\n {\\n break;\\n }\\n\\n tmp2 = a[z];\\n a[z] = a[max];\\n a[max] = tmp2;\\n z = max;\\n }\\n }\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int ARRAY_SIZE = argc - 1;\\n int TV[ARRAY_SIZE];\\n int i;\\n\\n /*\\n * At least one integer value must be supplied\\n */\\n if (argc == 1)\\n {\\n return 1;\\n }\\n\\n for (i = 0; i < argc - 1; ++i)\\n {\\n TV[i] = atoi (argv[i + 1]);\\n }\\n\\n heapsort (ARRAY_SIZE, TV);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.40130624175071716,\n \"alphanum_fraction\": 0.507982611656189,\n \"avg_line_length\": 16.66666603088379,\n \"blob_id\": \"98dbb297e525245d5801c5a64fd64f9ed4eb105a\",\n \"content_id\": \"ed44a8ad68ed16060604a2048df6022aaf32ab7e\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 1378,\n \"license_type\": \"no_license\",\n \"max_line_length\": 74,\n \"num_lines\": 78,\n \"path\": \"/benchmarks/lcdnum/lcdnum.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\r * LCD number (lcdnum) program taken from MDH suite and modified by Adam Betts\\r * to consume a test vector supplied on the command line.\\r *\\r * For this program, the test vector is a single hexadecimal digit\\r * The input range is therefore [0..15]\\r */\\r\\runsigned char\\rlcdnum (unsigned char a)\\r{\\r switch (a)\\r {\\r case 0x00:\\r return 0;\\r case 0x01:\\r return 0x24;\\r case 0x02:\\r return 1 + 4 + 8 + 16 + 64;\\r case 0x03:\\r return 1 + 4 + 8 + 32 + 64;\\r case 0x04:\\r return 2 + 4 + 8 + 32;\\r case 0x05:\\r return 1 + 4 + 8 + 16 + 64;\\r case 0x06:\\r return 1 + 2 + 8 + 16 + 32 + 64;\\r case 0x07:\\r return 1 + 4 + 32;\\r case 0x08:\\r return 0x7F; /* light all */\\r case 0x09:\\r return 0x0F + 32 + 64;\\r case 0x0A:\\r return 0x0F + 16 + 32;\\r case 0x0B:\\r return 2 + 8 + 16 + 32 + 64;\\r case 0x0C:\\r return 1 + 2 + 16 + 64;\\r case 0x0D:\\r return 4 + 8 + 16 + 32 + 64;\\r case 0x0E:\\r return 1 + 2 + 8 + 16 + 64;\\r case 0x0F:\\r return 1 + 2 + 8 + 16;\\r }\\r\\r return 0;\\r}\\r\\rint\\rmain (int argc, char *argv[])\\r{\\r int i;\\r volatile unsigned char OUT;\\r unsigned char a;\\r\\r /*\\r * One integer must be supplied\\r */\\r if (argc != 2)\\r {\\r return 1;\\r }\\r\\r a = atoi (argv[1]);\\r\\r for (i = 0; i < 10; i++)\\r {\\r if (i < 5)\\r {\\r a = a & 0x0F;\\r OUT = lcdnum(a);\\r }\\r }\\r\\r return 0;\\r}\\r\"\n },\n {\n \"alpha_fraction\": 0.5017825365066528,\n \"alphanum_fraction\": 0.5285205245018005,\n \"avg_line_length\": 15.260869979858398,\n \"blob_id\": \"a95c73b97799671c121f23a2971995f29defb5fa\",\n \"content_id\": \"af0872bb176ce62af94fe56f9d4774e3d0afc14c\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 1122,\n \"license_type\": \"no_license\",\n \"max_line_length\": 75,\n \"num_lines\": 69,\n \"path\": \"/benchmarks/combsort/combsort.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Comb sort which consumes a\\n * test vector supplied on the command line.\\n *\\n * For this program, the test vector is a list of integers to be sorted.\\n * Note that the size of the array is determined by the number of arguments\\n * given to the program, i.e. argc - 1.\\n */\\n\\n#define FALSE 0\\n#define TRUE 1\\n\\nvoid\\ncombsort (int ARRAY_SIZE, int a[])\\n{\\n float shrink_factor = 1.247330950103979;\\n int gap = ARRAY_SIZE;\\n int swapped = TRUE;\\n int i;\\n int tmp;\\n\\n while ((gap > 1) || swapped)\\n {\\n if (gap > 1)\\n {\\n gap = gap / shrink_factor;\\n }\\n\\n swapped = FALSE;\\n i = 0;\\n\\n while ((gap + i) < ARRAY_SIZE)\\n {\\n if (a[i] - a[i + gap] > 0)\\n {\\n tmp = a[i];\\n a[i] = a[i + gap];\\n a[i + gap] = tmp;\\n swapped = TRUE;\\n }\\n ++i;\\n }\\n }\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int ARRAY_SIZE = argc - 1;\\n int TV[ARRAY_SIZE];\\n int i;\\n\\n /*\\n * At least one integer value must be supplied\\n */\\n if (argc == 1)\\n {\\n return 1;\\n }\\n\\n for (i = 0; i < argc - 1; ++i)\\n {\\n TV[i] = atoi (argv[i + 1]);\\n }\\n\\n combsort (ARRAY_SIZE, TV);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.41493332386016846,\n \"alphanum_fraction\": 0.47146666049957275,\n \"avg_line_length\": 22.424999237060547,\n \"blob_id\": \"48213aa8ab55d293ec1c274b923fff843e603e9a\",\n \"content_id\": \"647db34f5e7173c22122707f69378d9a20088f0c\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 1875,\n \"license_type\": \"no_license\",\n \"max_line_length\": 81,\n \"num_lines\": 80,\n \"path\": \"/benchmarks/bezier/bezier.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Bezier curve algorithm taken from http://www-users.cs.york.ac.uk/~bernat/pwcet\\n * and modified by Adam Betts to consume a test vector supplied on the command line.\\n *\\n * For this program, an 80-element test vector is expected.\\n */\\n\\n#define STEPWIDTH 0.01 /* draws 1/STEPWIDTH +1 points between SP and EP */\\n#define XSIZE 800\\n#define YSIZE 600\\n#define CURVENO 20\\n\\nvoid\\nbezier (int data[20][4][2])\\n{\\n char screen[YSIZE][XSIZE];\\n int xco[4], yco[4];\\n int i;\\n int y;\\n int x;\\n float k;\\n\\n for (i = 0; i < CURVENO; i++)\\n { /* PAN_VARPATH */\\n /*calculate polynomial coefficients*/\\n xco[3] = data[i][0][0];\\n yco[3] = data[i][0][1];\\n xco[2] = 3 * (data[i][2][0] - data[i][0][0]);\\n yco[2] = 3 * (data[i][2][1] - data[i][0][1]);\\n xco[1] = 3 * (data[i][3][0] - data[i][2][0]) - xco[2];\\n yco[1] = 3 * (data[i][3][1] - data[i][2][1]) - yco[2];\\n xco[0] = data[i][1][0] - data[i][0][0] - xco[2] - xco[1];\\n yco[0] = data[i][1][1] - data[i][0][1] - yco[2] - yco[1];\\n\\n /*scan curve for t = 0 to t = 1 with STEPWIDTH*/\\n for (k = 0; k <= 1; k += STEPWIDTH)\\n { /* PAN_FIXED_LOOP PAN_VARPATH */\\n x = (int) (((float) xco[0] * k * k * k) + ((float) xco[1] * k * k)\\n + ((float) xco[2] * k) + (float) xco[3]);\\n y = (int) (((float) yco[0] * k * k * k) + ((float) yco[1] * k * k)\\n + ((float) yco[2] * k) + (float) yco[3]);\\n if ((x < XSIZE) && (x > 0) && (y < YSIZE) && (y > 0))\\n {\\n /*write dot to screen*/\\n screen[y][x] = 0; /*black*/\\n }\\n }\\n }\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n int TV[20][4][2];\\n int x;\\n int i;\\n int j;\\n int k;\\n\\n if (argc != 81)\\n {\\n return 1;\\n }\\n\\n k = 0;\\n for (i = 0; i < 20; i++)\\n {\\n for (j = 0; j < 4; j++)\\n {\\n x = atoi (argv[(k + 1)]);\\n TV[i][j][0] = x % 800;\\n TV[i][j][1] = x % 800;\\n k++;\\n }\\n }\\n\\n bezier (TV);\\n\\n return 0;\\n}\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.566476047039032,\n \"alphanum_fraction\": 0.5696926116943359,\n \"avg_line_length\": 34.871795654296875,\n \"blob_id\": \"71e762fc1e2447037a4d383635497798c29d3eb0\",\n \"content_id\": \"124e36509cd48b6b9a6626c6dbb4ed5ed9fcecf9\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 2798,\n \"license_type\": \"no_license\",\n \"max_line_length\": 105,\n \"num_lines\": 78,\n \"path\": \"/tools/trace_filter.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import argparse\\nimport sys\\n\\nfrom graphs import graph\\nfrom system import traces, program, database\\nfrom utils import messages\\n\\n\\ndef filter_trace(ppg: graph.ProgramPointGraph, ipg: graph.InstrumentationPointGraph, trace_file):\\n all_traces = traces.Traces()\\n trace = traces.Trace()\\n with open(trace_file, 'r') as rd:\\n for line in rd:\\n lexemes = line.split()\\n if lexemes:\\n if len(lexemes) == 2:\\n program_point = graph.Vertex.id_pool[int(lexemes[0])]\\n v = ppg.get_vertex(program_point)\\n else:\\n p = graph.Vertex.id_pool[int(lexemes[0])]\\n s = graph.Vertex.id_pool[int(lexemes[1])]\\n program_point = graph.ControlFlowEdge(p, s)\\n v = ppg.get_vertex(program_point)\\n\\n time = lexemes[-1]\\n if v in ipg:\\n trace.append(traces.TraceElement(v, time))\\n else:\\n all_traces.append(trace)\\n trace = traces.Trace()\\n return all_traces\\n\\n\\ndef main(**kwargs):\\n the_program = program.IO.read(kwargs['filename'])\\n\\n subprogram_trace = {}\\n for trace_file in kwargs['traces']:\\n name = traces.TraceFile.extract_subprogram(the_program, trace_file)\\n subprogram_trace[name] = trace_file\\n\\n for subprogram in the_program:\\n if subprogram.name in subprogram_trace:\\n messages.debug_message('Filtering traces for {}'.format(subprogram.name))\\n ppg = graph.ProgramPointGraph.create_from_control_flow_graph(subprogram.cfg)\\n ppg.dotify()\\n lnt = graph.LoopNests(ppg)\\n lnt.dotify()\\n\\n with database.Database(kwargs['database']) as db:\\n ipg = graph.InstrumentationPointGraph.create(ppg, lnt, db)\\n ipg.dotify()\\n all_traces = filter_trace(ppg, ipg, subprogram_trace[subprogram.name])\\n all_traces.write(ipg.trace_filename())\\n\\n\\ndef parse_the_command_line():\\n parser = argparse.ArgumentParser(description='Filter a set of traces to instrumented program points')\\n\\n parser.add_argument('--filename',\\n help='read the program from this file',\\n required=True)\\n\\n parser.add_argument('--database',\\n help='use the instrumentation indicated in this file',\\n required=True)\\n\\n parser.add_argument('--traces',\\n help='files containing traces',\\n required=True,\\n nargs='+')\\n\\n return parser.parse_args()\\n\\n\\nif __name__ == '__main__':\\n assert sys.version_info >= (3, 0), 'Script requires Python 3.0 or greater to run'\\n main(**vars(parse_the_command_line()))\\n\"\n },\n {\n \"alpha_fraction\": 0.49329492449760437,\n \"alphanum_fraction\": 0.5841278433799744,\n \"avg_line_length\": 23.41176414489746,\n \"blob_id\": \"f5f6afeab7b5b475be682e9c24f713835f1f0791\",\n \"content_id\": \"e538c18d703c2118754d17f1dc4285533ed4c5d3\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 19090,\n \"license_type\": \"no_license\",\n \"max_line_length\": 81,\n \"num_lines\": 782,\n \"path\": \"/benchmarks/adpcm/adpcm.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Adaptive pulse code modulation algorithm taken from MDH suite and modified by\\n * Adam Betts to consume a test vector supplied on the command line.\\n *\\n * For this program, the test vector consists of\\n */\\n\\n/* Common sampling rate for sound cards on IBM/PC */\\n#define SAMPLE_RATE 11025\\n\\n#define PI 3141\\n#define SIZE 3\\n#define IN_END 4\\n\\ntypedef struct\\n{\\n int real, imag;\\n} COMPLEX;\\n\\n/* variables for transimit quadrature mirror filter here */\\nint tqmf[24];\\n\\n/* QMF filter coefficients:\\n scaled by a factor of 4 compared to G722 CCITT recommendation */\\nint h[24] =\\n {12, -44, -44, 212, 48, -624, 128, 1448, -840, -3220, 3804, 15504, 15504,\\n 3804, -3220, -840, 1448, 128, -624, 48, 212, -44, -44, 12};\\n\\nint xl, xh;\\n\\n/* variables for receive quadrature mirror filter here */\\nint accumc[11], accumd[11];\\n\\n/* outputs of decode() */\\nint xout1, xout2;\\n\\nint xs, xd;\\n\\n/* variables for encoder (hi and lo) here */\\n\\nint il, szl, spl, sl, el;\\n\\nint qq4_code4_table[16] =\\n {0, -20456, -12896, -8968, -6288, -4240, -2584, -1200, 20456, 12896, 8968,\\n 6288, 4240, 2584, 1200, 0};\\n\\nint qq5_code5_table[32] =\\n {-280, -280, -23352, -17560, -14120, -11664, -9752, -8184, -6864, -5712,\\n -4696, -3784, -2960, -2208, -1520, -880, 23352, 17560, 14120, 11664,\\n 9752, 8184, 6864, 5712, 4696, 3784, 2960, 2208, 1520, 880, 280, -280};\\n\\nint qq6_code6_table[64] =\\n {-136, -136, -136, -136, -24808, -21904, -19008, -16704, -14984, -13512,\\n -12280, -11192, -10232, -9360, -8576, -7856, -7192, -6576, -6000, -5456,\\n -4944, -4464, -4008, -3576, -3168, -2776, -2400, -2032, -1688, -1360,\\n -1040, -728, 24808, 21904, 19008, 16704, 14984, 13512, 12280, 11192,\\n 10232, 9360, 8576, 7856, 7192, 6576, 6000, 5456, 4944, 4464, 4008, 3576,\\n 3168, 2776, 2400, 2032, 1688, 1360, 1040, 728, 432, 136, -432, -136};\\n\\nint delay_bpl[6];\\n\\nint delay_dltx[6];\\n\\nint wl_code_table[16] =\\n {-60, 3042, 1198, 538, 334, 172, 58, -30, 3042, 1198, 538, 334, 172, 58, -30,\\n -60};\\n\\nint wl_table[8] =\\n {-60, -30, 58, 172, 334, 538, 1198, 3042};\\n\\nint ilb_table[32] =\\n {2048, 2093, 2139, 2186, 2233, 2282, 2332, 2383, 2435, 2489, 2543, 2599,\\n 2656, 2714, 2774, 2834, 2896, 2960, 3025, 3091, 3158, 3228, 3298, 3371,\\n 3444, 3520, 3597, 3676, 3756, 3838, 3922, 4008};\\n\\nint nbl; /* delay line */\\nint al1, al2;\\nint plt, plt1, plt2;\\nint rs;\\nint dlt;\\nint rlt, rlt1, rlt2;\\n\\n/* decision levels - pre-multiplied by 8, 0 to indicate end */\\nint decis_levl[30] =\\n {280, 576, 880, 1200, 1520, 1864, 2208, 2584, 2960, 3376, 3784, 4240, 4696,\\n 5200, 5712, 6288, 6864, 7520, 8184, 8968, 9752, 10712, 11664, 12896,\\n 14120, 15840, 17560, 20456, 23352, 32767};\\n\\nint detl;\\n\\n/* quantization table 31 long to make quantl look-up easier,\\n last entry is for mil=30 case when wd is max */\\nint quant26bt_pos[31] =\\n {61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43,\\n 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 32};\\n\\n/* quantization table 31 long to make quantl look-up easier,\\n last entry is for mil=30 case when wd is max */\\nint quant26bt_neg[31] =\\n {63, 62, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15,\\n 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 4};\\n\\nint deth;\\nint sh; /* this comes from adaptive predictor */\\nint eh;\\n\\nint qq2_code2_table[4] =\\n {-7408, -1616, 7408, 1616};\\n\\nint wh_code_table[4] =\\n {798, -214, 798, -214};\\n\\nint dh, ih;\\nint nbh, szh;\\nint sph, ph, yh, rh;\\n\\nint delay_dhx[6];\\n\\nint delay_bph[6];\\n\\nint ah1, ah2;\\nint ph1, ph2;\\nint rh1, rh2;\\n\\n/* variables for decoder here */\\nint ilr, yl, rl;\\nint dec_deth, dec_detl, dec_dlt;\\n\\nint dec_del_bpl[6];\\n\\nint dec_del_dltx[6];\\n\\nint dec_plt, dec_plt1, dec_plt2;\\nint dec_szl, dec_spl, dec_sl;\\nint dec_rlt1, dec_rlt2, dec_rlt;\\nint dec_al1, dec_al2;\\nint dl;\\nint dec_nbl, dec_yh, dec_dh, dec_nbh;\\n\\n/* variables used in filtez */\\nint dec_del_bph[6];\\n\\nint dec_del_dhx[6];\\n\\nint dec_szh;\\n/* variables used in filtep */\\nint dec_rh1, dec_rh2;\\nint dec_ah1, dec_ah2;\\nint dec_ph, dec_sph;\\n\\nint dec_sh, dec_rh;\\n\\nint dec_ph1, dec_ph2;\\n\\n/* G722 encode function two ints in, one 8 bit output */\\n\\n/* put input samples in xin1 = first value, xin2 = second value */\\n/* returns il and ih stored together */\\n\\n/* MAX: 1 */\\nint\\nmy_abs (int n)\\n{\\n int m;\\n\\n if (n >= 0)\\n m = n;\\n else\\n m = -n;\\n return m;\\n}\\n\\n/* MAX: 1 */\\nint\\nmy_fabs (int n)\\n{\\n int f;\\n\\n if (n >= 0)\\n f = n;\\n else\\n f = -n;\\n return f;\\n}\\n\\nint\\nmy_sin (int rad)\\n{\\n int diff;\\n int app = 0;\\n\\n int inc = 1;\\n\\n /* MAX dependent on rad's value, say 50 */\\n while (rad > 2 * PI)\\n rad -= 2 * PI;\\n /* MAX dependent on rad's value, say 50 */\\n while (rad < -2 * PI)\\n rad += 2 * PI;\\n diff = rad;\\n app = diff;\\n diff = (diff * (-(rad * rad))) / ((2 * inc) * (2 * inc + 1));\\n app = app + diff;\\n inc++;\\n /* REALLY: while(my_fabs(diff) >= 0.00001) { */\\n /* MAX: 1000 */\\n while (my_fabs (diff) >= 1)\\n {\\n diff = (diff * (-(rad * rad))) / ((2 * inc) * (2 * inc + 1));\\n app = app + diff;\\n inc++;\\n }\\n\\n return app;\\n}\\n\\nint\\nmy_cos (int rad)\\n{\\n return (my_sin (PI / 2 - rad));\\n}\\n\\n/* upzero - inputs: dlt, dlti[0-5], bli[0-5], outputs: updated bli[0-5] */\\n/* also implements delay of bli and update of dlti from dlt */\\n\\nvoid\\nupzero (int dlt, int *dlti, int *bli)\\n{\\n int i, wd2, wd3;\\n /*if dlt is zero, then no sum into bli */\\n if (dlt == 0)\\n {\\n for (i = 0; i < 6; i++)\\n {\\n bli[i] = (int) ((255L * bli[i]) >> 8L); /* leak factor of\\n * 255/256 */\\n }\\n }\\n else\\n {\\n for (i = 0; i < 6; i++)\\n {\\n if ((long) dlt * dlti[i] >= 0)\\n wd2 = 128;\\n else\\n wd2 = -128;\\n wd3 = (int) ((255L * bli[i]) >> 8L); /* leak factor of\\n * 255/256 */\\n bli[i] = wd2 + wd3;\\n }\\n }\\n /* implement delay line for dlt */\\n dlti[5] = dlti[4];\\n dlti[4] = dlti[3];\\n dlti[3] = dlti[2];\\n dlti[1] = dlti[0];\\n dlti[0] = dlt;\\n return;\\n}\\n\\n/* MAX: 1 */\\nint\\nencode (int xin1, int xin2)\\n{\\n int i;\\n int *h_ptr, *tqmf_ptr, *tqmf_ptr1;\\n long int xa, xb;\\n int decis;\\n\\n /* transmit quadrature mirror filters implemented here */\\n h_ptr = h;\\n tqmf_ptr = tqmf;\\n xa = (long) (*tqmf_ptr++) * (*h_ptr++);\\n xb = (long) (*tqmf_ptr++) * (*h_ptr++);\\n /* main multiply accumulate loop for samples and coefficients */\\n /* MAX: 10 */\\n for (i = 0; i < 10; i++)\\n {\\n xa += (long) (*tqmf_ptr++) * (*h_ptr++);\\n xb += (long) (*tqmf_ptr++) * (*h_ptr++);\\n }\\n /* final mult/accumulate */\\n xa += (long) (*tqmf_ptr++) * (*h_ptr++);\\n xb += (long) (*tqmf_ptr) * (*h_ptr++);\\n\\n /* update delay line tqmf */\\n tqmf_ptr1 = tqmf_ptr - 2;\\n /* MAX: 22 */\\n for (i = 0; i < 22; i++)\\n *tqmf_ptr-- = *tqmf_ptr1--;\\n *tqmf_ptr-- = xin1;\\n *tqmf_ptr = xin2;\\n\\n /* scale outputs */\\n xl = (xa + xb) >> 15;\\n xh = (xa - xb) >> 15;\\n\\n /* end of quadrature mirror filter code */\\n\\n /* starting with lower sub band encoder */\\n\\n /* filtez - compute predictor output section - zero section */\\n szl = filtez (delay_bpl, delay_dltx);\\n\\n /* filtep - compute predictor output signal (pole section) */\\n spl = filtep (rlt1, al1, rlt2, al2);\\n\\n /* compute the predictor output value in the lower sub_band encoder */\\n sl = szl + spl;\\n el = xl - sl;\\n\\n /* quantl: quantize the difference signal */\\n il = quantl (el, detl);\\n\\n /* invqxl: computes quantized difference signal */\\n /* for invqbl, truncate by 2 lsbs, so mode = 3 */\\n dlt = ((long) detl * qq4_code4_table[il >> 2]) >> 15;\\n\\n /* logscl: updates logarithmic quant. scale factor in low sub band */\\n nbl = logscl (il, nbl);\\n\\n /* scalel: compute the quantizer scale factor in the lower sub band */\\n /* calling parameters nbl and 8 (constant such that scalel can be scaleh) */\\n detl = scalel (nbl, 8);\\n\\n /* parrec - simple addition to compute recontructed signal for adaptive pred */\\n plt = dlt + szl;\\n\\n /* upzero: update zero section predictor coefficients (sixth order)*/\\n /* calling parameters: dlt, dlt1, dlt2, ..., dlt6 from dlt */\\n /* bpli (linear_buffer in which all six values are delayed */\\n /* return params: updated bpli, delayed dltx */\\n upzero (dlt, delay_dltx, delay_bpl);\\n\\n /* uppol2- update second predictor coefficient apl2 and delay it as al2 */\\n /* calling parameters: al1, al2, plt, plt1, plt2 */\\n al2 = uppol2 (al1, al2, plt, plt1, plt2);\\n\\n /* uppol1 :update first predictor coefficient apl1 and delay it as al1 */\\n /* calling parameters: al1, apl2, plt, plt1 */\\n al1 = uppol1 (al1, al2, plt, plt1);\\n\\n /* recons : compute recontructed signal for adaptive predictor */\\n rlt = sl + dlt;\\n\\n /* done with lower sub_band encoder; now implement delays for next time*/\\n rlt2 = rlt1;\\n rlt1 = rlt;\\n plt2 = plt1;\\n plt1 = plt;\\n\\n /* high band encode */\\n\\n szh = filtez (delay_bph, delay_dhx);\\n\\n sph = filtep (rh1, ah1, rh2, ah2);\\n\\n /* predic: sh = sph + szh */\\n sh = sph + szh;\\n /* subtra: eh = xh - sh */\\n eh = xh - sh;\\n\\n /* quanth - quantization of difference signal for higher sub-band */\\n /* quanth: in-place for speed params: eh, deth (has init. value) */\\n if (eh >= 0)\\n {\\n ih = 3; /* 2,3 are pos codes */\\n }\\n else\\n {\\n ih = 1; /* 0,1 are neg codes */\\n }\\n decis = (564L * (long) deth) >> 12L;\\n if (my_abs (eh) > decis)\\n ih--; /* mih = 2 case */\\n\\n /* invqah: compute the quantized difference signal, higher sub-band*/\\n dh = ((long) deth * qq2_code2_table[ih]) >> 15L;\\n\\n /* logsch: update logarithmic quantizer scale factor in hi sub-band*/\\n nbh = logsch (ih, nbh);\\n\\n /* note : scalel and scaleh use same code, different parameters */\\n deth = scalel (nbh, 10);\\n\\n /* parrec - add pole predictor output to quantized diff. signal */\\n ph = dh + szh;\\n\\n /* upzero: update zero section predictor coefficients (sixth order) */\\n /* calling parameters: dh, dhi, bphi */\\n /* return params: updated bphi, delayed dhx */\\n upzero (dh, delay_dhx, delay_bph);\\n\\n /* uppol2: update second predictor coef aph2 and delay as ah2 */\\n /* calling params: ah1, ah2, ph, ph1, ph2 */\\n ah2 = uppol2 (ah1, ah2, ph, ph1, ph2);\\n\\n /* uppol1: update first predictor coef. aph2 and delay it as ah1 */\\n ah1 = uppol1 (ah1, ah2, ph, ph1);\\n\\n /* recons for higher sub-band */\\n yh = sh + dh;\\n\\n /* done with higher sub-band encoder, now Delay for next time */\\n rh2 = rh1;\\n rh1 = yh;\\n ph2 = ph1;\\n ph1 = ph;\\n\\n /* multiplex ih and il to get signals together */\\n return (il | (ih << 6));\\n}\\n\\n/* decode function, result in xout1 and xout2 */\\n\\nvoid\\ndecode (int input)\\n{\\n int i;\\n long int xa1, xa2; /* qmf accumulators */\\n int *h_ptr, *ac_ptr, *ac_ptr1, *ad_ptr, *ad_ptr1;\\n\\n /* split transmitted word from input into ilr and ih */\\n ilr = input & 0x3f;\\n ih = input >> 6;\\n\\n /* LOWER SUB_BAND DECODER */\\n\\n /* filtez: compute predictor output for zero section */\\n dec_szl = filtez (dec_del_bpl, dec_del_dltx);\\n\\n /* filtep: compute predictor output signal for pole section */\\n dec_spl = filtep (dec_rlt1, dec_al1, dec_rlt2, dec_al2);\\n\\n dec_sl = dec_spl + dec_szl;\\n\\n /* invqxl: compute quantized difference signal for adaptive predic */\\n dec_dlt = ((long) dec_detl * qq4_code4_table[ilr >> 2]) >> 15;\\n\\n /* invqxl: compute quantized difference signal for decoder output */\\n dl = ((long) dec_detl * qq6_code6_table[il]) >> 15;\\n\\n rl = dl + dec_sl;\\n\\n /* logscl: quantizer scale factor adaptation in the lower sub-band */\\n dec_nbl = logscl (ilr, dec_nbl);\\n\\n /* scalel: computes quantizer scale factor in the lower sub band */\\n dec_detl = scalel (dec_nbl, 8);\\n\\n /* parrec - add pole predictor output to quantized diff. signal */\\n /* for partially reconstructed signal */\\n dec_plt = dec_dlt + dec_szl;\\n\\n /* upzero: update zero section predictor coefficients */\\n upzero (dec_dlt, dec_del_dltx, dec_del_bpl);\\n\\n /* uppol2: update second predictor coefficient apl2 and delay it as al2 */\\n dec_al2 = uppol2 (dec_al1, dec_al2, dec_plt, dec_plt1, dec_plt2);\\n\\n /* uppol1: update first predictor coef. (pole setion) */\\n dec_al1 = uppol1 (dec_al1, dec_al2, dec_plt, dec_plt1);\\n\\n /* recons : compute recontructed signal for adaptive predictor */\\n dec_rlt = dec_sl + dec_dlt;\\n\\n /* done with lower sub band decoder, implement delays for next time */\\n dec_rlt2 = dec_rlt1;\\n dec_rlt1 = dec_rlt;\\n dec_plt2 = dec_plt1;\\n dec_plt1 = dec_plt;\\n\\n /* HIGH SUB-BAND DECODER */\\n\\n /* filtez: compute predictor output for zero section */\\n dec_szh = filtez (dec_del_bph, dec_del_dhx);\\n\\n /* filtep: compute predictor output signal for pole section */\\n dec_sph = filtep (dec_rh1, dec_ah1, dec_rh2, dec_ah2);\\n\\n /* predic:compute the predictor output value in the higher sub_band decoder */\\n dec_sh = dec_sph + dec_szh;\\n\\n /* invqah: in-place compute the quantized difference signal */\\n dec_dh = ((long) dec_deth * qq2_code2_table[ih]) >> 15L;\\n\\n /* logsch: update logarithmic quantizer scale factor in hi sub band */\\n dec_nbh = logsch (ih, dec_nbh);\\n\\n /* scalel: compute the quantizer scale factor in the higher sub band */\\n dec_deth = scalel (dec_nbh, 10);\\n\\n /* parrec: compute partially recontructed signal */\\n dec_ph = dec_dh + dec_szh;\\n\\n /* upzero: update zero section predictor coefficients */\\n upzero (dec_dh, dec_del_dhx, dec_del_bph);\\n\\n /* uppol2: update second predictor coefficient aph2 and delay it as ah2 */\\n dec_ah2 = uppol2 (dec_ah1, dec_ah2, dec_ph, dec_ph1, dec_ph2);\\n\\n /* uppol1: update first predictor coef. (pole setion) */\\n dec_ah1 = uppol1 (dec_ah1, dec_ah2, dec_ph, dec_ph1);\\n\\n /* recons : compute recontructed signal for adaptive predictor */\\n rh = dec_sh + dec_dh;\\n\\n /* done with high band decode, implementing delays for next time here */\\n dec_rh2 = dec_rh1;\\n dec_rh1 = rh;\\n dec_ph2 = dec_ph1;\\n dec_ph1 = dec_ph;\\n\\n /* end of higher sub_band decoder */\\n\\n /* end with receive quadrature mirror filters */\\n xd = rl - rh;\\n xs = rl + rh;\\n\\n /* receive quadrature mirror filters implemented here */\\n h_ptr = h;\\n ac_ptr = accumc;\\n ad_ptr = accumd;\\n xa1 = (long) xd * (*h_ptr++);\\n xa2 = (long) xs * (*h_ptr++);\\n /* main multiply accumulate loop for samples and coefficients */\\n for (i = 0; i < 10; i++)\\n {\\n xa1 += (long) (*ac_ptr++) * (*h_ptr++);\\n xa2 += (long) (*ad_ptr++) * (*h_ptr++);\\n }\\n /* final mult/accumulate */\\n xa1 += (long) (*ac_ptr) * (*h_ptr++);\\n xa2 += (long) (*ad_ptr) * (*h_ptr++);\\n\\n /* scale by 2^14 */\\n xout1 = xa1 >> 14;\\n xout2 = xa2 >> 14;\\n\\n /* update delay lines */\\n ac_ptr1 = ac_ptr - 1;\\n ad_ptr1 = ad_ptr - 1;\\n for (i = 0; i < 10; i++)\\n {\\n *ac_ptr-- = *ac_ptr1--;\\n *ad_ptr-- = *ad_ptr1--;\\n }\\n *ac_ptr = xd;\\n *ad_ptr = xs;\\n\\n return;\\n}\\n\\n/* clear all storage locations */\\n\\nvoid\\nreset ()\\n{\\n int i;\\n\\n detl = dec_detl = 32; /* reset to min scale factor */\\n deth = dec_deth = 8;\\n nbl = al1 = al2 = plt1 = plt2 = rlt1 = rlt2 = 0;\\n nbh = ah1 = ah2 = ph1 = ph2 = rh1 = rh2 = 0;\\n dec_nbl = dec_al1 = dec_al2 = dec_plt1 = dec_plt2 = dec_rlt1 = dec_rlt2 = 0;\\n dec_nbh = dec_ah1 = dec_ah2 = dec_ph1 = dec_ph2 = dec_rh1 = dec_rh2 = 0;\\n\\n for (i = 0; i < 6; i++)\\n {\\n delay_dltx[i] = 0;\\n delay_dhx[i] = 0;\\n dec_del_dltx[i] = 0;\\n dec_del_dhx[i] = 0;\\n }\\n\\n for (i = 0; i < 6; i++)\\n {\\n delay_bpl[i] = 0;\\n delay_bph[i] = 0;\\n dec_del_bpl[i] = 0;\\n dec_del_bph[i] = 0;\\n }\\n\\n for (i = 0; i < 23; i++)\\n tqmf[i] = 0;\\n\\n for (i = 0; i < 11; i++)\\n {\\n accumc[i] = 0;\\n accumd[i] = 0;\\n }\\n return;\\n}\\n\\n/* filtez - compute predictor output signal (zero section) */\\n/* input: bpl1-6 and dlt1-6, output: szl */\\n\\nint\\nfiltez (int *bpl, int *dlt)\\n{\\n int i;\\n long int zl;\\n zl = (long) (*bpl++) * (*dlt++);\\n /* MAX: 6 */\\n for (i = 1; i < 6; i++)\\n zl += (long) (*bpl++) * (*dlt++);\\n\\n return ((int) (zl >> 14)); /* x2 here */\\n}\\n\\n/* filtep - compute predictor output signal (pole section) */\\n/* input rlt1-2 and al1-2, output spl */\\n\\nint\\nfiltep (int rlt1, int al1, int rlt2, int al2)\\n{\\n long int pl, pl2;\\n pl = 2 * rlt1;\\n pl = (long) al1 * pl;\\n pl2 = 2 * rlt2;\\n pl += (long) al2 * pl2;\\n return ((int) (pl >> 15));\\n}\\n\\n/* quantl - quantize the difference signal in the lower sub-band */\\nint\\nquantl (int el, int detl)\\n{\\n int ril, mil;\\n long int wd, decis;\\n\\n /* abs of difference signal */\\n wd = my_abs (el);\\n /* determine mil based on decision levels and detl gain */\\n /* MAX: 30 */\\n for (mil = 0; mil < 30; mil++)\\n {\\n decis = (decis_levl[mil] * (long) detl) >> 15L;\\n if (wd <= decis)\\n break;\\n }\\n /* if mil=30 then wd is less than all decision levels */\\n if (el >= 0)\\n ril = quant26bt_pos[mil];\\n else\\n ril = quant26bt_neg[mil];\\n return (ril);\\n}\\n\\nint\\nlogscl (int il, int nbl)\\n{\\n long int wd;\\n wd = ((long) nbl * 127L) >> 7L; /* leak factor 127/128 */\\n nbl = (int) wd + wl_code_table[il >> 2];\\n if (nbl < 0)\\n nbl = 0;\\n if (nbl > 18432)\\n nbl = 18432;\\n return (nbl);\\n}\\n\\n/* scalel: compute quantizer scale factor in lower or upper sub-band*/\\n\\nint\\nscalel (int nbl, int shift_constant)\\n{\\n int wd1, wd2, wd3;\\n wd1 = (nbl >> 6) & 31;\\n wd2 = nbl >> 11;\\n wd3 = ilb_table[wd1] >> (shift_constant + 1 - wd2);\\n return (wd3 << 3);\\n}\\n\\n/* uppol2 - update second predictor coefficient (pole section) */\\n/* inputs: al1, al2, plt, plt1, plt2. outputs: apl2 */\\n\\nint\\nuppol2 (int al1, int al2, int plt, int plt1, int plt2)\\n{\\n long int wd2, wd4;\\n int apl2;\\n wd2 = 4L * (long) al1;\\n if ((long) plt * plt1 >= 0L)\\n wd2 = -wd2; /* check same sign */\\n wd2 = wd2 >> 7; /* gain of 1/128 */\\n if ((long) plt * plt2 >= 0L)\\n {\\n wd4 = wd2 + 128;/* same sign case */\\n }\\n else\\n {\\n wd4 = wd2 - 128;\\n }\\n apl2 = wd4 + (127L * (long) al2 >> 7L); /* leak factor of 127/128 */\\n\\n /* apl2 is limited to +-.75 */\\n if (apl2 > 12288)\\n apl2 = 12288;\\n if (apl2 < -12288)\\n apl2 = -12288;\\n return (apl2);\\n}\\n\\n/* uppol1 - update first predictor coefficient (pole section) */\\n/* inputs: al1, apl2, plt, plt1. outputs: apl1 */\\n\\nint\\nuppol1 (int al1, int apl2, int plt, int plt1)\\n{\\n long int wd2;\\n int wd3, apl1;\\n wd2 = ((long) al1 * 255L) >> 8L; /* leak factor of 255/256 */\\n if ((long) plt * plt1 >= 0L)\\n {\\n apl1 = (int) wd2 + 192; /* same sign case */\\n }\\n else\\n {\\n apl1 = (int) wd2 - 192;\\n }\\n /* note: wd3= .9375-.75 is always positive */\\n wd3 = 15360 - apl2; /* limit value */\\n if (apl1 > wd3)\\n apl1 = wd3;\\n if (apl1 < -wd3)\\n apl1 = -wd3;\\n return (apl1);\\n}\\n\\nint\\nlogsch (int ih, int nbh)\\n{\\n int wd;\\n wd = ((long) nbh * 127L) >> 7L; /* leak factor 127/128 */\\n nbh = wd + wh_code_table[ih];\\n if (nbh < 0)\\n nbh = 0;\\n if (nbh > 22528)\\n nbh = 22528;\\n return (nbh);\\n}\\n\\nint\\nmain ()\\n{\\n int i, j, f /* ,answer */;\\n static int test_data[SIZE * 2], compressed[SIZE], result[SIZE * 2];\\n\\n /* reset, initialize required memory */\\n reset ();\\n\\n /* read in amplitude and frequency for test data */\\n j = 10;\\n f = 2000;\\n\\n /* 16 KHz sample rate */\\n /* XXmain_0, MAX: 2 */\\n /*\\n * Since the number of times we loop in my_sin depends on the\\n * argument we add the fact: xxmain_0:[]:\\n */\\n for (i = 0; i < SIZE; i++)\\n {\\n test_data[i] = (int) j * my_cos (f * PI * i);\\n }\\n\\n for (i = 0; i < IN_END; i += 2)\\n {\\n compressed[i / 2] = encode (test_data[i], test_data[i + 1]);\\n }\\n\\n /* MAX: 2 */\\n for (i = 0; i < IN_END; i += 2)\\n {\\n decode (compressed[i / 2]);\\n result[i] = xout1;\\n result[i + 1] = xout2;\\n }\\n\\n return result[i] + result[i + 1];\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.5048502683639526,\n \"alphanum_fraction\": 0.5491353869438171,\n \"avg_line_length\": 19.084745407104492,\n \"blob_id\": \"19dec59dd844fdd1250e6bd0cf7b95ecc6c37dc3\",\n \"content_id\": \"211aa53dbafed0cabfd94e6d78353e96dfc70058\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 2371,\n \"license_type\": \"no_license\",\n \"max_line_length\": 75,\n \"num_lines\": 118,\n \"path\": \"/DaikonPathInformation/benchmarks/insertsort.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Insert sort taken from MDH suite and modified by Adam Betts to consume a\\n * test vector supplied on the command line.\\n *\\n * For this program, the test vector is a list of integers to be sorted.\\n * Note that the size of the array is determined by the number of arguments\\n * given to the program, i.e. argc - 1.\\n */\\n\\nint\\ninsertsort (int ARRAY_SIZE, int a[])\\n{\\n#ifdef CBMC\\n//==========> insertsort : header 4\\nint __count_4_5 = 0;\\nint __count_4_5_L = 0; //Loop counter\\n//==========> insertsort : header 7\\nint __count_4_6 = 0;\\nint __count_5_6 = 0;\\nint __count_7_2 = 0; //Loop counter\\n//==========> insertsort : header 1\\nint __count_8 = 0;\\nint __count_7_8 = 0;\\n#endif\\n int i, j, key;\\n\\n #ifdef CBMC\\n __count_7_2 = 0;\\n #endif\\n for (j = 1; j < ARRAY_SIZE; j++) // 7\\n {\\n #ifdef CBMC\\n __count_7_2++;\\n #endif\\n key = a[j];\\n i = j - 1;\\n\\n #ifdef CBMC\\n __count_4_5_L = 0;\\n #endif\\n while (a[i] > key && \\n (\\n #ifdef CBMC\\n (\\n __count_4_5_L++,\\n __count_4_5++\\n ),\\n #endif\\n i >= 0\\n )\\n ) // 4, 5\\n {\\n a[i+1] = a[i];\\n i--;\\n }\\n #ifdef CBMC\\n assert(__count_4_5_L <= 98); // Loop counter property\\n #endif\\n\\n #ifdef CBMC\\n if (a[i] <= key) __count_4_6++;\\n else __count_5_6++;\\n #endif\\n\\n a[i+1] = key;\\n }\\n #ifdef CBMC\\n assert(__count_7_2 <= 100); // Loop counter property\\n #endif\\n\\n #ifdef CBMC\\n __count_7_8++;\\n __count_8++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_8 >= 1); // Lower capacity constraint\\nassert(__count_8 <= 1); // Upper capacity constraint\\nassert(__count_7_8 >= 1); // Lower capacity constraint\\nassert(__count_7_8 <= 1); // Upper capacity constraint\\n//assert(__count_4_5 >= 1979); // Lower capacity constraint\\nassert(__count_4_5 <= 3385); // Upper capacity constraint\\n//assert(__count_4_6 >= 99); // Lower capacity constraint\\nassert(__count_4_6 <= 99); // Upper capacity constraint\\n//assert(__count_5_6 == 0); // Dead code\\n#endif\\n\\n return a[0];\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int ARRAY_SIZE = argc - 1;\\n int TV[ARRAY_SIZE];\\n int i;\\n\\n /*\\n * At least one integer value must be supplied\\n */\\n if (argc == 1)\\n {\\n return 1;\\n }\\n\\n for (i = 0; i < argc - 1; i++)\\n {\\n TV[i] = atoi (argv[i + 1]);\\n }\\n \\n #ifdef CBMC\\n __CPROVER_assume(ARRAY_SIZE >= 1 && ARRAY_SIZE <= 100);\\n #endif\\n\\n int val = insertsort (ARRAY_SIZE, TV);\\n\\n return 0;\\n}\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.3496890068054199,\n \"alphanum_fraction\": 0.365929514169693,\n \"avg_line_length\": 13.90109920501709,\n \"blob_id\": \"5bf5c5d631ab0db5ac9894c19a1c372645134e5a\",\n \"content_id\": \"eff6cb20d4670e25d5402dfe85abe10a04ef388a\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 2894,\n \"license_type\": \"no_license\",\n \"max_line_length\": 74,\n \"num_lines\": 182,\n \"path\": \"/benchmarks/matrix_inverse/matrix_inverse.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\r\\n * Matrix inversion taken from MDH suite and modified by Adam Betts to\\r\\n * consume a test vector supplied on the command line.\\r\\n *\\r\\n * For this program, the test vector consists of 9 integers since there is\\r\\n * a single 3*3 matrix to be initialised before inversion.\\r\\n */\\r\\n\\r\\n#define UPPERLIMIT 3\\r\\n\\r\\ndouble\\r\\nfabs (double n)\\r\\n{\\r\\n if (n >= 0)\\r\\n {\\r\\n return n;\\r\\n }\\r\\n else\\r\\n {\\r\\n return -n;\\r\\n }\\r\\n}\\r\\n\\r\\nvoid\\r\\nminver (double a[][UPPERLIMIT], int row, int col, double eps)\\r\\n{\\r\\n int work[500];\\r\\n int i;\\r\\n int j;\\r\\n int k;\\r\\n int r;\\r\\n int iw;\\r\\n int s;\\r\\n int t;\\r\\n int u;\\r\\n int v;\\r\\n double w;\\r\\n double wmax;\\r\\n double pivot;\\r\\n double api;\\r\\n double w1;\\r\\n double b[UPPERLIMIT][UPPERLIMIT];\\r\\n double c[UPPERLIMIT][UPPERLIMIT];\\r\\n double e[UPPERLIMIT][UPPERLIMIT];\\r\\n\\r\\n if (row < 2 || row > 500 || eps <= 0.0)\\r\\n {\\r\\n return;\\r\\n }\\r\\n\\r\\n w1 = 1.0;\\r\\n for (i = 0; i < row; i++)\\r\\n {\\r\\n work[i] = i;\\r\\n }\\r\\n\\r\\n for (k = 0; k < row; k++)\\r\\n {\\r\\n wmax = 0.0;\\r\\n for (i = k; i < row; i++)\\r\\n {\\r\\n w = fabs (a[i][k]);\\r\\n if (w > wmax)\\r\\n {\\r\\n wmax = w;\\r\\n r = i;\\r\\n }\\r\\n }\\r\\n pivot = a[r][k];\\r\\n api = fabs (pivot);\\r\\n\\r\\n if (api <= eps)\\r\\n {\\r\\n return;\\r\\n }\\r\\n\\r\\n w1 *= pivot;\\r\\n u = k * col;\\r\\n v = r * col;\\r\\n\\r\\n if (r != k)\\r\\n {\\r\\n w1 = -w;\\r\\n iw = work[k];\\r\\n work[k] = work[r];\\r\\n work[r] = iw;\\r\\n for (j = 0; j < row; j++)\\r\\n {\\r\\n s = u + j;\\r\\n t = v + j;\\r\\n w = a[k][j];\\r\\n a[k][j] = a[r][j];\\r\\n a[r][j] = w;\\r\\n }\\r\\n }\\r\\n\\r\\n for (i = 0; i < row; i++)\\r\\n {\\r\\n a[k][i] /= pivot;\\r\\n }\\r\\n\\r\\n for (i = 0; i < row; i++)\\r\\n {\\r\\n if (i != k)\\r\\n {\\r\\n v = i * col;\\r\\n s = v + k;\\r\\n w = a[i][k];\\r\\n if (w != 0.0)\\r\\n {\\r\\n for (j = 0; j < row; j++)\\r\\n {\\r\\n if (j != k)\\r\\n {\\r\\n a[i][j] -= w * a[k][j];\\r\\n }\\r\\n }\\r\\n a[i][k] = -w / pivot;\\r\\n }\\r\\n }\\r\\n }\\r\\n a[k][k] = 1.0 / pivot;\\r\\n }\\r\\n\\r\\n for (i = 0; i < row; i++)\\r\\n {\\r\\n while (1)\\r\\n {\\r\\n k = work[i];\\r\\n\\r\\n if (k == i)\\r\\n {\\r\\n break;\\r\\n }\\r\\n\\r\\n iw = work[k];\\r\\n work[k] = work[i];\\r\\n work[i] = iw;\\r\\n for (j = 0; j < row; j++)\\r\\n {\\r\\n u = j * col;\\r\\n s = u + i;\\r\\n t = u + k;\\r\\n w = a[k][i];\\r\\n a[k][i] = a[k][k];\\r\\n a[k][k] = w;\\r\\n }\\r\\n }\\r\\n }\\r\\n}\\r\\n\\r\\nint\\r\\nmain (int argc, char **argv)\\r\\n{\\r\\n int i;\\r\\n int j;\\r\\n int k;\\r\\n double a[UPPERLIMIT][UPPERLIMIT];\\r\\n double eps = 1.0e-6;\\r\\n\\r\\n /*\\r\\n * Need 9 values to fill up the matrix.\\r\\n */\\r\\n if (argc != 10)\\r\\n {\\r\\n return 1;\\r\\n }\\r\\n\\r\\n k = 0;\\r\\n for (i = 0; i < UPPERLIMIT; ++i)\\r\\n {\\r\\n for (j = 0; j < UPPERLIMIT; ++j)\\r\\n {\\r\\n a[i][j] = atoi (argv[k + 1]);\\r\\n k++;\\r\\n }\\r\\n }\\r\\n\\r\\n minver (a, UPPERLIMIT, UPPERLIMIT, eps);\\r\\n\\r\\n return 0;\\r\\n}\\r\\n\"\n },\n {\n \"alpha_fraction\": 0.4551753103733063,\n \"alphanum_fraction\": 0.5589478015899658,\n \"avg_line_length\": 25.479839324951172,\n \"blob_id\": \"e81a6a3bff4c6196fd6a6d67736e4a3443282bf5\",\n \"content_id\": \"b8d43b7bca909a4416846163abff731366c56a03\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 26269,\n \"license_type\": \"no_license\",\n \"max_line_length\": 95,\n \"num_lines\": 992,\n \"path\": \"/DaikonPathInformation/benchmarks/compress.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#define BUFFERSIZE 50\\n#define HSIZE 257\\n#define BITS 16\\n#define INIT_BITS 9\\n#define BLOCK_MASK 0x80\\n#define FIRST 257\\t/* first free entry */\\n#define\\tCLEAR 256\\t/* table clear output code */\\n#define CHECK_GAP 10000\\t/* ratio check interval */\\n\\n#define MAXCODE(n_bits) ((1 << (n_bits)) - 1)\\n\\ntypedef long int code_int;\\ntypedef unsigned long int count_int;\\ntypedef unsigned short int count_short;\\ntypedef\\tunsigned char char_type;\\n\\nint exit_stat = 0;\\nint n_bits; /* number of bits/code */\\nint maxbits = BITS; /* user settable max # bits/code */\\nint nomagic = 1; /* Use a 3-byte magic number header, unless old file */\\nint zcat_flg = 0; /* Write output on stdout, suppress messages */\\nint quiet = 1; /* don't tell me about compression */\\nint block_compress = BLOCK_MASK;\\nint clear_flg = 0;\\nint InCnt;\\nint apsim_InCnt;\\nint force = 0;\\nint offset;\\nlong int in_count = 1;\\t\\t\\t/* length of input */\\nlong int bytes_out;\\t\\t\\t/* length of compressed output */\\nlong int out_count = 0;\\t\\t\\t/* # of codes output (for debugging) */\\nlong int ratio = 0;\\nchar ofname [100];\\nchar orig_text_buffer[BUFFERSIZE];\\nchar comp_text_buffer[BUFFERSIZE+5];\\nchar buf[BITS];\\nunsigned char *InBuff;\\nunsigned char *OutBuff;\\nunsigned short codetab [HSIZE];\\n\\ncount_int checkpoint = CHECK_GAP;\\ncode_int maxcode; /* maximum code, given n_bits */\\ncode_int maxmaxcode = 1L << BITS; /* should NEVER generate this code */\\ncode_int hsize = HSIZE; /* for dynamic table sizing */\\ncode_int free_ent = 0; /* first unused entry */\\ncount_int fsize;\\ncount_int htab [HSIZE];\\n\\nchar_type lmask[9] = {0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00};\\nchar_type rmask[9] = {0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};\\n\\nvoid \\ncl_hash (count_int hsize)\\t\\t/* reset code table */\\n{\\n#ifdef CBMC\\n//==========> cl_hash : header 81\\nint __count_81_80 = 0;\\nint __count_81_80_L = 0; //Loop counter\\n//==========> cl_hash : header 78\\nint __count_78 = 0;\\nint __count_78_78 = 0; //Loop counter\\n//==========> cl_hash : header 77\\nint __count_82 = 0;\\nint __count_81_82 = 0;\\n#endif\\n\\n register count_int *htab_p = htab+hsize;\\n register long i;\\n register long m1 = -1;\\n\\n i = hsize - 16;\\n\\n #ifdef CBMC\\n __count_78_78--;\\n #endif\\n do // 78\\n {\\t\\n #ifdef CBMC\\n __count_78++;\\n __count_78_78++;\\n #endif\\n /* might use Sys V memset(3) here */\\n *(htab_p-16) = m1;\\n *(htab_p-15) = m1;\\n *(htab_p-14) = m1;\\n *(htab_p-13) = m1;\\n *(htab_p-12) = m1;\\n *(htab_p-11) = m1;\\n *(htab_p-10) = m1;\\n *(htab_p-9) = m1;\\n *(htab_p-8) = m1;\\n *(htab_p-7) = m1;\\n *(htab_p-6) = m1;\\n *(htab_p-5) = m1;\\n *(htab_p-4) = m1;\\n *(htab_p-3) = m1;\\n *(htab_p-2) = m1;\\n *(htab_p-1) = m1;\\n htab_p -= 16;\\n } while ((i -= 16) >= 0);\\n #ifdef CBMC\\n //assert(__count_78_78 <= 2); // Loop counter property\\n #endif\\n\\n #ifdef CBMC\\n __count_81_80_L = 0;\\n #endif\\n for (i += 16; i > 0; i--) // 81\\n {\\n #ifdef CBMC\\n __count_81_80_L++;\\n __count_81_80++;\\n #endif\\n *--htab_p = m1; //80\\n }\\n #ifdef CBMC\\n assert(__count_81_80_L <= 2); // Loop counter property\\n\\n __count_81_82++;\\n __count_82++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_82 >= 1); // Lower capacity constraint\\nassert(__count_82 <= 1); // Upper capacity constraint\\nassert(__count_78 >= 3); // Lower capacity constraint\\nassert(__count_78 <= 3); // Upper capacity constraint\\nassert(__count_81_80 >= 1); // Lower capacity constraint\\nassert(__count_81_80 <= 1); // Upper capacity constraint\\nassert(__count_81_82 >= 1); // Lower capacity constraint\\nassert(__count_81_82 <= 1); // Upper capacity constraint\\n#endif\\n\\n}\\n\\nvoid \\nputbyte (char c)\\n{\\n#ifdef CBMC\\n//==========> putbyte : header 108\\nint __count_108 = 0;\\n#endif\\n *OutBuff++ = c; \\t\\t /* apsim_unknown comp_text_buffer */\\n#ifdef CBMC\\n__count_108++;\\n#endif\\n\\n#ifdef CBMC\\nassert(__count_108 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_108 <= 0); // Upper capacity constraint\\n#endif\\n\\n}\\n\\nvoid \\nwritebytes (char *buf, int n)\\n{\\n#ifdef CBMC\\n//==========> writebytes : header 17\\nint __count_17_18 = 0;\\nint __count_17_18_L = 0; //Loop counter\\n//==========> writebytes : header 15\\nint __count_19 = 0;\\nint __count_17_19 = 0;\\nint __count_18_19 = 0;\\n#endif\\n\\n int i;\\n #ifdef CBMC\\n __count_17_18_L = 0;\\n #endif\\n for (i=0; (i= 9223372036854775807); // Lower capacity constraint\\nassert(__count_17_19 <= 0); // Upper capacity constraint\\nassert(__count_17_18 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_17_18 <= 0); // Upper capacity constraint\\nassert(__count_19 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_19 <= 0); // Upper capacity constraint\\nassert(__count_18_19 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_18_19 <= 0); // Upper capacity constraint\\n#endif\\n\\n}\\n\\nvoid \\noutput (code_int code)\\n{\\n#ifdef CBMC\\n//==========> output : header 90\\nint __count_90_91 = 0;\\nint __count_90_91_L = 0; //Loop counter\\n//==========> output : header 83\\nint __count_107 = 0;\\nint __count_84_85 = 0;\\nint __count_84_86 = 0;\\nint __count_86_88 = 0;\\nint __count_87_88 = 0;\\nint __count_88_94 = 0;\\nint __count_91_93 = 0;\\nint __count_92_93 = 0;\\nint __count_94_96 = 0;\\nint __count_95_96 = 0;\\nint __count_95_107 = 0;\\nint __count_96_99 = 0;\\nint __count_98_99 = 0;\\nint __count_99_100 = 0;\\nint __count_101_102 = 0;\\nint __count_103_107 = 0;\\nint __count_104_105 = 0;\\nint __count_104_106 = 0;\\n#endif\\n /*\\n * On the VAX, it is important to have the register declarations\\n * in exactly the order given, or the asm will break.\\n */\\n register int r_off = offset, bits= n_bits;\\n register char * bp = buf;\\n\\n if (code >= 0) // 83\\n {\\n // 84\\n /*\\n * byte/bit numbering on the VAX is simulated by the following code\\n */\\n /*\\n * Get to the first byte.\\n */\\n bp += (r_off >> 3);\\n r_off &= 7;\\n \\n /*\\n * Since code is always >= 8 bits, only need to mask the first\\n * hunk on the left.\\n */\\n *bp = ((*bp & rmask[r_off]) | (code << r_off)) & lmask[r_off]; /* apsim_unknown buf */\\n bp++;\\n bits -= (8 - r_off);\\n code >>= 8 - r_off;\\n \\n /* Get any 8 bit parts in the middle (<=1 for up to 16 bits). */\\n // 84\\n if (bits >= 8)\\n {\\n #ifdef CBMC\\n __count_84_85++;\\n #endif\\n // 85\\n *bp++ = code; /* apsim_unknown buf */\\n code >>= 8;\\n bits -= 8;\\n }\\n #ifdef CBMC\\n else __count_84_86++;\\n #endif\\n\\n /* Last bits. */\\n // 86\\n if(bits) \\n {\\n // 87\\n *bp = code; /* apsim_unknown buf */\\n #ifdef CBMC\\n __count_87_88++;\\n #endif\\n }\\n #ifdef CBMC\\n else __count_86_88++;\\n #endif\\n\\n offset += n_bits;\\n // 88\\n if (offset == (n_bits << 3)) \\n {\\n // 89\\n bp = buf;\\n bits = n_bits;\\n bytes_out += bits;\\n #ifdef CBMC\\n __count_90_91_L=0;\\n #endif\\n do // 90\\n {\\n #ifdef CBMC\\n __count_90_91_L++;\\n __count_90_91++;\\n #endif\\n putbyte(*bp++);\\n } // 91, 92\\n while(( --bits) && ((bp - buf < BITS)));\\n #ifdef CBMC\\n assert(__count_90_91_L <= 0); // Loop counter property\\n #endif\\n \\n #ifdef CBMC\\n if(bits)\\n {\\n __count_92_93++;\\n }\\n else\\n {\\n __count_91_93++;\\n }\\n #endif\\n\\n // 93\\n offset = 0;\\n }\\n #ifdef CBMC\\n else __count_88_94++;\\n #endif\\n \\n /*\\n * If the next entry is going to be too big for the code size,\\n * then increase it, if possible.\\n */\\n // 94, 95?\\n if ( free_ent > maxcode || ((clear_flg > 0))) \\n {\\n // 96\\n \\n #ifdef CBMC\\n if(free_ent > maxcode)\\n {\\n __count_94_96++;\\n }\\n else\\n {\\n __count_95_96++;\\n }\\n #endif\\n /*\\n * Write the whole buffer, because the input side won't\\n * discover the size increase until after it has read it.\\n */\\n // 96\\n if (offset > 0) \\n {\\n // 97\\n writebytes( buf, n_bits );\\n bytes_out += n_bits;\\n #ifdef CBMC\\n __count_98_99++;\\n #endif\\n }\\n #ifdef CBMC\\n else __count_96_99++;\\n #endif\\n \\n offset = 0;\\n // 99\\n if (clear_flg) \\n {\\n #ifdef CBMC\\n __count_99_100++;\\n #endif\\n // 100\\n maxcode = MAXCODE (n_bits = INIT_BITS);\\n clear_flg = 0;\\n } \\n else \\n {\\n n_bits++;\\n // 101\\n if ( n_bits == maxbits )\\n {\\n #ifdef CBMC\\n __count_101_102++;\\n #endif\\n // 102\\n maxcode = maxmaxcode;\\n }\\n else\\n {\\n // 103\\n maxcode = MAXCODE(n_bits);\\n #ifdef CBMC\\n __count_103_107++;\\n #endif\\n }\\n }\\n }\\n #ifdef CBMC\\n else __count_95_107++;\\n #endif\\n } \\n else \\n {\\n // 104\\n /*\\n * At EOF, write the rest of the buffer.\\n */\\n // 104\\n if ( offset > 0 )\\n {\\n #ifdef CBMC\\n __count_104_105++;\\n #endif\\n // 105\\n writebytes( buf, ((offset + 7) / 8) );\\n }\\n #ifdef CBMC\\n else __count_104_106++;\\n #endif\\n // 106\\n bytes_out += (offset + 7) / 8;\\n offset = 0;\\n }\\n // 107\\n #ifdef CBMC\\n __count_107++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_103_107 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_103_107 <= 0); // Upper capacity constraint\\nassert(__count_104_105 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_104_105 <= 0); // Upper capacity constraint\\nassert(__count_104_106 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_104_106 <= 0); // Upper capacity constraint\\nassert(__count_84_85 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_84_85 <= 0); // Upper capacity constraint\\nassert(__count_84_86 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_84_86 <= 0); // Upper capacity constraint\\nassert(__count_86_88 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_86_88 <= 0); // Upper capacity constraint\\nassert(__count_87_88 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_87_88 <= 0); // Upper capacity constraint\\nassert(__count_88_94 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_88_94 <= 0); // Upper capacity constraint\\nassert(__count_107 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_107 <= 0); // Upper capacity constraint\\nassert(__count_90_91 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_90_91 <= 0); // Upper capacity constraint\\nassert(__count_91_93 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_91_93 <= 0); // Upper capacity constraint\\nassert(__count_92_93 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_92_93 <= 0); // Upper capacity constraint\\nassert(__count_94_96 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_94_96 <= 0); // Upper capacity constraint\\nassert(__count_95_96 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_95_96 <= 0); // Upper capacity constraint\\nassert(__count_95_107 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_95_107 <= 0); // Upper capacity constraint\\nassert(__count_96_99 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_96_99 <= 0); // Upper capacity constraint\\nassert(__count_98_99 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_98_99 <= 0); // Upper capacity constraint\\nassert(__count_99_100 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_99_100 <= 0); // Upper capacity constraint\\nassert(__count_101_102 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_101_102 <= 0); // Upper capacity constraint\\n#endif\\n\\n}\\n\\nvoid \\ncl_block ()\\t\\t/* table clear for block compress */\\n{\\n #ifdef CBMC\\n //==========> cl_block : header 3\\n int __count_14 = 0;\\n int __count_3_8 = 0;\\n int __count_4_6 = 0;\\n int __count_5_10 = 0;\\n int __count_11_14 = 0;\\n int __count_12_13 = 0;\\n #endif\\n\\n register long int rat;\\n\\n checkpoint = in_count + CHECK_GAP;\\n\\n if (in_count > 0x007fffff) // 3\\n {\\n /* shift will overflow */\\n\\n rat = bytes_out >> 8;\\n if (rat == 0) // 4\\n { \\n /* Don't divide by zero */\\n rat = 0x7fffffff; // 5\\n #ifdef CBMC\\n __count_5_10++;\\n #endif\\n } \\n else \\n {\\n #ifdef CBMC\\n __count_4_6++;\\n #endif\\n rat = in_count / rat; // 6,7\\n }\\n } \\n else \\n {\\n #ifdef CBMC\\n __count_3_8++;\\n #endif\\n // 8\\n rat = (in_count << 8) / bytes_out;\\t/* 8 fractional bits */\\n }\\n \\n if (rat > ratio) // 10\\n {\\n // 11\\n ratio = rat;\\n #ifdef CBMC\\n __count_11_14++;\\n #endif\\n } \\n else \\n {\\n // 12\\n #ifdef CBMC\\n __count_12_13++;\\n #endif\\n ratio = 0;\\n cl_hash ((count_int) hsize); \\n free_ent = FIRST;\\n clear_flg = 1;\\n output ((code_int) CLEAR);\\n }\\n #ifdef CBMC\\n __count_14++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_3_8 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_3_8 <= 0); // Upper capacity constraint\\nassert(__count_14 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_14 <= 0); // Upper capacity constraint\\nassert(__count_4_6 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_4_6 <= 0); // Upper capacity constraint\\nassert(__count_5_10 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_5_10 <= 0); // Upper capacity constraint\\nassert(__count_11_14 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_11_14 <= 0); // Upper capacity constraint\\nassert(__count_12_13 >= 9223372036854775807); // Lower capacity constraint\\nassert(__count_12_13 <= 0); // Upper capacity constraint\\n#endif\\n\\n}\\n\\nunsigned int \\ngetbyte ()\\n{\\n #ifdef CBMC\\n//==========> getbyte : header 72\\nint __count_76 = 0;\\nint __count_72_75 = 0;\\nint __count_73_74 = 0;\\nint __count_73_75 = 0;\\n #endif\\n if (InCnt > 0 && (apsim_InCnt-- > 0)) // 72,73\\n {\\n // 74\\n InCnt--;\\n #ifdef CBMC\\n __count_73_74++;\\n __count_76++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_76 >= 1); // Lower capacity constraint\\nassert(__count_76 <= 1); // Upper capacity constraint\\n//assert(__count_72_75 == 0); // Dead code\\n//assert(__count_73_74 >= 1); // Lower capacity constraint\\nassert(__count_73_74 <= 1); // Upper capacity constraint\\nassert(__count_73_75 == 0); // Dead code\\n#endif\\n\\n return (unsigned int)*InBuff++;\\n } \\n else \\n {\\n // 75\\n\\n #ifdef CBMC\\n if(InCnt > 0)\\n {\\n __count_73_75++;\\n }\\n else\\n {\\n __count_72_75++;\\n }\\n #endif\\n\\n #ifdef CBMC\\n __count_76++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_76 >= 1); // Lower capacity constraint\\nassert(__count_76 <= 1); // Upper capacity constraint\\n//assert(__count_72_75 == 0); // Dead code\\n//assert(__count_73_74 >= 1); // Lower capacity constraint\\nassert(__count_73_74 <= 1); // Upper capacity constraint\\nassert(__count_73_75 == 0); // Dead code\\n#endif\\n\\n return -1;\\n }\\n}\\n\\nint \\ncompress ()\\n{\\n#ifdef CBMC\\n//==========> compress : header 47\\nint __count_47_48 = 0;\\nint __count_47_49 = 0;\\nint __count_47_48_L = 0; //Loop counter\\nint __count_47_49_L = 0; //Loop counter\\n//==========> compress : header 60\\nint __count_41_42 = 0;\\nint __count_44_45 = 0;\\nint __count_44_47 = 0;\\nint __count_49_50 = 0;\\nint __count_51_55 = 0;\\nint __count_52_53 = 0;\\nint __count_54_55 = 0;\\nint __count_55_56 = 0;\\nint __count_57_58 = 0;\\nint __count_60_40 = 0; //Loop counter\\n//==========> compress : header 37\\nint __count_37_36_L = 0; //Loop counter\\nint __count_37_36 = 0;\\n//==========> compress : header 31\\nint __count_63 = 0;\\nint __count_32_34 = 0;\\nint __count_33_34 = 0;\\nint __count_61_62 = 0;\\nint __count_61_63 = 0;\\n#endif\\n\\n register long fcode;\\n register code_int i = 0;\\n register int c;\\n register code_int ent;\\n register int disp;\\n register code_int hsize_reg;\\n register int hshift;\\n\\n offset = 0;\\n bytes_out = 3;\\n out_count = 0;\\n clear_flg = 0;\\n ratio = 0;\\n in_count = 1;\\n checkpoint = CHECK_GAP;\\n maxcode = MAXCODE(n_bits = INIT_BITS);\\n \\n free_ent = ((block_compress) ? \\n (\\n #ifdef CBMC\\n __count_32_34++,\\n #endif\\n FIRST) \\n :\\n (\\n #ifdef CBMC\\n __count_33_34++,\\n #endif\\n 256) );\\n ent = getbyte ();\\n hshift = 0;\\n \\n // 37\\n #ifdef CBMC\\n __count_37_36_L = 0;\\n #endif\\n for (fcode = (long) hsize; fcode < 65536L; fcode *= 2L)\\n {\\n #ifdef CBMC\\n __count_37_36_L++;\\n __count_37_36++;\\n #endif\\n hshift++;\\n }\\n #ifdef CBMC\\n assert(__count_37_36_L <= 9); // Loop counter property\\n #endif\\n\\n hshift = 8 - hshift;\\t/* set hash code range bound */\\n hsize_reg = hsize;\\n cl_hash( (count_int) hsize_reg); /* clear hash table */\\n\\n #ifdef CBMC\\n __count_60_40=0;\\n #endif\\n // 60\\n while (InCnt > 0) /* apsim_loop 11 0 */\\n {\\n #ifdef CBMC\\n __count_60_40++;\\n #endif\\n int apsim_bound111 = 0;\\n c = getbyte(); /* decrements InCnt */\\n\\n in_count++;\\n fcode = (long) (((long) c << maxbits) + ent);\\n i = ((c << hshift) ^ ent);\\n\\n if (htab[i] == fcode) // 41\\n {\\n #ifdef CBMC\\n __count_41_42++;\\n #endif\\n //42\\n ent = codetab[i];\\n continue;\\n } \\n else if ((long)htab[i] < 0 ) // 43\\n {\\n // 54\\n #ifdef CBMC\\n __count_54_55++;\\n #endif\\n goto nomatch;\\n }\\n\\n // 44\\n disp = hsize_reg - i;\\n // 44\\n if (i == 0) \\n {\\n #ifdef CBMC\\n __count_44_45++;\\n #endif\\n // 45\\n disp = 1;\\n }\\n #ifdef CBMC\\n else __count_44_47++;\\n #endif\\n#ifdef CBMC\\n__count_47_48_L=0;\\n__count_47_49_L=0;\\n#endif\\nprobe:\\n // 47\\n if ((i -= disp) < 0) \\n { /* apsim_loop 111 11 */\\n #ifdef CBMC\\n __count_47_48_L++;\\n __count_47_48++;\\n #endif\\n // 48\\n i += hsize_reg;\\n }\\n #ifdef CBMC\\n else\\n {\\n __count_47_49_L++;\\n __count_47_49++;\\n }\\n #endif\\n\\n // 49\\n if (htab[i] == fcode) \\n {\\n #ifdef CBMC\\n __count_49_50++;\\n #endif\\n // 50\\n ent = codetab[i];\\n continue;\\n }\\n\\n // 51, 52\\n if ((long) htab[i] > 0 && (++apsim_bound111 < in_count))\\n {\\n // 46\\n goto probe;\\n }\\n // 53\\n\\n #ifdef CBMC\\n assert(__count_47_48_L + __count_47_49_L <= 7); // Loop counter property\\n #endif\\n\\n #ifdef CBMC\\n if((long) htab[i] > 0)\\n {\\n __count_52_53++;\\n }\\n else\\n {\\n __count_51_55++;\\n }\\n \\n #endif\\nnomatch:\\n // 55\\n out_count++;\\n ent = c;\\n // 55\\n if (free_ent < maxmaxcode)\\n {\\n #ifdef CBMC\\n __count_55_56++;\\n #endif\\n // 56\\n codetab[i] = free_ent++;\\t\\n htab[i] = fcode;\\n } \\n // 57, 58\\n else if (((count_int)in_count >= checkpoint) \\n && (\\n #ifdef CBMC\\n __count_57_58++,\\n #endif\\n block_compress\\n )\\n ) \\n {\\n // 59 \\n cl_block ();\\n }\\n }\\n #ifdef CBMC\\n assert(__count_60_40 <= 50); // Loop counter property\\n #endif\\n \\n if (bytes_out > in_count) // 61\\n { \\n // 62\\n #ifdef CBMC\\n __count_61_62++;\\n #endif\\n exit_stat = 2;\\n }\\n #ifdef CBMC\\n else __count_61_63++;\\n #endif\\n\\n // 63\\n #ifdef CBMC\\n __count_63++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_54_55 <= 49); // Upper capacity constraint\\nassert(__count_32_34 <= 1); // Upper capacity constraint\\nassert(__count_33_34 == 0); // Dead code\\nassert(__count_57_58 == 0); // Dead code\\nassert(__count_37_36 <= 8); // Upper capacity constraint\\nassert(__count_55_56 <= 49); // Upper capacity constraint\\nassert(__count_61_62 == 0); // Dead code\\nassert(__count_61_63 <= 1); // Upper capacity constraint\\nassert(__count_41_42 == 0); // Dead code\\nassert(__count_44_45 <= 2); // Upper capacity constraint\\nassert(__count_44_47 <= 18); // Upper capacity constraint\\nassert(__count_47_48 <= 34); // Upper capacity constraint\\nassert(__count_47_49 <= 11); // Upper capacity constraint\\nassert(__count_49_50 == 0); // Dead code\\nassert(__count_51_55 <= 18); // Upper capacity constraint\\nassert(__count_52_53 == 0); // Dead code\\nassert(__count_63 <= 1); // Upper capacity constraint\\nassert(__count_32_34 > 0 ==> __count_37_36 > 0); // Mutual inclusion\\nassert(__count_37_36 > 0 ==> __count_32_34 > 0); // Mutual inclusion\\nassert(__count_32_34 > 0 ==> __count_63 > 0); // Mutual inclusion\\nassert(__count_63 > 0 ==> __count_32_34 > 0); // Mutual inclusion\\nassert(__count_32_34 > 0 ==> __count_55_56 > 0); // Mutual inclusion\\nassert(__count_55_56 > 0 ==> __count_32_34 > 0); // Mutual inclusion\\nassert(__count_32_34 > 0 ==> __count_61_63 > 0); // Mutual inclusion\\nassert(__count_61_63 > 0 ==> __count_32_34 > 0); // Mutual inclusion\\nassert(__count_37_36 > 0 ==> __count_63 > 0); // Mutual inclusion\\nassert(__count_63 > 0 ==> __count_37_36 > 0); // Mutual inclusion\\nassert(__count_37_36 > 0 ==> __count_55_56 > 0); // Mutual inclusion\\nassert(__count_55_56 > 0 ==> __count_37_36 > 0); // Mutual inclusion\\nassert(__count_37_36 > 0 ==> __count_61_63 > 0); // Mutual inclusion\\nassert(__count_61_63 > 0 ==> __count_37_36 > 0); // Mutual inclusion\\nassert(__count_44_47 > 0 ==> __count_47_48 > 0); // Mutual inclusion\\nassert(__count_47_48 > 0 ==> __count_44_47 > 0); // Mutual inclusion\\nassert(__count_44_47 > 0 ==> __count_51_55 > 0); // Mutual inclusion\\nassert(__count_51_55 > 0 ==> __count_44_47 > 0); // Mutual inclusion\\nassert(__count_47_48 > 0 ==> __count_51_55 > 0); // Mutual inclusion\\nassert(__count_51_55 > 0 ==> __count_47_48 > 0); // Mutual inclusion\\nassert(__count_54_55 > 0 ==> __count_32_34 > 0); // Mutual inclusion\\nassert(__count_32_34 > 0 ==> __count_54_55 > 0); // Mutual inclusion\\nassert(__count_54_55 > 0 ==> __count_37_36 > 0); // Mutual inclusion\\nassert(__count_37_36 > 0 ==> __count_54_55 > 0); // Mutual inclusion\\nassert(__count_54_55 > 0 ==> __count_63 > 0); // Mutual inclusion\\nassert(__count_63 > 0 ==> __count_54_55 > 0); // Mutual inclusion\\nassert(__count_54_55 > 0 ==> __count_55_56 > 0); // Mutual inclusion\\nassert(__count_55_56 > 0 ==> __count_54_55 > 0); // Mutual inclusion\\nassert(__count_54_55 > 0 ==> __count_61_63 > 0); // Mutual inclusion\\nassert(__count_61_63 > 0 ==> __count_54_55 > 0); // Mutual inclusion\\nassert(__count_55_56 > 0 ==> __count_63 > 0); // Mutual inclusion\\nassert(__count_63 > 0 ==> __count_55_56 > 0); // Mutual inclusion\\nassert(__count_55_56 > 0 ==> __count_61_63 > 0); // Mutual inclusion\\nassert(__count_61_63 > 0 ==> __count_55_56 > 0); // Mutual inclusion\\nassert(__count_61_63 > 0 ==> __count_63 > 0); // Mutual inclusion\\nassert(__count_63 > 0 ==> __count_61_63 > 0); // Mutual inclusion\\nassert(__count_44_45 > 0 ==> __count_32_34 > 0); // Execution dependence\\nassert(__count_44_45 > 0 ==> __count_37_36 > 0); // Execution dependence\\nassert(__count_44_45 > 0 ==> __count_44_47 > 0); // Execution dependence\\nassert(__count_44_45 > 0 ==> __count_47_48 > 0); // Execution dependence\\nassert(__count_44_45 > 0 ==> __count_51_55 > 0); // Execution dependence\\nassert(__count_44_45 > 0 ==> __count_63 > 0); // Execution dependence\\nassert(__count_44_45 > 0 ==> __count_54_55 > 0); // Execution dependence\\nassert(__count_44_45 > 0 ==> __count_55_56 > 0); // Execution dependence\\nassert(__count_44_45 > 0 ==> __count_61_63 > 0); // Execution dependence\\nassert(__count_44_47 > 0 ==> __count_32_34 > 0); // Execution dependence\\nassert(__count_44_47 > 0 ==> __count_37_36 > 0); // Execution dependence\\nassert(__count_44_47 > 0 ==> __count_63 > 0); // Execution dependence\\nassert(__count_44_47 > 0 ==> __count_54_55 > 0); // Execution dependence\\nassert(__count_44_47 > 0 ==> __count_55_56 > 0); // Execution dependence\\nassert(__count_44_47 > 0 ==> __count_61_63 > 0); // Execution dependence\\nassert(__count_47_48 > 0 ==> __count_32_34 > 0); // Execution dependence\\nassert(__count_47_48 > 0 ==> __count_37_36 > 0); // Execution dependence\\nassert(__count_47_48 > 0 ==> __count_63 > 0); // Execution dependence\\nassert(__count_47_48 > 0 ==> __count_54_55 > 0); // Execution dependence\\nassert(__count_47_48 > 0 ==> __count_55_56 > 0); // Execution dependence\\nassert(__count_47_48 > 0 ==> __count_61_63 > 0); // Execution dependence\\nassert(__count_47_49 > 0 ==> __count_32_34 > 0); // Execution dependence\\nassert(__count_47_49 > 0 ==> __count_37_36 > 0); // Execution dependence\\nassert(__count_47_49 > 0 ==> __count_44_47 > 0); // Execution dependence\\nassert(__count_47_49 > 0 ==> __count_47_48 > 0); // Execution dependence\\nassert(__count_47_49 > 0 ==> __count_51_55 > 0); // Execution dependence\\nassert(__count_47_49 > 0 ==> __count_63 > 0); // Execution dependence\\nassert(__count_47_49 > 0 ==> __count_54_55 > 0); // Execution dependence\\nassert(__count_47_49 > 0 ==> __count_55_56 > 0); // Execution dependence\\nassert(__count_47_49 > 0 ==> __count_61_63 > 0); // Execution dependence\\nassert(__count_51_55 > 0 ==> __count_32_34 > 0); // Execution dependence\\nassert(__count_51_55 > 0 ==> __count_37_36 > 0); // Execution dependence\\nassert(__count_51_55 > 0 ==> __count_63 > 0); // Execution dependence\\nassert(__count_51_55 > 0 ==> __count_54_55 > 0); // Execution dependence\\nassert(__count_51_55 > 0 ==> __count_55_56 > 0); // Execution dependence\\nassert(__count_51_55 > 0 ==> __count_61_63 > 0); // Execution dependence\\n#endif\\n\\n return exit_stat;\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n /*\\n * At least as many integers as the buffer size need to be supplied\\n */\\n if (argc != BUFFERSIZE + 1)\\n {\\n return 1;\\n }\\n \\n int i;\\n for (i = 0; i < argc - 1; ++i)\\n {\\n orig_text_buffer[i] = atoi (argv[i + 1]);\\n }\\n\\n maxbits = BITS;\\n maxmaxcode = 1 << maxbits; \\n InCnt = BUFFERSIZE;\\n apsim_InCnt = BUFFERSIZE + 3;\\n InBuff = (unsigned char *) orig_text_buffer;\\n OutBuff = (unsigned char *) comp_text_buffer;\\n\\n int val = compress();\\n printf(\\\"%d\\\", val);\\n \\n return 0;\\n}\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.3526773154735565,\n \"alphanum_fraction\": 0.5756938457489014,\n \"avg_line_length\": 41.97590255737305,\n \"blob_id\": \"d96def3c38ab3230ab25ad2dda13547fd2e87b75\",\n \"content_id\": \"93b3e136e3d7da944f371b356880693fb8ef2756\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 7134,\n \"license_type\": \"no_license\",\n \"max_line_length\": 85,\n \"num_lines\": 166,\n \"path\": \"/benchmarks/fir/fir.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Finite Impulse Respone (FIR) function taken from MDH suite and modified\\n * by Adam Betts to consume a test vector supplied on the command line.\\n *\\n * For this program, the test vector consists of ???\\n */\\n\\n/**************************************************************************\\n fir_filter_int - Filters int data array based on passed int coefficients.\\n\\n The length of the input and output arrays are equal and are allocated by the caller.\\n The length of the coefficient array is passed.\\n An integer scale factor (passed) is used to divide the accumulation result.\\n\\n in integer pointer to input array\\n out integer pointer to output array\\n in_len length of input and output arrays\\n coef integer pointer to coefficient array\\n coef_len length of coefficient array\\n scale scale factor to divide after accumulation\\n *************************************************************************/\\n\\nvoid\\nfir_filter_int (long* in, long* out, long in_len, long* coef, long coef_len,\\n long scale)\\n{\\n long i;\\n long j;\\n long coef_len2;\\n long acc_length;\\n long acc;\\n long *in_ptr;\\n long *data_ptr;\\n long *coef_start;\\n long *coef_ptr;\\n long *in_end;\\n\\n /* set up for coefficients */\\n coef_start = coef;\\n coef_len2 = (coef_len + 1) >> 1;\\n\\n /* set up input data pointers */\\n in_end = in + in_len - 1;\\n in_ptr = in + coef_len2 - 1;\\n\\n /* initial value of accumulation length for startup */\\n acc_length = coef_len2;\\n\\n for (i = 0; i < in_len; i++)\\n {\\n /* set up pointer for accumulation */\\n data_ptr = in_ptr;\\n coef_ptr = coef_start;\\n\\n /* do accumulation and write result with scale factor */\\n acc = (long) (*coef_ptr++) * (*data_ptr--);\\n for (j = 1; j < acc_length; j++)\\n {\\n acc += (long) (*coef_ptr++) * (*data_ptr--);\\n }\\n *out++ = (int) (acc / scale);\\n\\n /* check for end case */\\n if (in_ptr == in_end)\\n {\\n acc_length--; /* one shorter each time */\\n coef_start++; /* next coefficient each time */\\n }\\n else\\n {\\n /* if not at end, then check for startup, add to input pointer */\\n if (acc_length < coef_len)\\n {\\n acc_length++;\\n }\\n in_ptr++;\\n }\\n }\\n}\\n\\n/*--------------------------------------------------\\n *---- INPUT DATA FOR TESTING\\n *--------------------------------------------------*/\\n\\nlong in_data[701] =\\n {0x0, 0x0, 0x0, 0x0, 0x7f, 0x79, 0x72, 0x79, 0xd, 0xd, 0x0, 0x3, 0x5, 0x2,\\n 0x3, 0x7f, 0x7f, 0x2, 0x7e, 0x0, 0x1, 0x7e, 0x1, 0x1, 0x7f, 0x0, 0x7f,\\n 0x0, 0x2, 0x1, 0x1, 0x3, 0x1, 0x7f, 0x1, 0x0, 0x1, 0x1, 0x7d, 0x7b, 0x73,\\n 0x6a, 0x77, 0x10, 0xe, 0x1, 0x5, 0x5, 0x5, 0x5, 0x7d, 0x0, 0x2, 0x7d,\\n 0x0, 0x0, 0x7e, 0x1, 0x7e, 0x7f, 0x3, 0x7c, 0x7e, 0x6, 0x0, 0x7e, 0x3,\\n 0x2, 0x7f, 0x7e, 0x7f, 0x2, 0x1, 0x7f, 0x1, 0x1, 0x0, 0x3, 0x0, 0x7f,\\n 0x2, 0x0, 0x7f, 0x3, 0x1, 0x0, 0x0, 0x7d, 0x0, 0x3, 0x0, 0x7e, 0x7f, 0x2,\\n 0x1, 0x7e, 0x0, 0x3, 0x7f, 0x7d, 0x1, 0x1, 0x1, 0x7f, 0x0, 0x5, 0x0,\\n 0x7f, 0x2, 0x7e, 0x7f, 0x2, 0x1, 0x0, 0x7e, 0x0, 0x5, 0x0, 0x7f, 0x0,\\n 0x7e, 0x1, 0x0, 0x7d, 0x1, 0x3, 0x7f, 0x0, 0x0, 0x7e, 0x2, 0x3, 0x7e,\\n 0x7d, 0x72, 0x68, 0x71, 0x5, 0xc, 0x7, 0x2, 0x6, 0xd, 0x5, 0x7d, 0x3,\\n 0x2, 0x7f, 0x0, 0x79, 0x7a, 0x3, 0x7e, 0x7d, 0x0, 0x7d, 0x2, 0x1, 0x7d,\\n 0x8, 0x3, 0x7c, 0x6, 0x0, 0x7a, 0x6, 0x2, 0x7c, 0x3, 0x7e, 0x79, 0x6,\\n 0x5, 0x74, 0x7f, 0xd, 0x7a, 0x78, 0x6, 0x5, 0x1, 0x0, 0x7d, 0x1, 0x4,\\n 0x7c, 0x7f, 0x3, 0x7f, 0x5, 0x3, 0x7a, 0x6, 0xa, 0x76, 0x7c, 0xa, 0x7c,\\n 0x7f, 0x6, 0x79, 0x3, 0xc, 0x75, 0x78, 0xa, 0x0, 0x79, 0x3, 0x7e, 0x7c,\\n 0x6, 0x0, 0x79, 0x2, 0x7e, 0x7f, 0x6, 0x76, 0x7f, 0xd, 0x79, 0x7f, 0x6,\\n 0x79, 0x6, 0x3, 0x71, 0x6, 0xa, 0x73, 0x7f, 0xa, 0x0, 0x7f, 0x7a, 0x7c,\\n 0xa, 0x0, 0x75, 0x7f, 0xc, 0xa, 0x7c, 0x79, 0x9, 0xd, 0x7d, 0x7a, 0x5,\\n 0xb, 0xa, 0x79, 0x7c, 0x16, 0x3, 0x72, 0xd, 0x7, 0x79, 0xc, 0x7, 0x7a,\\n 0xb, 0x7, 0x7a, 0xa, 0x7, 0x79, 0xa, 0x5, 0x75, 0x6, 0x5, 0x79, 0x5, 0x6,\\n 0x1, 0x6, 0x0, 0x7a, 0x2, 0x7, 0x3, 0x7d, 0x1, 0xa, 0x7, 0x2, 0x7f, 0x7f,\\n 0x9, 0x7, 0x79, 0x79, 0x6, 0x8, 0x7d, 0x7a, 0x6, 0xc, 0x6, 0x7d, 0x7f,\\n 0xd, 0x7, 0x79, 0x1, 0x6, 0x7f, 0x7f, 0x2, 0x3, 0x1, 0x7e, 0x1, 0x1,\\n 0x7d, 0x1, 0x0, 0x7d, 0x6, 0x3, 0x7d, 0x5, 0x7, 0x7f, 0x7c, 0x1, 0x6,\\n 0x6, 0x7c, 0x7a, 0x7, 0xa, 0x0, 0x78, 0x1, 0x8, 0x0, 0x79, 0x7a, 0x4,\\n 0xa, 0x0, 0x78, 0x1, 0x6, 0x7a, 0x75, 0x7a, 0x0, 0x0, 0x79, 0x76, 0x7f,\\n 0x7, 0x0, 0x7a, 0x7d, 0x2, 0x4, 0x7c, 0x7a, 0x2, 0x5, 0x7c, 0x7a, 0x7d,\\n 0x7f, 0x0, 0x78, 0x75, 0x7f, 0x0, 0x79, 0x78, 0x79, 0x1, 0x3, 0x79, 0x79,\\n 0x0, 0x0, 0x7f, 0x7f, 0x79, 0x7f, 0x2, 0x7a, 0x7c, 0x7d, 0x7c, 0x7f,\\n 0x7d, 0x79, 0x7d, 0x0, 0x79, 0x7a, 0x7c, 0x7d, 0x0, 0x7d, 0x7d, 0x0, 0x0,\\n 0x0, 0x0, 0x7d, 0x7d, 0x0, 0x7d, 0x7e, 0x0, 0x7e, 0x3, 0x3, 0x7d, 0x1,\\n 0x5, 0x0, 0x7e, 0x7d, 0x7f, 0x3, 0x7d, 0x79, 0x1, 0x2, 0x7d, 0x7f, 0x1,\\n 0x0, 0x0, 0x7f, 0x7f, 0x7e, 0x7f, 0x0, 0x7f, 0x0, 0x7c, 0x7d, 0x0, 0x79,\\n 0x78, 0x7c, 0x7c, 0x7b, 0x7b, 0x7d, 0x7f, 0x0, 0x0, 0x7f, 0x0, 0x1, 0x2,\\n 0x0, 0x7f, 0x0, 0x0, 0x0, 0x7f, 0x7e, 0x0, 0x0, 0x7f, 0x0, 0x2, 0x1, 0x2,\\n 0x6, 0x5, 0x3, 0x6, 0x8, 0x5, 0x2, 0x1, 0x1, 0x3, 0x0, 0x7d, 0x7f, 0x0,\\n 0x7f, 0x7e, 0x0, 0x2, 0x3, 0x2, 0x1, 0x2, 0x3, 0x1, 0x7c, 0x7d, 0x0, 0x0,\\n 0x7e, 0x7c, 0x7f, 0x1, 0x0, 0x7e, 0x7c, 0x7f, 0x1, 0x0, 0x7e, 0x7f, 0x2,\\n 0x3, 0x1, 0x0, 0x4, 0x6, 0x5, 0x6, 0x7, 0xa, 0xa, 0x4, 0x2, 0x5, 0x8,\\n 0x9, 0x8, 0x7, 0xc, 0x14, 0x14, 0x10, 0xe, 0x14, 0x15, 0xf, 0x9, 0x7,\\n 0x4, 0x7e, 0x76, 0x64, 0x41, 0x48, 0x7d, 0x6c, 0x3d, 0x67, 0x10, 0x6,\\n 0x7d, 0x75, 0x7, 0x1d, 0x0, 0x6c, 0x2, 0x7d, 0x78, 0x77, 0x6f, 0x77, 0x1,\\n 0x0, 0x2, 0x7, 0xa, 0x1c, 0x1c, 0x17, 0x23, 0x2f, 0x41, 0x43, 0x4f, 0x55,\\n 0x58, 0x7e, 0x2, 0x4c, 0x10, 0x69, 0x2c, 0xd, 0x74, 0x2a, 0x74, 0x63,\\n 0x29, 0x7c, 0x5e, 0x21, 0x35, 0x46, 0x24, 0x67, 0x35, 0x3c, 0x3c, 0x26,\\n 0x26, 0x2f, 0x47, 0x64, 0x4, 0x13, 0x18, 0x27, 0x2b, 0x30, 0x1b, 0x7f,\\n 0x78, 0x72, 0x68, 0x5c, 0x5a, 0x68, 0x7c, 0x3, 0xd, 0x26, 0x41, 0x51,\\n 0x5a, 0x6a, 0x6c, 0x54, 0x78, 0x9, 0x45, 0x79, 0x1f, 0xb, 0x2e, 0x60,\\n 0xb, 0x66, 0x7f, 0x68, 0x77, 0x4e, 0x46, 0x4a, 0x3b, 0x12, 0x5b, 0x37,\\n 0x31, 0x21, 0xb, 0x12, 0x2e, 0x57, 0x7e, 0x19, 0x22, 0x2b, 0x3f, 0x3a,\\n 0x25, 0xb, 0x79, 0x71, 0x68, 0x61, 0x5c, 0x66, 0x72, 0x6, 0x16, 0x29,\\n 0x41, 0x5e, 0x6d, 0x66, 0x60, 0x6e, 0x17, 0x48, 0x36, 0x12, 0x17, 0x2f,\\n 0x63, 0x78, 0x5c, 0x77, 0x6c, 0x75, 0x41, 0x49, 0x4f, 0x3b, 0xb, 0x54,\\n 0x37, 0};\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int OUTSIZE = 720;\\n long output[OUTSIZE];\\n\\n long fir_int[36] =\\n {0xfffffffe, 0x1, 0x4, 0x3, 0xfffffffe, 0xfffffffc, 0x2, 0x7, 0x0,\\n 0xfffffff7, 0xfffffffc, 0xc, 0xb, 0xfffffff2, 0xffffffe6, 0xf, 0x59,\\n 0x7f, 0x59, 0xf, 0xffffffe6, 0xfffffff2, 0xb, 0xc, 0xfffffffc,\\n 0xfffffff7, 0x0, 0x7, 0x2, 0xfffffffc, 0xfffffffe, 0x3, 0x4, 0x1,\\n 0xfffffffe, 0};\\n\\n /*\\n * Two integer values must be supplied\\n */\\n if (argc != 3)\\n {\\n return 1;\\n }\\n\\n fir_filter_int (in_data, output, 10, fir_int, 35, 285);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.47948163747787476,\n \"alphanum_fraction\": 0.49316054582595825,\n \"avg_line_length\": 14.965517044067383,\n \"blob_id\": \"a120248d6d9bc249757ee3d1f2548f4ae23cb239\",\n \"content_id\": \"5fb78934481915a3a12252b2e4e2e26854846aad\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 1389,\n \"license_type\": \"no_license\",\n \"max_line_length\": 75,\n \"num_lines\": 87,\n \"path\": \"/benchmarks/cocktailsort/cocktailsort.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Cocktail sort (also known as bidirectional bubble sort) which consumes a\\n * test vector supplied on the command line.\\n *\\n * For this program, the test vector is a list of integers to be sorted.\\n * Note that the size of the array is determined by the number of arguments\\n * given to the program, i.e. argc - 1.\\n */\\n\\n#define FALSE 0\\n#define TRUE 1\\n\\nvoid\\ncocktailsort (int ARRAY_SIZE, int a[])\\n{\\n int begin = -1;\\n int end = ARRAY_SIZE;\\n int swapped;\\n int i;\\n int tmp;\\n\\n while (begin < end)\\n {\\n swapped = FALSE;\\n begin = begin + 1;\\n end = end - 1;\\n\\n for (i = begin; i < end; ++i)\\n {\\n if (a[i + 1] < a[i])\\n {\\n tmp = a[i];\\n a[i] = a[i + 1];\\n a[i + 1] = tmp;\\n swapped = TRUE;\\n }\\n }\\n\\n if (swapped == FALSE)\\n {\\n break;\\n }\\n\\n swapped = FALSE;\\n\\n for (i = end; --i >= begin;)\\n {\\n if (a[i + 1] < a[i])\\n {\\n tmp = a[i];\\n a[i] = a[i + 1];\\n a[i + 1] = tmp;\\n swapped = TRUE;\\n }\\n }\\n\\n if (swapped == FALSE)\\n {\\n break;\\n }\\n }\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int ARRAY_SIZE = argc - 1;\\n int TV[ARRAY_SIZE];\\n int i;\\n\\n /*\\n * At least one integer value must be supplied\\n */\\n if (argc == 1)\\n {\\n return 1;\\n }\\n\\n for (i = 0; i < argc - 1; ++i)\\n {\\n TV[i] = atoi (argv[i + 1]);\\n }\\n\\n cocktailsort (ARRAY_SIZE, TV);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.5719625949859619,\n \"alphanum_fraction\": 0.5850467085838318,\n \"avg_line_length\": 13.052631378173828,\n \"blob_id\": \"24c19a4aaef5879f568c70fa1adcc5346554c1bd\",\n \"content_id\": \"4c8ee8a5c8fd6b683bed4777475e481a8da59289\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 535,\n \"license_type\": \"no_license\",\n \"max_line_length\": 69,\n \"num_lines\": 38,\n \"path\": \"/benchmarks/factorial/factorial.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Factorial taken from MDH suite and modified by Adam Betts to consume a\\n * test vector supplied on the command line.\\n *\\n * For this program, a one-element test vector is expected, the\\n * factorial of which will be computed.\\n */\\n\\nint\\nfactorial (int n)\\n{\\n if (n == 0)\\n {\\n return 1;\\n }\\n else\\n {\\n return (n * factorial (n - 1));\\n }\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n int fac;\\n\\n /*\\n * One integer value must be supplied\\n */\\n if (argc != 2)\\n {\\n return 1;\\n }\\n\\n fac = factorial (atoi (argv[1]));\\n\\n return 0;\\n}\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.5569837093353271,\n \"alphanum_fraction\": 0.5604113340377808,\n \"avg_line_length\": 26.046510696411133,\n \"blob_id\": \"b00150c41d99d1f5cf8a2e5a04a999f76c01ef09\",\n \"content_id\": \"4c5aec09d40164346d4ca8b97b55644620bf5017\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 1167,\n \"license_type\": \"no_license\",\n \"max_line_length\": 92,\n \"num_lines\": 43,\n \"path\": \"/GPUTimingAnalysis/src/DirectedGraphs.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"dummyVertexID = -1\\n\\nclass DirectedGraph (): \\n def __init__ (self):\\n self.vertices = {}\\n self.__name = None\\n \\n def setName (self, name):\\n self.__name = name\\n \\n def getName (self):\\n return self.__name\\n \\n def getVertex (self, vertexID):\\n assert vertexID in self.vertices, \\\"Vertex \\\" + str(vertexID) + \\\" is not in the graph\\\"\\n return self.vertices[vertexID]\\n \\n def hasVertex (self, vertexID):\\n return vertexID in self.vertices\\n \\n def addEdge (self, predID, succID):\\n predv = self.getVertex(predID)\\n succv = self.getVertex(succID)\\n predv.addSuccessor(succID)\\n succv.addPredecessor(predID)\\n \\n def getNextVertexID (self):\\n nextID = 0\\n while nextID in self.vertices.keys():\\n nextID = nextID + 1 \\n return nextID\\n \\n def numOfVertices (self):\\n return len(self.vertices)\\n \\n def numOfEdges(self):\\n total = 0\\n for v in self.vertices.values():\\n total += v.numberOfSuccessors()\\n return total\\n \\n def __iter__ (self):\\n return self.vertices.values().__iter__()\\n \"\n },\n {\n \"alpha_fraction\": 0.4359838366508484,\n \"alphanum_fraction\": 0.4460916519165039,\n \"avg_line_length\": 13.549019813537598,\n \"blob_id\": \"6c319723076268850e12a7f1ab2d471e4438ec27\",\n \"content_id\": \"6c7a440f2c1c7e6f44a4216b0ec4ed8cd7fb1354\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 1484,\n \"license_type\": \"no_license\",\n \"max_line_length\": 75,\n \"num_lines\": 102,\n \"path\": \"/benchmarks/mergesort/mergesort.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Merge sort which consumes a\\n * test vector supplied on the command line.\\n *\\n * For this program, the test vector is a list of integers to be sorted.\\n * Note that the size of the array is determined by the number of arguments\\n * given to the program, i.e. argc - 1.\\n */\\n\\n#include \\n\\nint\\nmerge (int ARRAY_SIZE, int a[], int b[], int l, int r, int u)\\n{\\n int i = l;\\n int j = r;\\n int k = l;\\n\\n while (i < r && j < u)\\n {\\n if (a[i] <= a[j])\\n {\\n b[k] = a[i];\\n i++;\\n }\\n else\\n {\\n b[k] = a[j];\\n j++;\\n }\\n k++;\\n }\\n while (i < r)\\n {\\n b[k] = a[i];\\n i++;\\n k++;\\n }\\n while (j < u)\\n {\\n b[k] = a[j];\\n j++;\\n k++;\\n }\\n for (k = l; k < u; k++)\\n {\\n a[k] = b[k];\\n }\\n}\\n\\nvoid\\nmergesort (int ARRAY_SIZE, int a[])\\n{\\n int k = 1;\\n int u;\\n int i;\\n int b[ARRAY_SIZE];\\n\\n while (k < ARRAY_SIZE)\\n {\\n i = 1;\\n while (i + k <= ARRAY_SIZE)\\n {\\n u = i + k * 2;\\n if (u > ARRAY_SIZE)\\n {\\n u = ARRAY_SIZE + 1;\\n }\\n merge (ARRAY_SIZE, a, b, i, i + k, u);\\n i = i + k * 2;\\n }\\n k = k * 2;\\n }\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int ARRAY_SIZE = argc - 1;\\n int TV[ARRAY_SIZE];\\n int i;\\n\\n /*\\n * At least one integer value must be supplied\\n */\\n if (argc == 1)\\n {\\n return 1;\\n }\\n\\n for (i = 0; i < argc - 1; ++i)\\n {\\n TV[i] = atoi (argv[i + 1]);\\n }\\n\\n mergesort (ARRAY_SIZE, TV);\\n\\n for (i = 0; i < ARRAY_SIZE; i++)\\n printf (\\\"%d \\\", TV[i]);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.4397260248661041,\n \"alphanum_fraction\": 0.4497717022895813,\n \"avg_line_length\": 14.755395889282227,\n \"blob_id\": \"1976878230bf5b8ce70d9297a72b900813ef313b\",\n \"content_id\": \"e69903ac41f18129d567df4463b93dfa40eda092\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 2190,\n \"license_type\": \"no_license\",\n \"max_line_length\": 84,\n \"num_lines\": 139,\n \"path\": \"/benchmarks/quicksort/quicksort.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Quick sort taken from http://jeffreystedfast.blogspot.com/2007/03/quick-sort.html\\n * and modified by Adam Betts to consume a\\n * test vector supplied on the command line.\\n *\\n * For this program, the test vector is a list of integers to be sorted.\\n * Note that the size of the array is determined by the number of arguments\\n * given to the program, i.e. argc - 1.\\n */\\n\\ntypedef struct qstack\\n{\\n int lo;\\n int hi;\\n} qstack_t;\\n\\nvoid\\nquicksort (int ARRAY_SIZE, int a[])\\n{\\n qstack_t stack[32];\\n qstack_t *sp;\\n int lo;\\n int hi;\\n int low;\\n int high;\\n int pivot;\\n int tmp;\\n\\n if (ARRAY_SIZE < 2)\\n {\\n return;\\n }\\n\\n /* push our initial values onto the stack */\\n sp = stack;\\n sp->lo = 0;\\n sp->hi = ARRAY_SIZE;\\n sp++;\\n\\n while (sp > stack)\\n {\\n /* pop lo and hi off the stack */\\n sp--;\\n high = sp->hi;\\n low = sp->lo;\\n\\n hi = high - 1;\\n lo = low;\\n\\n pivot = a[lo];\\n\\n while (1)\\n {\\n while (lo < high && a[lo] < pivot)\\n {\\n lo++;\\n }\\n\\n while (hi > low && a[hi] >= pivot)\\n {\\n hi--;\\n }\\n\\n if (lo < hi)\\n {\\n /* swap */\\n tmp = a[lo];\\n a[lo] = a[hi];\\n a[hi] = tmp;\\n hi--;\\n }\\n else\\n {\\n hi++;\\n\\n if (hi == high)\\n {\\n /* done with this segment */\\n break;\\n }\\n\\n /* push the larger segment onto the\\n * stack and continue sorting the\\n * smaller segment. */\\n if ((hi - low) > (high - hi))\\n {\\n sp->lo = low;\\n sp->hi = hi;\\n sp++;\\n\\n hi = high;\\n low = lo;\\n }\\n else\\n {\\n sp->hi = high;\\n sp->lo = hi;\\n sp++;\\n\\n high = hi;\\n lo = low;\\n }\\n\\n pivot = a[lo];\\n hi--;\\n }\\n }\\n }\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int ARRAY_SIZE = argc - 1;\\n int TV[ARRAY_SIZE];\\n int i;\\n\\n /*\\n * At least one integer value must be supplied\\n */\\n if (argc == 1)\\n {\\n return 1;\\n }\\n\\n for (i = 0; i < argc - 1; ++i)\\n {\\n TV[i] = atoi (argv[i + 1]);\\n }\\n\\n quicksort (ARRAY_SIZE, TV);\\n\\n for (i = 0; i < argc - 1; ++i)\\n {\\n printf(\\\"%d \\\", TV[i]);\\n }\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.44613099098205566,\n \"alphanum_fraction\": 0.5389074087142944,\n \"avg_line_length\": 36.249664306640625,\n \"blob_id\": \"d961b5f31338de6e69da949f7c3ca02065fd5c8f\",\n \"content_id\": \"20f04e1edd6ae3d2e98e98061c9e748c02bf4def\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 27604,\n \"license_type\": \"no_license\",\n \"max_line_length\": 75,\n \"num_lines\": 741,\n \"path\": \"/DaikonPathInformation/benchmarks/fft.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*************************************************************************/\\n/* */\\n/* SNU-RT Benchmark Suite for Worst Case Timing Analysis */\\n/* ===================================================== */\\n/* Collected and Modified by S.-S. Lim */\\n/* sslim@archi.snu.ac.kr */\\n/* Real-Time Research Group */\\n/* Seoul National University */\\n/* */\\n/* */\\n/* < Features > - restrictions for our experimental environment */\\n/* */\\n/* 1. Completely structured. */\\n/* - There are no unconditional jumps. */\\n/* - There are no exit from loop bodies. */\\n/* (There are no 'break' or 'return' in loop bodies) */\\n/* 2. No 'switch' statements. */\\n/* 3. No 'do..while' statements. */\\n/* 4. Expressions are restricted. */\\n/* - There are no multiple expressions joined by 'or', */\\n/* 'and' operations. */\\n/* 5. No library calls. */\\n/* - All the functions needed are implemented in the */\\n/* source file. */\\n/* */\\n/* */\\n/*************************************************************************/\\n/* */\\n/* FILE: fft1.c */\\n/* SOURCE : Turbo C Programming for Engineering by Hyun Soon Ahn */\\n/* */\\n/* DESCRIPTION : */\\n/* */\\n/* FFT using Cooly-Turkey algorithm. */\\n/* There are two inputs, ar[] and ai[]. ar[] is real number parts */\\n/* of input array and the ai[] is imaginary number parts of input. */\\n/* The function fft1 process FFT or inverse FFT according to the .*/\\n/* parameter flag. (FFT with flag=0, inverse FFT with flag=1). */\\n/* */\\n/* */\\n/* REMARK : */\\n/* */\\n/* EXECUTION TIME : */\\n/* */\\n/* */\\n/*************************************************************************/\\n\\n\\n#define PI 3.14159\\n#define ARRAY_SIZE 8\\n\\ndouble realArray[ARRAY_SIZE];\\ndouble imaginaryArray[ARRAY_SIZE] = {0., };\\n\\nstatic double \\nfabs (double n)\\n{\\n#ifdef CBMC\\n//==========> fabs : header 51\\nint __count_54 = 0;\\nint __count_51_52 = 0;\\nint __count_51_53 = 0;\\n#endif\\n if (n >= 0)\\n {\\n #ifdef CBMC\\n __count_51_52++;\\n #endif\\n // 52\\n #ifdef CBMC\\n __count_54++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_51_52 <= 1); // Upper capacity constraint\\nassert(__count_51_53 <= 1); // Upper capacity constraint\\nassert(__count_54 >= 1); // Lower capacity constraint\\nassert(__count_54 <= 1); // Upper capacity constraint\\nassert(__count_51_52 > 0 ==> __count_54 > 0); // Execution dependence\\nassert(__count_51_53 > 0 ==> __count_54 > 0); // Execution dependence\\n#endif\\n\\n return n;\\n }\\n else\\n {\\n #ifdef CBMC\\n __count_51_53++;\\n #endif\\n // 53\\n #ifdef CBMC\\n __count_54++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_51_52 <= 1); // Upper capacity constraint\\nassert(__count_51_53 <= 1); // Upper capacity constraint\\nassert(__count_54 >= 1); // Lower capacity constraint\\nassert(__count_54 <= 1); // Upper capacity constraint\\nassert(__count_51_52 > 0 ==> __count_54 > 0); // Execution dependence\\nassert(__count_51_53 > 0 ==> __count_54 > 0); // Execution dependence\\n#endif\\n\\n return -n;\\n }\\n}\\n\\nstatic double \\nlog(double n)\\n{\\n#ifdef CBMC\\n//==========> log : header 55\\nint __count_55 = 0;\\n#endif\\n #ifdef CBMC\\n __count_55++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_55 >= 1); // Lower capacity constraint\\nassert(__count_55 <= 1); // Upper capacity constraint\\n#endif\\n\\n return 4.5;\\n}\\n\\nstatic double \\nsin (double rad)\\n{\\n#ifdef CBMC\\n//==========> sin : header 48\\nint __count_48_49 = 0;\\nint __count_48_49_L = 0; //Loop counter\\n//==========> sin : header 45\\nint __count_45_44 = 0;\\nint __count_45_44_L = 0; //Loop counter\\n//==========> sin : header 42\\nint __count_42_41 = 0;\\nint __count_42_41_L = 0; //Loop counter\\n//==========> sin : header 40\\nint __count_50 = 0;\\nint __count_42_43 = 0;\\n#endif\\n double app;\\n\\n double diff;\\n int inc = 1;\\n int counter =0;\\n\\n #ifdef CBMC\\n __count_42_41_L = 0;\\n #endif\\n while (rad > 2*PI) // 42\\n\\t{\\n #ifdef CBMC\\n __count_42_41++;\\n __count_42_41_L++;\\n #endif\\n rad -= 2*PI;\\n }\\n #ifdef CBMC\\n assert(__count_42_41_L <= 1); // Loop counter property\\n __count_42_43++;\\n #endif\\n\\n while (rad < -2*PI) // 45\\n {\\n #ifdef CBMC\\n __count_45_44++;\\n __count_45_44_L++;\\n #endif\\n rad += 2*PI;\\n }\\n app = diff = rad;\\n diff = (diff * (-(rad*rad))) /\\n ((2.0 * inc) * (2.0 * inc + 1.0));\\n app = app + diff;\\n inc++;\\n\\n #ifdef CBMC\\n __count_48_49_L = 0;\\n #endif\\n while(\\n (\\n#ifdef CBMC\\n (__count_48_49_L++,\\n __count_48_49++),\\n#endif\\n fabs(diff)\\n ) >= 0.00001) { // 48, 49\\n counter++;\\n diff = (diff * (-(rad*rad))) /\\n ((2.0 * inc) * (2.0 * inc + 1.0));\\n app = app + diff;\\n inc++;\\n }\\n #ifdef CBMC\\n assert(__count_48_49_L <= 8); // Loop counter property\\n __count_50++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_42_41 == 0); // Dead code\\nassert(__count_50 >= 1); // Lower capacity constraint\\nassert(__count_50 <= 1); // Upper capacity constraint\\nassert(__count_48_49 >= 1); // Lower capacity constraint\\nassert(__count_48_49 <= 7); // Upper capacity constraint\\nassert(__count_42_43 >= 1); // Lower capacity constraint\\nassert(__count_42_43 <= 1); // Upper capacity constraint\\nassert(__count_45_44 == 0); // Dead code\\n#endif\\n\\n return(app);\\n}\\n\\nstatic double \\ncos (double rad)\\n{\\n#ifdef CBMC\\n//==========> cos : header 1\\nint __count_2 = 0;\\nint __count_1_2 = 0;\\n#endif\\n double sin();\\n\\n #ifdef CBMC\\n __count_1_2++;\\n __count_2++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_2 >= 1); // Lower capacity constraint\\nassert(__count_2 <= 1); // Upper capacity constraint\\nassert(__count_1_2 >= 1); // Lower capacity constraint\\nassert(__count_1_2 <= 1); // Upper capacity constraint\\n#endif\\n\\n return (sin (PI / 2.0 - rad));\\n}\\n\\nint \\nfft (int n, int flag)\\n{\\n#ifdef CBMC\\n//==========> fft : header 19\\nint __count_19_18 = 0;\\nint __count_19_18_L = 0; //Loop counter\\n//==========> fft : header 30\\nint __count_30_29 = 0;\\nint __count_30_29_L = 0; //Loop counter\\n//==========> fft : header 21\\nint __count_19_20 = 0;\\nint __count_21_15 = 0; //Loop counter\\n//==========> fft : header 32\\nint __count_25_26 = 0;\\nint __count_25_27 = 0;\\nint __count_32_25 = 0; //Loop counter\\n//==========> fft : header 23\\nint __count_21_22 = 0;\\nint __count_23_14 = 0; //Loop counter\\n//==========> fft : header 9\\nint __count_9_8 = 0;\\nint __count_9_8_L = 0; //Loop counter\\n//==========> fft : header 37\\nint __count_37_36 = 0;\\nint __count_37_36_L = 0; //Loop counter\\n//==========> fft : header 3\\nint __count_39 = 0;\\nint __count_4_39 = 0;\\nint __count_11_13 = 0;\\nint __count_12_13 = 0;\\nint __count_33_34 = 0;\\nint __count_37_38 = 0;\\n#endif\\n int i, j, k, it, xp, xp2, j1, j2, iter;\\n double sign, w, wr, wi, dr1, dr2, di1, di2, tr, ti, arg;\\n\\n if (n < 2) // 3\\n {\\n #ifdef CBMC\\n __count_4_39++;\\n __count_39++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_25_26 >= 2); // Lower capacity constraint\\nassert(__count_25_26 <= 2); // Upper capacity constraint\\nassert(__count_25_27 >= 5); // Lower capacity constraint\\nassert(__count_25_27 <= 5); // Upper capacity constraint\\nassert(__count_30_29 >= 4); // Lower capacity constraint\\nassert(__count_30_29 <= 4); // Upper capacity constraint\\nassert(__count_37_38 <= 1); // Upper capacity constraint\\nassert(__count_39 >= 1); // Lower capacity constraint\\nassert(__count_39 <= 1); // Upper capacity constraint\\nassert(__count_37_36 <= 8); // Upper capacity constraint\\nassert(__count_33_34 <= 1); // Upper capacity constraint\\nassert(__count_9_8 >= 1); // Lower capacity constraint\\nassert(__count_9_8 <= 1); // Upper capacity constraint\\nassert(__count_11_13 <= 1); // Upper capacity constraint\\nassert(__count_12_13 <= 1); // Upper capacity constraint\\nassert(__count_19_18 >= 4); // Lower capacity constraint\\nassert(__count_19_18 <= 4); // Upper capacity constraint\\nassert(__count_19_20 >= 4); // Lower capacity constraint\\nassert(__count_19_20 <= 4); // Upper capacity constraint\\nassert(__count_21_22 >= 1); // Lower capacity constraint\\nassert(__count_21_22 <= 1); // Upper capacity constraint\\nassert(__count_4_39 == 0); // Dead code\\nassert(__count_33_34 > 0 ==> __count_12_13 > 0); // Mutual inclusion\\nassert(__count_12_13 > 0 ==> __count_33_34 > 0); // Mutual inclusion\\nassert(__count_37_36 > 0 ==> __count_11_13 > 0); // Mutual inclusion\\nassert(__count_11_13 > 0 ==> __count_37_36 > 0); // Mutual inclusion\\nassert(__count_37_38 > 0 ==> __count_11_13 > 0); // Mutual inclusion\\nassert(__count_11_13 > 0 ==> __count_37_38 > 0); // Mutual inclusion\\nassert(__count_37_38 > 0 ==> __count_37_36 > 0); // Mutual inclusion\\nassert(__count_37_36 > 0 ==> __count_37_38 > 0); // Mutual inclusion\\nassert(__count_33_34 > 0 ==> __count_11_13 == 0); // Mutual exclusion\\nassert(__count_11_13 > 0 ==> __count_33_34 == 0); // Mutual exclusion\\nassert(__count_37_36 > 0 ==> __count_12_13 == 0); // Mutual exclusion\\nassert(__count_12_13 > 0 ==> __count_37_36 == 0); // Mutual exclusion\\nassert(__count_37_38 > 0 ==> __count_12_13 == 0); // Mutual exclusion\\nassert(__count_12_13 > 0 ==> __count_37_38 == 0); // Mutual exclusion\\nassert(__count_11_13 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_30_29 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_30_29 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_30_29 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_30_29 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_30_29 > 0); // Execution dependence\\n#endif\\n\\n return 999; // 4\\n }\\n\\n iter = log((double)n)/log(2.0);\\n j = 1;\\n #ifdef CBMC\\n __count_9_8_L = 0;\\n #endif\\n for(i = 0; i < iter; i++) // 9\\n {\\n #ifdef CBMC\\n __count_9_8_L++;\\n __count_9_8++;\\n #endif\\n j *= 2;\\n }\\n #ifdef CBMC\\n assert(__count_9_8_L <= 2); // Loop counter property\\n #endif\\n\\n /* Main FFT Loops */\\n #ifdef CBMC\\n // TODO: check\\n if (flag == 1) // 10\\n {\\n sign = 1.0; // 12?\\n __count_12_13++;\\n }\\n else\\n {\\n sign = -1.0; // 11?\\n __count_11_13++;\\n }\\n #else\\n sign = ((flag == 1) ? 1.0 : -1.0); // 10, 11, 12\\n #endif\\n xp2 = n;\\n\\n #ifdef CBMC\\n __count_23_14 = 0;\\n #endif\\n for(it = 0; it < iter; it++) // 23\\n {\\n #ifdef CBMC\\n __count_23_14++;\\n #endif\\n\\n // 14\\n xp = xp2;\\n xp2 /= 2;\\n w = PI / xp2;\\n #ifdef CBMC\\n __count_21_15 = 0;\\n #endif\\n for(k = 0; k < xp2; k++) // 21\\n {\\n #ifdef CBMC\\n __count_21_15++;\\n #endif\\n arg = k * w;\\n wr = cos(arg);\\n wi = sign * sin(arg);\\n i = k - xp;\\n #ifdef CBMC\\n __count_19_18_L = 0;\\n #endif\\n for(j = xp; j <= n; j += xp) // 19\\n {\\n #ifdef CBMC\\n __count_19_18_L++;\\n __count_19_18++;\\n #endif\\n \\tj1 = j + i;\\n \\tj2 = j1 + xp2;\\n \\tdr1 = realArray[j1];\\n \\tdr2 = realArray[j2];\\n \\tdi1 = imaginaryArray[j1];\\n \\tdi2 = imaginaryArray[j2];\\n \\ttr = dr1 - dr2;\\n \\tti = di1 - di2;\\n \\trealArray[j1] = dr1 + dr2;\\n \\timaginaryArray[j1] = di1 + di2;\\n \\trealArray[j2] = tr * wr - ti * wi;\\n \\timaginaryArray[j2] = ti * wr + tr * wi;\\n }\\n #ifdef CBMC\\n assert(__count_19_18_L <= 2); // Loop counter property\\n __count_19_20++;\\n #endif\\n }\\n #ifdef CBMC\\n assert(__count_21_15 <= 5); // Loop counter property\\n __count_21_22++;\\n #endif\\n }\\n #ifdef CBMC\\n assert(__count_23_14 <= 2); // Loop counter property\\n #endif\\n// 24\\n /* Digit Reverse Counter */\\n j1 = n / 2;\\n j2 = n - 1;\\n j = 1;\\n\\n #ifdef CBMC\\n __count_32_25 = 0;\\n #endif\\n for(i = 1;i <= j2; i++) // 32\\n {\\n #ifdef CBMC\\n __count_32_25++;\\n #endif\\n\\n if(i < j) // 25\\n {\\n #ifdef CBMC\\n __count_25_26++;\\n #endif\\n // 26\\n tr = realArray[j-1];\\n ti = imaginaryArray[j-1];\\n realArray[j-1] = realArray[i-1];\\n imaginaryArray[j-1] = imaginaryArray[i-1];\\n realArray[i-1] = tr;\\n imaginaryArray[i-1] = ti;\\n }\\n #ifdef CBMC\\n else __count_25_27++;\\n #endif\\n \\n k = j1;\\n #ifdef CBMC\\n __count_30_29_L = 0;\\n #endif\\n while(k < j) // 30\\n {\\n #ifdef CBMC\\n __count_30_29_L++;\\n __count_30_29++;\\n #endif\\n j -= k;\\n k /= 2;\\n }\\n #ifdef CBMC\\n assert(__count_30_29_L <= 3); // Loop counter property\\n #endif\\n j += k;\\n }\\n #ifdef CBMC\\n assert(__count_32_25 <= 8); // Loop counter property\\n #endif\\n \\n if(flag == 0) // 33\\n {\\n #ifdef CBMC\\n __count_33_34++;\\n __count_39++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_25_26 >= 2); // Lower capacity constraint\\nassert(__count_25_26 <= 2); // Upper capacity constraint\\nassert(__count_25_27 >= 5); // Lower capacity constraint\\nassert(__count_25_27 <= 5); // Upper capacity constraint\\nassert(__count_30_29 >= 4); // Lower capacity constraint\\nassert(__count_30_29 <= 4); // Upper capacity constraint\\nassert(__count_37_38 <= 1); // Upper capacity constraint\\nassert(__count_39 >= 1); // Lower capacity constraint\\nassert(__count_39 <= 1); // Upper capacity constraint\\nassert(__count_37_36 <= 8); // Upper capacity constraint\\nassert(__count_33_34 <= 1); // Upper capacity constraint\\nassert(__count_9_8 >= 1); // Lower capacity constraint\\nassert(__count_9_8 <= 1); // Upper capacity constraint\\nassert(__count_11_13 <= 1); // Upper capacity constraint\\nassert(__count_12_13 <= 1); // Upper capacity constraint\\nassert(__count_19_18 >= 4); // Lower capacity constraint\\nassert(__count_19_18 <= 4); // Upper capacity constraint\\nassert(__count_19_20 >= 4); // Lower capacity constraint\\nassert(__count_19_20 <= 4); // Upper capacity constraint\\nassert(__count_21_22 >= 1); // Lower capacity constraint\\nassert(__count_21_22 <= 1); // Upper capacity constraint\\nassert(__count_4_39 == 0); // Dead code\\nassert(__count_33_34 > 0 ==> __count_12_13 > 0); // Mutual inclusion\\nassert(__count_12_13 > 0 ==> __count_33_34 > 0); // Mutual inclusion\\nassert(__count_37_36 > 0 ==> __count_11_13 > 0); // Mutual inclusion\\nassert(__count_11_13 > 0 ==> __count_37_36 > 0); // Mutual inclusion\\nassert(__count_37_38 > 0 ==> __count_11_13 > 0); // Mutual inclusion\\nassert(__count_11_13 > 0 ==> __count_37_38 > 0); // Mutual inclusion\\nassert(__count_37_38 > 0 ==> __count_37_36 > 0); // Mutual inclusion\\nassert(__count_37_36 > 0 ==> __count_37_38 > 0); // Mutual inclusion\\nassert(__count_33_34 > 0 ==> __count_11_13 == 0); // Mutual exclusion\\nassert(__count_11_13 > 0 ==> __count_33_34 == 0); // Mutual exclusion\\nassert(__count_37_36 > 0 ==> __count_12_13 == 0); // Mutual exclusion\\nassert(__count_12_13 > 0 ==> __count_37_36 == 0); // Mutual exclusion\\nassert(__count_37_38 > 0 ==> __count_12_13 == 0); // Mutual exclusion\\nassert(__count_12_13 > 0 ==> __count_37_38 == 0); // Mutual exclusion\\nassert(__count_11_13 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_30_29 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_30_29 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_30_29 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_30_29 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_30_29 > 0); // Execution dependence\\n#endif\\n\\n return 0; // 34\\n }\\n\\n w = n;\\n #ifdef CBMC\\n __count_37_36_L = 0;\\n #endif\\n for(i = 0; i < n; i++) // 37\\n {\\n #ifdef CBMC\\n __count_37_36_L++;\\n __count_37_36++;\\n #endif\\n realArray[i] /= w;\\n imaginaryArray[i] /= w;\\n }\\n #ifdef CBMC\\n assert(__count_37_36_L <= 9); // Loop counter property\\n __count_37_38++;\\n #endif\\n\\n #ifdef CBMC\\n __count_39++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_25_26 >= 2); // Lower capacity constraint\\nassert(__count_25_26 <= 2); // Upper capacity constraint\\nassert(__count_25_27 >= 5); // Lower capacity constraint\\nassert(__count_25_27 <= 5); // Upper capacity constraint\\nassert(__count_30_29 >= 4); // Lower capacity constraint\\nassert(__count_30_29 <= 4); // Upper capacity constraint\\nassert(__count_37_38 <= 1); // Upper capacity constraint\\nassert(__count_39 >= 1); // Lower capacity constraint\\nassert(__count_39 <= 1); // Upper capacity constraint\\nassert(__count_37_36 <= 8); // Upper capacity constraint\\nassert(__count_33_34 <= 1); // Upper capacity constraint\\nassert(__count_9_8 >= 1); // Lower capacity constraint\\nassert(__count_9_8 <= 1); // Upper capacity constraint\\nassert(__count_11_13 <= 1); // Upper capacity constraint\\nassert(__count_12_13 <= 1); // Upper capacity constraint\\nassert(__count_19_18 >= 4); // Lower capacity constraint\\nassert(__count_19_18 <= 4); // Upper capacity constraint\\nassert(__count_19_20 >= 4); // Lower capacity constraint\\nassert(__count_19_20 <= 4); // Upper capacity constraint\\nassert(__count_21_22 >= 1); // Lower capacity constraint\\nassert(__count_21_22 <= 1); // Upper capacity constraint\\nassert(__count_4_39 == 0); // Dead code\\nassert(__count_33_34 > 0 ==> __count_12_13 > 0); // Mutual inclusion\\nassert(__count_12_13 > 0 ==> __count_33_34 > 0); // Mutual inclusion\\nassert(__count_37_36 > 0 ==> __count_11_13 > 0); // Mutual inclusion\\nassert(__count_11_13 > 0 ==> __count_37_36 > 0); // Mutual inclusion\\nassert(__count_37_38 > 0 ==> __count_11_13 > 0); // Mutual inclusion\\nassert(__count_11_13 > 0 ==> __count_37_38 > 0); // Mutual inclusion\\nassert(__count_37_38 > 0 ==> __count_37_36 > 0); // Mutual inclusion\\nassert(__count_37_36 > 0 ==> __count_37_38 > 0); // Mutual inclusion\\nassert(__count_33_34 > 0 ==> __count_11_13 == 0); // Mutual exclusion\\nassert(__count_11_13 > 0 ==> __count_33_34 == 0); // Mutual exclusion\\nassert(__count_37_36 > 0 ==> __count_12_13 == 0); // Mutual exclusion\\nassert(__count_12_13 > 0 ==> __count_37_36 == 0); // Mutual exclusion\\nassert(__count_37_38 > 0 ==> __count_12_13 == 0); // Mutual exclusion\\nassert(__count_12_13 > 0 ==> __count_37_38 == 0); // Mutual exclusion\\nassert(__count_11_13 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_11_13 > 0 ==> __count_30_29 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_12_13 > 0 ==> __count_30_29 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_33_34 > 0 ==> __count_30_29 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_37_36 > 0 ==> __count_30_29 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_39 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_9_8 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_19_18 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_19_20 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_21_22 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_25_27 > 0); // Execution dependence\\nassert(__count_37_38 > 0 ==> __count_30_29 > 0); // Execution dependence\\n#endif\\n\\n return 0;\\n}\\n\\nint \\nmain (int argc, char *argv[])\\n{\\n int i;\\n int n = ARRAY_SIZE;\\n int flag;\\n int chkerr;\\n\\n /*\\n * At least eight values must be supplied\\n */\\n if (argc != 9)\\n {\\n return 1;\\n }\\n\\n for (i = 0; i < argc - 1; ++i)\\n {\\n sscanf(argv[i+1], \\\"%lf\\\", realArray+i);\\n }\\n\\n /* forward fft */\\n flag = 0;\\n chkerr = fft(ARRAY_SIZE, flag);\\n\\n /* inverse fft */\\n flag = 1;\\n chkerr = fft(ARRAY_SIZE, flag);\\n \\n printf(\\\"%d\\\", chkerr);\\n\\n return 0;\\n}\\n\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.5838536024093628,\n \"alphanum_fraction\": 0.5848467946052551,\n \"avg_line_length\": 52.732826232910156,\n \"blob_id\": \"4c26623708ed1c100b53d7dd9ba697a5db94d78a\",\n \"content_id\": \"686c4e55cb5292924f90f932bea66292da1a2cd2\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 7048,\n \"license_type\": \"no_license\",\n \"max_line_length\": 125,\n \"num_lines\": 131,\n \"path\": \"/DaikonPathInformation/src/programs.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import directed_graphs\\nimport vertices\\nimport debug\\nimport copy\\n \\nclass Program:\\n def __init__(self):\\n self.callg = directed_graphs.CallGraph()\\n self.cfgs = {}\\n self.archived_cfgs = {}\\n\\n def get_context_graph(self):\\n return directed_graphs.ContextGraph(self.callg)\\n \\n def addCFG (self, cfg):\\n assert cfg.name not in self.cfgs, \\\"Trying to add duplicate CFG for function '%s'\\\" % cfg.name\\n self.callg.addVertex(cfg.name)\\n self.cfgs[cfg.name] = cfg\\n \\n def remove_function(self, function_name):\\n if function_name in self.cfgs:\\n # Archive the CFG as it is no longer needed\\n cfg = self.cfgs[function_name]\\n self.__archivedCFGS[function_name] = cfg\\n del self.cfgs[function_name]\\n if self.callg.hasVertexWithName(function_name):\\n self.callg.removeVertex(function_name)\\n \\n def remove_problematic_functions(self):\\n functions = set()\\n for function_name, cfg in self.cfgs.iteritems():\\n callee_name = cfg.is_call_site(cfg.get_exitID())\\n if callee_name is not None or cfg.get_exitID() == vertices.dummyID:\\n functions.add(function_name)\\n for function_name in functions:\\n # This check is essential as the function may have been removed in the meantime\\n if function_name in self.cfgs:\\n cfg = self.cfgs[function_name]\\n dfs = directed_graphs.DepthFirstSearch(self.callg, self.callg.getVertexWithName(function_name).vertexID)\\n for vertexID in dfs.getPostorder():\\n callv = self.callg.getVertex(vertexID)\\n for calle in callv.getPredecessoredges():\\n predID = calle.vertexID\\n predv = self.callg.getVertex(predID)\\n for callSiteID in calle.getCallSites():\\n callerName = predv.name\\n callerCFG = self.getCFG(callerName)\\n callerCFG.remove_call_site(callSiteID)\\n self.remove_function(callv.name)\\n \\n def inline_calls(self):\\n debug.verbose_message(\\\"Inlining to create single CFG\\\", __name__)\\n rootv = self.callg.getVertex(self.callg.rootID)\\n dfs = directed_graphs.DepthFirstSearch(self.callg, rootv.vertexID)\\n for vertexID in dfs.post_order:\\n succv = self.callg.getVertex(vertexID)\\n for calle in succv.predecessors.values():\\n predv = self.callg.getVertex(calle.vertexID)\\n for call_siteID in calle.getCallSites():\\n debug.debug_message(\\\"Inlining '%s' into '%s' at call site %d\\\" % (succv.name, predv.name, call_siteID), 1)\\n self.__doInline(self.cfgs[predv.name], self.cfgs[succv.name], call_siteID)\\n self.cfgs[succv.name].remove_call_site(call_siteID)\\n for vertexID in dfs.post_order:\\n callv = self.callg.getVertex(vertexID)\\n if callv != rootv:\\n self.remove_function(callv.name)\\n else:\\n cfg = self.cfgs[rootv.name]\\n cfg.addEdge(cfg.get_exitID(), cfg.get_entryID())\\n\\n def do_inline(self, callerCFG, calleeCFG, call_siteID):\\n call_sitev = callerCFG.getVertex(call_siteID)\\n returnv = callerCFG.getVertex(call_sitev.successors.keys()[0])\\n new_entryID, new_exitID = self.duplicate_CFG(callerCFG, calleeCFG)\\n self.link_duplicate(callerCFG, call_sitev, returnv, new_entryID, new_exitID)\\n \\n def duplicate_CFG(self, callerCFG, calleeCFG):\\n oldID_to_newID = {}\\n for v in calleeCFG:\\n oldID_to_newID[v.vertexID] = callerCFG.get_next_vertexID()\\n clonev = copy.deepcopy(v)\\n clonev.vertexID = oldID_to_newID[v.vertexID]\\n clonev.originalID = v.originalID\\n clonev.predecessors = {}\\n clonev.successors = {}\\n callerCFG.addVertex(clonev)\\n for v in calleeCFG:\\n predID = v.vertexID\\n for succID in v.successors.keys():\\n if predID != calleeCFG.get_exitID() and succID != calleeCFG.get_entryID():\\n new_predID = oldID_to_newID[predID]\\n new_succID = oldID_to_newID[succID]\\n callerCFG.addEdge(new_predID, new_succID)\\n return oldID_to_newID[calleeCFG.get_entryID()], oldID_to_newID[calleeCFG.get_exitID()]\\n \\n def link_duplicate(self, callerCFG, callSitev, returnv, new_entryID, new_exitID): \\n callerCFG.addEdge(callSitev.vertexID, new_entryID)\\n callerCFG.addEdge(new_exitID, returnv.vertexID)\\n callerCFG.removeEdge(callSitev.vertexID, returnv.vertexID)\\n \\n def output(self):\\n totalMutualExclusion = 0\\n totalMutualInclusion = 0\\n totalDependencies = 0\\n totalNever = 0\\n totalAlways = 0 \\n for function_name, cfg in self.cfgs.iteritems():\\n pathg = self.getPathInfoGraph(function_name)\\n mutualExclusionPairs = len(pathg.mutualExclusionPairs())\\n mutualInclusionPairs = len(pathg.mutualInclusionPairs())\\n dependencies = len(pathg.executionDependencies())\\n neverExecute = pathg.numOfNeverExecuteedges()\\n alwaysExecute = pathg.numOfAlwaysExecuteedges()\\n totalMutualExclusion += mutualExclusionPairs\\n totalMutualInclusion += mutualInclusionPairs\\n totalDependencies += dependencies\\n totalNever += neverExecute\\n totalAlways += alwaysExecute\\n debug.verbose_message(\\\"In %s...\\\" % function_name, __name__)\\n debug.verbose_message(\\\"...#CFG edges = %d\\\" % cfg.numOfedges(), __name__)\\n debug.verbose_message(\\\"...#monitored = %d\\\" % pathg.numOfvertices(), __name__)\\n debug.verbose_message(\\\"...#mutual exclusion pairs = %d\\\" % mutualExclusionPairs, __name__)\\n debug.verbose_message(\\\"...#mutual inclusion pairs = %d\\\" % mutualInclusionPairs, __name__)\\n debug.verbose_message(\\\"...#execution dependencies = %d\\\" % dependencies, __name__)\\n debug.verbose_message(\\\"...#never execute = %d\\\" % neverExecute, __name__)\\n debug.verbose_message(\\\"...#always execute = %d\\\" % alwaysExecute, __name__)\\n debug.verbose_message(\\\"...#TOTAL mutual exclusion pairs = %d\\\" % totalMutualExclusion, __name__)\\n debug.verbose_message(\\\"...#TOTAL mutual inclusion pairs = %d\\\" % totalMutualInclusion, __name__)\\n debug.verbose_message(\\\"...#TOTAL execution dependencies = %d\\\" % totalDependencies, __name__)\\n debug.verbose_message(\\\"...#TOTAL never execute = %d\\\" % totalAlways, __name__)\\n debug.verbose_message(\\\"...#TOTAL always execute = %d\\\" % totalAlways, __name__)\\n \\n\"\n },\n {\n \"alpha_fraction\": 0.46075740456581116,\n \"alphanum_fraction\": 0.5304610133171082,\n \"avg_line_length\": 21.563467025756836,\n \"blob_id\": \"0b3bc238926a634ac98f1ee0c977277e13c096e3\",\n \"content_id\": \"769d0c441ad431cc2312daade72010a3eed2468c\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 7288,\n \"license_type\": \"no_license\",\n \"max_line_length\": 84,\n \"num_lines\": 323,\n \"path\": \"/DaikonPathInformation/benchmarks/quicksort.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Quick sort taken from http://jeffreystedfast.blogspot.com/2007/03/quick-sort.html\\n * and modified by Adam Betts to consume a\\n * test vector supplied on the command line.\\n *\\n * For this program, the test vector is a list of integers to be sorted.\\n * Note that the size of the array is determined by the number of arguments\\n * given to the program, i.e. argc - 1.\\n */\\n\\ntypedef struct qstack\\n{\\n int lo;\\n int hi;\\n} qstack_t;\\n\\nvoid\\nquicksort (int ARRAY_SIZE, int a[])\\n{\\n#ifdef CBMC\\n//==========> quicksort : header 10\\nint __count_11_9 = 0;\\nint __count_10_11 = 0; //Loop counter\\n//==========> quicksort : header 6\\nint __count_6_10 = 0;\\nint __count_7_5 = 0;\\nint __count_7_8 = 0;\\nint __count_10_12 = 0;\\nint __count_11_12 = 0;\\nint __count_12_13 = 0;\\nint __count_16_18 = 0;\\nint __count_17_18 = 0;\\nint __count_6_10_L = 0; //Loop counter\\nint __count_6_7 = 0; //Loop counter\\n//==========> quicksort : header 20\\nint __count_14_19 = 0;\\nint __count_20_3 = 0; //Loop counter\\n//==========> quicksort : header 1\\nint __count_23 = 0;\\nint __count_20_21 = 0;\\nint __count_22_23 = 0;\\n#endif\\n\\n qstack_t stack[32];\\n qstack_t *sp;\\n int lo;\\n int hi;\\n int low;\\n int high;\\n int pivot;\\n int tmp;\\n\\n if (ARRAY_SIZE < 2) // 1\\n {\\n \\t// 22\\n #ifdef CBMC\\n __count_22_23++;\\n __count_23++;\\n #endif\\n\\n#ifdef CBMC\\n//assert(__count_7_8 >= 327); // Lower capacity constraint\\nassert(__count_7_8 <= 353); // Upper capacity constraint\\n//assert(__count_7_5 >= 241); // Lower capacity constraint\\nassert(__count_7_5 <= 516); // Upper capacity constraint\\n//assert(__count_10_12 >= 156); // Lower capacity constraint\\nassert(__count_10_12 <= 169); // Upper capacity constraint\\nassert(__count_11_9 >= 227); // Lower capacity constraint\\nassert(__count_11_9 <= 500); // Upper capacity constraint\\nassert(__count_11_12 >= 164); // Lower capacity constraint\\nassert(__count_11_12 <= 197); // Upper capacity constraint\\nassert(__count_12_13 >= 128); // Lower capacity constraint\\nassert(__count_12_13 <= 154); // Upper capacity constraint\\nassert(__count_14_19 >= 100); // Lower capacity constraint\\nassert(__count_14_19 <= 100); // Upper capacity constraint\\nassert(__count_16_18 >= 12); // Lower capacity constraint\\nassert(__count_16_18 <= 31); // Upper capacity constraint\\nassert(__count_17_18 >= 68); // Lower capacity constraint\\nassert(__count_17_18 <= 87); // Upper capacity constraint\\nassert(__count_20_21 >= 1); // Lower capacity constraint\\nassert(__count_20_21 <= 1); // Upper capacity constraint\\nassert(__count_22_23 == 0); // Dead code\\nassert(__count_23 >= 1); // Lower capacity constraint\\nassert(__count_23 <= 1); // Upper capacity constraint\\nassert(__count_6_10 == 0); // Dead code\\n#endif\\n\\n return;\\n }\\n\\n /* push our initial values onto the stack */\\n sp = stack;\\n sp->lo = 0;\\n sp->hi = ARRAY_SIZE;\\n sp++;\\n\\n #ifdef CBMC\\n __count_20_3 = 0;\\n #endif\\n while (sp > stack) // 20\\n {\\n\\t#ifdef CBMC\\n\\t__count_20_3++;\\n\\t#endif\\n\\t// 3\\n\\n /* pop lo and hi off the stack */\\n sp--;\\n high = sp->hi;\\n low = sp->lo;\\n\\n hi = high - 1;\\n lo = low;\\n\\n pivot = a[lo];\\n\\n #ifdef CBMC\\n __count_6_10_L = 0;\\n #endif\\n while (1) // 6?\\n {\\n #ifdef CBMC\\n __count_6_7 = 0;\\n #endif\\n while ( \\n lo < high && // 6\\n (\\n #ifdef CBMC \\n __count_6_7++,\\n #endif\\n a[lo] < pivot) // 7\\n )\\n {\\n #ifdef CBMC\\n __count_7_5++;\\n #endif\\n lo++;\\n }\\n\\n #ifdef CBMC\\n if(lo < high)\\n {\\n \\t__count_7_8++; // (then 8->10)\\n }\\n else\\n {\\n \\t__count_6_10++;\\n \\t__count_6_10_L++;\\n }\\n #endif\\n\\n\\n #ifdef CBMC\\n __count_10_11 = 0;\\n #endif\\n // 10\\n while (\\n hi > low && // 10\\n (\\n #ifdef CBMC\\n __count_10_11++,\\n #endif\\n a[hi] >= pivot) // 11\\n )\\n {\\n #ifdef CBMC\\n __count_11_9++;\\n #endif\\n // 9\\n hi--;\\n }\\n #ifdef CBMC\\n assert(__count_10_11 <= 60); // Loop counter property\\n #endif\\n \\n #ifdef CBMC\\n if(hi > low)\\n {\\n \\t__count_11_12++;\\n }\\n else\\n {\\n \\t__count_10_12++;\\n }\\n #endif\\n\\n\\n // 12\\n if (lo < hi)\\n {\\n #ifdef CBMC\\n __count_12_13++;\\n #endif\\n \\t// 13\\n \\n /* swap */\\n tmp = a[lo];\\n a[lo] = a[hi];\\n a[hi] = tmp;\\n hi--;\\n }\\n else\\n {\\n hi++;\\n // 14\\n if (hi == high)\\n {\\n // 19\\n #ifdef CBMC\\n __count_14_19++;\\n #endif\\n /* done with this segment */\\n break;\\n }\\n\\n\\n /* push the larger segment onto the\\n * stack and continue sorting the\\n * smaller segment. */\\n\\n // 15\\n if ((hi - low) > (high - hi))\\n {\\n \\t// 16\\n #ifdef CBMC\\n \\t__count_16_18++;\\n #endif\\n \\n sp->lo = low;\\n sp->hi = hi;\\n sp++;\\n\\n hi = high;\\n low = lo;\\n }\\n else\\n {\\n \\t// 17\\n #ifdef CBMC\\n __count_17_18++;\\n #endif\\n sp->hi = high;\\n sp->lo = hi;\\n sp++;\\n\\n high = hi;\\n lo = low;\\n }\\n // 18\\n pivot = a[lo];\\n hi--;\\n }\\n }\\n #ifdef CBMC\\n assert(__count_6_10_L + __count_6_7 <= 138); // Loop counter property\\n #endif\\n }\\n #ifdef CBMC\\n assert(__count_20_3 <= 101); // Loop counter property\\n #endif\\n\\n // 21\\n #ifdef CBMC\\n __count_20_21++;\\n __count_23++;\\n #endif\\n \\n#ifdef CBMC\\n//assert(__count_7_8 >= 327); // Lower capacity constraint\\nassert(__count_7_8 <= 353); // Upper capacity constraint\\n//assert(__count_7_5 >= 241); // Lower capacity constraint\\nassert(__count_7_5 <= 516); // Upper capacity constraint\\n//assert(__count_10_12 >= 156); // Lower capacity constraint\\nassert(__count_10_12 <= 169); // Upper capacity constraint\\nassert(__count_11_9 >= 227); // Lower capacity constraint\\nassert(__count_11_9 <= 500); // Upper capacity constraint\\nassert(__count_11_12 >= 164); // Lower capacity constraint\\nassert(__count_11_12 <= 197); // Upper capacity constraint\\nassert(__count_12_13 >= 128); // Lower capacity constraint\\nassert(__count_12_13 <= 154); // Upper capacity constraint\\nassert(__count_14_19 >= 100); // Lower capacity constraint\\nassert(__count_14_19 <= 100); // Upper capacity constraint\\nassert(__count_16_18 >= 12); // Lower capacity constraint\\nassert(__count_16_18 <= 31); // Upper capacity constraint\\nassert(__count_17_18 >= 68); // Lower capacity constraint\\nassert(__count_17_18 <= 87); // Upper capacity constraint\\nassert(__count_20_21 >= 1); // Lower capacity constraint\\nassert(__count_20_21 <= 1); // Upper capacity constraint\\nassert(__count_22_23 == 0); // Dead code\\nassert(__count_23 >= 1); // Lower capacity constraint\\nassert(__count_23 <= 1); // Upper capacity constraint\\nassert(__count_6_10 == 0); // Dead code\\n#endif\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int ARRAY_SIZE = argc - 1;\\n int TV[ARRAY_SIZE];\\n int i;\\n\\n /*\\n * At least one integer value must be supplied\\n */\\n if (argc == 1)\\n {\\n return 1;\\n }\\n \\n #ifdef CBMC\\n __CPROVER_assume(ARRAY_SIZE >= 1 && ARRAY_SIZE <= 100);\\n #endif\\n\\n for (i = 0; i < argc - 1; ++i)\\n {\\n TV[i] = atoi (argv[i + 1]);\\n }\\n\\n quicksort (ARRAY_SIZE, TV);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.5918958187103271,\n \"alphanum_fraction\": 0.6237336993217468,\n \"avg_line_length\": 21.29032325744629,\n \"blob_id\": \"89555afe2b0bcb2b4b1723f028cf944fd082a19a\",\n \"content_id\": \"3dcb8b9d3287afc9242240ed64072832cbfc46a2\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 691,\n \"license_type\": \"no_license\",\n \"max_line_length\": 85,\n \"num_lines\": 31,\n \"path\": \"/DaikonPathInformation/src/timing.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from __future__ import print_function\\n\\nimport atexit\\nimport time\\n\\ndef seconds_to_string(the_time):\\n return \\\"%d:%02d:%02d.%03d\\\" % \\\\\\n reduce(lambda ll,b : divmod(ll[0],b) + ll[1:], [(the_time*1000,),1000,60,60])\\n\\nline = \\\"=\\\"*60\\ndef log(s, elapsed=None):\\n print(line)\\n the_time = time.clock()\\n print(seconds_to_string(the_time), '-', s)\\n if elapsed:\\n print(\\\"Elapsed time:\\\", elapsed)\\n print(line)\\n print()\\n return the_time\\n\\ndef endlog():\\n end = time.clock()\\n elapsed = end-start\\n log(\\\"End Program\\\", seconds_to_string(elapsed))\\n\\ndef now():\\n return seconds_to_string(time.clock())\\n\\nstart = time.clock()\\natexit.register(endlog)\\nlog(\\\"Start Program\\\")\\n\"\n },\n {\n \"alpha_fraction\": 0.5746042132377625,\n \"alphanum_fraction\": 0.5787621736526489,\n \"avg_line_length\": 35.296512603759766,\n \"blob_id\": \"9c85a1f8be323d06eb40bc1d26efd7e046d2f244\",\n \"content_id\": \"1a838b2236a9924c38d294750688b7797ac12f80\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 6253,\n \"license_type\": \"no_license\",\n \"max_line_length\": 130,\n \"num_lines\": 172,\n \"path\": \"/DaikonPathInformation/src/tool_CBMC.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#!/usr/bin/env python\\n\\nfrom __future__ import print_function\\n\\nimport os\\nimport re\\nimport shutil\\nimport signal\\nimport functools\\nimport subprocess\\nimport argparse\\nimport config\\n\\nnumber_of_assert_failures = 0\\nthe_CBMC_process = None\\n\\nclass CBMCAssertFailure:\\n UNWIND = 0\\n ASSERTION = 1\\n\\nclass TimeoutException (Exception):\\n pass\\n\\ndef timeout(seconds=10):\\n def decorator(func):\\n def handle_timeout(signum, frame):\\n if not the_CBMC_process.poll():\\n the_CBMC_process.kill()\\n print(\\\"TIMEOUT reached!\\\")\\n raise TimeoutException()\\n def wrapper(*args, **kwargs):\\n signal.signal(signal.SIGALRM, handle_timeout)\\n signal.alarm(seconds)\\n try:\\n result = func(*args, **kwargs)\\n finally:\\n signal.alarm(0)\\n return result\\n return functools.wraps(func)(wrapper)\\n return decorator\\n\\ndef count_asserts():\\n cmd = \\\"ack-grep --count assert %s\\\" % config.Arguments.program_file\\n proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE) \\n proc.wait()\\n line = proc.stdout.readlines()[0].strip()\\n print(line)\\n count = re.findall(r':[0-9]+', line)[0]\\n return int(count[1:])\\n\\ndef uncomment_failing_asserts():\\n new_filename = config.Arguments.program_file + '.temp'\\n new_file = open(new_filename, 'w')\\n cmd = \\\"sed 's/\\\\/\\\\/assert/assert/g' %s\\\" % config.Arguments.program_file\\n proc = subprocess.Popen(cmd, shell=True, stdout=new_file) \\n proc.wait()\\n new_file.close()\\n shutil.move(new_filename, config.Arguments.program_file)\\n\\ndef comment_failing_assert(failedAssert):\\n commented_assert = \\\"\\\\/\\\\/assert(%s);\\\" % failedAssert\\n sedAssert = re.sub(r'\\\\s+', r'.*',failedAssert)\\n assert_string = \\\"assert(%s);\\\" % sedAssert\\n new_filename = config.Arguments.program_file + '.temp'\\n new_file = open(new_filename, 'w')\\n cmd = \\\"sed 's/%s/%s/g' %s\\\" % (assert_string, commented_assert, config.Arguments.program_file)\\n proc = subprocess.Popen(cmd, shell=True, stdout=new_file) \\n proc.wait()\\n new_file.close()\\n shutil.move(new_filename, config.Arguments.program_file)\\n\\ndef get_failing_assert(filename):\\n stdin,stdout = os.popen2(\\\"tail -n 3 %s\\\" % filename)\\n stdin.close()\\n lines = stdout.readlines()\\n stdout.close()\\n line = lines[0].strip()\\n if line.startswith(\\\"unwinding assertion\\\"):\\n return CBMCAssertFailure.UNWIND, None\\n else:\\n assert re.search(r'\\\\s*__count_[0-9]+_[0-9]+', line)\\n return CBMCAssertFailure.ASSERTION, line\\n\\ndef run_CBMC(unwind, root_function):\\n global the_CBMC_process, number_of_assert_failures\\n cmd = '%s --unwind %d -DCBMC %s --function %s' % (config.Arguments.CBMC, unwind, config.Arguments.program_file, root_function)\\n print(\\\"Running '%s'\\\" % cmd)\\n success = False\\n cbmcOutput = os.path.abspath(os.getcwd() + os.sep + '%s.cbmc' % root_function)\\n while not success:\\n with open(cbmcOutput,'wb') as out:\\n the_CBMC_process = subprocess.Popen(cmd, shell=True, stdout=out) \\n the_CBMC_process.wait()\\n out = open(cbmcOutput,'r')\\n for line in out:\\n if line.startswith(\\\"VERIFICATION SUCCESSFUL\\\"):\\n success = True\\n break\\n out.close()\\n if not success:\\n failType, failedAssert = get_failing_assert(cbmcOutput)\\n if failType == CBMCAssertFailure.ASSERTION:\\n number_of_assert_failures += 1\\n print(\\\"Assertion '%s' failed in '%s'\\\" % (failedAssert, config.Arguments.program_file))\\n comment_failing_assert(failedAssert)\\n else:\\n print(\\\"Insufficient unwinding\\\")\\n return success\\n return success\\n\\n@timeout(config.Arguments.timeout)\\ndef run(root_function):\\n unwind = 4\\n success = False\\n while not success:\\n success = run_CBMC(unwind, root_function)\\n unwind *= 2\\n\\ndef the_command_line():\\n parser = argparse.ArgumentParser(description=\\\"Verify dynamic analysis conjectures using CBMC\\\")\\n \\n parser.add_argument(\\\"program_file\\\",\\n help=\\\"a '.c' file with CBMC instrumentation and assertions\\\")\\n \\n parser.add_argument(\\\"--CBMC\\\",\\n help=\\\"path to CBMC\\\")\\n \\n parser.add_argument(\\\"--timeout\\\",\\n type=int,\\n help=\\\"set number of seconds at which to timeout\\\",\\n default=600)\\n \\n parser.add_argument(\\\"--uncomment\\\",\\n action=\\\"store_true\\\",\\n help=\\\"uncomment failed assertions\\\")\\n \\n parser.add_argument(\\\"-d\\\",\\n \\\"--debug\\\",\\n type=int,\\n help=\\\"debug mode\\\",\\n default=0)\\n \\n parser.add_argument(\\\"-v\\\",\\n \\\"--verbose\\\",\\n action=\\\"store_true\\\",\\n help=\\\"be verbose\\\",\\n default=False)\\n \\n parser.parse_args(namespace=config.Arguments)\\n \\n config.Arguments.basename = os.path.splitext(os.path.basename(config.Arguments.program_file))\\n \\n if not config.Arguments.uncomment:\\n assert config.Arguments.CBMC, \\\"You need to pass the path to CBMC\\\"\\n assert os.path.exists(config.Arguments.CBMC), \\\"The CBMC path '%s' does not exist\\\" % config.Arguments.CBMC\\n assert os.path.isfile(config.Arguments.CBMC), \\\"'%s' is not a file\\\" % config.Arguments.CBMC\\n config.Arguments.CBMC = os.path.abspath(config.Arguments.CBMC)\\n\\nif __name__ == \\\"__main__\\\":\\n the_command_line()\\n if config.Arguments.uncomment:\\n uncomment_failing_asserts(config.Arguments.program)\\n else:\\n root_function = os.path.splitext(config.Arguments.basename)[0]\\n try:\\n run(root_function)\\n except:\\n pass\\n finally:\\n print(\\\"In %s, %d asserts out of %d failed\\\" % (config.Arguments.program, \\n number_of_assert_failures, \\n count_asserts(config.Arguments.program)))\\n \\n \\n\"\n },\n {\n \"alpha_fraction\": 0.3878205120563507,\n \"alphanum_fraction\": 0.42692306637763977,\n \"avg_line_length\": 15.421052932739258,\n \"blob_id\": \"99e3a507af1668638ee95a0bcecf51ed8860aa7f\",\n \"content_id\": \"119e5abc2149b64fb0d0643e9a41991ce366bc90\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 1560,\n \"license_type\": \"no_license\",\n \"max_line_length\": 76,\n \"num_lines\": 95,\n \"path\": \"/benchmarks/expint/expint.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Exponential integral function taken from MDH suite and modified by Adam Betts\\n * to consume a test vector supplied on the command line.\\n *\\n * For this program, the test vector consists of 2 integers.\\n */\\n\\nlong int\\nexpint (int n, int x)\\n{\\n int i, ii, nm1;\\n long int a, b, c, d, del, fact, h, psi, ans;\\n \\n /* arg = 50 => 49 */\\n nm1 = n - 1;\\n\\n if (x > 1)\\n {\\n b = x + n;\\n c = 2e6;\\n d = 3e7;\\n h = d;\\n\\n /* MAXIT is 100 */\\n for (i = 1; i <= 100; i++)\\n {\\n\\tprintf(\\\"HERE 1\\\\n\\\");\\n a = -i * (nm1 + i);\\n b += 2;\\n d = 10* (a *d+b);\\n c=b+a/c;\\n del=c*d;\\n h *= del;\\n if (del < 10000)\\n {\\n ans=h*-x;\\n return ans;\\n }\\n }\\n }\\n else\\n {\\n /*\\n * For the current argument, will always take '2' path here\\n */\\n ans = nm1 != 0 ? 2 : 1000;\\n fact=1;\\n for (i=1;i<=100;i++)\\n {\\nprintf(\\\"HERE 2\\\\n\\\");\\n fact *= -x/i;\\n if (i != nm1)\\n {\\n /*\\n * Depends on parameter n\\n */\\n del = -fact/(i-nm1);\\n }\\n else\\n {\\n /*\\n * This fat piece only runs ONCE on iteration 49\\n */\\n psi = 0x00FF;\\n for (ii=1; ii <= nm1; ii++)\\n { \\n psi += ii + nm1;\\n }\\n del = psi + fact * x * x + (8* x ) << 4 - x;\\n }\\n ans += del;\\n }\\n\\n }\\n\\n printf(\\\"Returning %d\\\\n\\\", ans);\\n\\n return ans;\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n /*\\n * Two integer values must be supplied\\n */\\n if (argc != 3)\\n {\\n return 1;\\n }\\n\\n expint (atoi (argv[1]), atoi (argv[2]));\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.42262521386146545,\n \"alphanum_fraction\": 0.47876349091529846,\n \"avg_line_length\": 24.585399627685547,\n \"blob_id\": \"59d83eae29be8cfa53f3cf1aa853dd0459807e6b\",\n \"content_id\": \"cdbb28020ce47fa092f91fd7475fd2ff501e94be\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 108304,\n \"license_type\": \"no_license\",\n \"max_line_length\": 69,\n \"num_lines\": 4233,\n \"path\": \"/benchmarks/petri/petri.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Petri net (nsichneu) taken from MDH suite and modified by Adam Betts to\\n * consume a test vector supplied on the command line.\\n *\\n * For this program, the test vector consists of a single integer.\\n */\\n\\nvoid\\npetri (int n)\\n{\\n int P1_is_marked = 3;\\n long P1_marking_member_0[3];\\n int P2_is_marked = 5;\\n long P2_marking_member_0[5];\\n int P3_is_marked = 0;\\n long P3_marking_member_0[6];\\n\\n while (n > 0)\\n {\\n n--;\\n\\n /* Permutation for Place P1 : 0, 1, 2 */\\n /* Transition T1 */\\n if ((P1_is_marked >= 3) && (P3_is_marked + 3 <= 6)\\n && (P1_marking_member_0[1] == P1_marking_member_0[2]))\\n {\\n\\n long x;\\n long y;\\n long z;\\n\\n x = P1_marking_member_0[0];\\n y = P1_marking_member_0[1];\\n\\n /* Transition condition */\\n if (x < y)\\n {\\n\\n /* demarking of input places */\\n P1_is_marked -= 3;\\n\\n /* preaction */\\n z = x - y;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = x;\\n P3_marking_member_0[P3_is_marked + 1] = y;\\n P3_marking_member_0[P3_is_marked + 2] = z;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P1 : 0, 2, 1 */\\n /* Transition T1 */\\n if ((P1_is_marked >= 3) && (P3_is_marked + 3 <= 6)\\n && (P1_marking_member_0[2] == P1_marking_member_0[1]))\\n {\\n\\n long x;\\n long y;\\n long z;\\n\\n x = P1_marking_member_0[0];\\n y = P1_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((x < y))\\n {\\n\\n /* demarking of input places */\\n P1_is_marked -= 3;\\n\\n /* preaction */\\n z = x - y;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = x;\\n P3_marking_member_0[P3_is_marked + 1] = y;\\n P3_marking_member_0[P3_is_marked + 2] = z;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P1 : 1, 0, 2 */\\n /* Transition T1 */\\n if ((P1_is_marked >= 3) && (P3_is_marked + 3 <= 6)\\n && (P1_marking_member_0[0] == P1_marking_member_0[2]))\\n {\\n\\n long x;\\n long y;\\n long z;\\n\\n x = P1_marking_member_0[1];\\n y = P1_marking_member_0[0];\\n\\n /* Transition condition */\\n if (x < y)\\n {\\n\\n /* demarking of input places */\\n P1_is_marked -= 3;\\n\\n /* preaction */\\n z = x - y;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = x;\\n P3_marking_member_0[P3_is_marked + 1] = y;\\n P3_marking_member_0[P3_is_marked + 2] = z;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P1 : 1, 2, 0 */\\n /* Transition T1 */\\n if ((P1_is_marked >= 3) && (P3_is_marked + 3 <= 6)\\n && (P1_marking_member_0[2] == P1_marking_member_0[0]))\\n {\\n\\n long x;\\n long y;\\n long z;\\n\\n x = P1_marking_member_0[1];\\n y = P1_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((x < y))\\n {\\n\\n /* demarking of input places */\\n P1_is_marked -= 3;\\n\\n /* preaction */\\n z = x - y;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = x;\\n P3_marking_member_0[P3_is_marked + 1] = y;\\n P3_marking_member_0[P3_is_marked + 2] = z;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P1 : 2, 0, 1 */\\n /* Transition T1 */\\n if ((P1_is_marked >= 3) && (P3_is_marked + 3 <= 6)\\n && (P1_marking_member_0[0] == P1_marking_member_0[1]))\\n {\\n long x;\\n long y;\\n long z;\\n\\n x = P1_marking_member_0[2];\\n y = P1_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((x < y))\\n {\\n\\n /* demarking of input places */\\n P1_is_marked -= 3;\\n\\n /* preaction */\\n z = x - y;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = x;\\n P3_marking_member_0[P3_is_marked + 1] = y;\\n P3_marking_member_0[P3_is_marked + 2] = z;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P1 : 2, 1, 0 */\\n /* Transition T1 */\\n if ((P1_is_marked >= 3) && (P3_is_marked + 3 <= 6)\\n && (P1_marking_member_0[1] == P1_marking_member_0[0]))\\n {\\n long x;\\n long y;\\n long z;\\n\\n x = P1_marking_member_0[2];\\n y = P1_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((x < y))\\n {\\n\\n /* demarking of input places */\\n P1_is_marked -= 3;\\n\\n /* preaction */\\n z = x - y;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = x;\\n P3_marking_member_0[P3_is_marked + 1] = y;\\n P3_marking_member_0[P3_is_marked + 2] = z;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 1, 2, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && (((P3_is_marked + 3) <= 6))\\n && (((P2_marking_member_0[1] == P2_marking_member_0[2]))\\n && ((P2_marking_member_0[1] == P2_marking_member_0[3]))))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 1, 3, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && (((P3_is_marked + 3) <= 6))\\n && ((P2_marking_member_0[1] == P2_marking_member_0[3])\\n && (P2_marking_member_0[1] == P2_marking_member_0[2])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 2, 1, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[1])\\n && (P2_marking_member_0[2] == P2_marking_member_0[3])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 2, 3, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[3])\\n && (P2_marking_member_0[2] == P2_marking_member_0[1])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 3, 1, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[1])\\n && (P2_marking_member_0[3] == P2_marking_member_0[2])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 3, 2, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[2])\\n && (P2_marking_member_0[3] == P2_marking_member_0[1])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 0, 2, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[2])\\n && (P2_marking_member_0[0] == P2_marking_member_0[3])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 0, 3, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[3])\\n && (P2_marking_member_0[0] == P2_marking_member_0[2])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 2, 0, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[0])\\n && (P2_marking_member_0[2] == P2_marking_member_0[3])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 2, 3, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[3])\\n && (P2_marking_member_0[2] == P2_marking_member_0[0])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 3, 0, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[0])\\n && (P2_marking_member_0[3] == P2_marking_member_0[2])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 3, 2, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[2])\\n && (P2_marking_member_0[3] == P2_marking_member_0[0])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 0, 1, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[1])\\n && (P2_marking_member_0[0] == P2_marking_member_0[3])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 0, 3, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[3])\\n && (P2_marking_member_0[0] == P2_marking_member_0[1])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 1, 0, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[0])\\n && (P2_marking_member_0[1] == P2_marking_member_0[3])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 1, 3, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[3])\\n && (P2_marking_member_0[1] == P2_marking_member_0[0])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 3, 0, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[0])\\n && (P2_marking_member_0[3] == P2_marking_member_0[1])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 3, 1, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[1])\\n && (P2_marking_member_0[3] == P2_marking_member_0[0])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 0, 1, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[1])\\n && (P2_marking_member_0[0] == P2_marking_member_0[2])))\\n {\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 0, 2, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[2])\\n && (P2_marking_member_0[0] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 1, 0, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[0])\\n && (P2_marking_member_0[1] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 1, 2, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[2])\\n && (P2_marking_member_0[1] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 2, 0, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[0])\\n && (P2_marking_member_0[2] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 2, 1, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 4) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[1])\\n && (P2_marking_member_0[2] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 1, 2, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[2])\\n && (P2_marking_member_0[1] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 1, 3, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[3])\\n && (P2_marking_member_0[1] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 1, 4, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[4])\\n && (P2_marking_member_0[1] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 1, 4, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[4])\\n && (P2_marking_member_0[1] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 2, 1, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[1])\\n && (P2_marking_member_0[2] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 2, 3, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[3])\\n && (P2_marking_member_0[2] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 2, 4, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[4])\\n && (P2_marking_member_0[2] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 2, 4, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[4])\\n && (P2_marking_member_0[2] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 3, 1, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[1])\\n && (P2_marking_member_0[3] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 3, 2, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[2])\\n && (P2_marking_member_0[3] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 3, 4, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[4])\\n && (P2_marking_member_0[3] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 3, 4, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[4])\\n && (P2_marking_member_0[3] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 4, 1, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[1])\\n && (P2_marking_member_0[4] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 4, 1, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[1])\\n && (P2_marking_member_0[4] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 4, 2, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[2])\\n && (P2_marking_member_0[4] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 4, 2, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[2])\\n && (P2_marking_member_0[4] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 4, 3, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[3])\\n && (P2_marking_member_0[4] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 0, 4, 3, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[3])\\n && (P2_marking_member_0[4] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[0];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 0, 2, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[2])\\n && (P2_marking_member_0[0] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 0, 3, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[3])\\n && (P2_marking_member_0[0] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 0, 4, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[4])\\n && (P2_marking_member_0[0] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 0, 4, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[4])\\n && (P2_marking_member_0[0] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 2, 0, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[0])\\n && (P2_marking_member_0[2] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 2, 3, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[3])\\n && (P2_marking_member_0[2] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 2, 4, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[4])\\n && (P2_marking_member_0[2] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 2, 4, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[4])\\n && (P2_marking_member_0[2] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 3, 0, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[0])\\n && (P2_marking_member_0[3] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 3, 2, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[2])\\n && (P2_marking_member_0[3] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 3, 4, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[4])\\n && (P2_marking_member_0[3] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 3, 4, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[4])\\n && (P2_marking_member_0[3] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 4, 0, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[0])\\n && (P2_marking_member_0[4] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 4, 0, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[0])\\n && (P2_marking_member_0[4] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 4, 2, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[2])\\n && (P2_marking_member_0[4] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 4, 2, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[2])\\n && (P2_marking_member_0[4] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 4, 3, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[3])\\n && (P2_marking_member_0[4] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 1, 4, 3, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[3])\\n && (P2_marking_member_0[4] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[1];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 0, 1, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[1])\\n && (P2_marking_member_0[0] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 0, 3, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[3])\\n && (P2_marking_member_0[0] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 0, 4, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[4])\\n && (P2_marking_member_0[0] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 0, 4, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[4])\\n && (P2_marking_member_0[0] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 1, 0, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[0])\\n && (P2_marking_member_0[1] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 1, 3, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[3])\\n && (P2_marking_member_0[1] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 1, 4, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[4])\\n && (P2_marking_member_0[1] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 1, 4, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[4])\\n && (P2_marking_member_0[1] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 3, 0, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[0])\\n && (P2_marking_member_0[3] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 3, 1, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[1])\\n && (P2_marking_member_0[3] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 3, 4, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[4])\\n && (P2_marking_member_0[3] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 3, 4, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[4])\\n && (P2_marking_member_0[3] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 4, 0, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[0])\\n && (P2_marking_member_0[4] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 4, 0, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[0])\\n && (P2_marking_member_0[4] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 4, 1, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[1])\\n && (P2_marking_member_0[4] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 4, 1, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[1])\\n && (P2_marking_member_0[4] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 4, 3, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[3])\\n && (P2_marking_member_0[4] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 2, 4, 3, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[3])\\n && (P2_marking_member_0[4] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[2];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 0, 1, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[1])\\n && (P2_marking_member_0[0] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 0, 2, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[2])\\n && (P2_marking_member_0[0] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 0, 4, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[4])\\n && (P2_marking_member_0[0] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 0, 4, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[4])\\n && (P2_marking_member_0[0] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 1, 0, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[0])\\n && (P2_marking_member_0[1] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 1, 2, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[2])\\n && (P2_marking_member_0[1] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 1, 4, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[4])\\n && (P2_marking_member_0[1] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 1, 4, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[4])\\n && (P2_marking_member_0[1] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 2, 0, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[0])\\n && (P2_marking_member_0[2] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 2, 1, 4 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[1])\\n && (P2_marking_member_0[2] == P2_marking_member_0[4])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 2, 4, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[4])\\n && (P2_marking_member_0[2] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 2, 4, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[4])\\n && (P2_marking_member_0[2] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 4, 0, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[0])\\n && (P2_marking_member_0[4] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 4, 0, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[0])\\n && (P2_marking_member_0[4] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 4, 1, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[1])\\n && (P2_marking_member_0[4] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 4, 1, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[1])\\n && (P2_marking_member_0[4] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 4, 2, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[2])\\n && (P2_marking_member_0[4] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 3, 4, 2, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[4] == P2_marking_member_0[2])\\n && (P2_marking_member_0[4] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[3];\\n b = P2_marking_member_0[4];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 0, 1, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[1])\\n && (P2_marking_member_0[0] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 0, 1, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[1])\\n && (P2_marking_member_0[0] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 0, 2, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[2])\\n && (P2_marking_member_0[0] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 0, 2, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[2])\\n && (P2_marking_member_0[0] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 0, 3, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[3])\\n && (P2_marking_member_0[0] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 0, 3, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[0] == P2_marking_member_0[3])\\n && (P2_marking_member_0[0] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[0];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 1, 0, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[0])\\n && (P2_marking_member_0[1] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 1, 0, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[0])\\n && (P2_marking_member_0[1] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 1, 2, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[2])\\n && (P2_marking_member_0[1] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 1, 2, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[2])\\n && (P2_marking_member_0[1] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 1, 3, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[3])\\n && (P2_marking_member_0[1] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 1, 3, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[1] == P2_marking_member_0[3])\\n && (P2_marking_member_0[1] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[1];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 2, 0, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[0])\\n && (P2_marking_member_0[2] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 2, 0, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[0])\\n && (P2_marking_member_0[2] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 2, 1, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[1])\\n && (P2_marking_member_0[2] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[3];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 2, 1, 3 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[1])\\n && (P2_marking_member_0[2] == P2_marking_member_0[3])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 2, 3, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[3])\\n && (P2_marking_member_0[2] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 2, 3, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[2] == P2_marking_member_0[3])\\n && (P2_marking_member_0[2] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[2];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 3, 0, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[0])\\n && (P2_marking_member_0[3] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 3, 0, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[0])\\n && (P2_marking_member_0[3] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 3, 1, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[1])\\n && (P2_marking_member_0[3] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[2];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 3, 1, 2 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[1])\\n && (P2_marking_member_0[3] == P2_marking_member_0[2])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 3, 2, 0 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[2])\\n && (P2_marking_member_0[3] == P2_marking_member_0[0])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_marking_member_0[0] = P2_marking_member_0[1];\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n\\n /* Permutation for Place P2 : 4, 3, 2, 1 */\\n /* Transition T2 */\\n if ((P2_is_marked >= 5) && ((P3_is_marked + 3) <= 6)\\n && ((P2_marking_member_0[3] == P2_marking_member_0[2])\\n && (P2_marking_member_0[3] == P2_marking_member_0[1])))\\n {\\n\\n long a;\\n long b;\\n long c;\\n\\n a = P2_marking_member_0[4];\\n b = P2_marking_member_0[3];\\n\\n /* Transition condition */\\n if ((b > a))\\n {\\n\\n /* demarking of input places */\\n P2_is_marked -= 4;\\n\\n /* preaction */\\n c = a + b;\\n\\n /* marking of output places */\\n P3_marking_member_0[P3_is_marked + 0] = a;\\n P3_marking_member_0[P3_is_marked + 1] = b;\\n P3_marking_member_0[P3_is_marked + 2] = c;\\n P3_is_marked += 3;\\n\\n } /* end of if (Transition condition) */\\n }\\n }\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n /*\\n * One integer must be supplied\\n */\\n if (argc != 2)\\n {\\n return 1;\\n }\\n\\n petri (atoi (argv[1]));\\n\\n return 0;\\n}\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.6236162185668945,\n \"alphanum_fraction\": 0.6420664191246033,\n \"avg_line_length\": 18.35714340209961,\n \"blob_id\": \"e21af447f530f4cd0c8429838437559a12da13d0\",\n \"content_id\": \"10c611f6507bb7b0d021fe14564aafb0ff8cfa2e\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 271,\n \"license_type\": \"no_license\",\n \"max_line_length\": 41,\n \"num_lines\": 14,\n \"path\": \"/GPUTimingAnalysis/src/Debug.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"verbose = False\\ndebug = 0\\n\\ndef debugMessage (string, debugLevel=1):\\n if debug > 0 and debugLevel <= debug:\\n print(string)\\n\\ndef verboseMessage (string):\\n if verbose or debug > 0:\\n print(string)\\n\\ndef exitMessage(string):\\n print(string)\\n exit(1)\\n\"\n },\n {\n \"alpha_fraction\": 0.35875943303108215,\n \"alphanum_fraction\": 0.4279128313064575,\n \"avg_line_length\": 15.921985626220703,\n \"blob_id\": \"863119d5e70856e841e6c15d97a76803af1a361c\",\n \"content_id\": \"350c4a482cb68fff4e8d935bdae09950aa8a8073\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 2386,\n \"license_type\": \"no_license\",\n \"max_line_length\": 76,\n \"num_lines\": 141,\n \"path\": \"/DaikonPathInformation/benchmarks/exponential_integral.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Exponential integral function taken from MDH suite and modified by Adam Betts\\n * to consume a test vector supplied on the command line.\\n *\\n * For this program, the test vector consists of 2 integers.\\n */\\n\\nlong int\\nexponential_integral (int n, int x)\\n{\\n #ifdef CBMC\\n int __count_25_27 = 0;\\n int __count_26_45 = 0;\\n int __count_29_44 = 0;\\n int __count_31_33 = 0;\\n int __count_32_33 = 0;\\n int __count_37_42 = 0;\\n int __count_39_40 = 0;\\n int __count_L28 = 0;\\n int __count_L43 = 0;\\n int __count_L40 = 0;\\n #endif\\n\\n int i, ii, nm1;\\n long int a, b, c, d, del, fact, h, psi, ans;\\n \\n nm1 = n - 1;\\n if (x > 1) // 20\\n {\\n // 23\\n b = x + n;\\n c = 2e6;\\n d = 3e7;\\n h = d;\\n\\n for (i = 1; \\n #ifdef CBMC\\n __count_L28++,\\n #endif\\n i <= 100; i++) // 28\\n {\\n a = -i * (nm1 + i);\\n b += 2;\\n d = 10* (a *d+b);\\n c=b+a/c;\\n del=c*d;\\n h *= del;\\n if (del < 10000) // 25\\n {\\n // 26\\n #ifdef CBMC\\n __count_26_45++;\\n #endif\\n ans=h*-x;\\n return ans;\\n }\\n #ifdef CBMC\\n else __count_25_27++;\\n #endif\\n }\\n #ifdef CBMC\\n __count_29_44++;\\n #endif\\n }\\n else\\n {\\n #ifdef CBMC\\n // TODO: check\\n if(nm1 != 0) // 30\\n {\\n ans = 2; // 31\\n __count_31_33++;\\n }\\n else\\n {\\n ans = 1000;\\n __count_32_33++;\\n }\\n #else\\n ans = nm1 != 0 ? 2 : 1000;\\n #endif\\n fact=1;\\n for (i=1;\\n #ifdef CBMC\\n __count_L43++,\\n #endif\\n i<=100;i++) // 43\\n {\\n fact *= -x/i;\\n if (i != nm1) // 35\\n { // 36\\n del = -fact/(i-nm1);\\n #ifdef CBMC\\n __count_37_42++;\\n #endif\\n }\\n else\\n { // 38\\n psi = 0x00FF;\\n for (ii=1; \\n #ifdef CBMC\\n __count_L40++,\\n #endif\\n ii <= nm1; ii++) // 40\\n { \\n psi += ii + nm1;\\n #ifdef CBMC\\n __count_39_40++;\\n #endif\\n }\\n del = psi + fact * x * x + (8* x ) << 4 - x;\\n }\\n ans += del;\\n }\\n }\\n return ans;\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n long int answer;\\n int param1;\\n int param2;\\n\\n /*\\n * Two integer values must be supplied\\n */\\n if (argc != 3)\\n {\\n return 1;\\n }\\n\\n param1 = atoi (argv[1]);\\n param2 = atoi (argv[2]);\\n answer = exponential_integral(param1, param2);\\n \\n printf(\\\"%d\\\", param1);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.4222418963909149,\n \"alphanum_fraction\": 0.4839719533920288,\n \"avg_line_length\": 31.290109634399414,\n \"blob_id\": \"6c0c13963c88a1abc35da444f7746edfa9365535\",\n \"content_id\": \"dd82d2052f5610708ee96ad743456d07c5de7522\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 14693,\n \"license_type\": \"no_license\",\n \"max_line_length\": 94,\n \"num_lines\": 455,\n \"path\": \"/DaikonPathInformation/benchmarks/LUdecomposition.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/* MDH WCET BENCHMARK SUITE. File version $Id: ludcmp.c,v 1.2 2006/01/27 13:15:28 jgn Exp $ */\\n\\n/*************************************************************************/\\n/* */\\n/* SNU-RT Benchmark Suite for Worst Case Timing Analysis */\\n/* ===================================================== */\\n/* Collected and Modified by S.-S. Lim */\\n/* sslim@archi.snu.ac.kr */\\n/* Real-Time Research Group */\\n/* Seoul National University */\\n/* */\\n/* */\\n/* < Features > - restrictions for our experimental environment */\\n/* */\\n/* 1. Completely structured. */\\n/* - There are no unconditional jumps. */\\n/* - There are no exit from loop bodies. */\\n/* (There are no 'break' or 'return' in loop bodies) */\\n/* 2. No 'switch' statements. */\\n/* 3. No 'do..while' statements. */\\n/* 4. Expressions are restricted. */\\n/* - There are no multiple expressions joined by 'or', */\\n/* 'and' operations. */\\n/* 5. No library calls. */\\n/* - All the functions needed are implemented in the */\\n/* source file. */\\n/* */\\n/* */\\n/*************************************************************************/\\n/* */\\n/* FILE: ludcmp.c */\\n/* SOURCE : Turbo C Programming for Engineering */\\n/* */\\n/* DESCRIPTION : */\\n/* */\\n/* Simultaneous linear equations by LU decomposition. */\\n/* The arrays a[][] and b[] are input and the array x[] is output */\\n/* row vector. */\\n/* The variable n is the number of equations. */\\n/* The input arrays are initialized in function main. */\\n/* */\\n/* */\\n/* REMARK : */\\n/* */\\n/* EXECUTION TIME : */\\n/* */\\n/* */\\n/*************************************************************************/\\n\\n\\n/* Changes:\\n * JG 2005/12/12: Indented program. Removed unused variable nmax.\\n */\\n\\n/*\\n** Benchmark Suite for Real-Time Applications, by Sung-Soo Lim\\n**\\n** III-4. ludcmp.c : Simultaneous Linear Equations by LU Decomposition\\n** (from the book C Programming for EEs by Hyun Soon Ahn)\\n*/\\n\\n#define ARRAY_DIMENSION 6\\ndouble a[ARRAY_DIMENSION][ARRAY_DIMENSION], b[ARRAY_DIMENSION], x[ARRAY_DIMENSION];\\n\\nstatic double \\nfabs (double n)\\n{\\n#ifdef CBMC\\n//==========> fabs : header 37\\nint __count_40 = 0;\\nint __count_37_38 = 0;\\nint __count_37_39 = 0;\\n#endif\\n\\n if (n >= 0)\\n {\\n #ifdef CBMC\\n __count_37_38++;\\n __count_40++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_40 >= 1); // Lower capacity constraint\\nassert(__count_40 <= 1); // Upper capacity constraint\\nassert(__count_37_38 <= 1); // Upper capacity constraint\\nassert(__count_37_39 <= 1); // Upper capacity constraint\\nassert(__count_37_38 > 0 ==> __count_40 > 0); // Execution dependence\\nassert(__count_37_39 > 0 ==> __count_40 > 0); // Execution dependence\\n#endif\\n\\n return n;\\n }\\n else\\n {\\n #ifdef CBMC\\n __count_37_39++;\\n __count_40++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_40 >= 1); // Lower capacity constraint\\nassert(__count_40 <= 1); // Upper capacity constraint\\nassert(__count_37_38 <= 1); // Upper capacity constraint\\nassert(__count_37_39 <= 1); // Upper capacity constraint\\nassert(__count_37_38 > 0 ==> __count_40 > 0); // Execution dependence\\nassert(__count_37_39 > 0 ==> __count_40 > 0); // Execution dependence\\n#endif\\n\\n return -n; // 39\\n }\\n}\\n\\nint\\nLUdecomposition (int n, double eps)\\n{\\n#ifdef CBMC\\n//==========> ludecomposition : header 18\\nint __count_18_17 = 0;\\nint __count_18_17_L = 0; //Loop counter\\n//==========> ludecomposition : header 12\\nint __count_12_11 = 0;\\nint __count_12_11_L = 0; //Loop counter\\n//==========> ludecomposition : header 32\\nint __count_32_31 = 0;\\nint __count_32_31_L = 0; //Loop counter\\n//==========> ludecomposition : header 26\\nint __count_26_25 = 0;\\nint __count_26_25_L = 0; //Loop counter\\n//==========> ludecomposition : header 20\\nint __count_18_19 = 0;\\nint __count_20_16 = 0; //Loop counter\\n//==========> ludecomposition : header 14\\nint __count_9_13 = 0;\\nint __count_12_13 = 0;\\nint __count_14_9 = 0; //Loop counter\\n//==========> ludecomposition : header 34\\nint __count_32_33 = 0;\\nint __count_34_30 = 0; //Loop counter\\n//==========> ludecomposition : header 28\\nint __count_26_27 = 0;\\nint __count_28_24 = 0; //Loop counter\\n//==========> ludecomposition : header 22\\nint __count_14_15 = 0;\\nint __count_22_5 = 0; //Loop counter\\n//==========> ludecomposition : header 1\\nint __count_36 = 0;\\nint __count_1_3 = 0;\\nint __count_2_3 = 0;\\nint __count_6_7 = 0;\\nint __count_34_35 = 0;\\n#endif\\n\\n int i, j, k;\\n double w, y[100];\\n\\n if (n > 99 || eps <= 0.0) // 1,2\\n {\\n #ifdef CBMC\\n if (n>99) __count_1_3++;\\n else if (eps <= 0.0) __count_2_3++;\\n\\n __count_36++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_36 >= 1); // Lower capacity constraint\\nassert(__count_36 <= 1); // Upper capacity constraint\\nassert(__count_1_3 == 0); // Dead code\\nassert(__count_2_3 == 0); // Dead code\\nassert(__count_26_27 >= 5); // Lower capacity constraint\\nassert(__count_26_27 <= 5); // Upper capacity constraint\\nassert(__count_26_25 >= 15); // Lower capacity constraint\\nassert(__count_26_25 <= 15); // Upper capacity constraint\\nassert(__count_6_7 == 0); // Dead code\\nassert(__count_32_33 >= 5); // Lower capacity constraint\\nassert(__count_32_33 <= 5); // Upper capacity constraint\\nassert(__count_32_31 >= 15); // Lower capacity constraint\\nassert(__count_32_31 <= 15); // Upper capacity constraint\\nassert(__count_9_13 >= 5); // Lower capacity constraint\\nassert(__count_9_13 <= 5); // Upper capacity constraint\\nassert(__count_34_35 >= 1); // Lower capacity constraint\\nassert(__count_34_35 <= 1); // Upper capacity constraint\\nassert(__count_12_11 >= 20); // Lower capacity constraint\\nassert(__count_12_11 <= 20); // Upper capacity constraint\\nassert(__count_12_13 >= 10); // Lower capacity constraint\\nassert(__count_12_13 <= 10); // Upper capacity constraint\\nassert(__count_14_15 >= 5); // Lower capacity constraint\\nassert(__count_14_15 <= 5); // Upper capacity constraint\\nassert(__count_18_17 >= 35); // Lower capacity constraint\\nassert(__count_18_17 <= 35); // Upper capacity constraint\\nassert(__count_18_19 >= 15); // Lower capacity constraint\\nassert(__count_18_19 <= 15); // Upper capacity constraint\\n#endif\\n return 999;\\n }\\n\\n #ifdef CBMC\\n __count_22_5 = 0;\\n #endif\\n for (i = 0; i < n; i++) // 22\\n {\\n #ifdef CBMC\\n __count_22_5++;\\n #endif\\n if (fabs(a[i][i]) <= eps) // 6\\n {\\n #ifdef CBMC\\n __count_6_7++;\\n #endif\\n // 7\\n #ifdef CBMC\\n __count_36++;\\n #endif\\n#ifdef CBMC\\nassert(__count_36 >= 1); // Lower capacity constraint\\nassert(__count_36 <= 1); // Upper capacity constraint\\nassert(__count_1_3 == 0); // Dead code\\nassert(__count_2_3 == 0); // Dead code\\nassert(__count_26_27 >= 5); // Lower capacity constraint\\nassert(__count_26_27 <= 5); // Upper capacity constraint\\nassert(__count_26_25 >= 15); // Lower capacity constraint\\nassert(__count_26_25 <= 15); // Upper capacity constraint\\nassert(__count_6_7 == 0); // Dead code\\nassert(__count_32_33 >= 5); // Lower capacity constraint\\nassert(__count_32_33 <= 5); // Upper capacity constraint\\nassert(__count_32_31 >= 15); // Lower capacity constraint\\nassert(__count_32_31 <= 15); // Upper capacity constraint\\nassert(__count_9_13 >= 5); // Lower capacity constraint\\nassert(__count_9_13 <= 5); // Upper capacity constraint\\nassert(__count_34_35 >= 1); // Lower capacity constraint\\nassert(__count_34_35 <= 1); // Upper capacity constraint\\nassert(__count_12_11 >= 20); // Lower capacity constraint\\nassert(__count_12_11 <= 20); // Upper capacity constraint\\nassert(__count_12_13 >= 10); // Lower capacity constraint\\nassert(__count_12_13 <= 10); // Upper capacity constraint\\nassert(__count_14_15 >= 5); // Lower capacity constraint\\nassert(__count_14_15 <= 5); // Upper capacity constraint\\nassert(__count_18_17 >= 35); // Lower capacity constraint\\nassert(__count_18_17 <= 35); // Upper capacity constraint\\nassert(__count_18_19 >= 15); // Lower capacity constraint\\nassert(__count_18_19 <= 15); // Upper capacity constraint\\n#endif\\n return 1;\\n }\\n \\n #ifdef CBMC\\n __count_14_9 = 0;\\n #endif\\n for (j = i + 1; j <= n; j++) // 14\\n {\\n #ifdef CBMC\\n __count_14_9++;\\n #endif\\n w = a[j][i];\\n if (i != 0) // 9\\n { \\n #ifdef CBMC\\n __count_12_11_L = 0;\\n #endif\\n for (k = 0; k < i; k++) // 12\\n {\\n #ifdef CBMC\\n __count_12_11_L++;\\n __count_12_11++;\\n #endif\\n w -= a[j][k] * a[k][i];\\n }\\n #ifdef CBMC\\n assert(__count_12_11_L <= 5); // Loop counter property\\n __count_12_13++;\\n #endif\\n }\\n #ifdef CBMC\\n else __count_9_13++;\\n #endif\\n a[j][i] = w / a[i][i];\\n }\\n #ifdef CBMC\\n assert(__count_14_9 <= 6); // Loop counter property\\n __count_14_15++;\\n #endif\\n\\n #ifdef CBMC\\n __count_20_16 = 0;\\n #endif\\n for (j = i + 1; j <= n; j++) // 20\\n {\\n #ifdef CBMC\\n __count_20_16++;\\n #endif\\n w = a[i + 1][j];\\n #ifdef CBMC\\n __count_18_17_L = 0;\\n #endif\\n for (k = 0; k <= i; k++) // 18\\n {\\n #ifdef CBMC\\n __count_18_17_L++;\\n __count_18_17++;\\n #endif\\n w -= a[i + 1][k] * a[k][j];\\n }\\n #ifdef CBMC\\n assert(__count_18_17_L <= 6); // Loop counter property\\n __count_18_19++;\\n #endif\\n a[i + 1][j] = w;\\n }\\n #ifdef CBMC\\n assert(__count_20_16 <= 6); // Loop counter property\\n #endif\\n }\\n #ifdef CBMC\\n assert(__count_22_5 <= 6); // Loop counter property\\n #endif\\n\\n y[0] = b[0];\\n \\n #ifdef CBMC\\n __count_28_24 = 0;\\n #endif\\n for (i = 1; i <= n; i++) // 28\\n {\\n #ifdef CBMC\\n __count_28_24++;\\n #endif\\n w = b[i];\\n #ifdef CBMC\\n __count_26_25_L = 0;\\n #endif\\n for (j = 0; j < i; j++) // 26\\n {\\n #ifdef CBMC\\n __count_26_25_L++;\\n __count_26_25++;\\n #endif\\n w -= a[i][j] * y[j];\\n }\\n #ifdef CBMC\\n assert(__count_26_25_L <= 6); // Loop counter property\\n __count_26_27++;\\n #endif\\n y[i] = w;\\n }\\n #ifdef CBMC\\n assert(__count_28_24 <= 6); // Loop counter property\\n #endif\\n \\n x[n] = y[n] / a[n][n];\\n #ifdef CBMC\\n __count_34_30 = 0;\\n #endif\\n for (i = n - 1; i >= 0; i--) // 34\\n {\\n #ifdef CBMC\\n __count_34_30++;\\n #endif\\n w = y[i];\\n #ifdef CBMC\\n __count_32_31_L = 0;\\n #endif\\n for (j = i + 1; j <= n; j++) // 32\\n {\\n #ifdef CBMC\\n __count_32_31_L++;\\n __count_32_31++;\\n #endif\\n w -= a[i][j] * x[j];\\n }\\n #ifdef CBMC\\n assert(__count_32_31_L <= 6); // Loop counter property\\n __count_32_33++;\\n #endif\\n x[i] = w / a[i][i];\\n }\\n #ifdef CBMC\\n assert(__count_34_30 <= 6); // Loop counter property\\n __count_34_35++;\\n #endif\\n \\n #ifdef CBMC\\n __count_36++;\\n #endif\\n\\n\\n#ifdef CBMC\\nassert(__count_36 >= 1); // Lower capacity constraint\\nassert(__count_36 <= 1); // Upper capacity constraint\\nassert(__count_1_3 == 0); // Dead code\\nassert(__count_2_3 == 0); // Dead code\\nassert(__count_26_27 >= 5); // Lower capacity constraint\\nassert(__count_26_27 <= 5); // Upper capacity constraint\\nassert(__count_26_25 >= 15); // Lower capacity constraint\\nassert(__count_26_25 <= 15); // Upper capacity constraint\\nassert(__count_6_7 == 0); // Dead code\\nassert(__count_32_33 >= 5); // Lower capacity constraint\\nassert(__count_32_33 <= 5); // Upper capacity constraint\\nassert(__count_32_31 >= 15); // Lower capacity constraint\\nassert(__count_32_31 <= 15); // Upper capacity constraint\\nassert(__count_9_13 >= 5); // Lower capacity constraint\\nassert(__count_9_13 <= 5); // Upper capacity constraint\\nassert(__count_34_35 >= 1); // Lower capacity constraint\\nassert(__count_34_35 <= 1); // Upper capacity constraint\\nassert(__count_12_11 >= 20); // Lower capacity constraint\\nassert(__count_12_11 <= 20); // Upper capacity constraint\\nassert(__count_12_13 >= 10); // Lower capacity constraint\\nassert(__count_12_13 <= 10); // Upper capacity constraint\\nassert(__count_14_15 >= 5); // Lower capacity constraint\\nassert(__count_14_15 <= 5); // Upper capacity constraint\\nassert(__count_18_17 >= 35); // Lower capacity constraint\\nassert(__count_18_17 <= 35); // Upper capacity constraint\\nassert(__count_18_19 >= 15); // Lower capacity constraint\\nassert(__count_18_19 <= 15); // Upper capacity constraint\\n#endif\\n\\n return 0;\\n}\\n\\nint \\nmain (int argc, char* argv[])\\n{\\n int i, j, k, chkerr;\\n double w;\\n double eps = 1.0e-6;\\n\\n /*\\n * There is 1 matrix of size ARRAY_DIMENSION * ARRAY_DIMENSION that need to be filled up.\\n */\\n if (argc != ARRAY_DIMENSION * ARRAY_DIMENSION +1)\\n {\\n return 1;\\n }\\n \\n k = 0;\\n for (i = 0; i <= ARRAY_DIMENSION - 1; i++) \\n {\\n w = 0.0;\\n for (j = 0; j <= ARRAY_DIMENSION - 1; j++) \\n {\\n a[i][j] = atoi (argv[k + 1]);\\n\\n k++;\\n if (i == j)\\n a[i][j] *= 10.0;\\n w += a[i][j];\\n }\\n b[i] = w;\\n }\\n\\n chkerr = LUdecomposition (ARRAY_DIMENSION - 1, eps);\\n \\n printf(\\\"%d\\\", chkerr);\\n\\n return 0;\\n}\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.5600992441177368,\n \"alphanum_fraction\": 0.5649853348731995,\n \"avg_line_length\": 39.43465042114258,\n \"blob_id\": \"3cc243ad77cbf04e055ad50ad9dcf3e6dbb7ffce\",\n \"content_id\": \"d87d33f5d4f297ef949207754b357cebd7bb20fb\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 13303,\n \"license_type\": \"no_license\",\n \"max_line_length\": 146,\n \"num_lines\": 329,\n \"path\": \"/GPUTimingAnalysis/src/Main.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#!/usr/bin/python2.6\\n\\nimport sys, optparse, os, time\\nimport Debug\\n\\n# The command-line parser and its options\\ncmdline = optparse.OptionParser(add_help_option=False)\\n\\ncmdline.add_option(\\\"-d\\\",\\n \\\"--debug\\\",\\n action=\\\"store\\\",\\n dest=\\\"debug\\\",\\n type=\\\"int\\\",\\n help=\\\"Debug mode.\\\",\\n default=False)\\n\\ncmdline.add_option(\\\"-C\\\",\\n \\\"--deep-clean\\\",\\n action=\\\"store_true\\\",\\n dest=\\\"deepclean\\\",\\n help=\\\"Clean previous runs of GPGPU-sim and uDrawgraph files.\\\",\\n default=False)\\n\\ncmdline.add_option(\\\"-h\\\",\\n \\\"--help\\\",\\n action=\\\"help\\\",\\n help=\\\"Display this help message.\\\")\\n\\ncmdline.add_option(\\\"-v\\\",\\n \\\"--verbose\\\",\\n action=\\\"store_true\\\",\\n dest=\\\"verbose\\\",\\n help=\\\"Be verbose.\\\",\\n default=False)\\n\\ncmdline.add_option(\\\"-u\\\",\\n \\\"--udraw\\\",\\n action=\\\"store_true\\\",\\n dest=\\\"udraw\\\",\\n help=\\\"Generate uDrawGraph files.\\\",\\n default=False)\\n\\ncmdline.add_option(\\\"-T\\\",\\n \\\"--number-of-tests\\\",\\n action=\\\"store\\\",\\n type=\\\"int\\\",\\n dest=\\\"tests\\\",\\n help=\\\"The number of times to run the kernel. [Default is %default].\\\",\\n default=0,\\n metavar=\\\"\\\")\\n\\ncmdline.add_option(\\\"--no-parsing\\\",\\n action=\\\"store_true\\\",\\n dest=\\\"noParse\\\",\\n help=\\\"Do not parse traces.\\\",\\n default=False)\\n\\nopts, args = cmdline.parse_args(sys.argv[1:])\\nDebug.verbose = opts.verbose\\nDebug.debug = opts.debug\\ngpgpuFileExt = '.gpgpusim'\\nrunPrefix = 'run'\\n\\ndef createGraphs (program, basepath):\\n import UDrawGraph, ICFGs, Trees, IPGs\\n Debug.debugMessage(\\\"Creating data structures\\\", 1)\\n for cfg in program.getCFGs():\\n functionName = cfg.getName()\\n UDrawGraph.makeUdrawFile (cfg, basepath, \\\"%s.%s\\\" % (functionName, \\\"cfg\\\"))\\n predomTree = Trees.Dominators(cfg, cfg.getEntryID())\\n reverseg = cfg.getReverseCFG()\\n postdomTree = Trees.Dominators(reverseg, reverseg.getEntryID())\\n UDrawGraph.makeUdrawFile (predomTree, basepath, \\\"%s.%s\\\" % (functionName, \\\"pre\\\"))\\n UDrawGraph.makeUdrawFile (postdomTree, basepath, \\\"%s.%s\\\" % (functionName, \\\"post\\\"))\\n icfg = ICFGs.ICFG(cfg)\\n icfg.setEntryID()\\n icfg.setExitID()\\n icfg.addExitEntryEdge()\\n program.addICFG(icfg)\\n UDrawGraph.makeUdrawFile (icfg, basepath, \\\"%s.%s\\\" % (functionName, \\\"icfg\\\"))\\n lnt = Trees.LoopNests(icfg, icfg.getEntryID())\\n program.addLNT(lnt)\\n UDrawGraph.makeUdrawFile (lnt, basepath, \\\"%s.%s\\\" % (functionName, \\\"lnt\\\"))\\n ipg = IPGs.IPG(icfg, lnt)\\n program.addIPG(ipg)\\n icfg.addBranchDivergenceEdges(lnt)\\n ipg.updateWithBranchDivergentPaths()\\n UDrawGraph.makeUdrawFile (icfg, basepath, \\\"%s.%s\\\" % (functionName, \\\"icfg\\\"))\\n UDrawGraph.makeUdrawFile (ipg, basepath, \\\"%s.%s\\\" % (functionName, \\\"ipg\\\"))\\n \\ndef getLineOfTimingTrace (line):\\n import shlex\\n tokenizer = shlex.shlex(line, posix=True)\\n tokenizer.whitespace += ','\\n lexemes = list(tokenizer)\\n PCIndex = 0 \\n warpIndex = 1\\n SMIndex = 2\\n cycleIndex = 3\\n SMAndWarp = int(lexemes[SMIndex]), int(lexemes[warpIndex])\\n timingTuple = lexemes[PCIndex], int(lexemes[cycleIndex])\\n return SMAndWarp, timingTuple\\n\\ndef getWarp (allWarpTraces, SMAndWarp):\\n import Traces\\n key = (SMAndWarp[0], SMAndWarp[1])\\n if key in allWarpTraces:\\n return allWarpTraces[key]\\n w = Traces.WarpTrace(SMAndWarp[0], SMAndWarp[1])\\n allWarpTraces[key] = w\\n return w\\n\\ndef analyseHWMT (program, firstTuple, lastTuple):\\n Debug.debugMessage(\\\"Analysing start tuple %s and last tuple %s\\\" % (firstTuple, lastTuple), 1)\\n ipointID = int(firstTuple[0], 0)\\n startTime = int(firstTuple[1])\\n endTime = int(lastTuple[1])\\n ipg = program.getIPGWithEntryIpointID(ipointID)\\n functionName = ipg.getName()\\n end2end = endTime - startTime\\n Debug.debugMessage(\\\"End-to-end(%s) = %d\\\" % (functionName, end2end), 1)\\n program.updateHWMT(functionName, end2end)\\n\\ndef splitTraces (program, generatedFiles):\\n Debug.debugMessage(\\\"Splitting traces\\\", 1)\\n allWarpTraces = {}\\n for outfile in generatedFiles:\\n traceFound = False\\n newKernel = False\\n firstTuple = None\\n lastTuple = None\\n Debug.debugMessage(\\\"Analysing file '%s'\\\" % outfile, 1)\\n with open(outfile, 'r') as f:\\n for line in f:\\n if line.startswith(\\\"NEW KERNEL\\\"):\\n traceFound = True\\n if firstTuple:\\n analyseHWMT(program, firstTuple, lastTuple)\\n firstTuple = None\\n continue\\n if traceFound:\\n SMAndWarp, timingTuple = getLineOfTimingTrace(line)\\n print \\n w = getWarp (allWarpTraces, SMAndWarp)\\n w.appendToTrace(timingTuple)\\n lastTuple = timingTuple\\n if not firstTuple:\\n firstTuple = timingTuple \\n analyseHWMT(program, firstTuple, lastTuple)\\n return allWarpTraces\\n\\ndef writeTraces (allWarpTraces, basename, basepath):\\n traceFileName = basepath + os.sep + basename + \\\".warps.trace\\\"\\n with open(traceFileName, 'w') as f:\\n for w in allWarpTraces.values(): \\n f.write(\\\"\\\\n%s\\\\n\\\" % ('=' * 20))\\n f.write(\\\"SM = %d WARP = %d\\\\n\\\" % (w.getMultiprocessorID(), w.getWarpID()))\\n f.write(\\\"%s\\\\n\\\" % ('=' * 20))\\n for t in w.getTrace():\\n ipointID = int(t[0], 0)\\n time = long(t[1])\\n f.write(\\\"0x%04X %d\\\\n\\\" % (ipointID, time))\\n \\ndef createCFGs (outfile):\\n import ParseCFGs\\n cfgLines = []\\n cfgInput = False\\n with open(outfile, 'r') as f:\\n for line in f:\\n if line.startswith('0x'):\\n break\\n if \\\"*** CFG ***\\\" in line:\\n if not cfgInput:\\n cfgInput = True\\n else:\\n cfgInput = False\\n if cfgInput:\\n cfgLines.append(line)\\n program = ParseCFGs.createProgram(cfgLines)\\n return program \\n\\ndef doAnalysis (generatedFiles, basename, basepath): \\n import Traces, WCET\\n # Create the CFGs\\n program = createCFGs(generatedFiles[0])\\n # Create the IPG\\n createGraphs(program, basepath)\\n if not opts.noParse:\\n # Split into warp-specific traces\\n allWarpTraces = splitTraces (program, generatedFiles)\\n if Debug.debug >= 5:\\n writeTraces(allWarpTraces, basename, basepath)\\n traceData = Traces.TraceData(allWarpTraces, program)\\n traceData.output()\\n \\n print \\\"%s End-to-end timing data %s\\\" % (\\\"=\\\" * 11, \\\"=\\\" * 11)\\n for ipg in program.getIPGs():\\n functionName = ipg.getName()\\n print \\\"ACET(%s) = %ld\\\" % (functionName, traceData.getACET(functionName))\\n print \\\"HWMT(%s) = %ld\\\" % (functionName, program.getHWMT(functionName))\\n # Create an ILP from the IPG and the parsed data\\n ilp = WCET.LinearProgram(ipg, traceData, functionName, basepath)\\n print \\\"WCET(%s) = %ld\\\" % (ipg.getName(), ilp.getWCET())\\n \\ndef runCUDAKernel (basepath):\\n from subprocess import Popen, PIPE\\n import signal\\n import re\\n \\n cmd = args[0]\\n Debug.debugMessage(\\\"CUDA application command '%s'\\\" % cmd, 1)\\n \\n run = 0\\n for filename in os.listdir(basepath):\\n match = re.search(r'%s[0-9]+%s' % (runPrefix, gpgpuFileExt), filename)\\n if match:\\n index = filename.find(gpgpuFileExt)\\n num = int(filename[len(runPrefix):index])\\n if num > run:\\n run = num\\n run += 1\\n \\n # Run the program on GPGPU-sim and get generated output\\n outfiles = []\\n generatedFiles = []\\n for i in xrange(run, opts.tests + run):\\n outfilename = basepath + os.sep + runPrefix + str(i) + gpgpuFileExt\\n generatedFiles.append(outfilename)\\n outfiles.append(outfilename)\\n assert generatedFiles, \\\"No output files were generated\\\"\\n processes = []\\n pidToOutFilename = {}\\n pidToOutFile = {}\\n while True:\\n while outfiles and len(processes) < multiprocessing.cpu_count()/2:\\n outfilename = outfiles.pop()\\n outfile = open(outfilename, 'w')\\n Debug.debugMessage(\\\"Spawning new process for '%s'\\\" % outfilename, 1)\\n proc = Popen(cmd, shell=True, stdout=outfile)\\n processes.append(proc)\\n pidToOutFile[proc.pid] = outfile\\n pidToOutFilename[proc.pid] = outfilename\\n for p in processes:\\n if p.poll() is not None:\\n processes.remove(p)\\n pidToOutFile[p.pid].close()\\n if p.returncode != 0:\\n Debug.debugMessage(\\\"Process failed for output file '%s' with return code %d\\\" % (pidToOutFilename[p.pid], p.returncode), 1)\\n outfiles.append(pidToOutFilename[p.pid])\\n if not processes and not outfiles:\\n break\\n else:\\n time.sleep(1)\\n p = Popen(['ps', '-A'], stdout=PIPE)\\n out, err = p.communicate()\\n for line in out.splitlines():\\n if 'cuobjdump_to_pt' in line:\\n pid = int(line.split(None, 1)[0])\\n os.kill(pid, signal.SIGKILL)\\n Debug.debugMessage(\\\"Killing stray CUDA-to-PTXPlus process\\\", 1)\\n return generatedFiles\\n\\ndef checkCommandLineForAction (): \\n # Check that the user has passed the correct options\\n if opts.tests > 0:\\n cudaBinary = args[0]\\n if not os.path.exists(cudaBinary):\\n Debug.exitMessage(\\\"The argument '%s' does not exist\\\" % cudaBinary)\\n elif not os.path.isfile(cudaBinary):\\n Debug.exitMessage(\\\"The argument '%s' is not a file\\\" % cudaBinary)\\n elif not os.access(cudaBinary, os.X_OK):\\n Debug.exitMessage(\\\"The argument '%s' does not have execute permission\\\" % cudaBinary)\\n # Get the filename of the binary without the path\\n basename = os.path.basename(cudaBinary)\\n basepath = os.path.abspath(os.path.dirname(cudaBinary))\\n generatedFiles = runCUDAKernel(basepath)\\n doAnalysis(generatedFiles, basename, basepath)\\n elif len(args) > 0:\\n for arg in args:\\n if not arg.endswith(gpgpuFileExt):\\n Debug.exitMessage(\\\"Each file must end with a '%s' suffix. You passed '%s'.\\\" % (gpgpuFileExt, arg))\\n basename = os.path.splitext(os.path.basename(args[0]))[0]\\n basepath = os.path.abspath(os.path.dirname(args[0]))\\n doAnalysis(args, basename, basepath)\\n else:\\n Debug.exitMessage(\\\"\\\"\\\"There are two ways to run this script:\\n 1) Either pass a CUDA binary as an argument and the number of times you want to run the kernel with the -T option; or\\n 2) Pass a number of files that were generated by GPGPU-sim from a previous testing run\\\"\\\"\\\")\\n\\ndef removeFile (fullPath):\\n print \\\"Removing '%s'\\\" % fullPath\\n os.remove(fullPath)\\n \\ndef postClean (abspath):\\n # The following file is generated by GPGPU-sim on every execution.\\n # It includes stats about each instruction execution\\n gpgpuInstrStats = abspath + os.sep + 'gpgpu_inst_stats.txt'\\n if os.path.exists(gpgpuInstrStats):\\n os.remove(gpgpuInstrStats)\\n for paths, dirs, files in os.walk(abspath):\\n files.sort()\\n for filename in files:\\n if filename.startswith('_cuobjdump_') or filename.startswith('_ptxplus_'):\\n removeFile(os.path.join(paths, filename))\\n \\ndef preClean (abspath):\\n import re\\n for paths, dirs, files in os.walk(os.path.abspath(os.curdir)):\\n files.sort()\\n for filename in files:\\n match = re.search(r'%s[0-9]+%s' % (runPrefix, gpgpuFileExt), filename)\\n if match:\\n removeFile(os.path.join(paths, filename))\\n elif filename.endswith('.udraw') or filename.endswith('.ilp'):\\n removeFile(os.path.join(paths, filename))\\n elif filename == 'benchmark.warps.trace':\\n removeFile(os.path.join(paths, filename))\\n \\nif __name__ == \\\"__main__\\\":\\n import multiprocessing\\n Debug.verboseMessage(\\\"You have %d CPUs on your system\\\" % multiprocessing.cpu_count())\\n if opts.deepclean:\\n preClean(os.path.abspath(os.curdir))\\n try:\\n # What to do depends on which parameters were parameters on the command line\\n checkCommandLineForAction ()\\n finally:\\n # Remove temporarily generated files\\n postClean (os.path.abspath(os.curdir))\\n\"\n },\n {\n \"alpha_fraction\": 0.6030157208442688,\n \"alphanum_fraction\": 0.6142627596855164,\n \"avg_line_length\": 45.7687873840332,\n \"blob_id\": \"41d12e4e08b8cbd3353e879f96aca6b2d1223d6d\",\n \"content_id\": \"6419abe804eed121a39b84f0d35a7fc0f1d55310\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 8091,\n \"license_type\": \"no_license\",\n \"max_line_length\": 148,\n \"num_lines\": 173,\n \"path\": \"/DaikonPathInformation/src/testing.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import config\\nimport debug\\nimport shlex\\nimport locale\\nimport gzip\\nimport re\\nimport os\\nimport subprocess\\nimport random\\nimport string\\nfrom pyevolve import G1DList, Mutators, Crossovers, GSimpleGA\\n\\nclass TestVectorProperties:\\n BaseType = [\\\"int\\\", \\\"double\\\", \\\"char\\\"]\\n \\n def __init__ (self):\\n self.read_file()\\n \\n def read_file(self):\\n locale.setlocale(locale.LC_ALL, 'en_US.UTF8')\\n with open(config.Arguments.test_specification_file, 'r') as f:\\n for line in f:\\n index = line.find('=')\\n if index == -1:\\n debug.exit_message(\\\"Found an invalid line '%s' in the test specification file\\\" % line)\\n else:\\n lhs = line[:index].strip()\\n rhs = line[index+1:].strip()\\n if lhs.lower() == \\\"type\\\":\\n self.base_type = rhs\\n elif lhs.lower() == \\\"length\\\":\\n try:\\n self.length = int(rhs)\\n except:\\n debug.exit_message(\\\"The length of the test vector must be a non-negative integer. It is '%s'.\\\" % rhs) \\n elif lhs.lower() == \\\"lower\\\":\\n try:\\n self.lower = locale.atoi(rhs)\\n except:\\n debug.exit_message(\\\"The lower bound on the range of elements in the test vector must be an integer. It is '%s'.\\\" % rhs) \\n elif lhs.lower() == \\\"upper\\\":\\n try:\\n self.upper = locale.atoi(rhs)\\n except:\\n debug.exit_message(\\\"The upper bound on the range of elements in the test vector must be an integer. It is '%s'.\\\" % rhs) \\n else:\\n debug.exit_message(\\\"Do not understand the line '%s' in the test specification file\\\" % line)\\n \\ndef get_next_trace_file_number(binary):\\n # Carry on from previous executions (if they exist)\\n nextrun = 0\\n gem5TraceDirectory = os.path.abspath(os.getcwd()) + os.sep + config.Arguments.m5_trace_directory\\n if os.path.exists(gem5TraceDirectory):\\n for filename in os.listdir(gem5TraceDirectory):\\n match = re.match(r'%s' % os.path.basename(binary), filename)\\n if match:\\n index1 = filename.rfind('.')\\n index2 = filename[:index1].rfind('.')\\n run = int(filename[index2+1:index1])\\n nextrun = max(nextrun, run)\\n return nextrun\\n\\ndef compress_trace(gem5_trace):\\n compressedFile = gem5_trace + '.gz'\\n f_in = open(gem5_trace, 'rb')\\n f_out = gzip.open(compressedFile, 'wb')\\n f_out.writelines(f_in)\\n f_out.close()\\n f_in.close()\\n os.remove(gem5_trace)\\n return compressedFile\\n\\ndef fitness_function(chromosome):\\n try:\\n if fitness_function.vectorProperties.base_type == TestVectorProperties.BaseType[2]:\\n # Sometimes this conversion fails and I don't see why?\\n # Just catch it and move on\\n chromosome.genomeList = [chr(val) for val in chromosome.genomeList]\\n except TypeError:\\n pass\\n \\n fitness_function.run += 1\\n traceFile = \\\"%s.%s.%d\\\" % (os.path.basename(fitness_function.binary), \\\"trace\\\", fitness_function.run)\\n cmd = '%s --debug-flags=Fetch --trace-file=%s %s --cpu-type=timing -c %s -o \\\"%s\\\"' % \\\\\\n (config.Arguments.gem5_simulator, traceFile, config.Arguments.gem5_config, fitness_function.binary, ' '.join(map(str, chromosome.genomeList)))\\n debug.debug_message(\\\"Running '%s' on gem5\\\" % cmd, 1)\\n proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) \\n returncode = proc.wait()\\n if returncode:\\n debug.exit_message(\\\"Running '%s' failed\\\" % cmd)\\n gem5_trace = os.path.abspath(os.getcwd()) + os.sep + config.Arguments.m5_trace_directory + os.sep + traceFile\\n assert os.path.exists(gem5_trace), \\\"Expected to find gem5 trace in '%s' but it is not there\\\" % gem5_trace\\n firstLines = os.popen(\\\"head -1 %s\\\" % gem5_trace).readlines()\\n lastLines = os.popen(\\\"tail -1 %s\\\" % gem5_trace).readlines()\\n assert len(firstLines) == 1\\n assert len(lastLines) == 1\\n firstLine = firstLines[0]\\n lastLine = lastLines[0]\\n time1 = shlex.split(firstLine)[0]\\n time2 = shlex.split(lastLine)[0]\\n time1 = time1[:-1]\\n time2 = time2[:-1]\\n score = int(time2) - int(time1)\\n debug.debug_message(\\\"Score = %d\\\" % score, 1)\\n fitness_function.gem5traces.append(compress_trace(gem5_trace))\\n return score\\n\\ndef runGAGem5(binary, populationSize=20, generations=20):\\n test_vector_properties = TestVectorProperties()\\n # Set up the fitness function's attributes\\n fitness_function.binary = binary\\n fitness_function.gem5traces = []\\n fitness_function.vectorProperties = test_vector_properties\\n fitness_function.run = get_next_trace_file_number(binary)\\n # Create the population\\n genome = G1DList.G1DList(test_vector_properties.length)\\n genome.setParams(rangemin=test_vector_properties.lower, \\\\\\n rangemax=test_vector_properties.upper)\\n genome.evaluator.set(fitness_function)\\n genome.mutator.set(Mutators.G1DListMutatorIntegerRange)\\n \\n # Cannot crossover if there is only a single gene in the chromosone\\n if test_vector_properties.length == 1:\\n genome.crossover.clear()\\n else:\\n genome.crossover.set(Crossovers.G1DListCrossoverTwoPoint)\\n \\n # Set up the engine\\n ga = GSimpleGA.GSimpleGA(genome)\\n ga.setPopulationSize(populationSize)\\n ga.setGenerations(generations)\\n ga.setCrossoverRate(0.9)\\n ga.setMutationRate(0.01)\\n ga.setElitism(True)\\n # Run the GA\\n ga.evolve(freq_stats=1) \\n return fitness_function.gem5traces\\n\\nclass RandomGeneration:\\n def __init__ (self, test_vector_properties):\\n self.test_vector_properties = test_vector_properties\\n \\n def next_test_vector(self):\\n vector = []\\n for i in xrange(1, self.test_vector_properties.length+1):\\n if self.test_vector_properties.base_type == TestVectorProperties.BaseType[0]: \\n vector.append(random.randint(self.test_vector_properties.lower, self.test_vector_properties.upper))\\n elif self.test_vector_properties.base_type == TestVectorProperties.BaseType[1]:\\n vector.append(random.uniform(self.test_vector_properties.lower, self.test_vector_properties.upper))\\n elif self.test_vector_properties.base_type == TestVectorProperties.BaseType[2]:\\n vector.append(random.choice(string.letters))\\n assert len(vector) == self.test_vector_properties.length, \\\"Created an invalid test vector of length %d\\\" % len(vector)\\n return ' '.join(str(val) for val in vector)\\n \\ndef run_gem5(binary):\\n test_vector_properties = TestVectorProperties()\\n run = get_next_trace_file_number(binary) + 1\\n # Now run the program n times\\n random_test_vectors = RandomGeneration(test_vector_properties)\\n gem5traces = []\\n for i in xrange(run, config.Arguments.tests + run):\\n traceFile = \\\"%s.%s.%d.gz\\\" % (os.path.basename(binary), \\\"trace\\\", i)\\n cmd = '%s --debug-flags=Fetch --trace-file=%s %s --cpu-type=timing -c %s -o \\\"%s\\\"' % \\\\\\n (config.Arguments.gem5_simulator, traceFile, config.Arguments.gem5_config, binary, random_test_vectors.next_test_vector())\\n debug.debug_message(\\\"Running '%s' on gem5\\\" % cmd, 1)\\n proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) \\n returncode = proc.wait()\\n if returncode:\\n debug.exit_message(\\\"Running '%s' failed\\\" % cmd)\\n gem5_trace = os.path.abspath(os.getcwd()) + os.sep + config.Arguments.m5_trace_directory + os.sep + traceFile\\n assert os.path.exists(gem5_trace), \\\"Expected to find gem5 trace in '%s' but it is not there\\\" % gem5_trace\\n gem5traces.append(gem5_trace)\\n return gem5traces\\n\"\n },\n {\n \"alpha_fraction\": 0.5358851552009583,\n \"alphanum_fraction\": 0.5706539154052734,\n \"avg_line_length\": 20.47260284423828,\n \"blob_id\": \"18dfce3d972dd7bc60172a41f363342f5e103eb8\",\n \"content_id\": \"27a922104ba90854fcd2b3b36a5d41c6ce8c9273\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 3135,\n \"license_type\": \"no_license\",\n \"max_line_length\": 88,\n \"num_lines\": 146,\n \"path\": \"/DaikonPathInformation/benchmarks/matrix_count.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Matrix count taken from MDH suite and modified\\n * by Adam Betts to consume a test vector supplied on the command line.\\n *\\n * For this program, the test vector consists of UPPERLIMIT * UPPERLIMIT integers \\n * since there is a matrix if that size to be initialised. \\n * The program does the following:\\n * 1) It counts the number of positive numbers in the matrix.\\n * 2) It sums the positive numbers.\\n * 3) It counts the number of negative numbers in the matrix.\\n * 4) It sums the negative numbers.\\n */\\n\\n#define UPPERLIMIT 5\\ntypedef int matrix[UPPERLIMIT][UPPERLIMIT];\\n\\nint Postotal;\\nint Negtotal;\\nint Poscnt;\\nint Negcnt;\\n\\nint\\nmatrix_count (matrix A)\\n{\\n #ifdef CBMC\\n//==========> matrix_count : header 7\\nint __count_4_6 = 0;\\nint __count_5_6 = 0;\\nint __count_7_3 = 0; //Loop counter\\n//==========> matrix_count : header 9\\nint __count_7_8 = 0;\\nint __count_9_2 = 0; //Loop counter\\n//==========> matrix_count : header 1\\nint __count_10 = 0;\\nint __count_9_10 = 0;\\n #endif\\n int i, j;\\n int Ptotal = 0;\\n int Ntotal = 0;\\n int Pcnt = 0;\\n int Ncnt = 0;\\n\\n #ifdef CBMC\\n __count_9_2 = 0;\\n #endif\\n for (i = 0; i < UPPERLIMIT; ++i) // 9\\n {\\n #ifdef CBMC\\n __count_9_2++;\\n #endif\\n\\n #ifdef CBMC\\n __count_7_3 = 0;\\n #endif\\n for (j = 0; j < UPPERLIMIT; ++j) // 7\\n {\\n #ifdef CBMC\\n __count_7_3++;\\n #endif\\n if (A[i][j] < 0) // 3\\n {\\n // 4\\n Ntotal += A[i][j];\\n Ncnt++;\\n #ifdef CBMC\\n __count_4_6++;\\n #endif\\n }\\n else\\n {\\n #ifdef CBMC\\n __count_5_6++;\\n #endif\\n Ptotal += A[i][j];\\n Pcnt++;\\n }\\n }\\n #ifdef CBMC\\n assert(__count_7_3 <= 6); // Loop counter property\\n __count_7_8++;\\n #endif\\n }\\n #ifdef CBMC\\n assert(__count_9_2 <= 6); // Loop counter property\\n #endif\\n\\n Postotal = Ptotal;\\n Poscnt = Pcnt;\\n Negtotal = Ntotal;\\n Negcnt = Ncnt;\\n \\n #ifdef CBMC\\n __count_9_10++;\\n __count_10++;\\n #endif\\n\\n#ifdef CBMC\\n//assert(__count_5_6 >= 4); // Lower capacity constraint\\n//assert(__count_5_6 <= 17); // Upper capacity constraint\\nassert(__count_7_8 >= 5); // Lower capacity constraint\\nassert(__count_7_8 <= 5); // Upper capacity constraint\\nassert(__count_10 >= 1); // Lower capacity constraint\\nassert(__count_10 <= 1); // Upper capacity constraint\\nassert(__count_9_10 >= 1); // Lower capacity constraint\\nassert(__count_9_10 <= 1); // Upper capacity constraint\\n//assert(__count_4_6 >= 8); // Lower capacity constraint\\n//assert(__count_4_6 <= 21); // Upper capacity constraint\\n#endif\\n\\n return Postotal + Poscnt + Negtotal + Negcnt;\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n int i, j, k;\\n matrix A;\\n\\n /*\\n * There is a matrix with UPPERLIMIT*UPPERLIMIT dimensions that needs to be filled up.\\n * This many values need to be passed on the command-line as a consequence.\\n */\\n if (argc != UPPERLIMIT * UPPERLIMIT + 1)\\n {\\n return 1;\\n }\\n\\n /*\\n * Initialise matrix A.\\n */\\n k = 0;\\n for (i = 0; i < UPPERLIMIT; ++i)\\n {\\n for (j = 0; j < UPPERLIMIT; ++j)\\n {\\n A[i][j] = atoi (argv[k + 1]);\\n k++;\\n }\\n }\\n\\n int val = matrix_count (A);\\n \\n printf(\\\"%d\\\", val);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.5073490738868713,\n \"alphanum_fraction\": 0.5110236406326294,\n \"avg_line_length\": 35.95145797729492,\n \"blob_id\": \"425fa42674e58de2760f20feadc9f5b8533608e0\",\n \"content_id\": \"c39c083f16f70d0e9e43623978d8fa30cbc989de\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 3810,\n \"license_type\": \"no_license\",\n \"max_line_length\": 91,\n \"num_lines\": 103,\n \"path\": \"/GPUTimingAnalysis/src/WCET.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import Debug\\nimport decimal, os\\n\\nedgePrefix = \\\"e_\\\"\\nendStmt = \\\";\\\"\\nplus = \\\" + \\\"\\nequals = \\\" = \\\"\\nltOrEqual = \\\" <= \\\"\\ncomma = \\\", \\\"\\nnewLine = \\\"\\\\n\\\"\\n\\nclass LinearProgram ():\\n def __init__(self, ipg, traceData, basename, basepath):\\n self.__wcet = 0\\n outputFilename = basepath + os.sep + basename + \\\".ilp\\\"\\n with open(outputFilename, 'w') as f:\\n self.__writeObjectiveFunction(f, ipg, traceData)\\n self.__writeStructuralConstraints(f, ipg)\\n self.__writeCountConstraints(f, ipg, traceData)\\n self.__writeNonNegativeConstraints(f, ipg)\\n self.__solve(ipg, outputFilename)\\n \\n def getWCET (self):\\n return self.__wcet\\n \\n def __solve(self, ipg, ilpFile):\\n from subprocess import Popen, PIPE\\n import shlex\\n Debug.debugMessage(\\\"Solving ILP\\\", 10)\\n command = \\\"lp_solve %s\\\" % ilpFile \\n proc = Popen(command, shell=True, executable=\\\"/bin/bash\\\", stdout=PIPE, stderr=PIPE)\\n returnCode = proc.wait()\\n if returnCode != 0:\\n Debug.exitMessage(\\\"Running '%s' failed\\\" % command)\\n for line in proc.stdout.readlines():\\n if line.startswith(\\\"Value of objective function\\\"):\\n lexemes = shlex.split(line)\\n wcet = long(decimal.Decimal(lexemes[-1]))\\n self.__wcet = wcet\\n \\n def __writeObjectiveFunction(self, f, ipg, traceData):\\n f.write(\\\"max: \\\")\\n count = 0\\n numOfEdges = ipg.numOfEdges()\\n for vertexID in ipg.vertices:\\n v = ipg.getVertex(vertexID)\\n for succe in v.getSuccessorEdges ():\\n count += 1\\n edgeID = succe.getEdgeID()\\n wcet = traceData.getWCETOfEdge(edgeID)\\n f.write(\\\"%d %s%d\\\" % (wcet, edgePrefix, edgeID))\\n if count < numOfEdges:\\n f.write(plus)\\n f.write(\\\"%s%s\\\" % (endStmt, newLine))\\n \\n def __writeStructuralConstraints(self, f, ipg):\\n f.write(newLine)\\n for vertexID in ipg.vertices:\\n v = ipg.getVertex(vertexID)\\n count = 0\\n for prede in v.getPredecessorEdges ():\\n count += 1\\n f.write(\\\"%s%d\\\" % (edgePrefix, prede.getEdgeID()))\\n if count < v.numberOfPredecessors():\\n f.write(plus)\\n \\n f.write(equals)\\n \\n count = 0\\n for succe in v.getSuccessorEdges ():\\n count += 1\\n f.write(\\\"%s%d\\\" % (edgePrefix, succe.getEdgeID()))\\n if count < v.numberOfSuccessors():\\n f.write(plus)\\n \\n f.write(\\\"%s%s\\\" % (endStmt, newLine))\\n \\n def __writeCountConstraints(self, f, ipg, traceData):\\n f.write(newLine)\\n for vertexID in ipg.vertices:\\n v = ipg.getVertex(vertexID)\\n for succe in v.getSuccessorEdges ():\\n edgeID = succe.getEdgeID()\\n wcec = traceData.getWCECOfEdge(edgeID)\\n if vertexID == ipg.getExitID():\\n wcec = 1\\n f.write(\\\"%s%d%s%d\\\" % (edgePrefix, edgeID, ltOrEqual, wcec))\\n f.write(\\\"%s%s\\\" % (endStmt, newLine))\\n \\n def __writeNonNegativeConstraints(self, f, ipg):\\n f.write(newLine)\\n f.write(\\\"int \\\")\\n count = 0\\n numOfEdges = ipg.numOfEdges()\\n for vertexID in ipg.vertices:\\n v = ipg.getVertex(vertexID)\\n for succe in v.getSuccessorEdges ():\\n edgeID = succe.getEdgeID()\\n count += 1\\n f.write(\\\"%s%d\\\" % (edgePrefix, edgeID))\\n if count < numOfEdges:\\n f.write(comma)\\n f.write(\\\"%s%s\\\" % (endStmt, newLine))\\n \"\n },\n {\n \"alpha_fraction\": 0.6060320734977722,\n \"alphanum_fraction\": 0.627709686756134,\n \"avg_line_length\": 20.18000030517578,\n \"blob_id\": \"cf05dc3a785050030c0afda241b89631289043f0\",\n \"content_id\": \"a142d95e5eff1b55f85c60eca0b92f4550cf7cd4\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Shell\",\n \"length_bytes\": 1061,\n \"license_type\": \"no_license\",\n \"max_line_length\": 91,\n \"num_lines\": 50,\n \"path\": \"/scripts/run_super_block_calculations.sh\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#!/bin/bash\\n\\nfunction clean_up {\\n rm -f [0-9][0-9]*.txt *.ilp\\n exit\\n}\\n\\ntrap clean_up INT\\n\\nMIN_VERTICES=10\\nMAX_VERTICES=1000\\nSUBPROGRAMS=100\\nLOOPS=0\\nNESTING_DEPTH=1\\nOUTPUT_DIR=super_block_results\\n\\nmkdir -p $OUTPUT_DIR\\n\\nwhile getopts \\\":s:l:n:a:b\\\" opt; do\\n case $opt in\\n a) MIN_VERTICES=$OPTARG\\n ;;\\n b) MAX_VERTICES=$OPTARG\\n ;;\\n s) SUBPROGRAMS=$OPTARG\\n ;;\\n l) LOOPS=$OPTARG\\n ;;\\n n) NESTING_DEPTH=$OPTARG\\n ;;\\n \\\\?)\\n echo \\\"Invalid option: -$OPTARG\\\" >&2\\n exit 1\\n ;;\\n :)\\n echo \\\"Option -$OPTARG requires an argument.\\\" >&2\\n exit 1\\n ;;\\n esac\\ndone\\n\\nfor i in `seq $MIN_VERTICES $MAX_VERTICES`;\\ndo\\n echo \\\"Doing analysis on control flow graphs with $i vertices\\\"\\n python3 ../tools/program_generator.py --vertices $i --program_file $i.txt\\\\\\n --subprograms $SUBPROGRAMS --loops $LOOPS --nesting-depth $NESTING_DEPTH\\n python3 ../tools/super_block_calculations.py $i.txt\\\\\\n --output $OUTPUT_DIR/$i.subprograms_$SUBPROGRAMS.loops_$LOOPS.depth_$NESTING_DEPTH.txt\\\\\\n --repeat 10 --folded\\ndone\\n\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.5463177561759949,\n \"alphanum_fraction\": 0.5538023114204407,\n \"avg_line_length\": 55.632911682128906,\n \"blob_id\": \"28db4e5111b5839d3d9e97aff3946dcfe310c168\",\n \"content_id\": \"d02a4fc7e3ef3b0753d03b48c6e156cafa43b3f9\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 35807,\n \"license_type\": \"no_license\",\n \"max_line_length\": 211,\n \"num_lines\": 632,\n \"path\": \"/DaikonPathInformation/src/traces.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import edges\\nimport vertices\\nimport debug\\nimport arm\\nimport config\\nimport random\\nimport os\\nimport shlex\\nimport gzip\\n\\nnewTrace = \\\"=>\\\"\\nendTrace = \\\"<=\\\"\\n\\nclass Generatetraces:\\n maxNumberOfCalls = 20\\n maxLoopIterations = 10\\n \\n def __init__ (self, program, numberOftraces=1):\\n self.__program = program\\n filename = config.Arguments.basepath + os.sep + config.Arguments.basename + \\\".traces\\\"\\n with open(filename, 'w') as self.__outfile:\\n for trace in xrange(1, numberOftraces+1):\\n debug.debug_message(\\\"Generating trace #%d\\\" % trace, 1)\\n self.__outfile.write(\\\"%s\\\\n\\\" % newTrace)\\n self.__generateTrace() \\n self.__outfile.write(\\\"\\\\n%s\\\\n\\\" % endTrace)\\n \\n def __generateTrace (self):\\n # To keep track of loop tail iteration count\\n self.__functionToTailCount = {}\\n # To keep trace of the number of function calls\\n self.__numberOfCalls = 0\\n callg = self.__program.getCallGraph()\\n rootv = callg.getVertex(callg.getRootID())\\n self.__currentCallv = rootv\\n self.__currentCFG = self.__program.getCFG(rootv.getName())\\n self.__currentLNT = self.__program.getLNT(rootv.getName())\\n self.__currentv = self.__currentCFG.getVertex(self.__currentCFG.getEntryID())\\n self.__vertexID = self.__currentv.vertexID\\n self.__callStack = []\\n while True: \\n self.__outfile.write(\\\"%d \\\" % self.__vertexID)\\n if self.__vertexID == self.__currentCFG.getExitID():\\n if callg.getVertexWithName(self.__currentCFG.getName()) == rootv:\\n # End of the program reached\\n break\\n else:\\n # End of function call\\n debug.debug_message(\\\"Returning from %s\\\" % self.__currentCallv.getName(), 5)\\n self.__currentCallv, self.__currentCFG, self.__currentLNT, self.__currentv = self.__callStack.pop()\\n self.__vertexID = self.__currentv.vertexID\\n # Go past the call site\\n self.__chooseSuccessorInICFG()\\n elif self.__currentLNT.isLoopTail(self.__vertexID):\\n tupleIndex = self.__currentCFG.getName(), self.__vertexID\\n if tupleIndex not in self.__functionToTailCount:\\n self.__functionToTailCount[tupleIndex] = 1\\n self.__chooseSuccessorInICFG()\\n elif self.__functionToTailCount[tupleIndex] < Generatetraces.maxLoopIterations:\\n self.__functionToTailCount[tupleIndex] += 1\\n self.__chooseSuccessorInICFG()\\n else:\\n self.__chooseNonLoopBackEdgeSuccessorInICFG()\\n elif self.__currentCFG.isCallSite(self.__vertexID):\\n # Make the call. First save state then move to the callee ICFG\\n self.__callStack.append((self.__currentCallv, self.__currentCFG, self.__currentLNT, self.__currentv))\\n succID = self.__currentCallv.getSuccessorWithCallSite(self.__vertexID)\\n self.__currentCallv = callg.getVertex(succID)\\n calleeName = self.__currentCallv.getName()\\n debug.debug_message(\\\"Calling %s\\\" % self.__currentCallv.getName(), 5)\\n self.__currentCFG = self.__program.getICFG(calleeName)\\n self.__currentLNT = self.__program.getLNT(calleeName)\\n self.__currentv = self.__currentCFG.getVertex(self.__currentCFG.getEntryID())\\n self.__vertexID = self.__currentv.vertexID\\n else:\\n self.__chooseSuccessorInICFG()\\n \\n def __chooseSuccessorInICFG (self):\\n succIndex = random.randint(0, self.__currentv.numberOfSuccessors() - 1)\\n succID = self.__currentv.getSuccessorIDs()[succIndex]\\n self.__currentv = self.__currentCFG.getVertex(succID)\\n self.__vertexID = self.__currentv.vertexID\\n \\n def __chooseNonLoopBackEdgeSuccessorInICFG (self):\\n succIDs = [succID for succID in self.__currentv.getSuccessorIDs() if not self.__currentLNT.isLoopBackEdge(self.__vertexID, succID)]\\n succIndex = random.randint(0, len(succIDs) - 1)\\n succID = succIDs[succIndex]\\n self.__currentv = self.__currentCFG.getVertex(succID)\\n self.__vertexID = self.__currentv.vertexID\\n \\nclass TraceInformation:\\n def __init__ (self, program):\\n self._program = program\\n self._allruns = set([])\\n self._initialiseOptionalPathInformation()\\n self._initialiseRequiredPathInformation()\\n \\n def _initialiseOptionalPathInformation (self):\\n self._executionCountsThisRun = {}\\n self._relativeExecutionCountsThisRun = {}\\n for cfg in self._program.getcfgs():\\n pathg = self._program.getPathInfoGraph(cfg.name)\\n lnt = self._program.getLNT(cfg.name)\\n self._executionCountsThisRun[pathg] = {}\\n self._relativeExecutionCountsThisRun[pathg] = {}\\n for v in pathg:\\n self._executionCountsThisRun[pathg][v.vertexID] = 0\\n for headerID in lnt.getHeaderIDs():\\n self._executionCountsThisRun[pathg][headerID] = 0\\n self._relativeExecutionCountsThisRun[pathg][headerID] = 0\\n \\n def _initialiseRequiredPathInformation (self):\\n self._longestTime = 0\\n self._executionTimes = {}\\n for cfg in self._program.getcfgs():\\n functionName = cfg.getName()\\n for v in cfg:\\n self._executionTimes[(functionName, v.getOriginalVertexID())] = 0\\n \\n def _endOfFunction (self, cfg, lnt, pathg):\\n functionName = cfg.getName()\\n debug.debug_message(\\\"Falsifying conjectures in %s\\\" % functionName, 10)\\n # Mutual inclusion and mutual exclusion\\n for v in pathg:\\n vertexID = v.vertexID\\n executionCount = self._executionCountsThisRun[pathg][vertexID]\\n # Capacity execution counts \\n for succe in v.getSuccessoredges(edges.PathInformationEdgeType.CAPACITY_BOUNDS):\\n if executionCount < succe.lower:\\n debug.debug_message(\\\"Falsifying conjecture that %s executes at least %d times. Found %d instead\\\" % (v.__str__(), succe.lower, executionCount), 1)\\n succe.lower = executionCount\\n if executionCount > succe.upper:\\n debug.debug_message(\\\"Falsifying conjecture that %s executes at most %d times. Found %d instead\\\" % (v.__str__(), succe.upper, executionCount), 1)\\n succe.upper = executionCount\\n # If this vertex has been triggered in this run\\n if executionCount > 0:\\n # Falsify execution implication conjectures\\n mutualExclusionCandiates = set([])\\n falsified = set([])\\n for succe in v.getSuccessoredges(edges.PathInformationEdgeType.INCLUSION):\\n succID = succe.vertexID\\n if self._executionCountsThisRun[pathg][succID] == 0:\\n succv = pathg.getVertex(succID)\\n debug.debug_message(\\\"When %s executes, %s does not always execute (EXECUTION DEPENDENCE FALSIFIED)\\\" % (v.__str__(), succv.__str__()), 1)\\n falsified.add(succID)\\n if not succv.hasSuccessorEdge(vertexID, edges.PathInformationEdgeType.INCLUSION):\\n mutualExclusionCandiates.add(succID)\\n for succID in falsified:\\n v.removeSuccessorEdge(succID, edges.PathInformationEdgeType.INCLUSION)\\n # Falsify mutual-exclusion conjectures\\n falsified = set([])\\n for succe in v.getSuccessoredges(edges.PathInformationEdgeType.EXCLUSION):\\n succID = succe.vertexID\\n if self._executionCountsThisRun[pathg][succID] > 0:\\n succv = pathg.getVertex(succID)\\n debug.debug_message(\\\"When %s executes, %s may execute (EXCLUSIVITY FALSIFIED)\\\" % (v.__str__(), succv.__str__()), 1)\\n falsified.add(succID)\\n for succID in falsified:\\n v.removeSuccessorEdge(succID, edges.PathInformationEdgeType.EXCLUSION) \\n succv = pathg.getVertex(succID)\\n succv.removeSuccessorEdge(vertexID, edges.PathInformationEdgeType.EXCLUSION)\\n # Add mutual-exclusion conjectures\\n for succID in mutualExclusionCandiates:\\n succv = pathg.getVertex(succID)\\n v.addSuccessorEdge(succID, edges.PathInformationEdgeType.EXCLUSION)\\n succv.addSuccessorEdge(vertexID, edges.PathInformationEdgeType.EXCLUSION)\\n debug.debug_message(\\\"New conjecture: %s and %s are MUTUALLY EXCLUSIVE\\\" % (v.__str__(), succv.__str__()), 1)\\n \\n for headerID in lnt.getHeaderIDs():\\n programPoint = list(pathg.getLoopMonitoredProgramPoints(headerID))[0]\\n pathv = pathg.getProgramPointVertex(programPoint)\\n succe = pathv.getSuccessoredges(edges.PathInformationEdgeType.LOOP_BOUNDS)[0]\\n executionCount = self._executionCountsThisRun[pathg][headerID]\\n if executionCount > succe.upper:\\n debug.debug_message(\\\"Falsifying conjecture that %d executes at most %d times. Found %d instead\\\" % (headerID, succe.upper, executionCount), 1)\\n succe.upper = executionCount\\n self._executionCountsThisRun[pathg][headerID] = 0\\n \\n for v in pathg:\\n vertexID = v.vertexID\\n self._executionCountsThisRun[pathg][vertexID] = 0\\n \\n def _end (self):\\n for cfg in self._program.getcfgs():\\n functionName = cfg.getName()\\n pathg = self._program.getPathInfoGraph(functionName) \\n debug.verbose_message(\\n\\\"\\\"\\\"%s\\nFUNCTION '%s'\\n%s\\\"\\\"\\\" \\\\\\n% ('*' * 100, functionName, '*' * 100), __name__)\\n for vertexID1, vertexID2 in pathg.mutualInclusionPairs():\\n v1 = pathg.getVertex(vertexID1)\\n v2 = pathg.getVertex(vertexID2)\\n succe1 = v1.getSuccessoredges(edges.PathInformationEdgeType.CAPACITY_BOUNDS)[0]\\n succe2 = v2.getSuccessoredges(edges.PathInformationEdgeType.CAPACITY_BOUNDS)[0]\\n if succe1.lower > 0 and succe2.lower > 0:\\n debug.verbose_message(\\\" IGNORING MUTUAL INCLUSION: %s and %s\\\" % (v1.__str__(), v2.__str__()), __name__)\\n v1.removeSuccessorEdge(vertexID2, edges.PathInformationEdgeType.INCLUSION)\\n v2.removeSuccessorEdge(vertexID1, edges.PathInformationEdgeType.INCLUSION)\\n \\n for v in pathg:\\n vertexID = v.vertexID\\n succe = v.getSuccessoredges(edges.PathInformationEdgeType.CAPACITY_BOUNDS)[0]\\n if succe.lower == 0 and succe.upper == 0:\\n for succe in v.getSuccessoredges(edges.PathInformationEdgeType.INCLUSION):\\n succID = succe.vertexID\\n succv = pathg.getVertex(succID)\\n succv.removeSuccessorEdge(vertexID, edges.PathInformationEdgeType.INCLUSION)\\n debug.verbose_message(\\\" IGNORING MUTUAL INCLUSION BECAUSE OF DEAD CODE: %s and %s\\\" % (v.__str__(), succv.__str__()), __name__)\\n for succe in v.getSuccessoredges(edges.PathInformationEdgeType.EXCLUSION):\\n succID = succe.vertexID\\n succv = pathg.getVertex(succID)\\n succv.removeSuccessorEdge(vertexID, edges.PathInformationEdgeType.EXCLUSION)\\n debug.verbose_message(\\\" IGNORING MUTUAL EXCLUSION BECAUSE OF DEAD CODE: %s and %s\\\" % (v.__str__(), succv.__str__()), __name__)\\n v.removeAllSuccessors()\\n \\n def _normaliseData (self):\\n for tupleKey in self._executionTimes.keys():\\n self._executionTimes[tupleKey] *= pow(10,-3)\\n self._longestTime *= pow(10,-3)\\n \\n def __computeInnerRelativeBounds (self, pathg, lnt, pathv, headerv):\\n for succID in headerv.getSuccessorIDs():\\n succv = lnt.getVertex(succID)\\n if isinstance(succv, vertices.HeaderVertex):\\n innerHeaderID = succv.getHeaderID()\\n innerProgramPoint = list(pathg.getLoopMonitoredProgramPoints(innerHeaderID))[0]\\n innerPathv = pathg.getProgramPointVertex(innerProgramPoint)\\n succe = innerPathv.getSuccessoredges(edges.PathInformationEdgeType.LOOP_BOUNDS)[0]\\n executionCount = self._relativeExecutionCountsThisRun[pathg][innerHeaderID]\\n if executionCount > succe.relative:\\n debug.debug_message(\\\"Falsifying conjecture that %d executes at most %d times relative to its innermost enclosing loop. Found %d instead\\\" % (innerHeaderID, succe.relative, executionCount), 1)\\n succe.relative = executionCount\\n self._relativeExecutionCountsThisRun[pathg][innerHeaderID] = 0\\n \\n def __analyseProgramPoint (self, pathg, lnt, pathv):\\n vertexID = pathv.vertexID\\n self._executionCountsThisRun[pathg][vertexID] += 1\\n if pathv.isEffectiveHeaderCounter():\\n for headerID in pathv.getHeaderIDsForWhichToCount():\\n self._relativeExecutionCountsThisRun[pathg][headerID] += 1\\n self._executionCountsThisRun[pathg][headerID] += 1\\n headerv = lnt.getVertex(lnt.getVertex(pathv.getHeaderID()).getParentID())\\n self.__computeInnerRelativeBounds(pathg, lnt, pathv, headerv)\\n \\n def _analyseCFGVertex (self, pathg, lnt, vertexID):\\n pathv = pathg.isMonitoredVertex(vertexID)\\n if pathv:\\n self.__analyseProgramPoint(pathg, lnt, pathv)\\n \\n def _analyseCFGEdge (self, pathg, lnt, predID, succID):\\n pathv = pathg.isMonitoredEdge(predID, succID)\\n if pathv:\\n self.__analyseProgramPoint(pathg, lnt, pathv)\\n \\n def getExecutionTime (self, functionName, vertexID):\\n tupleKey = (functionName, vertexID)\\n assert tupleKey in self._executionTimes\\n return self._executionTimes[tupleKey]\\n \\n def getLongestTime (self):\\n return self._longestTime \\n \\n def _outputConjectures (self): \\n for cfg in self._program.getcfgs():\\n functionName = cfg.getName()\\n pathg = self._program.getPathInfoGraph(functionName)\\n debug.verbose_message(\\n\\\"\\\"\\\"%s\\nFUNCTION '%s'\\n%s\\\"\\\"\\\" \\\\\\n% ('*' * 100, functionName, '*' * 100), __name__)\\n \\n for v in pathg:\\n for succe in v.getSuccessoredges(edges.PathInformationEdgeType.CAPACITY_BOUNDS):\\n if succe.lower == 0 and succe.upper == 0:\\n debug.verbose_message(\\\" NEVER EXECUTES: %s\\\" % (v.__str__(),), __name__)\\n elif succe.lower > 0:\\n debug.verbose_message(\\\" ALWAYS EXECUTES: %s, at least %d time(s), at most %d time(s)\\\" % (v.__str__(), succe.lower, succe.upper), __name__)\\n else:\\n debug.verbose_message(\\\" MAY EXECUTE: %s, at most %d time(s)\\\" % (v.__str__(), succe.upper), __name__)\\n \\n \\n debug.verbose_message(\\n\\\"\\\"\\\"%s\\nDEPENDENT EXECUTION CONJECTURES\\n%s\\\"\\\"\\\" \\\\\\n % ('-' * 50, '-' * 50), __name__)\\n for vertexID1, vertexID2 in pathg.mutualInclusionPairs():\\n v1 = pathg.getVertex(vertexID1)\\n v2 = pathg.getVertex(vertexID2)\\n debug.verbose_message(\\\" MUTUALLY INCLUSIVE: %s and %s\\\" % (v1.__str__(), v2.__str__()), __name__)\\n for vertexID1, vertexID2 in pathg.mutualExclusionPairs():\\n v1 = pathg.getVertex(vertexID1)\\n v2 = pathg.getVertex(vertexID2)\\n debug.verbose_message(\\\" MUTUALLY EXCLUSIVE: %s and %s\\\" % (v1.__str__(), v2.__str__()), __name__)\\n for vertexID1, vertexID2 in pathg.executionDependencies():\\n v1 = pathg.getVertex(vertexID1)\\n v2 = pathg.getVertex(vertexID2)\\n debug.verbose_message(\\\" ONE-WAY DEPENDENCY: %s on %s\\\" % (v1.__str__(), v2.__str__()), __name__)\\n \\n def _outputCBMCConjectures (self): \\n for cfg in self._program.getcfgs():\\n functionName = cfg.getName()\\n pathg = self._program.getPathInfoGraph(functionName)\\n lnt = self._program.getLNT(functionName)\\n print(\\n\\\"\\\"\\\"%s\\nFUNCTION '%s'\\n%s\\\"\\\"\\\" \\\\\\n% ('*' * 100, functionName, '*' * 100))\\n \\n print \\\"#ifdef CBMC\\\"\\n \\n for lntv in lnt:\\n if isinstance(lntv, vertices.HeaderVertex):\\n headerID = lntv.getHeaderID()\\n if headerID != cfg.getEntryID():\\n loopBody = lnt.getLoopBody(headerID)\\n v = cfg.getVertex(headerID)\\n forwardedges = []\\n for succID in v.getSuccessorIDs():\\n if succID in loopBody:\\n forwardedges.append((headerID, succID))\\n count = 1\\n lhs = \\\"\\\"\\n for edge in forwardedges:\\n lhs += \\\"__count_%d_%d \\\" % (edge[0], edge[1])\\n if count < len(forwardedges):\\n lhs += \\\" + \\\"\\n relativeBound = 0\\n for programPoint in pathg.getLoopMonitoredProgramPoints(headerID):\\n pathv = pathg.getProgramPointVertex(programPoint)\\n succe = pathv.getSuccessoredges(edges.PathInformationEdgeType.LOOP_BOUNDS)[0]\\n relativeBound = max(relativeBound, succe.relative)\\n print(\\\"assert(%s <= %d); // Loop counter property\\\" % (lhs, relativeBound))\\n \\n for v in pathg:\\n programPoint = v.getProgramPoint()\\n if isinstance(programPoint, tuple):\\n programPointStr = \\\"__count_%d_%d\\\" % (programPoint[0], programPoint[1])\\n else:\\n programPointStr = \\\"__count_%d\\\" % programPoint\\n for succe in v.getSuccessoredges(edges.PathInformationEdgeType.CAPACITY_BOUNDS):\\n if succe.lower == 0 and succe.upper == 0:\\n print(\\\"assert(%s == 0); // Dead code\\\" % (programPointStr))\\n elif succe.lower > 0:\\n print(\\\"assert(%s >= %d); // Lower capacity constraint\\\" % (programPointStr, succe.lower))\\n print(\\\"assert(%s <= %d); // Upper capacity constraint\\\" % (programPointStr, succe.upper))\\n else:\\n print(\\\"assert(%s <= %d); // Upper capacity constraint\\\" % (programPointStr, succe.upper))\\n \\n for vertexID1, vertexID2 in pathg.mutualInclusionPairs():\\n v1 = pathg.getVertex(vertexID1)\\n v2 = pathg.getVertex(vertexID2)\\n programPoint1 = v1.getProgramPoint()\\n if isinstance(programPoint1, tuple):\\n programPoint1Str = \\\"__count_%d_%d\\\" % (programPoint1[0], programPoint1[1])\\n else:\\n programPoint1Str = \\\"__count_%d\\\" % programPoint1\\n programPoint2 = v2.getProgramPoint()\\n if isinstance(programPoint2, tuple):\\n programPoint2Str = \\\"__count_%d_%d\\\" % (programPoint2[0], programPoint2[1])\\n else:\\n programPoint2Str = \\\"__count_%d\\\" % programPoint2\\n print(\\\"assert(%s > 0 ==> %s > 0); // Mutual inclusion\\\" % (programPoint1Str, programPoint2Str))\\n print(\\\"assert(%s > 0 ==> %s > 0); // Mutual inclusion\\\" % (programPoint2Str, programPoint1Str))\\n for vertexID1, vertexID2 in pathg.mutualExclusionPairs():\\n v1 = pathg.getVertex(vertexID1)\\n v2 = pathg.getVertex(vertexID2)\\n programPoint1 = v1.getProgramPoint()\\n if isinstance(programPoint1, tuple):\\n programPoint1Str = \\\"__count_%d_%d\\\" % (programPoint1[0], programPoint1[1])\\n else:\\n programPoint1Str = \\\"__count_%d\\\" % programPoint1\\n programPoint2 = v2.getProgramPoint()\\n if isinstance(programPoint2, tuple):\\n programPoint2Str = \\\"__count_%d_%d\\\" % (programPoint2[0], programPoint2[1])\\n else:\\n programPoint2Str = \\\"__count_%d\\\" % programPoint2\\n print(\\\"assert(%s > 0 ==> %s == 0); // Mutual exclusion\\\" % (programPoint1Str, programPoint2Str))\\n print(\\\"assert(%s > 0 ==> %s == 0); // Mutual exclusion\\\" % (programPoint2Str, programPoint1Str))\\n for vertexID1, vertexID2 in pathg.executionDependencies():\\n v1 = pathg.getVertex(vertexID1)\\n v2 = pathg.getVertex(vertexID2)\\n programPoint1 = v1.getProgramPoint()\\n if isinstance(programPoint1, tuple):\\n programPoint1Str = \\\"__count_%d_%d\\\" % (programPoint1[0], programPoint1[1])\\n else:\\n programPoint1Str = \\\"__count_%d\\\" % programPoint1\\n programPoint2 = v2.getProgramPoint()\\n if isinstance(programPoint2, tuple):\\n programPoint2Str = \\\"__count_%d_%d\\\" % (programPoint2[0], programPoint2[1])\\n else:\\n programPoint2Str = \\\"__count_%d\\\" % programPoint2\\n print(\\\"assert(%s > 0 ==> %s > 0); // Execution dependence\\\" % (programPoint1Str, programPoint2Str))\\n print \\\"#endif\\\"\\n \\nclass Parsetraces (TraceInformation):\\n def __init__ (self, basename, tracefile, program):\\n TraceInformation.__init__(self, program)\\n self.__initialise()\\n self.__parse(tracefile)\\n self._end()\\n self._outputConjectures() \\n self.__assignRandomWCETs()\\n \\n def __assignRandomWCETs (self):\\n for cfg in self._program.getcfgs():\\n functionName = cfg.getName()\\n for v in cfg:\\n self._executionTimes[(functionName, v.getOriginalVertexID())] = random.randint(1,100)\\n\\n def __initialise (self):\\n self.__currentContextv = None\\n self.__currentCFG = None\\n self.__currentLNT = None\\n self.__predBB = None\\n self.__currentBB = None\\n self.__currentHeaderID = None\\n self.__currentPathg = None\\n self.__stack = []\\n self.__contextg = self._program.getContextGraph()\\n rootv = self.__contextg.getVertex(self.__contextg.getRootID())\\n self.__rootCFG = self._program.getCFG(rootv.getName())\\n self.__entryToCFG = {} \\n for cfg in self._program.getcfgs():\\n self.__entryToCFG[cfg.getEntryID()] = cfg\\n \\n def __reset (self):\\n self.__currentContextv = self.__contextg.getVertex(self.__contextg.getRootID())\\n self.__currentCFG = self._program.getCFG(self.__currentContextv.getName())\\n self.__currentLNT = self._program.getLNT(self.__currentContextv.getName())\\n self.__currentPathg = self._program.getPathInfoGraph(self.__currentContextv.getName())\\n self.__predBB = None\\n self.__currentBB = None\\n \\n def __parse (self, tracefile):\\n runID = 0\\n with open(tracefile, 'r') as f:\\n for line in f:\\n if line.startswith(newTrace):\\n runID += 1\\n debug.debug_message(\\\"=====> Run %d\\\" % runID, 1)\\n self._allruns.add(runID)\\n self.__reset()\\n elif line.startswith(endTrace):\\n self.__handleReturn()\\n else:\\n lexemes = shlex.split(line)\\n for lex in lexemes:\\n nextID = int(lex)\\n if nextID == self.__rootCFG.getEntryID():\\n self.__currentBB = self.__currentCFG.getVertex(nextID)\\n else:\\n found = False\\n for succID in self.__currentBB.getSuccessorIDs():\\n if succID == nextID:\\n self.__predBB = self.__currentBB\\n self.__currentBB = self.__currentCFG.getVertex(succID)\\n # We have switched basic blocks in the current CFG\\n self._analyseCFGEdge(self.__currentPathg, self.__currentLNT, self.__predBB.vertexID, self.__currentBB.vertexID)\\n found = True\\n break\\n if not found:\\n if self.__currentBB.vertexID == self.__currentCFG.getExitID():\\n succIDs = self.__currentBB.getSuccessorIDs()\\n assert len(succIDs) == 1\\n succv = self.__currentCFG.getVertex(succIDs[0])\\n self.__predBB = self.__currentBB\\n self.__currentBB = succv\\n # Since we have switched basic blocks in the current CFG, analyse the super blocks\\n self._analyseCFGEdge(self.__currentPathg, self.__currentLNT, self.__predBB.vertexID, self.__currentBB.vertexID) \\n else:\\n self.__handleCall(nextID) \\n # We have switched basic blocks in the current CFG\\n self._analyseCFGVertex(self.__currentPathg, self.__currentLNT, self.__currentBB.vertexID)\\n \\n def __handleReturn (self):\\n debug.debug_message(\\\"Returning because of basic block %d\\\" % self.__currentBB.vertexID, 1)\\n self._endOfFunction(self.__currentCFG, self.__currentLNT, self.__currentPathg)\\n if self.__stack:\\n (self.__currentContextv, self.__currentCFG, self.__currentLNT, self.__predBB, self.__currentBB, self.__currentPathg) = self.__stack.pop()\\n \\n def __handleCall (self, nextID):\\n callerFrame = (self.__currentContextv, self.__currentCFG, self.__currentLNT, self.__predBB, self.__currentBB, self.__currentPathg)\\n self.__stack.append(callerFrame)\\n newContextID = self.__currentContextv.getSuccessorWithCallSite(self.__currentBB.vertexID)\\n self.__currentContextv = self.__contextg.getVertex(newContextID)\\n self.__currentCFG = self.__entryToCFG[nextID]\\n self.__currentLNT = self._program.getLNT(self.__currentCFG.getName())\\n self.__currentPathg = self._program.getPathInfoGraph(self.__currentCFG.getName())\\n self.__predBB = None\\n self.__currentBB = self.__currentCFG.getVertex(self.__currentCFG.getEntryID())\\n \\nclass Gem5Parser (TraceInformation):\\n def __init__ (self, program, traceFiles):\\n debug.verbose_message(\\\"Parsing gem5 traces\\\", __name__)\\n TraceInformation.__init__(self, program)\\n self.__initialise()\\n self.__parse(traceFiles)\\n self._end()\\n self._normaliseData()\\n self._outputConjectures()\\n self._outputCBMCConjectures()\\n \\n def __initialise (self):\\n self.__currentContextv = None\\n self.__currentCFG = None\\n self.__currentLNT = None\\n self.__predBB = None\\n self.__currentBB = None\\n self.__currentHeaderID = None\\n self.__currentPathg = None\\n self.__time1 = None\\n self.__stack = []\\n self.__contextg = self._program.getContextGraph()\\n rootv = self.__contextg.getVertex(self.__contextg.getRootID())\\n self.__rootCFG = self._program.getCFG(rootv.getName())\\n self.__firstAddr = self.__rootCFG.getFirstInstruction().getAddress()\\n lastbb = self.__rootCFG.getVertex(self.__rootCFG.getExitID())\\n for instruction in reversed(lastbb.getInstructions()):\\n if instruction.getOp() not in arm.armInstructionSet.Nops:\\n self.__lastAddr = instruction.getAddress()\\n break\\n assert self.__lastAddr, \\\"Unable to find last address\\\"\\n debug.debug_message(\\\"Start address of root function '%s' is %s\\\" % (rootv.getName(), hex(self.__firstAddr)), 1) \\n debug.debug_message(\\\"End address of root function '%s' is %s\\\" % (rootv.getName(), hex(self.__lastAddr)), 1)\\n \\n def __parse (self, traceFiles):\\n runID = 0\\n for filename in traceFiles:\\n parsing = False \\n with gzip.open(filename, 'r') as f:\\n runID += 1\\n self._allruns.add(runID)\\n debug.debug_message(\\\"Analysing gem5 trace file '%s'\\\" % filename, 1)\\n for line in f:\\n lexemes = shlex.split(line)\\n PCLexeme = lexemes[-1]\\n assert len(PCLexeme) == 11, \\\"Unable to parse program counter %s\\\" % PCLexeme\\n try:\\n time = int(lexemes[0][:-1])\\n PCLexeme = PCLexeme[5:]\\n PC = int(PCLexeme, 16)\\n if PC == self.__firstAddr:\\n self.__time1 = time\\n startTime = time\\n parsing = True\\n self.__currentContextv = self.__contextg.getVertex(self.__contextg.getRootID())\\n self.__currentCFG = self._program.getCFG(self.__currentContextv.getName())\\n self.__currentLNT = self._program.getLNT(self.__currentContextv.getName())\\n self.__currentPathg = self._program.getPathInfoGraph(self.__currentContextv.getName())\\n self.__predBB = None\\n self.__currentBB = self.__currentCFG.getVertex(self.__currentCFG.getEntryID())\\n self._analyseCFGVertex(self.__currentPathg, self.__currentLNT, self.__currentBB.vertexID) \\n if parsing:\\n self.__parseAddress (time, PC, runID)\\n if PC == self.__lastAddr:\\n # Stop parsing\\n parsing = False\\n # Compute the HWMT\\n totalTime = time - startTime\\n self._longestTime = max(self._longestTime, totalTime)\\n # Falsify conjectures\\n self._endOfFunction(self.__currentCFG, self.__currentLNT, self.__currentPathg)\\n except ValueError:\\n debug.exit_message(\\\"Cannot cast %s into an integer: it is not a hexadecimal string\\\" % PCLexeme)\\n\\n def __getCFGWithAddress (self, address):\\n for cfg in self._program.getcfgs():\\n firstAddress = cfg.getFirstInstruction().getAddress()\\n if firstAddress == address:\\n return cfg\\n assert False, \\\"Unable to find CFG with start address %s\\\" % hex(address)\\n \\n def __analyseWCETOfBasicBlock (self, executionTime):\\n tupleKey = (self.__currentCFG.getName(), self.__currentBB.getOriginalVertexID())\\n assert tupleKey in self._executionTimes\\n self._executionTimes[tupleKey] = max(self._executionTimes[tupleKey], executionTime) \\n \\n def __parseAddress (self, time, address, runID):\\n if address == self.__lastAddr:\\n self.__analyseWCETOfBasicBlock(time - self.__time1)\\n if not self.__currentBB.hasAddress(address):\\n # Instructions in the current basic block have finished. Analyse its execution time\\n self.__analyseWCETOfBasicBlock(time - self.__time1)\\n # Move the time marker forward to the current time to reflect that we are transitioning\\n # to a new basic block\\n self.__time1 = time\\n # Make the switch to the next basic block\\n if self.__currentCFG.isCallSite(self.__currentBB.vertexID):\\n self.__handleCall(address)\\n elif self.__currentCFG.getExitID() == self.__currentBB.vertexID:\\n self.__handleReturn()\\n # Since we have switched basic blocks in the current CFG, analyse the super blocks\\n self._analyseCFGEdge(self.__currentPathg, self.__currentLNT, self.__predBB.vertexID, self.__currentBB.vertexID) \\n else:\\n for succID in self.__currentBB.getSuccessorIDs():\\n succv = self.__currentCFG.getVertex(succID)\\n if succv.hasAddress(address):\\n self.__predBB = self.__currentBB\\n self.__currentBB = succv\\n break\\n # Since we have switched basic blocks in the current CFG, analyse the super blocks\\n self._analyseCFGEdge(self.__currentPathg, self.__currentLNT, self.__predBB.vertexID, self.__currentBB.vertexID) \\n debug.debug_message(\\\"Now in CFG '%s' at basic block %d\\\" % (self.__currentCFG.getName(), self.__currentBB.vertexID), 10) \\n self._analyseCFGVertex(self.__currentPathg, self.__currentLNT, self.__currentBB.vertexID) \\n \\n def __handleReturn (self):\\n if self.__currentCFG.getExitID() == self.__currentBB.vertexID and self.__currentCFG != self.__rootCFG:\\n # Falsify conjectures\\n self._endOfFunction(self.__currentCFG, self.__currentLNT, self.__currentPathg)\\n (self.__currentContextv, self.__currentCFG, self.__currentLNT, self.__predBB, self.__currentBB, self.__currentPathg) = self.__stack.pop()\\n succIDs = self.__currentBB.getSuccessorIDs()\\n assert len(succIDs) == 1\\n succv = self.__currentCFG.getVertex(succIDs[0])\\n self.__predBB = self.__currentBB\\n self.__currentBB = succv\\n \\n def __handleCall (self, address):\\n callerFrame = (self.__currentContextv, self.__currentCFG, self.__currentLNT, self.__predBB, self.__currentBB, self.__currentPathg)\\n self.__stack.append(callerFrame)\\n newContextID = self.__currentContextv.getSuccessorWithCallSite(self.__currentBB.vertexID)\\n self.__currentContextv = self.__contextg.getVertex(newContextID)\\n self.__currentCFG = self.__getCFGWithAddress(address)\\n self.__currentLNT = self._program.getLNT(self.__currentCFG.getName())\\n self.__predBB = None\\n self.__currentBB = self.__currentCFG.getVertex(self.__currentCFG.getEntryID())\\n self.__currentPathg = self._program.getPathInfoGraph(self.__currentCFG.getName())\\n assert self.__currentBB.hasAddress(address), \\\"Calling into '%s' because of address %s but basic block does not contain an instruction with that address\\\" % (self.__currentCFG.getName(), hex(address)) \\n \\n\"\n },\n {\n \"alpha_fraction\": 0.5261992812156677,\n \"alphanum_fraction\": 0.5431734323501587,\n \"avg_line_length\": 15.9375,\n \"blob_id\": \"e455456a5ece8c3fce5c3a64bb54cb598ba7b5f9\",\n \"content_id\": \"a7c72162987b8b8502d319d150d645d0aee15907\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 1355,\n \"license_type\": \"no_license\",\n \"max_line_length\": 75,\n \"num_lines\": 80,\n \"path\": \"/benchmarks/bubblesort/bubblesort.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Bubble sort taken from MDH suite and modified by Adam Betts to consume a\\n * test vector supplied on the command line.\\n *\\n * For this program, the test vector is a list of integers to be sorted.\\n * Note that the size of the array is determined by the number of arguments\\n * given to the program, i.e. argc - 1.\\n */\\n\\n/*\\n * Swaps the values if the value pointed to by a is greater than the\\n * value pointed to by b and returns 1 if a swap is performed, 0 otherwise\\n */\\nint\\nswapIfLarger (int *a, int *b)\\n{\\n\\tint tmp;\\n\\tint swapped = 0;\\n\\tif (*a > *b)\\n\\t{\\t\\n\\t\\ttmp = *a;\\n\\t\\t*a = *b;\\n\\t\\t*b = tmp;\\n\\t\\tswapped = 1;\\n\\t}\\n\\treturn swapped;\\n}\\n\\nvoid\\nbubblesort (int ARRAY_SIZE, int a[])\\n{\\n int i, j, tmp;\\n int swapped = 0;\\n for (i = 0; i < ARRAY_SIZE - 1; i++)\\n {\\n swapped = 0;\\n for (j = 0; j < ARRAY_SIZE - 1 - i; j++)\\n {\\n if (swapIfLarger(&a[j], &a[j+1]))\\n {\\n swapped = 1;\\n }\\n }\\n\\tif (swapped == 0)\\n {\\n break;\\n }\\n }\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int ARRAY_SIZE = argc - 1;\\n int TV[ARRAY_SIZE];\\n int i;\\n\\n /*\\n * At least one integer value must be supplied\\n */\\n if (argc == 1)\\n {\\n return 1;\\n }\\n\\n for (i = 0; i < argc - 1; ++i)\\n {\\n TV[i] = atoi (argv[i + 1]);\\n }\\n\\n bubblesort (ARRAY_SIZE, TV);\\n\\n for (i = 0; i < argc - 1; ++i)\\n {\\n printf(\\\"%i \\\", TV[i]);\\n }\\n printf(\\\"\\\\n\\\");\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.460576593875885,\n \"alphanum_fraction\": 0.5081625580787659,\n \"avg_line_length\": 21.031999588012695,\n \"blob_id\": \"a65f63407b1de41c400881fa33d167c4e0d3bccf\",\n \"content_id\": \"ec7ec79e2917b5e79009f6990c594dd1faeafba7\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 2879,\n \"license_type\": \"no_license\",\n \"max_line_length\": 82,\n \"num_lines\": 125,\n \"path\": \"/DaikonPathInformation/benchmarks/squareroot.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\r\\n * Square root (Sqrt) program taken from MDH suite and modified by Adam Betts\\r\\n * to consume a test vector supplied on the command line.\\r\\n *\\r\\n * For this program, the test vector is a single element for which the square root\\r\\n * is computed.\\r\\n */\\r\\n\\r\\nfloat\\r\\nsquareroot (float val)\\r\\n{\\r\\n#ifdef CBMC\\r\\n//==========> squareroot : header 8\\r\\nint __count_4_7 = 0;\\r\\nint __count_5_6 = 0;\\r\\nint __count_5_7 = 0;\\r\\nint __count_8_4 = 0; //Loop counter\\r\\n//==========> squareroot : header 1\\r\\nint __count_9 = 0;\\r\\nint __count_2_9 = 0;\\r\\nint __count_8_9 = 0;\\r\\n#endif\\r\\n\\r\\n float x = val / 10;\\r\\n float dx;\\r\\n double diff;\\r\\n double min_tol = 0.00001;\\r\\n int i;\\r\\n int flag = 0;\\r\\n\\r\\n if (val == 0)\\r\\n {\\r\\n x = 0;\\r\\n #ifdef CBMC\\r\\n __count_2_9++;\\r\\n #endif\\r\\n }\\r\\n else\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_8_4 = 0;\\r\\n #endif\\r\\n for (i = 1; i < 20; i++)\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_8_4++;\\r\\n #endif\\r\\n if (!flag)\\r\\n {\\r\\n dx = (val - (x * x)) / (2.0 * x);\\r\\n x = x + dx;\\r\\n diff = val - (x * x);\\r\\n if (fabs (diff) <= min_tol) // 5\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_5_6++;\\r\\n #endif\\r\\n flag = 1;\\r\\n }\\r\\n #ifdef CBMC\\r\\n else __count_5_7++;\\r\\n #endif\\r\\n }\\r\\n else\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_4_7++;\\r\\n #endif\\r\\n x = x;\\r\\n }\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_8_4 <= 20); // Loop counter property\\r\\n __count_8_9++;\\r\\n #endif\\r\\n }\\r\\n #ifdef CBMC\\r\\n __count_9++;\\r\\n #endif\\r\\n\\r\\n#ifdef CBMC\\r\\n\\r\\nassert(__count_9 >= 1); // Lower capacity constraint\\r\\nassert(__count_9 <= 1); // Upper capacity constraint\\r\\n//assert(__count_2_9 == 0); // Dead code\\r\\n//assert(__count_4_7 <= 7); // Upper capacity constraint\\r\\nassert(__count_5_6 <= 1); // Upper capacity constraint\\r\\n//assert(__count_5_7 >= 11); // Lower capacity constraint\\r\\nassert(__count_5_7 <= 19); // Upper capacity constraint\\r\\n//assert(__count_8_9 >= 1); // Lower capacity constraint\\r\\nassert(__count_8_9 <= 1); // Upper capacity constraint\\r\\nassert(__count_4_7 > 0 ==> __count_5_6 > 0); // Mutual inclusion\\r\\nassert(__count_5_6 > 0 ==> __count_4_7 > 0); // Mutual inclusion\\r\\nassert(__count_4_7 > 0 ==> __count_9 > 0); // Execution dependence\\r\\n//assert(__count_4_7 > 0 ==> __count_5_7 > 0); // Execution dependence\\r\\nassert(__count_4_7 > 0 ==> __count_8_9 > 0); // Execution dependence\\r\\nassert(__count_5_6 > 0 ==> __count_9 > 0); // Execution dependence\\r\\n//assert(__count_5_6 > 0 ==> __count_5_7 > 0); // Execution dependence\\r\\nassert(__count_5_6 > 0 ==> __count_8_9 > 0); // Execution dependence\\r\\n#endif\\r\\n\\r\\n return x;\\r\\n}\\r\\n\\r\\nint\\r\\nmain (int argc, char *argv[])\\r\\n{\\r\\n float val;\\r\\n unsigned int input;\\r\\n\\r\\n /*\\r\\n * One integer must be supplied\\r\\n */\\r\\n if (argc != 2)\\r\\n {\\r\\n return 1;\\r\\n }\\r\\n\\r\\n input = atoi(argv[1]);\\r\\n val = squareroot (input);\\r\\n \\r\\n printf(\\\"%f\\\", val);\\r\\n\\r\\n return 0;\\r\\n}\\r\\n\"\n },\n {\n \"alpha_fraction\": 0.7134119868278503,\n \"alphanum_fraction\": 0.7387505173683167,\n \"avg_line_length\": 75.19999694824219,\n \"blob_id\": \"7e2b3ef57116e6ac2ebdadb198900c5ab448c102\",\n \"content_id\": \"f80cf68905191c6f339320a000d04c2577b2b83d\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Shell\",\n \"length_bytes\": 2289,\n \"license_type\": \"no_license\",\n \"max_line_length\": 111,\n \"num_lines\": 30,\n \"path\": \"/DaikonPathInformation/benchmarks/runallO1.bash\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#!/bin/bash\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r select select.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r squareroot squareroot.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r statemate statemate.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r statistics statistics.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r exponential_integral exponential_integral.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r fastDiscreteCosineTransform fastDiscreteCosineTransform.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r fft fft.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r fibonacci fibonacci.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r finiteImpulseResponse finiteImpulseResponse.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r insertsort insertsort.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r janne_complex janne_complex.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r lcdnum lcdnum.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r LUdecomposition LUdecomposition.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r matrix_count matrix_count.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r matrix_inverse matrix_inverse.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r matrixmultiply matrixmultiply.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r mergesort mergesort.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r petri petri.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r prime prime.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r quadraticroots quadraticroots.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r quicksort quicksort.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r binary_search binary_search.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r bubblesort bubblesort.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r compress compress.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r cover cover.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r crc crc.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r edn edn.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r embedded embedded.c\\npython ../src/ToolGem5.py --compiler-flags O1 --ga -r adpcm adpcm.c\\n\\n\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.4178794324398041,\n \"alphanum_fraction\": 0.439708948135376,\n \"avg_line_length\": 13.516129493713379,\n \"blob_id\": \"b11e6a4c954bdec511461330bb95da64ee6d6c58\",\n \"content_id\": \"d88873f1589551e51fd140cc35bea30d8d88b584\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 962,\n \"license_type\": \"no_license\",\n \"max_line_length\": 82,\n \"num_lines\": 62,\n \"path\": \"/benchmarks/sqrt/sqrt.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\r\\n * Square root (Sqrt) program taken from MDH suite and modified by Adam Betts\\r\\n * to consume a test vector supplied on the command line.\\r\\n *\\r\\n * For this program, the test vector is a single element for which the square root\\r\\n * is computed.\\r\\n */\\r\\n\\r\\nfloat\\r\\nsqrt (float val)\\r\\n{\\r\\n float x = val / 10;\\r\\n float dx;\\r\\n double diff;\\r\\n double min_tol = 0.00001;\\r\\n int i;\\r\\n int flag = 0;\\r\\n\\r\\n if (val == 0)\\r\\n {\\r\\n x = 0;\\r\\n }\\r\\n else\\r\\n {\\r\\n for (i = 1; i < 20; i++)\\r\\n {\\r\\n if (!flag)\\r\\n {\\r\\n dx = (val - (x * x)) / (2.0 * x);\\r\\n x = x + dx;\\r\\n diff = val - (x * x);\\r\\n if (fabs (diff) <= min_tol)\\r\\n {\\r\\n flag = 1;\\r\\n }\\r\\n }\\r\\n else\\r\\n {\\r\\n x = x;\\r\\n }\\r\\n }\\r\\n }\\r\\n return x;\\r\\n}\\r\\n\\r\\nint\\r\\nmain (int argc, char *argv[])\\r\\n{\\r\\n float val;\\r\\n\\r\\n /*\\r\\n * One integer must be supplied\\r\\n */\\r\\n if (argc != 2)\\r\\n {\\r\\n return 1;\\r\\n }\\r\\n\\r\\n val = sqrt (atoi (argv[1]));\\r\\n\\r\\n return 0;\\r\\n}\\r\\n\"\n },\n {\n \"alpha_fraction\": 0.5466123223304749,\n \"alphanum_fraction\": 0.5517065525054932,\n \"avg_line_length\": 37.87128829956055,\n \"blob_id\": \"788af5ad38e77fca73551b96695e5adfcea329de\",\n \"content_id\": \"df15996123f073fe60d0c158d8185136ba1e6000\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 3926,\n \"license_type\": \"no_license\",\n \"max_line_length\": 110,\n \"num_lines\": 101,\n \"path\": \"/tools/database_generator.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import argparse\\nimport random\\nimport sys\\nimport threading\\n\\nfrom graphs import graph\\nfrom system import program, database\\nfrom utils import messages\\n\\n\\ndef add_automatic_wcet(db: database.Database, v, maximum_value):\\n db.add_wcet(v.program_point, random.randint(0, maximum_value))\\n\\n\\ndef add_automatic_wfreq(db: database.Database, v, lnt, maximum_value):\\n if lnt.is_header(v):\\n loop = lnt.find_loop(v)\\n if lnt.is_outermost_loop(loop):\\n db.add_wfreq(v.program_point, 1)\\n else:\\n db.add_wfreq(v.program_point, random.randint(1, maximum_value))\\n\\n\\ndef main(**kwargs):\\n the_program = program.IO.read(kwargs['filename'])\\n properties = program.IO.read_properties(kwargs['filename'])\\n\\n with database.Database(kwargs['database']) as db:\\n db.reset()\\n for subprogram in the_program:\\n messages.debug_message('Creating data for {}'.format(subprogram.name))\\n ppg = graph.ProgramPointGraph.create_from_control_flow_graph(subprogram.cfg)\\n ppg.dotify()\\n lnt = graph.LoopNests(ppg)\\n lnt.dotify()\\n\\n for v in ppg:\\n if not kwargs['manual_properties'] or v.program_point not in properties:\\n if isinstance(v.program_point, graph.Vertex):\\n add_automatic_wcet(db, v, kwargs['max_wcet'])\\n else:\\n db.add_wcet(v.program_point, 0)\\n add_automatic_wfreq(db, v, lnt, kwargs['max_loop_bound'])\\n else:\\n if properties[v.program_point].wcet is not None:\\n db.add_wcet(v.program_point, properties[v.program_point].wcet)\\n else:\\n add_automatic_wcet(db, v, kwargs['max_wcet'])\\n\\n if properties[v.program_point].bound is not None:\\n db.add_wfreq(v.program_point, properties[v.program_point].bound)\\n else:\\n add_automatic_wfreq(db, v, lnt, kwargs['max_loop_bound'])\\n\\n if not kwargs['manual_properties']:\\n ppg.choose_instrumentation()\\n for v in ppg:\\n db.set_instrumentation(v.program_point)\\n else:\\n for v in ppg:\\n if v.program_point in properties:\\n if properties[v.program_point].instrumentation:\\n db.set_instrumentation(v.program_point)\\n\\n\\ndef parse_the_command_line():\\n parser = argparse.ArgumentParser(description='Create a database of values needed in the WCET calculation')\\n\\n parser.add_argument('--filename',\\n help='read the program from this file',\\n required=True)\\n\\n parser.add_argument('--database',\\n help='write the data to this file',\\n required=True)\\n\\n parser.add_argument('--max-wcet',\\n type=int,\\n help='set the maximum possible value for execution times of basic blocks',\\n default=20,\\n metavar='')\\n\\n parser.add_argument('--max-loop-bound',\\n type=int,\\n help='set the maximum possible value for execution frequency bounds on loop headers',\\n default=10,\\n metavar='')\\n\\n parser.add_argument('--manual-properties',\\n action='store_true',\\n help='use properties of program points as specified manually in the program file',\\n default=False)\\n\\n return parser.parse_args()\\n\\n\\nif __name__ == '__main__':\\n assert sys.version_info >= (3, 0), 'Script requires Python 3.0 or greater to run'\\n threading.stack_size(2 ** 6 * 2 ** 20)\\n sys.setrecursionlimit(2 ** 20)\\n main(**vars(parse_the_command_line()))\\n\"\n },\n {\n \"alpha_fraction\": 0.5086750984191895,\n \"alphanum_fraction\": 0.5801787376403809,\n \"avg_line_length\": 24.178808212280273,\n \"blob_id\": \"f1f580281f3596dfce17fbed7f8fb2849b09bc39\",\n \"content_id\": \"351d22867e4c90c675260a061b672f5351f78897\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 3804,\n \"license_type\": \"no_license\",\n \"max_line_length\": 91,\n \"num_lines\": 151,\n \"path\": \"/DaikonPathInformation/benchmarks/finiteImpulseResponse.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#define TEST_VECTOR_LENGTH 720\\n\\nlong \\nfiniteImpulseResponse (long* in,long* out,long in_len, long* coef,long coef_len,long scale)\\n{\\n#ifdef CBMC\\n//==========> finiteimpulseresponse : header 25\\nint __count_25_24 = 0;\\nint __count_25_24_L = 0; //Loop counter\\n//==========> finiteimpulseresponse : header 33\\nint __count_27_28 = 0;\\nint __count_29_30 = 0;\\nint __count_29_31 = 0;\\nint __count_33_23 = 0; //Loop counter\\n//==========> finiteimpulseresponse : header 22\\nint __count_34 = 0;\\nint __count_33_34 = 0;\\n#endif\\n\\n long i,j,coef_len2,acc_length;\\n long acc;\\n long *in_ptr,*data_ptr,*coef_start,*coef_ptr,*in_end;\\n\\n /* set up for coefficients */\\n coef_start = coef;\\n coef_len2 = (coef_len + 1) >> 1;\\n\\n /* set up input data pointers */\\n in_end = in + in_len - 1;\\n in_ptr = in + coef_len2 - 1;\\n\\n /* initial value of accumulation length for startup */\\n acc_length = coef_len2;\\n\\n #ifdef CBMC\\n __count_33_23 = 0;\\n #endif\\n for(i = 0 ; \\n i < in_len ; i++) // 33\\n {\\n #ifdef CBMC\\n __count_33_23++;\\n #endif\\n /* set up pointer for accumulation */\\n data_ptr = in_ptr;\\n coef_ptr = coef_start;\\n\\n /* do accumulation and write result with scale factor */\\n acc = (long)(*coef_ptr++) * (*data_ptr--);\\n\\n #ifdef CBMC\\n __count_25_24_L = 0;\\n #endif\\n for(j = 1 ; j < acc_length ; j++) // 25\\n {\\n #ifdef CBMC\\n __count_25_24_L++;\\n __count_25_24++;\\n #endif\\n acc += (long)(*coef_ptr++) * (*data_ptr--);\\n }\\n #ifdef CBMC\\n assert(__count_25_24_L <= 35); // Loop counter property\\n #endif\\n *out++ = (int)(acc/scale);\\n\\n /* check for end case */\\n if(in_ptr == in_end) // 27\\n {\\n #ifdef CBMC\\n __count_27_28++;\\n #endif\\n // 28\\n acc_length--; /* one shorter each time */\\n coef_start++; /* next coefficient each time */\\n }\\n else \\n {\\n /* if not at end, then check for startup, add to input pointer */\\n if(acc_length < coef_len) // 29\\n {\\n #ifdef CBMC\\n __count_29_30++;\\n #endif\\n // 30\\n acc_length++;\\n }\\n #ifdef CBMC\\n else __count_29_31++;\\n #endif\\n in_ptr++;\\n }\\n }\\n #ifdef CBMC\\n assert(__count_33_23 <= 701); // Loop counter property\\n #endif\\n \\n #ifdef CBMC\\n __count_33_34++;\\n __count_34++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_33_34 >= 1); // Lower capacity constraint\\nassert(__count_33_34 <= 1); // Upper capacity constraint\\nassert(__count_25_24 >= 23494); // Lower capacity constraint\\nassert(__count_25_24 <= 23494); // Upper capacity constraint\\nassert(__count_27_28 >= 18); // Lower capacity constraint\\nassert(__count_27_28 <= 18); // Upper capacity constraint\\nassert(__count_34 >= 1); // Lower capacity constraint\\nassert(__count_34 <= 1); // Upper capacity constraint\\nassert(__count_29_30 >= 17); // Lower capacity constraint\\nassert(__count_29_30 <= 17); // Upper capacity constraint\\nassert(__count_29_31 >= 665); // Lower capacity constraint\\nassert(__count_29_31 <= 665); // Upper capacity constraint\\n#endif\\n\\n return *coef;\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{ \\n if (argc != TEST_VECTOR_LENGTH + 1)\\n {\\n return 1;\\n }\\n \\n long in_data[TEST_VECTOR_LENGTH+1];\\n int i;\\n for (i = 0; i < argc - 1; ++i)\\n {\\n in_data[i] = (long) atoi (argv[i + 1]);\\n }\\n // Sentinel value needed\\n in_data[TEST_VECTOR_LENGTH] = 0;\\n \\n long out_data[TEST_VECTOR_LENGTH+1];\\n \\n long fir_int[36]={\\n 0xfffffffe, 0x1, 0x4, 0x3, 0xfffffffe, 0xfffffffc, 0x2, 0x7, 0x0,\\n 0xfffffff7, 0xfffffffc, 0xc, 0xb, 0xfffffff2, 0xffffffe6, 0xf, 0x59, 0x7f,\\n 0x59, 0xf, 0xffffffe6, 0xfffffff2, 0xb, 0xc, 0xfffffffc, 0xfffffff7, 0x0,\\n 0x7, 0x2, 0xfffffffc, 0xfffffffe, 0x3, 0x4, 0x1, 0xfffffffe, 0};\\n\\n long val = finiteImpulseResponse (in_data, out_data, 700, fir_int, 35, 285); \\n \\n printf(\\\"%ld\\\", val);\\n\\n return 0;\\n}\\n\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.5169920325279236,\n \"alphanum_fraction\": 0.5394070744514465,\n \"avg_line_length\": 17.675676345825195,\n \"blob_id\": \"70664483145fc718c2f873a0d1a0ced6c18cb48e\",\n \"content_id\": \"7a72de62311cf25e17a6ff35d126e43897f4279e\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 1383,\n \"license_type\": \"no_license\",\n \"max_line_length\": 76,\n \"num_lines\": 74,\n \"path\": \"/benchmarks/matrix_mult/matrix_mult.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Matrix multiplication taken from MDH suite and modified by Adam Betts to\\n * consume a test vector supplied on the command line.\\n *\\n * For this program, the test vector consists of 25 integers since there are\\n * two 5*5 matrices to be initialised before multiplication.\\n */\\n\\n#define UPPERLIMIT 5\\ntypedef int matrix[UPPERLIMIT][UPPERLIMIT];\\n\\nvoid\\nmatrix_mult (matrix A, matrix B, matrix C)\\n{\\n int i, j, k;\\n\\n for (i = 0; i < UPPERLIMIT; ++i)\\n {\\n for (j = 0; j < UPPERLIMIT; ++j)\\n {\\n C[i][j] = 0;\\n for (k = 0; k < UPPERLIMIT; ++k)\\n {\\n C[i][j] += A[j][k] * B[k][j];\\n }\\n }\\n }\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n int i, j, k;\\n matrix A, B, C;\\n\\n /*\\n * There are 2 matrices with 20*20 dimensions that need to be filled up.\\n * 800 values need to be passed on the command-line as a consequence.\\n */\\n if (argc != 26)\\n {\\n return 1;\\n }\\n\\n /*\\n * Initialise matrix A.\\n */\\n k = 0;\\n for (i = 0; i < UPPERLIMIT; ++i)\\n {\\n for (j = 0; j < UPPERLIMIT; ++j)\\n {\\n A[i][j] = atoi (argv[k + 1]);\\n k++;\\n }\\n }\\n\\n /*\\n * Initialise matrix B but do NOT reset the value of k as it now refers\\n * to the 400th element of the command-line.\\n */\\n for (i = 0; i < UPPERLIMIT; ++i)\\n {\\n for (j = 0; j < UPPERLIMIT; ++j)\\n {\\n B[i][j] = atoi (argv[k + 1]);\\n k++;\\n }\\n }\\n\\n matrix_mult (A, B, C);\\n\\n return 0;\\n}\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.4193514883518219,\n \"alphanum_fraction\": 0.48503804206848145,\n \"avg_line_length\": 21.623151779174805,\n \"blob_id\": \"14bbcf92aaab949faa0b779fb4e9e6cb828d47b3\",\n \"content_id\": \"68507a7e5cbe64123e2ef968bfbbb02db46b5b07\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 9591,\n \"license_type\": \"no_license\",\n \"max_line_length\": 76,\n \"num_lines\": 406,\n \"path\": \"/DaikonPathInformation/benchmarks/matrix_inverse.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\r\\n * Matrix inversion taken from MDH suite and modified by Adam Betts to\\r\\n * consume a test vector supplied on the command line.\\r\\n *\\r\\n * For this program, the test vector consists of 9 integers since there is\\r\\n * a single UPPERLIMIT*UPPERLIMIT matrix to be initialised before inversion.\\r\\n */\\r\\n\\r\\n#define UPPERLIMIT 5\\r\\n\\r\\ndouble\\r\\nfabs (double n)\\r\\n{\\r\\n if (n >= 0)\\r\\n return n;\\r\\n else\\r\\n return -n;\\r\\n}\\r\\n\\r\\nint\\r\\nmatrix_inverse (double a[][UPPERLIMIT], int row, int col, double eps)\\r\\n{\\r\\n#ifdef CBMC\\r\\n//==========> matrix_inverse : header 38\\r\\nint __count_38_37 = 0;\\r\\nint __count_38_37_L = 0; //Loop counter\\r\\n//==========> matrix_inverse : header 28\\r\\nint __count_25_26 = 0;\\r\\nint __count_25_27 = 0;\\r\\nint __count_28_25 = 0; //Loop counter\\r\\n//==========> matrix_inverse : header 35\\r\\nint __count_38_39 = 0;\\r\\nint __count_35_36 = 0; //Loop counter\\r\\n//==========> matrix_inverse : header 17\\r\\nint __count_17_16 = 0;\\r\\nint __count_17_16_L = 0; //Loop counter\\r\\n//==========> matrix_inverse : header 31\\r\\nint __count_22_30 = 0;\\r\\nint __count_23_30 = 0;\\r\\nint __count_28_29 = 0;\\r\\nint __count_31_22 = 0; //Loop counter\\r\\n//==========> matrix_inverse : header 20\\r\\nint __count_20_19 = 0;\\r\\nint __count_20_19_L = 0; //Loop counter\\r\\n//==========> matrix_inverse : header 12\\r\\nint __count_9_10 = 0;\\r\\nint __count_9_11 = 0;\\r\\nint __count_12_9 = 0; //Loop counter\\r\\n//==========> matrix_inverse : header 41\\r\\nint __count_35_40 = 0;\\r\\nint __count_41_35 = 0; //Loop counter\\r\\n//==========> matrix_inverse : header 33\\r\\nint __count_14_18 = 0;\\r\\nint __count_17_18 = 0;\\r\\nint __count_33_8 = 0; //Loop counter\\r\\n//==========> matrix_inverse : header 6\\r\\nint __count_6_5 = 0;\\r\\nint __count_6_5_L = 0; //Loop counter\\r\\n//==========> matrix_inverse : header 1\\r\\nint __count_45 = 0;\\r\\nint __count_1_43 = 0;\\r\\nint __count_2_43 = 0;\\r\\nint __count_3_43 = 0;\\r\\nint __count_13_44 = 0;\\r\\nint __count_33_34 = 0;\\r\\n\\r\\n#endif\\r\\n\\r\\n int work[500];\\r\\n int i;\\r\\n int j;\\r\\n int k;\\r\\n int r;\\r\\n int iw;\\r\\n int s;\\r\\n int t;\\r\\n int u;\\r\\n int v;\\r\\n double w;\\r\\n double wmax;\\r\\n double pivot;\\r\\n double api;\\r\\n double w1;\\r\\n double b[UPPERLIMIT][UPPERLIMIT];\\r\\n double c[UPPERLIMIT][UPPERLIMIT];\\r\\n double e[UPPERLIMIT][UPPERLIMIT];\\r\\n\\r\\n if (row < 2 || row > 500 || eps <= 0.0)\\r\\n {\\r\\n #ifdef CBMC\\r\\n // TODO: check\\r\\n if (row < 2)\\r\\n __count_1_43++;\\r\\n else if (row > 500)\\r\\n __count_2_43++;\\r\\n else if (eps <= 0.0)\\r\\n __count_3_43++;\\r\\n #endif\\r\\n #ifdef CBMC\\r\\n __count_45++;\\r\\n #endif\\r\\n return;\\r\\n }\\r\\n\\r\\n w1 = 1.0;\\r\\n #ifdef CBMC\\r\\n __count_6_5_L = 0;\\r\\n #endif\\r\\n for (i = 0; i < row; i++) // 6\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_6_5++;\\r\\n __count_6_5_L++;\\r\\n #endif\\r\\n work[i] = i;\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_6_5_L <= 6); // Loop counter property\\r\\n #endif\\r\\n\\r\\n #ifdef CBMC\\r\\n __count_33_8 = 0;\\r\\n #endif\\r\\n for (k = 0; k < row; k++) // 33\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_33_8++;\\r\\n #endif\\r\\n wmax = 0.0;\\r\\n #ifdef CBMC\\r\\n __count_12_9 = 0;\\r\\n #endif\\r\\n for (i = k; i < row; i++) // 12\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_12_9++;\\r\\n #endif\\r\\n w = fabs (a[i][k]);\\r\\n if (w > wmax)\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_9_10++;\\r\\n #endif\\r\\n wmax = w;\\r\\n r = i;\\r\\n }\\r\\n #ifdef CBMC\\r\\n else __count_9_11++;\\r\\n #endif\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_12_9 <= 6); // Loop counter property\\r\\n #endif\\r\\n pivot = a[r][k];\\r\\n api = fabs (pivot);\\r\\n\\r\\n if (api <= eps) // 13 \\r\\n {\\r\\n // 44\\r\\n #ifdef CBMC\\r\\n __count_13_44++;\\r\\n __count_45++;\\r\\n #endif\\r\\n return;\\r\\n }\\r\\n\\r\\n w1 *= pivot;\\r\\n u = k * col;\\r\\n v = r * col;\\r\\n\\r\\n if (r != k) // 14\\r\\n {\\r\\n w1 = -w;\\r\\n iw = work[k];\\r\\n work[k] = work[r];\\r\\n work[r] = iw;\\r\\n #ifdef CBMC\\r\\n __count_17_16_L = 0;\\r\\n #endif\\r\\n for (j = 0; j < row; j++) // 17\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_17_16_L++;\\r\\n __count_17_16++;\\r\\n #endif\\r\\n s = u + j;\\r\\n t = v + j;\\r\\n w = a[k][j];\\r\\n a[k][j] = a[r][j];\\r\\n a[r][j] = w;\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_17_16_L <= 6); // Loop counter property\\r\\n __count_17_18++;\\r\\n #endif\\r\\n }\\r\\n #ifdef CBMC\\r\\n else __count_14_18++;\\r\\n #endif\\r\\n\\r\\n #ifdef CBMC\\r\\n __count_20_19_L = 0;\\r\\n #endif\\r\\n for (i = 0; i < row; i++) // 20\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_20_19_L++;\\r\\n __count_20_19++;\\r\\n #endif\\r\\n a[k][i] /= pivot;\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_20_19_L <= 6); // Loop counter property\\r\\n #endif\\r\\n\\r\\n #ifdef CBMC\\r\\n __count_31_22 = 0;\\r\\n #endif\\r\\n for (i = 0; i < row; i++) // 31\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_31_22++;\\r\\n #endif\\r\\n if (i != k) // 22\\r\\n {\\r\\n v = i * col;\\r\\n s = v + k;\\r\\n w = a[i][k];\\r\\n if (w != 0.0) // 23\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_28_25 = 0;\\r\\n #endif\\r\\n for (j = 0; j < row; j++) // 28\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_28_25++;\\r\\n #endif\\r\\n if (j != k) // 25\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_25_26++;\\r\\n #endif\\r\\n a[i][j] -= w * a[k][j];\\r\\n }\\r\\n #ifdef CBMC\\r\\n else __count_25_27++;\\r\\n #endif\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_28_25 <= 6); // Loop counter property\\r\\n __count_28_29++;\\r\\n #endif\\r\\n a[i][k] = -w / pivot;\\r\\n }\\r\\n #ifdef CBMC\\r\\n else __count_23_30++;\\r\\n #endif\\r\\n }\\r\\n #ifdef CBMC\\r\\n else __count_22_30++;\\r\\n #endif\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_31_22 <= 6); // Loop counter property\\r\\n #endif\\r\\n a[k][k] = 1.0 / pivot;\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_33_8 <= 6); // Loop counter property\\r\\n __count_33_34++;\\r\\n #endif\\r\\n\\r\\n #ifdef CBMC\\r\\n __count_41_35 = 0;\\r\\n #endif\\r\\n for (i = 0; i < row; i++) // 41\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_41_35++;\\r\\n #endif\\r\\n #ifdef CBMC\\r\\n __count_35_36 = 0;\\r\\n #endif\\r\\n while (1) // 35\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_35_36++;\\r\\n #endif\\r\\n k = work[i];\\r\\n\\r\\n if (k == i)\\r\\n {\\r\\n break;\\r\\n }\\r\\n\\r\\n iw = work[k];\\r\\n work[k] = work[i];\\r\\n work[i] = iw;\\r\\n #ifdef CBMC\\r\\n __count_38_37_L = 0;\\r\\n #endif\\r\\n for (j = 0; j < row; j++) // 38\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_38_37_L++;\\r\\n __count_38_37++;\\r\\n #endif\\r\\n u = j * col;\\r\\n s = u + i;\\r\\n t = u + k;\\r\\n w = a[k][i];\\r\\n a[k][i] = a[k][k];\\r\\n a[k][k] = w;\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_38_37_L <= 6); // Loop counter property\\r\\n __count_38_39++;\\r\\n #endif\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_35_36 <= 5); // Loop counter property\\r\\n __count_35_40++;\\r\\n #endif\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_41_35 <= 6); // Loop counter property\\r\\n __count_45++;\\r\\n #endif\\r\\n\\r\\n#ifdef CBMC\\r\\n\\r\\n\\r\\nassert(__count_13_44 == 0); // Dead code\\r\\nassert(__count_35_40 >= 5); // Lower capacity constraint\\r\\nassert(__count_35_40 <= 5); // Upper capacity constraint\\r\\nassert(__count_14_18 >= 1); // Lower capacity constraint\\r\\nassert(__count_14_18 <= 4); // Upper capacity constraint\\r\\nassert(__count_38_37 >= 5); // Lower capacity constraint\\r\\nassert(__count_38_37 <= 20); // Upper capacity constraint\\r\\nassert(__count_38_39 >= 1); // Lower capacity constraint\\r\\nassert(__count_38_39 <= 4); // Upper capacity constraint\\r\\nassert(__count_17_16 >= 5); // Lower capacity constraint\\r\\nassert(__count_17_16 <= 20); // Upper capacity constraint\\r\\nassert(__count_17_18 >= 1); // Lower capacity constraint\\r\\nassert(__count_17_18 <= 4); // Upper capacity constraint\\r\\nassert(__count_23_30 == 0); // Dead code\\r\\nassert(__count_20_19 >= 25); // Lower capacity constraint\\r\\nassert(__count_20_19 <= 25); // Upper capacity constraint\\r\\nassert(__count_45 >= 1); // Lower capacity constraint\\r\\nassert(__count_45 <= 1); // Upper capacity constraint\\r\\nassert(__count_22_30 >= 5); // Lower capacity constraint\\r\\nassert(__count_22_30 <= 5); // Upper capacity constraint\\r\\nassert(__count_1_43 == 0); // Dead code\\r\\nassert(__count_2_43 == 0); // Dead code\\r\\nassert(__count_3_43 == 0); // Dead code\\r\\nassert(__count_25_27 >= 20); // Lower capacity constraint\\r\\nassert(__count_25_27 <= 20); // Upper capacity constraint\\r\\nassert(__count_25_26 >= 80); // Lower capacity constraint\\r\\nassert(__count_25_26 <= 80); // Upper capacity constraint\\r\\nassert(__count_6_5 >= 5); // Lower capacity constraint\\r\\nassert(__count_6_5 <= 5); // Upper capacity constraint\\r\\nassert(__count_28_29 >= 20); // Lower capacity constraint\\r\\nassert(__count_28_29 <= 20); // Upper capacity constraint\\r\\nassert(__count_9_10 >= 6); // Lower capacity constraint\\r\\nassert(__count_9_10 <= 13); // Upper capacity constraint\\r\\nassert(__count_9_11 >= 2); // Lower capacity constraint\\r\\nassert(__count_9_11 <= 9); // Upper capacity constraint\\r\\nassert(__count_33_34 >= 1); // Lower capacity constraint\\r\\nassert(__count_33_34 <= 1); // Upper capacity constraint\\r\\n#endif\\r\\n}\\r\\n\\r\\nint\\r\\nmain (int argc, char **argv)\\r\\n{\\r\\n int i;\\r\\n int j;\\r\\n int k;\\r\\n double a[UPPERLIMIT][UPPERLIMIT];\\r\\n double eps = 1.0e-6;\\r\\n\\r\\n /*\\r\\n * Need UPPERLIMIT*UPPERLIMIT values to fill up the matrix.\\r\\n */\\r\\n if (argc != UPPERLIMIT*UPPERLIMIT+1)\\r\\n {\\r\\n return 1;\\r\\n }\\r\\n\\r\\n k = 0;\\r\\n for (i = 0; i < UPPERLIMIT; ++i)\\r\\n {\\r\\n for (j = 0; j < UPPERLIMIT; ++j)\\r\\n {\\r\\n a[i][j] = atoi (argv[k + 1]);\\r\\n k++;\\r\\n }\\r\\n }\\r\\n\\r\\n int val = matrix_inverse (a, UPPERLIMIT, UPPERLIMIT, eps);\\r\\n \\r\\n printf(\\\"%d\\\", val);\\r\\n\\r\\n return 0;\\r\\n}\\r\\n\"\n },\n {\n \"alpha_fraction\": 0.5568383932113647,\n \"alphanum_fraction\": 0.5577264428138733,\n \"avg_line_length\": 27.049999237060547,\n \"blob_id\": \"a5bc7de5459c309ec27d826886d07589244001b7\",\n \"content_id\": \"239ac07ce7fe374a403588c36d18ec22d3eaa2f0\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 1126,\n \"license_type\": \"no_license\",\n \"max_line_length\": 80,\n \"num_lines\": 40,\n \"path\": \"/GPUTimingAnalysis/src/Edges.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"class Edge (): \\n dummyEdgeID = -1\\n \\n def __init__ (self, vertexID, edgeID=None): \\n self._vertexID = vertexID\\n if edgeID is None:\\n self.__edgeID = Edge.dummyEdgeID\\n else:\\n self.__edgeID = edgeID\\n \\n def getVertexID (self):\\n return self._vertexID\\n \\n def setEdgeID (self, edgeID):\\n self.__edgeID = edgeID\\n \\n def getEdgeID (self):\\n assert self.__edgeID != Edge.dummyEdgeID, \\\"The edge ID has not been set\\\"\\n return self.__edgeID\\n \\nclass IPGEdge (Edge):\\n def __init__ (self, vertexID, edgeID=None):\\n Edge.__init__(self, vertexID, edgeID)\\n self.__edgeLabel = set()\\n self.__iterationEdge = False\\n \\n def addToEdgeLabel (self, vertices):\\n self.__edgeLabel.update(set(vertices))\\n \\n def getEdgeLabelSize (self):\\n return len(self.__edgeLabel)\\n \\n def getEdgeLabel (self):\\n return self.__edgeLabel\\n \\n def setIterationEdge (self):\\n self.__iterationEdge = True\\n \\n def isIterationEdge (self):\\n return self.__iterationEdge\\n \"\n },\n {\n \"alpha_fraction\": 0.5105158090591431,\n \"alphanum_fraction\": 0.5725038647651672,\n \"avg_line_length\": 23.026596069335938,\n \"blob_id\": \"41946386d762ef84aa226674c18763a7a8700200\",\n \"content_id\": \"09157cc067f0a1e02004a8399a71b4d10370b0e5\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 4517,\n \"license_type\": \"no_license\",\n \"max_line_length\": 75,\n \"num_lines\": 188,\n \"path\": \"/DaikonPathInformation/benchmarks/bubblesort.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Bubble sort taken from MDH suite and modified by Adam Betts to consume a\\n * test vector supplied on the command line.\\n *\\n * For this program, the test vector is a list of integers to be sorted.\\n * Note that the size of the array is determined by the number of arguments\\n * given to the program, i.e. argc - 1.\\n */\\n\\n/*\\n * Swaps the values if the value pointed to by a is greater than the\\n * value pointed to by b and returns 1 if a swap is performed, 0 otherwise\\n */\\nint\\nswapIfLarger (int *a, int *b)\\n{\\n #ifdef CBMC\\n//==========> swapiflarger : header 14\\nint __count_17 = 0;\\nint __count_14_15 = 0;\\nint __count_16_17 = 0;\\n #endif\\n\\n int tmp;\\n if (*a > *b)\\n {\\t\\n #ifdef CBMC\\n __count_14_15++;\\n #endif\\n tmp = *a;\\n *a = *b;\\n *b = tmp;\\n #ifdef CBMC\\n __count_17++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_16_17 <= 1); // Upper capacity constraint\\nassert(__count_14_15 <= 1); // Upper capacity constraint\\nassert(__count_17 >= 1); // Lower capacity constraint\\nassert(__count_17 <= 1); // Upper capacity constraint\\nassert(__count_16_17 > 0 ==> __count_17 > 0); // Execution dependence\\nassert(__count_14_15 > 0 ==> __count_17 > 0); // Execution dependence\\n#endif\\n\\n return 1;\\n }\\n #ifdef CBMC\\n else __count_16_17++;\\n #endif\\n\\n #ifdef CBMC\\n __count_17++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_16_17 <= 1); // Upper capacity constraint\\nassert(__count_14_15 <= 1); // Upper capacity constraint\\nassert(__count_17 >= 1); // Lower capacity constraint\\nassert(__count_17 <= 1); // Upper capacity constraint\\nassert(__count_16_17 > 0 ==> __count_17 > 0); // Execution dependence\\nassert(__count_14_15 > 0 ==> __count_17 > 0); // Execution dependence\\n#endif\\n\\n return 0;\\n}\\n\\nvoid\\nbubblesort (int ARRAY_SIZE, int a[])\\n{\\n\\n #ifdef CBMC\\n//==========> bubblesort : header 7\\nint __count_4_6 = 0;\\nint __count_5_6 = 0;\\nint __count_7_3 = 0; //Loop counter\\n//==========> bubblesort : header 10\\nint __count_7_8 = 0;\\nint __count_10_2 = 0; //Loop counter\\n//==========> bubblesort : header 1\\nint __count_13 = 0;\\nint __count_8_12 = 0;\\nint __count_10_11 = 0;\\n #endif\\n\\n int i, j, tmp;\\n int swapped = 0;\\n // header 10\\n for (i = 0;\\n i < ARRAY_SIZE - 1;\\n i++)\\n {\\n #ifdef CBMC\\n __count_10_2++;\\n __count_7_3 = 0;\\n #endif\\n swapped = 0;\\n // header 7\\n for (j = 0; \\n j < ARRAY_SIZE - 1 - i; \\n j++)\\n {\\n #ifdef CBMC\\n __count_7_3++;\\n #endif\\n if (swapIfLarger(&a[j], &a[j+1]))\\n { \\n #ifdef CBMC\\n __count_5_6++;\\n #endif\\n swapped = 1;\\n }\\n #ifdef CBMC\\n else __count_4_6++;\\n #endif\\n }\\n #ifdef CBMC\\n //assert(__count_7_3 <= 10); // Loop counter property\\n\\n // asserts for header 7\\n \\n __count_7_8++;\\n #endif\\n if (swapped == 0)\\n {\\n #ifdef CBMC\\n __count_8_12++;\\n #endif\\n break;\\n }\\n }\\n #ifdef CBMC\\n assert(__count_10_2 <= 10); // Loop counter property\\n __count_10_11++;\\n __count_13++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_13 >= 1); // Lower capacity constraint\\nassert(__count_13 <= 1); // Upper capacity constraint\\n//assert(__count_4_6 >= 3); // Lower capacity constraint\\nassert(__count_4_6 <= 24); // Upper capacity constraint\\n//assert(__count_5_6 >= 12); // Lower capacity constraint\\nassert(__count_5_6 <= 42); // Upper capacity constraint\\n//assert(__count_7_8 >= 5); // Lower capacity constraint\\nassert(__count_7_8 <= 9); // Upper capacity constraint\\nassert(__count_8_12 <= 1); // Upper capacity constraint\\nassert(__count_10_11 <= 1); // Upper capacity constraint\\nassert(__count_8_12 > 0 ==> __count_13 > 0); // Execution dependence\\nassert(__count_8_12 > 0 ==> __count_4_6 > 0); // Execution dependence\\n//assert(__count_8_12 > 0 ==> __count_5_6 > 0); // Execution dependence\\nassert(__count_8_12 > 0 ==> __count_7_8 > 0); // Execution dependence\\nassert(__count_10_11 > 0 ==> __count_13 > 0); // Execution dependence\\n//assert(__count_10_11 > 0 ==> __count_4_6 > 0); // Execution dependence\\n//assert(__count_10_11 > 0 ==> __count_5_6 > 0); // Execution dependence\\n//assert(__count_10_11 > 0 ==> __count_7_8 > 0); // Execution dependence\\n#endif\\n\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int ARRAY_SIZE = argc - 1;\\n int TV[ARRAY_SIZE];\\n int i;\\n\\n /*\\n * At least one integer value must be supplied\\n */\\n if (argc == 1)\\n {\\n return 1;\\n }\\n\\n for (i = 0; i < argc - 1; ++i)\\n {\\n TV[i] = atoi (argv[i + 1]);\\n }\\n \\n #ifdef CBMC\\n __CPROVER_assume(ARRAY_SIZE >= 1 && ARRAY_SIZE <= 100);\\n #endif\\n\\n bubblesort (ARRAY_SIZE, TV);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.584396481513977,\n \"alphanum_fraction\": 0.6079489588737488,\n \"avg_line_length\": 80.4800033569336,\n \"blob_id\": \"fb830466c3becabe42bff799ec9d4a3d033ce51b\",\n \"content_id\": \"ffb8d2b37b0fa224594f154ac1a41e1c7d9e23e4\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Shell\",\n \"length_bytes\": 2038,\n \"license_type\": \"no_license\",\n \"max_line_length\": 100,\n \"num_lines\": 25,\n \"path\": \"/DaikonPathInformation/benchmarks/runall.bash\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#/!/bin/bash\\npython ../src/ToolGem5.py adpcm m5out/adpcm.trace.*.gz\\npython ../src/ToolGem5.py binary_search m5out/binary_search.trace.*.gz\\npython ../src/ToolGem5.py bubblesort m5out/bubblesort.trace.*.gz\\npython ../src/ToolGem5.py matrix_count m5out/matrix_count.trace.*.gz\\npython ../src/ToolGem5.py compress m5out/compress.trace.*.gz\\npython ../src/ToolGem5.py cover m5out/cover.trace.*.gz\\npython ../src/ToolGem5.py crc m5out/crc.trace.*.gz\\npython ../src/ToolGem5.py edn m5out/edn.trace.*.gz\\npython ../src/ToolGem5.py fastDiscreteCosineTransform m5out/fastDiscreteCosineTransform.trace.*.gz\\npython ../src/ToolGem5.py fft m5out/fft.trace.*.gz\\npython ../src/ToolGem5.py finiteImpulseResponse m5out/finiteImpulseResponse.trace.*.gz\\npython ../src/ToolGem5.py insertsort m5out/insertsort.trace.*.gz\\npython ../src/ToolGem5.py janne_complex m5out/janne_complex.trace.*.gz\\npython ../src/ToolGem5.py lcdnum m5out/lcdnum.trace.*.gz\\npython ../src/ToolGem5.py LUdecomposition m5out/LUdecomposition.trace.*.gz\\npython ../src/ToolGem5.py embedded m5out/embedded.trace.*.gz\\npython ../src/ToolGem5.py statemate m5out/statemate.trace.*.gz\\npython ../src/ToolGem5.py matrix_inverse m5out/matrix_inverse.trace.*.gz\\npython ../src/ToolGem5.py matrixmultiply m5out/matrixmultiply.trace.*.gz\\npython ../src/ToolGem5.py quicksort m5out/quicksort.trace.*.gz\\npython ../src/ToolGem5.py quadraticroots m5out/quadraticroots.trace.*.gz\\npython ../src/ToolGem5.py select m5out/select.trace.*.gz\\npython ../src/ToolGem5.py squareroot m5out/squareroot.trace.*.gz\\npython ../src/ToolGem5.py statistics m5out/statistics.trace.*.gz\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.7968460321426392,\n \"alphanum_fraction\": 0.7968460321426392,\n \"avg_line_length\": 45.869564056396484,\n \"blob_id\": \"b0eedc03d3092d7f0fb8f60b44eb1f30f223f5a3\",\n \"content_id\": \"282a915850fee4d3d0512b20f0bf8a1650fedab9\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Shell\",\n \"length_bytes\": 1078,\n \"license_type\": \"no_license\",\n \"max_line_length\": 65,\n \"num_lines\": 23,\n \"path\": \"/DaikonPathInformation/benchmarks/staticAnalysis.bash\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#/!/bin/bash\\npython ../src/ToolSuperBlocks.py adpcm.txt \\npython ../src/ToolSuperBlocks.py binary_search.txt \\npython ../src/ToolSuperBlocks.py bubblesort.txt\\npython ../src/ToolSuperBlocks.py matrix_count.txt \\npython ../src/ToolSuperBlocks.py compress.txt\\npython ../src/ToolSuperBlocks.py cover.txt \\npython ../src/ToolSuperBlocks.py crc.txt\\npython ../src/ToolSuperBlocks.py edn.txt \\npython ../src/ToolSuperBlocks.py fastDiscreteCosineTransform.txt \\npython ../src/ToolSuperBlocks.py fft.txt \\npython ../src/ToolSuperBlocks.py insertsort.txt \\npython ../src/ToolSuperBlocks.py janne_complex.txt\\npython ../src/ToolSuperBlocks.py lcdnum.txt \\npython ../src/ToolSuperBlocks.py LUdecomposition.txt\\npython ../src/ToolSuperBlocks.py matrix_inverse.txt\\npython ../src/ToolSuperBlocks.py matrixmultiply.txt\\npython ../src/ToolSuperBlocks.py embedded.txt \\npython ../src/ToolSuperBlocks.py quicksort.txt \\npython ../src/ToolSuperBlocks.py quadraticroots.txt\\npython ../src/ToolSuperBlocks.py select.txt\\npython ../src/ToolSuperBlocks.py squareroot.txt\\npython ../src/ToolSuperBlocks.py statistics.txt\\n\"\n },\n {\n \"alpha_fraction\": 0.5243179202079773,\n \"alphanum_fraction\": 0.5373665690422058,\n \"avg_line_length\": 12.789473533630371,\n \"blob_id\": \"bc21c69494228f81e09fe7e29dbdc340d68f0523\",\n \"content_id\": \"16e9ede07eedd05ed5f40e72fafac0d3c7cd3ccc\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 843,\n \"license_type\": \"no_license\",\n \"max_line_length\": 69,\n \"num_lines\": 57,\n \"path\": \"/benchmarks/prime/prime.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\r\\n * Prime program taken from MDH suite and modified by Adam Betts\\r\\n * to consume a test vector supplied on the command line.\\r\\n *\\r\\n * For this program, the test vector is a single element. The program\\r\\n * determines if it is prime or not.\\r\\n */\\r\\n\\r\\nunsigned char\\r\\ndivides (unsigned int n, unsigned int m)\\r\\n{\\r\\n return m % n == 0;\\r\\n}\\r\\n\\r\\nunsigned char\\r\\neven (unsigned int n)\\r\\n{\\r\\n return divides (2, n);\\r\\n}\\r\\n\\r\\nunsigned char\\r\\nprime (unsigned int n)\\r\\n{\\r\\n int i;\\r\\n\\r\\n if (even (n))\\r\\n {\\r\\n return n == 2;\\r\\n }\\r\\n\\r\\n for (i = 3; i * i <= n; i += 2)\\r\\n {\\r\\n if (divides (i, n))\\r\\n {\\r\\n return 0;\\r\\n }\\r\\n }\\r\\n return n > 1;\\r\\n}\\r\\n\\r\\nint\\r\\nmain (int argc, char *argv[])\\r\\n{\\r\\n unsigned char answer;\\r\\n\\r\\n /*\\r\\n * One integer must be supplied\\r\\n */\\r\\n if (argc != 2)\\r\\n {\\r\\n return 1;\\r\\n }\\r\\n\\r\\n answer = prime (atoi (argv[1]));\\r\\n\\r\\n return 0;\\r\\n}\\r\\n\"\n },\n {\n \"alpha_fraction\": 0.5697329640388489,\n \"alphanum_fraction\": 0.5828741192817688,\n \"avg_line_length\": 20.254716873168945,\n \"blob_id\": \"9619d2496c892f717147e19cfffa8ea0f307aee4\",\n \"content_id\": \"7c0ea90d9041a3b9e23607ceb888eafd9f045190\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 2359,\n \"license_type\": \"no_license\",\n \"max_line_length\": 80,\n \"num_lines\": 106,\n \"path\": \"/benchmarks/st/st.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\r\\n * Statistics program taken from MDH suite and modified by Adam Betts to consume a\\r\\n * test vector supplied on the command line.\\r\\n *\\r\\n * For this program, the test vector is a list of doubles.\\r\\n * There must be an even number of doubles on the command line because there are\\r\\n * two arrays to fill, each of the same dimension.\\r\\n *\\r\\n * Unfortunately the 'math' header file is needed for the 'sqrt' function.\\r\\n * To compile and link correctly do:\\r\\n * 'gcc -lm -o st.c'\\r\\n */\\r\\n\\r\\n#include \\r\\n\\r\\ndouble\\r\\nSquare (double x)\\r\\n{\\r\\n return x * x;\\r\\n}\\r\\n\\r\\nvoid\\r\\nCalc_Sum_Mean (double Array[], double * Sum, double * Mean, int ARRAY_SIZE)\\r\\n{\\r\\n int i;\\r\\n\\r\\n *Sum = 0;\\r\\n for (i = 0; i < ARRAY_SIZE; i++)\\r\\n {\\r\\n *Sum += Array[i];\\r\\n }\\r\\n *Mean = *Sum / ARRAY_SIZE;\\r\\n}\\r\\n\\r\\nvoid\\r\\nCalc_Var_Stddev (double Array[], double Mean, double * Var, double * Stddev,\\r\\n int ARRAY_SIZE)\\r\\n{\\r\\n int i;\\r\\n double diffs = 0.0;\\r\\n\\r\\n for (i = 0; i < ARRAY_SIZE; i++)\\r\\n {\\r\\n diffs += Square (Array[i] - Mean);\\r\\n }\\r\\n *Var = diffs / ARRAY_SIZE;\\r\\n *Stddev = sqrt (*Var);\\r\\n}\\r\\n\\r\\nvoid\\r\\nCalc_LinCorrCoef (double ArrayA[], double ArrayB[], double MeanA, double MeanB,\\r\\n int ARRAY_SIZE)\\r\\n{\\r\\n int i;\\r\\n double numerator = 0.0;\\r\\n double Aterm = 0.0;\\r\\n double Bterm = 0.0;\\r\\n double Coef;\\r\\n\\r\\n for (i = 0; i < ARRAY_SIZE; i++)\\r\\n {\\r\\n numerator += (ArrayA[i] - MeanA) * (ArrayB[i] - MeanB);\\r\\n Aterm += Square (ArrayA[i] - MeanA);\\r\\n Bterm += Square (ArrayB[i] - MeanB);\\r\\n }\\r\\n Coef = numerator / (sqrt (Aterm) * sqrt (Bterm));\\r\\n}\\r\\n\\r\\nint\\r\\nmain (int argc, char *argv[])\\r\\n{\\r\\n const int ELEMENTS = argc - 1;\\r\\n int i;\\r\\n double ArrayA[ELEMENTS/2];\\r\\n double ArrayB[ELEMENTS/2];\\r\\n double SumA;\\r\\n double SumB;\\r\\n double MeanA;\\r\\n double MeanB;\\r\\n double VarA;\\r\\n double VarB;\\r\\n double StddevA;\\r\\n double StddevB;\\r\\n\\r\\n if (argc == 1 || ELEMENTS % 2 == 1)\\r\\n {\\r\\n return 1;\\r\\n }\\r\\n\\r\\n for (i = 0; i < ELEMENTS/2; i++)\\r\\n {\\r\\n ArrayA[i] = atoi (argv[i + 1]);\\r\\n }\\r\\n for (i = 0; i < ELEMENTS/2; i++)\\r\\n {\\r\\n ArrayB[i] = atoi (argv[i + 1]);\\r\\n }\\r\\n\\r\\n Calc_Sum_Mean (ArrayA, &SumA, &MeanA, ELEMENTS/2);\\r\\n Calc_Var_Stddev (ArrayA, MeanA, &VarA, &StddevA, ELEMENTS/2);\\r\\n Calc_Sum_Mean (ArrayB, &SumB, &MeanB, ELEMENTS/2);\\r\\n Calc_Var_Stddev (ArrayB, MeanB, &VarB, &StddevB, ELEMENTS/2);\\r\\n Calc_LinCorrCoef (ArrayA, ArrayB, MeanA, MeanB, ELEMENTS/2);\\r\\n\\r\\n return 0;\\r\\n}\\r\\n\"\n },\n {\n \"alpha_fraction\": 0.41516709327697754,\n \"alphanum_fraction\": 0.44215938448905945,\n \"avg_line_length\": 12.875,\n \"blob_id\": \"d3e8f409957f4dccd8e5231f34161ce1857b06e9\",\n \"content_id\": \"17a4765b7ee610160f7db30102ad47c80b965f7f\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 778,\n \"license_type\": \"no_license\",\n \"max_line_length\": 73,\n \"num_lines\": 56,\n \"path\": \"/benchmarks/janne_complex/janne_complex.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Janne Complex taken from MDH suite and modified by Adam Betts to consume a\\n * test vector supplied on the command line.\\n *\\n * For this program, a two-element test vector is expected.\\n */\\n\\nint\\njanne_complex (int a, int b)\\n{\\n while (a < 30)\\n {\\n while (b < a)\\n {\\n if (b > 5)\\n {\\n b = b * 3;\\n }\\n else\\n {\\n b = b + 2;\\n }\\n if (b >= 10 && b <= 12)\\n {\\n a = a + 10;\\n }\\n else\\n {\\n a = a + 1;\\n }\\n }\\n a = a + 2;\\n b = b - 10;\\n }\\n return 1;\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n int a, b, answer;\\n\\n /*\\n * Two integer values must be supplied\\n */\\n if (argc != 3)\\n {\\n return 1;\\n }\\n\\n a = atoi (argv[1]);\\n b = atoi (argv[2]);\\n answer = janne_complex (a, b);\\n\\n return 0;\\n}\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.3908906877040863,\n \"alphanum_fraction\": 0.5008097290992737,\n \"avg_line_length\": 26.44444465637207,\n \"blob_id\": \"9f5a496d0802ce7da23c251519087aa11ae781c8\",\n \"content_id\": \"e83da43667956dc65f857ecd37590bb8e0ad34b9\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 4940,\n \"license_type\": \"no_license\",\n \"max_line_length\": 79,\n \"num_lines\": 180,\n \"path\": \"/benchmarks/fdct/fdct.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Fast Discrete Cosine Transform (FDCT) taken from MDH suite and modified by\\n * Adam Betts to consume a test vector supplied on the command line.\\n *\\n * For this program, the test vector is a list of 64 integers.\\n */\\n\\n#define W1 2841 /* 2048*sqrt(2)*cos(1*pi/16) */\\n#define W2 2676 /* 2048*sqrt(2)*cos(2*pi/16) */\\n#define W3 2408 /* 2048*sqrt(2)*cos(3*pi/16) */\\n#define W5 1609 /* 2048*sqrt(2)*cos(5*pi/16) */\\n#define W6 1108 /* 2048*sqrt(2)*cos(6*pi/16) */\\n#define W7 565 /* 2048*sqrt(2)*cos(7*pi/16) */\\n\\n#define CONST_BITS 13\\n#define PASS1_BITS 2\\n\\nvoid\\nfdct (int *blk)\\n{\\n const int lx = 8;\\n int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;\\n int tmp10, tmp11, tmp12, tmp13;\\n int z1, z2, z3, z4, z5;\\n int i;\\n short int *block;\\n\\n int constant;\\n\\n block = blk;\\n\\n for (i = 0; i < 8; i++)\\n {\\n tmp0 = block[0] + block[7];\\n tmp7 = block[0] - block[7];\\n tmp1 = block[1] + block[6];\\n tmp6 = block[1] - block[6];\\n tmp2 = block[2] + block[5];\\n tmp5 = block[2] - block[5];\\n tmp3 = block[3] + block[4];\\n tmp4 = block[3] - block[4];\\n\\n tmp10 = tmp0 + tmp3;\\n tmp13 = tmp0 - tmp3;\\n tmp11 = tmp1 + tmp2;\\n tmp12 = tmp1 - tmp2;\\n\\n block[0] = ((tmp10 + tmp11) << PASS1_BITS);\\n block[4] = ((tmp10 - tmp11) << PASS1_BITS);\\n\\n constant = 4433;\\n z1 = (tmp12 + tmp13) * constant;\\n constant = 6270;\\n block[2] = (z1 + (tmp13 * constant)) >> (CONST_BITS - PASS1_BITS);\\n constant = -15137;\\n block[6] = (z1 + (tmp12 * constant)) >> (CONST_BITS - PASS1_BITS);\\n\\n z1 = tmp4 + tmp7;\\n z2 = tmp5 + tmp6;\\n z3 = tmp4 + tmp6;\\n z4 = tmp5 + tmp7;\\n constant = 9633;\\n z5 = ((z3 + z4) * constant); /* sqrt(2) * c3 */\\n\\n constant = 2446;\\n tmp4 = (tmp4 * constant); /* sqrt(2) * (-c1+c3+c5-c7) */\\n constant = 16819;\\n tmp5 = (tmp5 * constant); /* sqrt(2) * ( c1+c3-c5+c7) */\\n constant = 25172;\\n tmp6 = (tmp6 * constant); /* sqrt(2) * ( c1+c3+c5-c7) */\\n constant = 12299;\\n tmp7 = (tmp7 * constant); /* sqrt(2) * ( c1+c3-c5-c7) */\\n constant = -7373;\\n z1 = (z1 * constant); /* sqrt(2) * (c7-c3) */\\n constant = -20995;\\n z2 = (z2 * constant); /* sqrt(2) * (-c1-c3) */\\n constant = -16069;\\n z3 = (z3 * constant); /* sqrt(2) * (-c3-c5) */\\n constant = -3196;\\n z4 = (z4 * constant); /* sqrt(2) * (c5-c3) */\\n\\n z3 += z5;\\n z4 += z5;\\n\\n block[7] = (tmp4 + z1 + z3) >> (CONST_BITS - PASS1_BITS);\\n block[5] = (tmp5 + z2 + z4) >> (CONST_BITS - PASS1_BITS);\\n block[3] = (tmp6 + z2 + z3) >> (CONST_BITS - PASS1_BITS);\\n block[1] = (tmp7 + z1 + z4) >> (CONST_BITS - PASS1_BITS);\\n\\n block += lx;\\n }\\n\\n block = blk;\\n\\n for (i = 0; i < 8; i++)\\n {\\n tmp0 = block[0] + block[7* lx ];\\n tmp7 = block[0] - block[7* lx ];\\n tmp1 = block[lx] + block[6* lx ];\\n tmp6 = block[lx] - block[6* lx ];\\n tmp2 = block[2* lx ] + block[5* lx ];\\n tmp5 = block[2* lx ] - block[5* lx ];\\n tmp3 = block[3* lx ] + block[4* lx ];\\n tmp4 = block[3* lx ] - block[4* lx ];\\n\\n tmp10 = tmp0 + tmp3;\\n tmp13 = tmp0 - tmp3;\\n tmp11 = tmp1 + tmp2;\\n tmp12 = tmp1 - tmp2;\\n\\n block[0] = (tmp10 + tmp11) >> (PASS1_BITS + 3);\\n block[4* lx ] = (tmp10 - tmp11) >> (PASS1_BITS + 3);\\n\\n constant = 4433;\\n z1 = ((tmp12 + tmp13) * constant);\\n constant = 6270;\\n block[2* lx ] = (z1 + (tmp13 * constant)) >> (CONST_BITS + PASS1_BITS + 3);\\n constant = -15137;\\n block[6* lx ] = (z1 + (tmp12 * constant)) >> (CONST_BITS + PASS1_BITS + 3);\\n\\n z1 = tmp4 + tmp7;\\n z2 = tmp5 + tmp6;\\n z3 = tmp4 + tmp6;\\n z4 = tmp5 + tmp7;\\n constant = 9633;\\n z5 = ((z3 + z4) * constant); /* sqrt(2) * c3 */\\n\\n constant = 2446;\\n tmp4 = (tmp4 * constant); /* sqrt(2) * (-c1+c3+c5-c7) */\\n constant = 16819;\\n tmp5 = (tmp5 * constant); /* sqrt(2) * ( c1+c3-c5+c7) */\\n constant = 25172;\\n tmp6 = (tmp6 * constant); /* sqrt(2) * ( c1+c3+c5-c7) */\\n constant = 12299;\\n tmp7 = (tmp7 * constant); /* sqrt(2) * ( c1+c3-c5-c7) */\\n constant = -7373;\\n z1 = (z1 * constant); /* sqrt(2) * (c7-c3) */\\n constant = -20995;\\n z2 = (z2 * constant); /* sqrt(2) * (-c1-c3) */\\n constant = -16069;\\n z3 = (z3 * constant); /* sqrt(2) * (-c3-c5) */\\n constant = -3196;\\n z4 = (z4 * constant); /* sqrt(2) * (c5-c3) */\\n\\n z3 += z5;\\n z4 += z5;\\n\\n block[7* lx ] = (tmp4 + z1 + z3) >> (CONST_BITS + PASS1_BITS + 3);\\n block[5* lx ] = (tmp5 + z2 + z4) >> (CONST_BITS + PASS1_BITS + 3);\\n block[3* lx ] = (tmp6 + z2 + z3) >> (CONST_BITS + PASS1_BITS + 3);\\n block[lx] = (tmp7 + z1 + z4) >> (CONST_BITS + PASS1_BITS + 3);\\n\\n block++;\\n }\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int ARRAY_SIZE = 64;\\n int TV[ARRAY_SIZE];\\n int i;\\n\\n /*\\n * 64 integers must be supplied\\n */\\n if (argc != ARRAY_SIZE + 1)\\n {\\n return 1;\\n }\\n\\n for (i = 0; i < ARRAY_SIZE; ++i)\\n {\\n TV[i] = atoi (argv[i + 1]);\\n }\\n\\n fdct (TV);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.408564031124115,\n \"alphanum_fraction\": 0.5510250329971313,\n \"avg_line_length\": 29.342069625854492,\n \"blob_id\": \"c9f13bc1816cf3dd1ab7991216873c837fb1f970\",\n \"content_id\": \"e805d069c0ec72495afcf2d491771115ddb2ce1f\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 21999,\n \"license_type\": \"no_license\",\n \"max_line_length\": 102,\n \"num_lines\": 725,\n \"path\": \"/DaikonPathInformation/benchmarks/embedded.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"typedef struct IMMENSE { unsigned long l, r; } immense;\\ntypedef struct GREAT { unsigned long l, c, r; } great;\\n\\nunsigned long bit[33];\\n\\nstatic immense icd;\\nstatic char ipc1[57]={0,57,49,41,33,25,17,9,1,58,50,\\n 42,34,26,18,10,2,59,51,43,35,27,19,11,3,60,\\n 52,44,36,63,55,47,39,31,23,15,7,62,54,46,38,\\n 30,22,14,6,61,53,45,37,29,21,13,5,28,20,12,4};\\nstatic char ipc2[49]={0,14,17,11,24,1,5,3,28,15,6,21,\\n 10,23,19,12,4,26,8,16,7,27,20,13,2,41,52,31,\\n 37,47,55,30,40,51,45,33,48,44,49,39,56,34,\\n 53,46,42,50,36,29,32};\\n\\nunsigned long \\ngetbit (immense source, int bitno, int nbits) {\\n#ifdef CBMC\\n//==========> getbit : header 16\\nint __count_24 = 0;\\nint __count_17_18 = 0;\\nint __count_17_19 = 0;\\nint __count_21_22 = 0;\\nint __count_21_23 = 0;\\n#endif\\n\\n if (bitno <= nbits) // 16\\n {\\n // 17\\n #ifdef CBMC\\n // TODO: check \\n if(bit[bitno] & source.r)\\n {\\n __count_17_18++;\\n __count_24++;\\nassert(__count_21_22 <= 1); // Upper capacity constraint\\nassert(__count_21_23 <= 1); // Upper capacity constraint\\nassert(__count_17_18 <= 1); // Upper capacity constraint\\nassert(__count_17_19 <= 1); // Upper capacity constraint\\nassert(__count_24 >= 1); // Lower capacity constraint\\nassert(__count_24 <= 1); // Upper capacity constraint\\nassert(__count_17_18 > 0 ==> __count_24 > 0); // Execution dependence\\nassert(__count_17_19 > 0 ==> __count_24 > 0); // Execution dependence\\nassert(__count_21_22 > 0 ==> __count_24 > 0); // Execution dependence\\nassert(__count_21_23 > 0 ==> __count_24 > 0); // Execution dependence\\n return 1L;\\n }\\n else\\n {\\n __count_17_19++;\\n __count_24++;\\nassert(__count_21_22 <= 1); // Upper capacity constraint\\nassert(__count_21_23 <= 1); // Upper capacity constraint\\nassert(__count_17_18 <= 1); // Upper capacity constraint\\nassert(__count_17_19 <= 1); // Upper capacity constraint\\nassert(__count_24 >= 1); // Lower capacity constraint\\nassert(__count_24 <= 1); // Upper capacity constraint\\nassert(__count_17_18 > 0 ==> __count_24 > 0); // Execution dependence\\nassert(__count_17_19 > 0 ==> __count_24 > 0); // Execution dependence\\nassert(__count_21_22 > 0 ==> __count_24 > 0); // Execution dependence\\nassert(__count_21_23 > 0 ==> __count_24 > 0); // Execution dependence\\n return 0L;\\n }\\n #else\\n return bit[bitno] & source.r ? 1L : 0L;\\n #endif\\n }\\n else\\n {\\n // 21\\n #ifdef CBMC\\n // TODO: check\\n if (bit[bitno-nbits] & source.l)\\n {\\n __count_21_22++;\\n __count_24++;\\nassert(__count_21_22 <= 1); // Upper capacity constraint\\nassert(__count_21_23 <= 1); // Upper capacity constraint\\nassert(__count_17_18 <= 1); // Upper capacity constraint\\nassert(__count_17_19 <= 1); // Upper capacity constraint\\nassert(__count_24 >= 1); // Lower capacity constraint\\nassert(__count_24 <= 1); // Upper capacity constraint\\nassert(__count_17_18 > 0 ==> __count_24 > 0); // Execution dependence\\nassert(__count_17_19 > 0 ==> __count_24 > 0); // Execution dependence\\nassert(__count_21_22 > 0 ==> __count_24 > 0); // Execution dependence\\nassert(__count_21_23 > 0 ==> __count_24 > 0); // Execution dependence\\n return 1L;\\n }\\n else\\n {\\n __count_21_23++;\\n __count_24++;\\nassert(__count_21_22 <= 1); // Upper capacity constraint\\nassert(__count_21_23 <= 1); // Upper capacity constraint\\nassert(__count_17_18 <= 1); // Upper capacity constraint\\nassert(__count_17_19 <= 1); // Upper capacity constraint\\nassert(__count_24 >= 1); // Lower capacity constraint\\nassert(__count_24 <= 1); // Upper capacity constraint\\nassert(__count_17_18 > 0 ==> __count_24 > 0); // Execution dependence\\nassert(__count_17_19 > 0 ==> __count_24 > 0); // Execution dependence\\nassert(__count_21_22 > 0 ==> __count_24 > 0); // Execution dependence\\nassert(__count_21_23 > 0 ==> __count_24 > 0); // Execution dependence\\n return 0L;\\n }\\n #else\\n return bit[bitno-nbits] & source.l ? 1L : 0L;\\n #endif\\n }\\n}\\n \\nvoid \\nks (int n, great * kn) \\n{\\n#ifdef CBMC\\n//==========> ks : header 8\\nint __count_8_7 = 0;\\nint __count_8_7_L = 0; //Loop counter\\n//==========> ks : header 14\\nint __count_10_11 = 0;\\nint __count_14_10 = 0; //Loop counter\\n//==========> ks : header 1\\nint __count_15 = 0;\\nint __count_1_5 = 0;\\nint __count_2_5 = 0;\\nint __count_3_5 = 0;\\nint __count_4_5 = 0;\\nint __count_8_9 = 0;\\n#endif\\n\\n int i,j,k,l;\\n\\n if (n == 1 || n == 2 || n == 9 || n == 16) \\n {\\n #ifdef CBMC\\n // TODO: check\\n if (n == 1) __count_1_5++;\\n else if (n == 2) __count_2_5++;\\n else if (n == 9) __count_3_5++;\\n else if (n == 16) __count_4_5++;\\n #endif\\n icd.r = (icd.r | ((icd.r & 1L) << 28)) >> 1;\\n icd.l = (icd.l | ((icd.l & 1L) << 28)) >> 1;\\n }\\n else\\n {\\n #ifdef CBMC\\n __count_8_7_L = 0;\\n #endif\\n for (i=1;i<=2;i++) // 8\\n {\\n #ifdef CBMC\\n __count_8_7_L++;\\n __count_8_7++;\\n #endif\\n icd.r = (icd.r | ((icd.r & 1L) << 28)) >> 1;\\n icd.l = (icd.l | ((icd.l & 1L) << 28)) >> 1;\\n }\\n #ifdef CBMC\\n assert(__count_8_7_L <= 3); // Loop counter property\\n __count_8_9++;\\n #endif\\n } \\n \\n (*kn).r=(*kn).c=(*kn).l=0;\\n #ifdef CBMC\\n __count_14_10 = 0;\\n #endif\\n for (j=16,k=32,l=48; j>=1; j--,k--,l--) // 14\\n {\\n #ifdef CBMC\\n __count_14_10++;\\n #endif\\n (*kn).r=((*kn).r <<= 1) | (unsigned short) getbit(icd,ipc2[j],28);\\n (*kn).c=((*kn).c <<= 1) | (unsigned short) getbit(icd,ipc2[k],28);\\n (*kn).l=((*kn).l <<= 1) | (unsigned short) getbit(icd,ipc2[l],28);\\n #ifdef CBMC\\n __count_10_11++;\\n #endif\\n }\\n #ifdef CBMC\\n assert(__count_14_10 <= 17); // Loop counter property\\n __count_15++;\\n #endif\\n\\n\\n#ifdef CBMC\\nassert(__count_15 >= 1); // Lower capacity constraint\\nassert(__count_15 <= 1); // Upper capacity constraint\\nassert(__count_1_5 <= 1); // Upper capacity constraint\\nassert(__count_2_5 <= 1); // Upper capacity constraint\\nassert(__count_3_5 <= 1); // Upper capacity constraint\\nassert(__count_4_5 <= 1); // Upper capacity constraint\\nassert(__count_8_9 <= 1); // Upper capacity constraint\\nassert(__count_8_7 <= 2); // Upper capacity constraint\\nassert(__count_10_11 >= 16); // Lower capacity constraint\\nassert(__count_10_11 <= 16); // Upper capacity constraint\\nassert(__count_8_9 > 0 ==> __count_8_7 > 0); // Mutual inclusion\\nassert(__count_8_7 > 0 ==> __count_8_9 > 0); // Mutual inclusion\\nassert(__count_1_5 > 0 ==> __count_15 > 0); // Execution dependence\\nassert(__count_1_5 > 0 ==> __count_10_11 > 0); // Execution dependence\\nassert(__count_2_5 > 0 ==> __count_15 > 0); // Execution dependence\\nassert(__count_2_5 > 0 ==> __count_10_11 > 0); // Execution dependence\\nassert(__count_3_5 > 0 ==> __count_15 > 0); // Execution dependence\\nassert(__count_3_5 > 0 ==> __count_10_11 > 0); // Execution dependence\\nassert(__count_4_5 > 0 ==> __count_15 > 0); // Execution dependence\\nassert(__count_4_5 > 0 ==> __count_10_11 > 0); // Execution dependence\\nassert(__count_8_9 > 0 ==> __count_15 > 0); // Execution dependence\\nassert(__count_8_9 > 0 ==> __count_10_11 > 0); // Execution dependence\\nassert(__count_8_7 > 0 ==> __count_15 > 0); // Execution dependence\\nassert(__count_8_7 > 0 ==> __count_10_11 > 0); // Execution dependence\\n#endif\\n}\\n\\nvoid \\ncyfun (unsigned long ir, great k, unsigned long * iout) \\n{\\n#ifdef CBMC\\n//==========> cyfun : header 48\\nint __count_44_45 = 0;\\nint __count_44_46 = 0;\\nint __count_48_44 = 0; //Loop counter\\n//==========> cyfun : header 42\\nint __count_42_41 = 0;\\nint __count_42_41_L = 0; //Loop counter\\n//==========> cyfun : header 39\\nint __count_39_38 = 0;\\nint __count_39_38_L = 0; //Loop counter\\n//==========> cyfun : header 36\\nint __count_27_29 = 0;\\nint __count_28_29 = 0;\\nint __count_29_30 = 0;\\nint __count_29_31 = 0;\\nint __count_32_33 = 0;\\nint __count_32_34 = 0;\\nint __count_36_26 = 0; //Loop counter\\n//==========> cyfun : header 25\\nint __count_49 = 0;\\nint __count_36_37 = 0;\\n#endif\\n\\n static char iet[49]={0,32,1,2,3,4,5,4,5,6,7,8,9,8,9,\\n 10,11,12,13,12,13,14,15,16,17,16,17,18,19,\\n 20,21,20,21,22,23,24,25,24,25,26,27,28,29,\\n 28,29,30,31,32,1};\\n static char ipp[33]={0,16,7,20,21,29,12,28,17,1,15,\\n 23,26,5,18,31,10,2,8,24,14,32,27,3,9,19,13,\\n 30,6,22,11,4,25};\\n static char is[16][4][9]={\\n 0,14,15,10,7,2,12,4,13,0,0,3,13,13,14,10,13,1,\\n 0,4,0,13,10,4,9,1,7,0,15,13,1,3,11,4,6,2,\\n 0,4,1,0,13,12,1,11,2,0,15,13,7,8,11,15,0,15,\\n 0,1,14,6,6,2,14,4,11,0,12,8,10,15,8,3,11,1,\\n 0,13,8,9,14,4,10,2,8,0,7,4,0,11,2,4,11,13,\\n 0,14,7,4,9,1,15,11,4,0,8,10,13,0,12,2,13,14,\\n 0,1,14,14,3,1,15,14,4,0,4,7,9,5,12,2,7,8,\\n 0,8,11,9,0,11,5,13,1,0,2,1,0,6,7,12,8,7,\\n 0,2,6,6,0,7,9,15,6,0,14,15,3,6,4,7,4,10,\\n 0,13,10,8,12,10,2,12,9,0,4,3,6,10,1,9,1,4,\\n 0,15,11,3,6,10,2,0,15,0,2,2,4,15,7,12,9,3,\\n 0,6,4,15,11,13,8,3,12,0,9,15,9,1,14,5,4,10,\\n 0,11,3,15,9,11,6,8,11,0,13,8,6,0,13,9,1,7,\\n 0,2,13,3,7,7,12,7,14,0,1,4,8,13,2,15,10,8,\\n 0,8,4,5,10,6,8,13,1,0,1,14,10,3,1,5,10,4,\\n 0,11,1,0,13,8,3,14,2,0,7,2,7,8,13,10,7,13,\\n 0,3,9,1,1,8,0,3,10,0,10,12,2,4,5,6,14,12,\\n 0,15,5,11,15,15,7,10,0,0,5,11,4,9,6,11,9,15,\\n 0,10,7,13,2,5,13,12,9,0,6,0,8,7,0,1,3,5,\\n 0,12,8,1,1,9,0,15,6,0,11,6,15,4,15,14,5,12,\\n 0,6,2,12,8,3,3,9,3,0,12,1,5,2,15,13,5,6,\\n 0,9,12,2,3,12,4,6,10,0,3,7,14,5,0,1,0,9,\\n 0,12,13,7,5,15,4,7,14,0,11,10,14,12,10,14,12,11,\\n 0,7,6,12,14,5,10,8,13,0,14,12,3,11,9,7,15,0,\\n 0,5,12,11,11,13,14,5,5,0,9,6,12,1,3,0,2,0,\\n 0,3,9,5,5,6,1,0,15,0,10,0,11,12,10,6,14,3,\\n 0,9,0,4,12,0,7,10,0,0,5,9,11,10,9,11,15,14,\\n 0,10,3,10,2,3,13,5,3,0,0,5,5,7,4,0,2,5,\\n 0,0,5,2,4,14,5,6,12,0,3,11,15,14,8,3,8,9,\\n 0,5,2,14,8,0,11,9,5,0,6,14,2,2,5,8,3,6,\\n 0,7,10,8,15,9,11,1,7,0,8,5,1,9,6,8,6,2,\\n 0,0,15,7,4,14,6,2,8,0,13,9,12,14,3,13,12,11};\\n static char ibin[16]={0,8,4,12,2,10,6,14,1,9,5,13,3,11,7,15};\\n great ie;\\n unsigned long itmp,ietmp1,ietmp2;\\n char iec[9];\\n int jj,irow,icol,iss,j,l,m;\\n unsigned long *p;\\n\\n p = bit;\\n ie.r=ie.c=ie.l=0;\\n #ifdef CBMC\\n __count_36_26 = 0;\\n #endif\\n for (j=16,l=32,m=48;j>=1;j--,l--,m--) // 36\\n {\\n #ifdef CBMC\\n __count_36_26++;\\n #endif\\n\\n #ifdef CBMC\\n // TODO: check\\n if (p[iet[j]] & ir) // 26\\n {\\n ie.r = (ie.r <<=1) | 1; // 27\\n __count_27_29++;\\n }\\n else\\n {\\n ie.r = (ie.r <<=1) | 0; // 28\\n __count_28_29++;\\n }\\n #else\\n ie.r = (ie.r <<=1) | (p[iet[j]] & ir ? 1 : 0);\\n #endif\\n\\n #ifdef CBMC\\n if (p[iet[l]] & ir) // 29\\n {\\n __count_29_30++;\\n ie.c = (ie.c <<=1) | 1; //30\\n }\\n else\\n {\\n __count_29_31++;\\n ie.c = (ie.c <<=1) | 0; // 31\\n }\\n #else\\n ie.c = (ie.c <<=1) | (p[iet[l]] & ir ? 1 : 0);\\n #endif\\n\\n #ifdef CBMC\\n if (p[iet[m]] & ir) // 32\\n {\\n ie.l = (ie.l <<=1) | 1; // 33\\n __count_32_33++;\\n }\\n else\\n {\\n ie.l = (ie.l <<=1) | 0; // 34\\n __count_32_34++;\\n }\\n #else\\n ie.l = (ie.l <<=1) | (p[iet[m]] & ir ? 1 : 0);\\n #endif\\n }\\n #ifdef CBMC\\n assert(__count_36_26 <= 17); // Loop counter property\\n __count_36_37++;\\n #endif\\n \\n ie.r ^= k.r;\\n ie.c ^= k.c;\\n ie.l ^= k.l;\\n ietmp1=((unsigned long) ie.c << 16)+(unsigned long) ie.r;\\n ietmp2=((unsigned long) ie.l << 8)+((unsigned long) ie.c >> 8);\\n \\n #ifdef CBMC\\n __count_39_38_L = 0;\\n #endif\\n for (j=1,m=5;j<=4;j++,m++) // 39\\n {\\n #ifdef CBMC\\n __count_39_38_L++;\\n __count_39_38++;\\n #endif\\n iec[j]=ietmp1 & 0x3fL;\\n iec[m]=ietmp2 & 0x3fL;\\n ietmp1 >>= 6;\\n ietmp2 >>= 6;\\n }\\n #ifdef CBMC\\n assert(__count_39_38_L <= 5); // Loop counter property\\n #endif\\n \\n itmp=0L;\\n #ifdef CBMC\\n __count_42_41_L = 0;\\n #endif\\n for (jj=8;jj>=1;jj--) // 42\\n {\\n #ifdef CBMC\\n __count_42_41_L++;\\n __count_42_41++;\\n #endif\\n j =iec[jj];\\n irow=((j & 0x1) << 1)+((j & 0x20) >> 5);\\n icol=((j & 0x2) << 2)+(j & 0x4) +((j & 0x8) >> 2)+((j & 0x10) >> 4);\\n iss=is[icol][irow][jj];\\n itmp = (itmp <<= 4) | ibin[iss];\\n }\\n #ifdef CBMC\\n assert(__count_42_41_L <= 9); // Loop counter property\\n #endif\\n \\n *iout=0L;\\n p = bit;\\n #ifdef CBMC\\n __count_48_44 = 0;\\n #endif\\n for (j=32; j>=1;j--) // 48\\n {\\n #ifdef CBMC\\n __count_48_44++;\\n #endif\\n #ifdef CBMC\\n // TODO: check\\n if(p[ipp[j]] & itmp) // 44\\n {\\n __count_44_45++;\\n *iout = (*iout <<= 1) | 1; // 45\\n }\\n else\\n {\\n __count_44_46++;\\n *iout = (*iout <<= 1) | 0; // 46\\n }\\n #else\\n *iout = (*iout <<= 1) | (p[ipp[j]] & itmp ? 1 : 0);\\n #endif\\n }\\n #ifdef CBMC\\n assert(__count_48_44 <= 33); // Loop counter property\\n __count_49++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_27_29 <= 16); // Upper capacity constraint\\nassert(__count_28_29 <= 16); // Upper capacity constraint\\nassert(__count_29_30 <= 16); // Upper capacity constraint\\nassert(__count_29_31 <= 16); // Upper capacity constraint\\n//assert(__count_32_33 <= 15); // Upper capacity constraint\\nassert(__count_32_34 >= 1); // Lower capacity constraint\\nassert(__count_32_34 <= 16); // Upper capacity constraint\\nassert(__count_36_37 >= 1); // Lower capacity constraint\\nassert(__count_36_37 <= 1); // Upper capacity constraint\\nassert(__count_49 >= 1); // Lower capacity constraint\\nassert(__count_49 <= 1); // Upper capacity constraint\\n//assert(__count_44_45 >= 8); // Lower capacity constraint\\n//assert(__count_44_45 <= 23); // Upper capacity constraint\\n//assert(__count_44_46 >= 9); // Lower capacity constraint\\n//assert(__count_44_46 <= 24); // Upper capacity constraint\\nassert(__count_42_41 >= 8); // Lower capacity constraint\\nassert(__count_42_41 <= 8); // Upper capacity constraint\\nassert(__count_39_38 >= 4); // Lower capacity constraint\\nassert(__count_39_38 <= 4); // Upper capacity constraint\\nassert(__count_27_29 > 0 ==> __count_32_34 > 0); // Execution dependence\\nassert(__count_27_29 > 0 ==> __count_36_37 > 0); // Execution dependence\\nassert(__count_27_29 > 0 ==> __count_39_38 > 0); // Execution dependence\\nassert(__count_27_29 > 0 ==> __count_42_41 > 0); // Execution dependence\\nassert(__count_27_29 > 0 ==> __count_49 > 0); // Execution dependence\\nassert(__count_27_29 > 0 ==> __count_44_45 > 0); // Execution dependence\\nassert(__count_27_29 > 0 ==> __count_44_46 > 0); // Execution dependence\\nassert(__count_28_29 > 0 ==> __count_32_34 > 0); // Execution dependence\\nassert(__count_28_29 > 0 ==> __count_36_37 > 0); // Execution dependence\\nassert(__count_28_29 > 0 ==> __count_39_38 > 0); // Execution dependence\\nassert(__count_28_29 > 0 ==> __count_42_41 > 0); // Execution dependence\\nassert(__count_28_29 > 0 ==> __count_49 > 0); // Execution dependence\\nassert(__count_28_29 > 0 ==> __count_44_45 > 0); // Execution dependence\\nassert(__count_28_29 > 0 ==> __count_44_46 > 0); // Execution dependence\\nassert(__count_29_30 > 0 ==> __count_32_34 > 0); // Execution dependence\\nassert(__count_29_30 > 0 ==> __count_36_37 > 0); // Execution dependence\\nassert(__count_29_30 > 0 ==> __count_39_38 > 0); // Execution dependence\\nassert(__count_29_30 > 0 ==> __count_42_41 > 0); // Execution dependence\\nassert(__count_29_30 > 0 ==> __count_49 > 0); // Execution dependence\\nassert(__count_29_30 > 0 ==> __count_44_45 > 0); // Execution dependence\\nassert(__count_29_30 > 0 ==> __count_44_46 > 0); // Execution dependence\\nassert(__count_29_31 > 0 ==> __count_32_34 > 0); // Execution dependence\\nassert(__count_29_31 > 0 ==> __count_36_37 > 0); // Execution dependence\\nassert(__count_29_31 > 0 ==> __count_39_38 > 0); // Execution dependence\\nassert(__count_29_31 > 0 ==> __count_42_41 > 0); // Execution dependence\\nassert(__count_29_31 > 0 ==> __count_49 > 0); // Execution dependence\\nassert(__count_29_31 > 0 ==> __count_44_45 > 0); // Execution dependence\\nassert(__count_29_31 > 0 ==> __count_44_46 > 0); // Execution dependence\\nassert(__count_32_33 > 0 ==> __count_32_34 > 0); // Execution dependence\\nassert(__count_32_33 > 0 ==> __count_36_37 > 0); // Execution dependence\\nassert(__count_32_33 > 0 ==> __count_39_38 > 0); // Execution dependence\\nassert(__count_32_33 > 0 ==> __count_42_41 > 0); // Execution dependence\\nassert(__count_32_33 > 0 ==> __count_49 > 0); // Execution dependence\\nassert(__count_32_33 > 0 ==> __count_44_45 > 0); // Execution dependence\\nassert(__count_32_33 > 0 ==> __count_44_46 > 0); // Execution dependence\\n#endif\\n\\n}\\n \\nint \\nembedded (immense inp, immense key, int * newkey, int isw, immense * out) \\n{\\n#ifdef CBMC\\n//==========> embedded : header 63\\nint __count_61_62 = 0;\\nint __count_63_61 = 0; //Loop counter\\n//==========> embedded : header 59\\nint __count_56_57 = 0;\\nint __count_59_56 = 0; //Loop counter\\n//==========> embedded : header 80\\nint __count_80_77 = 0;\\nint __count_80_77_L = 0; //Loop counter\\n//==========> embedded : header 75\\nint __count_70_71 = 0;\\nint __count_70_72 = 0;\\nint __count_75_70 = 0; //Loop counter\\n//==========> embedded : header 53\\nint __count_53_52 = 0;\\nint __count_53_52_L = 0; //Loop counter\\n//==========> embedded : header 68\\nint __count_68_65 = 0;\\nint __count_68_65_L = 0; //Loop counter\\n//==========> embedded : header 50\\nint __count_81 = 0;\\nint __count_50_54 = 0;\\nint __count_53_54 = 0;\\nint __count_54_64 = 0;\\nint __count_59_60 = 0;\\n#endif\\n static char ip[65] =\\n {0,58,50,42,34,26,18,10,2,60,52,44,36,\\n 28,20,12,4,62,54,46,38,30,22,14,6,64,56,48,40,\\n 32,24,16,8,57,49,41,33,25,17,9,1,59,51,43,35,\\n 27,19,11,3,61,53,45,37,29,21,13,5,63,55,47,39,\\n 31,23,15,7};\\n static char ipm[65]=\\n {0,40,8,48,16,56,24,64,32,39,7,47,15,\\n 55,23,63,31,38,6,46,14,54,22,62,30,37,5,45,13,\\n 53,21,61,29,36,4,44,12,52,20,60,28,35,3,43,11,\\n 51,19,59,27,34,2,42,10,50,18,58,26,33,1,41,9,\\n 49,17,57,25};\\n static great kns[17];\\n static int initflag=1;\\n int ii,i,j,k;\\n unsigned long ic,shifter,getbit();\\n immense itmp;\\n great pg;\\n\\n if (initflag) // 50\\n {\\n initflag=0;\\n bit[1]=shifter=1L;\\n #ifdef CBMC\\n __count_53_52_L = 0;\\n #endif\\n for(j=2;j<=32;j++) // 53\\n {\\n #ifdef CBMC\\n __count_53_52_L++;\\n __count_53_52++;\\n #endif\\n bit[j] = (shifter <<= 1);\\n }\\n #ifdef CBMC\\n assert(__count_53_52_L <= 32); // Loop counter property\\n __count_53_54++;\\n #endif\\n }\\n #ifdef CBMC\\n else __count_50_54++;\\n #endif\\n \\n if (*newkey) // 54\\n {\\n *newkey=0;\\n icd.r=icd.l=0L;\\n #ifdef CBMC\\n __count_59_56 = 0;\\n #endif\\n for (j=28,k=56;j>=1;j--,k--) // 59\\n {\\n #ifdef CBMC\\n __count_59_56++;\\n __count_56_57++;\\n #endif\\n icd.r = (icd.r <<= 1) | getbit(key,ipc1[j],32);\\n icd.l = (icd.l <<= 1) | getbit(key,ipc1[k],32);\\n }\\n #ifdef CBMC\\n assert(__count_59_56 <= 29); // Loop counter property\\n __count_59_60++;\\n #endif\\n\\n #ifdef CBMC\\n __count_63_61 = 0;\\n #endif\\n for (i=1; i<=16;i++) // 63\\n { \\n #ifdef CBMC\\n __count_63_61++;\\n __count_61_62++;\\n #endif\\n //62\\n pg = kns[i]; ks(/* key,*/ i, &pg); kns[i] = pg;\\n }\\n #ifdef CBMC\\n assert(__count_63_61 <= 17); // Loop counter property\\n #endif\\n }\\n #ifdef CBMC\\n __count_54_64++;\\n #endif\\n \\n itmp.r=itmp.l=0L;\\n \\n #ifdef CBMC\\n __count_68_65_L = 0;\\n #endif\\n for (j=32,k=64;j>=1;j--,k--) // 68\\n {\\n #ifdef CBMC\\n __count_68_65_L++;\\n __count_68_65++;\\n #endif\\n itmp.r = (itmp.r <<= 1) | getbit(inp,ip[j],32);\\n itmp.l = (itmp.l <<= 1) | getbit(inp,ip[k],32);\\n }\\n #ifdef CBMC\\n assert(__count_68_65_L <= 33); // Loop counter property\\n #endif\\n \\n #ifdef CBMC\\n __count_75_70 = 0;\\n #endif\\n for (i=1;i<=16;i++) // 75\\n {\\n #ifdef CBMC\\n __count_75_70++;\\n // TODO: check \\n if(isw == 1)\\n {\\n ii = 17-i; // 71\\n __count_70_71++;\\n }\\n else\\n {\\n ii = i; // 72\\n __count_70_72++;\\n }\\n #else\\n ii = (isw == 1 ? 17-i : i);\\n #endif\\n cyfun(itmp.l, kns[ii], &ic);\\n ic ^= itmp.r;\\n itmp.r=itmp.l;\\n itmp.l=ic;\\n }\\n #ifdef CBMC\\n assert(__count_75_70 <= 17); // Loop counter property\\n #endif\\n \\n ic=itmp.r;\\n itmp.r=itmp.l;\\n itmp.l=ic;\\n (*out).r=(*out).l=0L;\\n \\n #ifdef CBMC\\n __count_80_77_L = 0;\\n #endif\\n for (j=32,k=64; j >= 1; j--, k--) // 80\\n {\\n #ifdef CBMC\\n __count_80_77_L++;\\n __count_80_77++;\\n #endif\\n (*out).r = ((*out).r <<= 1) | getbit(itmp,ipm[j],32);\\n (*out).l = ((*out).l <<= 1) | getbit(itmp,ipm[k],32);\\n }\\n #ifdef CBMC\\n assert(__count_80_77_L <= 33); // Loop counter property\\n #endif\\n \\n #ifdef CBMC\\n __count_81++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_50_54 == 0); // Dead code\\nassert(__count_53_52 >= 31); // Lower capacity constraint\\nassert(__count_53_52 <= 31); // Upper capacity constraint\\nassert(__count_53_54 >= 1); // Lower capacity constraint\\nassert(__count_53_54 <= 1); // Upper capacity constraint\\n//assert(__count_54_64 == 0); // Dead code\\nassert(__count_80_77 >= 32); // Lower capacity constraint\\nassert(__count_80_77 <= 32); // Upper capacity constraint\\nassert(__count_56_57 >= 28); // Lower capacity constraint\\nassert(__count_56_57 <= 28); // Upper capacity constraint\\nassert(__count_59_60 >= 1); // Lower capacity constraint\\nassert(__count_59_60 <= 1); // Upper capacity constraint\\nassert(__count_61_62 >= 16); // Lower capacity constraint\\nassert(__count_61_62 <= 16); // Upper capacity constraint\\nassert(__count_81 >= 1); // Lower capacity constraint\\nassert(__count_81 <= 1); // Upper capacity constraint\\nassert(__count_68_65 >= 32); // Lower capacity constraint\\nassert(__count_68_65 <= 32); // Upper capacity constraint\\n//assert(__count_70_72 >= 16); // Lower capacity constraint\\nassert(__count_70_72 <= 16); // Upper capacity constraint\\n//assert(__count_70_71 == 0); // Dead code\\n#endif\\n\\n return *newkey;\\n}\\n\\nint \\nmain (int argc, char *argv[])\\n{ \\n /*\\n * Six values must be supplied: unsigned long, unsigned long, unsigned long, unsigned long, int, int\\n */\\n if (argc != 7)\\n {\\n return 1;\\n }\\n \\n int newkey, isw;\\n immense inp, key, out;\\n \\n inp.l = atol(argv[1]);\\n inp.r = atol(argv[2]);\\n key.l = atol(argv[3]);\\n key.r = atol(argv[4]);\\n newkey = atoi(argv[5]);\\n isw = atoi(argv[6]); \\n // Adam Betts: 'newkey' needs to be set to 1 to trigger a conditional in 'embedded'\\n // Similarly for 'isw' \\n\\n int val = embedded(inp, key, &newkey, isw, &out);\\n printf(\\\"%d\\\", val);\\n \\n return 0;\\n}\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.5113486051559448,\n \"alphanum_fraction\": 0.5158880949020386,\n \"avg_line_length\": 57.592594146728516,\n \"blob_id\": \"d44a3c0e901d81f66c779ff5473c3f77c2ad9562\",\n \"content_id\": \"69bfd6978e993edefa40ab6e3451fca422a01074\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 17403,\n \"license_type\": \"no_license\",\n \"max_line_length\": 194,\n \"num_lines\": 297,\n \"path\": \"/DaikonPathInformation/src/arm.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import debug\\nimport directed_graphs\\nimport programs\\nimport vertices\\nimport utils\\nimport re\\nimport shlex\\n\\nclass InstructionSet:\\n Nops = ['nop', 'nop.n', 'nop.w']\\n PCRegister = 'pc'\\n Call = 'bl'\\n UnconditionalJumps = ['b', 'b.n', 'b.w']\\n LoadInstructions = ['ldr', 'ldr.n', 'ldr.w', 'tbh', 'tbb']\\n Branches = ['b',\\n 'bl',\\n 'bcc',\\n 'bcs',\\n 'beq',\\n 'bge',\\n 'bgt',\\n 'bhi',\\n 'ble',\\n 'bls',\\n 'blt',\\n 'bmi',\\n 'bne',\\n 'bpl',\\n 'bvs',\\n 'bvc',\\n 'b.n',\\n 'b.w',\\n 'bcc.n',\\n 'bcc.w',\\n 'bcs.n',\\n 'bcs.w',\\n 'beq.n',\\n 'beq.w',\\n 'bge.n',\\n 'bge.w',\\n 'bgt.n',\\n 'bgt.w',\\n 'bhi.n',\\n 'bhi.w',\\n 'ble.n',\\n 'ble.w',\\n 'bls.n',\\n 'bls.w',\\n 'blt.n',\\n 'blt.w',\\n 'bne.n',\\n 'bne.w'] \\n\\nclass Disassembler:\\n def __init__(self, filename, root_function):\\n self.start_address_to_function = {}\\n self.last_address_to_function = {}\\n self.jump_table_to_directives = {}\\n self.function_to_instructions = {}\\n self.function_to_start_address = {}\\n self.function_to_last_address = {}\\n self.function_to_leaders = {}\\n self.function_to_directives = {}\\n self.function_to_jump_table_basic_blocks = {}\\n self.instruction_to_basic_block = {}\\n self.next_vertexID = 1\\n self.program = programs.Program()\\n self.do_it(filename, root_function)\\n \\n def do_it(self, filename, root_function):\\n self.extract_instructions(filename)\\n self.identify_call_graph(root_function)\\n self.identify_leaders()\\n self.create_basic_blocks()\\n self.add_edges()\\n self.add_jump_table_edges()\\n self.program.callg.rootID = self.program.callg.get_vertex_with_name(root_function).vertexID\\n for cfg in self.program.cfgs.values():\\n cfg.set_entry_and_exit()\\n self.program.remove_problematic_functions()\\n \\n def extract_instructions(self, filename):\\n with open(filename, 'r') as f:\\n parse = False\\n last_instruction = None\\n last_jump_table_instruction = None\\n current_function = None\\n for line in f:\\n if parse:\\n if re.match(r'[0-9a-fA-F]+\\\\s<.*>.*', line):\\n if last_instruction:\\n assert current_function, \\\"No function detected yet\\\"\\n self.function_to_last_address[current_function] = last_instruction.address\\n self.last_address_to_function[last_instruction.address] = current_function \\n lexemes = shlex.split(line)\\n assert len(lexemes) == 2, \\\"Unable to handle disassembly line %s\\\" % line\\n address = int(lexemes[0], 16)\\n function_name = lexemes[1][1:-2]\\n debug.debug_message(\\\"Detected function '%s' @ start address %d\\\" % (function_name, address), __name__, 10)\\n self.start_address_to_function[address] = function_name\\n current_function = function_name\\n self.function_to_instructions[current_function] = []\\n self.function_to_directives[current_function] = []\\n self.function_to_start_address[current_function] = address\\n self.function_to_jump_table_basic_blocks[current_function] = []\\n last_jump_table_instruction = None\\n elif re.match(r'\\\\s*[0-9a-fA-F]+:.*', line):\\n # Ignore directives reserving space for data\\n if '.word' not in line and '.short' not in line and '.byte' not in line: \\n instruction = vertices.BasicBlock.Instruction.get_instruction(line)\\n self.function_to_instructions[current_function].append(instruction)\\n last_instruction = instruction\\n if self.is_jump_table_branch(instruction):\\n last_jump_table_instruction = instruction\\n self.jump_table_to_directives[instruction] = []\\n else:\\n self.function_to_directives[current_function].append(line)\\n if last_jump_table_instruction:\\n self.jump_table_to_directives[last_jump_table_instruction].append(line) \\n elif line.startswith('Disassembly of section'):\\n parse = '.text' in line\\n \\n def identify_call_graph(self, root_function):\\n assert root_function in self.function_to_instructions, \\\"Unable to locate root function '%s' in disassembly\\\" % root_function\\n self.functions = set()\\n stack = [root_function]\\n while stack:\\n function_name = stack.pop()\\n self.functions.add(function_name)\\n debug.debug_message(\\\"Analysing function '%s'\\\" % function_name, __name__, 10)\\n assert function_name in self.function_to_instructions, \\\"No instructions for '%s' discovered\\\" % function_name\\n for instruction in self.function_to_instructions[function_name]:\\n if InstructionSet.Call in instruction.the_instruction:\\n assert len(instruction.the_instruction) == 4, \\\"Unable to handle call instruction '%s' since it does not have 3 fields exactly\\\" % instruction.the_instruction\\n startAddress = int(instruction.the_instruction[2], 16)\\n assert startAddress in self.start_address_to_function, \\\"Unable to find function with start address %s (it should be %s)\\\" % (hex(startAddress), instruction.the_instruction[3])\\n callee_name = self.start_address_to_function[startAddress]\\n if callee_name not in self.functions:\\n stack.append(callee_name)\\n elif instruction.the_instruction[1] in InstructionSet.Branches:\\n assert len(instruction.the_instruction) == 4, \\\"Unable to handle branch instruction '%s' since it does not have 3 fields exactly\\\" % instruction.the_instruction\\n startAddress = int(instruction.the_instruction[2], 16)\\n if startAddress < self.function_to_start_address[function_name] or startAddress > self.function_to_last_address[function_name]:\\n callee_name = self.get_callee_name(instruction.the_instruction)\\n if callee_name not in self.functions:\\n stack.append(callee_name)\\n \\n def get_callee_name(self, an_instruction):\\n # The callee name should be delimited by '<' and '>'\\n assert an_instruction[3].startswith('<') and an_instruction[3].endswith('>'), \\\"Unable to parse callee name %s\\\" % an_instruction[3]\\n callee_name = an_instruction[3][1:-1]\\n # Some of the target addresses are NOT the callee start address. In those cases it is an offset from the base address indicated by '+'\\n index = callee_name.find('+')\\n if index != -1:\\n callee_name = callee_name[:index]\\n startAddress = int(an_instruction[2], 16) \\n assert startAddress >= self.function_to_start_address[callee_name] and startAddress <= self.function_to_last_address[callee_name], \\\\\\n \\\"The address %s is outside the legal range of addresses for %s\\\" % (hex(startAddress), callee_name)\\n return callee_name\\n \\n def is_jump_table_branch(self, instruction):\\n op = instruction.the_instruction[1]\\n if op in InstructionSet.LoadInstructions: \\n destination = instruction.the_instruction[2] \\n if re.match(r'.*%s.*' % InstructionSet.PCRegister, destination):\\n return True\\n return False\\n \\n def identify_leaders(self):\\n functionToBranchTargets = {}\\n for function_name in self.functions:\\n debug.debug_message(\\\"Identifying leaders in '%s'\\\" % function_name, __name__, 10)\\n self.function_to_leaders[function_name] = set()\\n functionToBranchTargets[function_name] = set()\\n newLeader = True\\n noopAfterJumpTableBranch = False\\n index = 0\\n for instruction, nextInstruction in utils.peekahead_iterator(self.function_to_instructions[function_name]):\\n if newLeader:\\n self.function_to_leaders[function_name].add(instruction)\\n newLeader = False\\n elif noopAfterJumpTableBranch:\\n assert instruction.the_instruction[1] in InstructionSet.Nops, \\\"Did not find an no-op after jump table branch. Instead found %s\\\" % instruction\\n noopAfterJumpTableBranch = False\\n newLeader = True\\n \\n op = instruction.the_instruction[1]\\n if op in InstructionSet.Branches:\\n newLeader = True\\n addressTarget = int(instruction.the_instruction[2], 16) \\n functionToBranchTargets[function_name].add(addressTarget)\\n elif self.is_jump_table_branch(instruction):\\n # Look for instructions with an explicit load into the PC\\n debug.debug_message(\\\"Instruction '%s' is loading a value into the PC\\\" % instruction, __name__, 10)\\n if nextInstruction and nextInstruction.the_instruction[0] in InstructionSet.Nops:\\n noopAfterJumpTableBranch = True\\n else:\\n newLeader = True\\n index += 1\\n for instruction in self.function_to_instructions[function_name]:\\n if instruction.address in functionToBranchTargets[function_name]:\\n self.function_to_leaders[function_name].add(instruction)\\n \\n def create_basic_blocks(self):\\n for function_name in self.functions:\\n debug.debug_message(\\\"Identifying basic blocks in '%s'\\\" % function_name, __name__, 10)\\n cfg = directed_graphs.CFG()\\n cfg.name = function_name\\n self.program.addCFG(cfg)\\n bb = None\\n for instruction in self.function_to_instructions[function_name]:\\n if instruction in self.function_to_leaders[function_name]:\\n debug.debug_message(\\\"Instruction @ %s is a leader\\\" % hex(instruction.address), __name__, 10)\\n bb = vertices.BasicBlock(self.next_vertexID, function_name)\\n cfg.addVertex(bb)\\n self.next_vertexID += 1\\n assert bb, \\\"Basic block is currently null\\\"\\n bb.instructions.append(instruction)\\n self.instruction_to_basic_block[instruction] = bb\\n if self.is_jump_table_branch(instruction):\\n self.function_to_jump_table_basic_blocks[function_name].append(bb)\\n \\n def add_edges(self):\\n for function_name in self.functions:\\n debug.debug_message(\\\"Adding edges in '%s'\\\" % function_name, __name__, 10)\\n cfg = self.program.cfgs[function_name]\\n predID = vertices.dummyID\\n for instruction in self.function_to_instructions[function_name]:\\n v = self.instruction_to_basic_block[instruction]\\n if predID != vertices.dummyID:\\n cfg.addEdge(predID, v.vertexID)\\n predID = vertices.dummyID\\n if v.instructions[-1] == instruction:\\n if instruction.the_instruction[1] == InstructionSet.Call:\\n callee_name = self.get_callee_name(instruction.the_instruction)\\n cfg.add_call_site(v.vertexID, callee_name)\\n self.program.callg.addEdge(function_name, callee_name, v.vertexID)\\n predID = v.vertexID\\n elif instruction.the_instruction[1] in InstructionSet.UnconditionalJumps:\\n jump_address = int(instruction.the_instruction[2], 16)\\n if jump_address >= self.function_to_start_address[function_name] and jump_address <= self.function_to_last_address[function_name]:\\n succv = cfg.get_basic_block_with_address(jump_address)\\n cfg.addEdge(v.vertexID, succv.vertexID)\\n else:\\n callee_name = self.start_address_to_function[jump_address]\\n cfg.add_call_site(v.vertexID, callee_name)\\n self.program.callg.addEdge(function_name, callee_name, v.vertexID)\\n predID = v.vertexID\\n elif instruction.the_instruction[1] in InstructionSet.Branches:\\n branch_address = int(instruction.the_instruction[2], 16)\\n if branch_address >= self.function_to_start_address[function_name] and branch_address <= self.function_to_last_address[function_name]:\\n succv = cfg.get_basic_block_with_address(branch_address)\\n cfg.addEdge(v.vertexID, succv.vertexID)\\n else:\\n callee_name = self.get_callee_name(instruction.the_instruction)\\n cfg.add_call_site(v.vertexID, callee_name)\\n self.program.callg.addEdge(function_name, callee_name, v.vertexID)\\n predID = v.vertexID\\n elif v in self.function_to_jump_table_basic_blocks[function_name]:\\n pass\\n else:\\n predID = v.vertexID\\n \\n def add_jump_table_edges(self):\\n for function_name in self.functions:\\n debug.debug_message(\\\"Adding jump table edges in '%s'\\\" % function_name, __name__, 10)\\n cfg = self.program.cfgs[function_name]\\n i = 0\\n hasJumpTablePredecessor = set()\\n for instr in self.function_to_instructions[function_name]:\\n # If the instruction loads into the PC...\\n if self.is_jump_table_branch(instr):\\n # Get the number of directives associated with this instruction to work out\\n # how many arms it has\\n assert instr in self.jump_table_to_directives\\n numberOfBranchArms = len(self.jump_table_to_directives[instr])\\n if instr.the_instruction[0] == InstructionSet.LoadInstructions[3] \\\\\\n or instr.the_instruction[0] == InstructionSet.LoadInstructions[4]:\\n numberOfBranchArms = 3\\n predv = cfg.get_basic_block_with_address(instr.address)\\n # Now go through each successive address, get the vertex associated with\\n # that address, and add an edge if the address belongs to a newly discovered\\n # basic block\\n for j in range(i, len(self.function_to_instructions[function_name])):\\n nextInstr = self.function_to_instructions[function_name][j]\\n address = nextInstr.address\\n if not predv.hasAddress(address):\\n succv = cfg.get_basic_block_with_address(address)\\n if not predv.hasSuccessor(succv.vertexID) and succv not in hasJumpTablePredecessor:\\n cfg.addEdge(predv.vertexID, succv.vertexID)\\n hasJumpTablePredecessor.add(succv)\\n numberOfBranchArms -= 1\\n # We know how many arms to expect. As soon as the supply has been\\n # exhausted, stop adding edges\\n if not numberOfBranchArms or self.is_jump_table_branch(nextInstr):\\n break\\n i += 1 \\n\"\n },\n {\n \"alpha_fraction\": 0.418154776096344,\n \"alphanum_fraction\": 0.5985119342803955,\n \"avg_line_length\": 31.780487060546875,\n \"blob_id\": \"13a268bc29bbfb99975231e0dd32e97f9d5461ba\",\n \"content_id\": \"962fbb6d29b5010bd51ee0d23c30150512bbabb4\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 6720,\n \"license_type\": \"no_license\",\n \"max_line_length\": 74,\n \"num_lines\": 205,\n \"path\": \"/benchmarks/dct/dct.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Discrete Cosine Transform (DCT) taken from MDH suite and modified by\\n * Adam Betts to consume a test vector supplied on the command line.\\n *\\n * For this program, the test vector is a list of 64 integers.\\n */\\n\\n#define DCTSIZE 8\\n#define BITS_IN_JSAMPLE 8\\n#define MULTIPLY16C16(var,const) ((var) * (const))\\n#define INT32 int\\n#define RIGHT_SHIFT(x,shft)\\t((x) >> (shft))\\n#define ONE\\t((INT32) 1)\\n#define DESCALE(x,n) RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)\\n#define SHIFT_TEMPS\\n\\n#define JPEG_INTERNALS\\n\\n#if BITS_IN_JSAMPLE == 8\\n#define CONST_BITS 13\\n#define PASS1_BITS 2\\n#else\\n#define CONST_BITS 13\\n#define PASS1_BITS 1\\t\\t/* lose a little precision to avoid overflow */\\n#endif\\n\\n#if CONST_BITS == 13\\n#define FIX_0_298631336 ((INT32) 2446)\\t/* FIX(0.298631336) */\\n#define FIX_0_390180644 ((INT32) 3196)\\t/* FIX(0.390180644) */\\n#define FIX_0_541196100 ((INT32) 4433)\\t/* FIX(0.541196100) */\\n#define FIX_0_765366865 ((INT32) 6270)\\t/* FIX(0.765366865) */\\n#define FIX_0_899976223 ((INT32) 7373)\\t/* FIX(0.899976223) */\\n#define FIX_1_175875602 ((INT32) 9633)\\t/* FIX(1.175875602) */\\n#define FIX_1_501321110 ((INT32) 12299)\\t/* FIX(1.501321110) */\\n#define FIX_1_847759065 ((INT32) 15137)\\t/* FIX(1.847759065) */\\n#define FIX_1_961570560 ((INT32) 16069)\\t/* FIX(1.961570560) */\\n#define FIX_2_053119869 ((INT32) 16819)\\t/* FIX(2.053119869) */\\n#define FIX_2_562915447 ((INT32) 20995)\\t/* FIX(2.562915447) */\\n#define FIX_3_072711026 ((INT32) 25172)\\t/* FIX(3.072711026) */\\n#else\\n#define FIX_0_298631336 FIX(0.298631336)\\n#define FIX_0_390180644 FIX(0.390180644)\\n#define FIX_0_541196100 FIX(0.541196100)\\n#define FIX_0_765366865 FIX(0.765366865)\\n#define FIX_0_899976223 FIX(0.899976223)\\n#define FIX_1_175875602 FIX(1.175875602)\\n#define FIX_1_501321110 FIX(1.501321110)\\n#define FIX_1_847759065 FIX(1.847759065)\\n#define FIX_1_961570560 FIX(1.961570560)\\n#define FIX_2_053119869 FIX(2.053119869)\\n#define FIX_2_562915447 FIX(2.562915447)\\n#define FIX_3_072711026 FIX(3.072711026)\\n#endif\\n\\n#if BITS_IN_JSAMPLE == 8\\n#define MULTIPLY(var,const) MULTIPLY16C16(var,const)\\n#else\\n#define MULTIPLY(var,const) ((var) * (const))\\n#endif\\n\\nvoid\\ndct (int *data)\\n{\\n INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;\\n INT32 tmp10, tmp11, tmp12, tmp13;\\n INT32 z1, z2, z3, z4, z5;\\n int *dataptr;\\n int ctr;\\n SHIFT_TEMPS\\n\\n dataptr = data;\\n for (ctr = DCTSIZE - 1; ctr >= 0; ctr--)\\n {\\n tmp0 = dataptr[0] + dataptr[7];\\n tmp7 = dataptr[0] - dataptr[7];\\n tmp1 = dataptr[1] + dataptr[6];\\n tmp6 = dataptr[1] - dataptr[6];\\n tmp2 = dataptr[2] + dataptr[5];\\n tmp5 = dataptr[2] - dataptr[5];\\n tmp3 = dataptr[3] + dataptr[4];\\n tmp4 = dataptr[3] - dataptr[4];\\n\\n tmp10 = tmp0 + tmp3;\\n tmp13 = tmp0 - tmp3;\\n tmp11 = tmp1 + tmp2;\\n tmp12 = tmp1 - tmp2;\\n\\n dataptr[0] = (INT32) ((tmp10 + tmp11) << PASS1_BITS);\\n dataptr[4] = (INT32) ((tmp10 - tmp11) << PASS1_BITS);\\n\\n z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);\\n dataptr[2] = (INT32) DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865),\\n CONST_BITS-PASS1_BITS);\\n dataptr[6] = (INT32) DESCALE(z1 + MULTIPLY(tmp12, - FIX_1_847759065),\\n CONST_BITS-PASS1_BITS);\\n\\n z1 = tmp4 + tmp7;\\n z2 = tmp5 + tmp6;\\n z3 = tmp4 + tmp6;\\n z4 = tmp5 + tmp7;\\n z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */\\n\\n tmp4 = MULTIPLY(tmp4, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */\\n tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */\\n tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */\\n tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */\\n z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */\\n z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */\\n z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */\\n z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */\\n\\n z3 += z5;\\n z4 += z5;\\n\\n dataptr[7] = (INT32) DESCALE(tmp4 + z1 + z3, CONST_BITS-PASS1_BITS);\\n dataptr[5] = (INT32) DESCALE(tmp5 + z2 + z4, CONST_BITS-PASS1_BITS);\\n dataptr[3] = (INT32) DESCALE(tmp6 + z2 + z3, CONST_BITS-PASS1_BITS);\\n dataptr[1] = (INT32) DESCALE(tmp7 + z1 + z4, CONST_BITS-PASS1_BITS);\\n\\n dataptr += DCTSIZE;\\n }\\n\\n dataptr = data;\\n for (ctr = DCTSIZE - 1; ctr >= 0; ctr--)\\n {\\n tmp0 = dataptr[DCTSIZE * 0] + dataptr[DCTSIZE * 7];\\n tmp7 = dataptr[DCTSIZE * 0] - dataptr[DCTSIZE * 7];\\n tmp1 = dataptr[DCTSIZE * 1] + dataptr[DCTSIZE * 6];\\n tmp6 = dataptr[DCTSIZE * 1] - dataptr[DCTSIZE * 6];\\n tmp2 = dataptr[DCTSIZE * 2] + dataptr[DCTSIZE * 5];\\n tmp5 = dataptr[DCTSIZE * 2] - dataptr[DCTSIZE * 5];\\n tmp3 = dataptr[DCTSIZE * 3] + dataptr[DCTSIZE * 4];\\n tmp4 = dataptr[DCTSIZE * 3] - dataptr[DCTSIZE * 4];\\n\\n tmp10 = tmp0 + tmp3;\\n tmp13 = tmp0 - tmp3;\\n tmp11 = tmp1 + tmp2;\\n tmp12 = tmp1 - tmp2;\\n\\n dataptr[DCTSIZE * 0] = (INT32) DESCALE(tmp10 + tmp11, PASS1_BITS);\\n dataptr[DCTSIZE * 4] = (INT32) DESCALE(tmp10 - tmp11, PASS1_BITS);\\n\\n z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);\\n dataptr[DCTSIZE * 2]\\n = (INT32) DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865),\\n CONST_BITS+PASS1_BITS);\\n dataptr[DCTSIZE * 6]\\n = (INT32) DESCALE(z1 + MULTIPLY(tmp12, - FIX_1_847759065),\\n CONST_BITS+PASS1_BITS);\\n\\n z1 = tmp4 + tmp7;\\n z2 = tmp5 + tmp6;\\n z3 = tmp4 + tmp6;\\n z4 = tmp5 + tmp7;\\n z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */\\n\\n tmp4 = MULTIPLY(tmp4, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */\\n tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */\\n tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */\\n tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */\\n z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */\\n z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */\\n z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */\\n z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */\\n\\n z3 += z5;\\n z4 += z5;\\n\\n dataptr[DCTSIZE * 7] = (INT32) DESCALE(tmp4 + z1 + z3,\\n CONST_BITS+PASS1_BITS);\\n dataptr[DCTSIZE * 5] = (INT32) DESCALE(tmp5 + z2 + z4,\\n CONST_BITS+PASS1_BITS);\\n dataptr[DCTSIZE * 3] = (INT32) DESCALE(tmp6 + z2 + z3,\\n CONST_BITS+PASS1_BITS);\\n dataptr[DCTSIZE * 1] = (INT32) DESCALE(tmp7 + z1 + z4,\\n CONST_BITS+PASS1_BITS);\\n\\n dataptr++;\\n }\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int ARRAY_SIZE = 64;\\n int TV[ARRAY_SIZE];\\n int i;\\n\\n /*\\n * 64 integers must be supplied\\n */\\n if (argc != ARRAY_SIZE + 1)\\n {\\n return 1;\\n }\\n\\n for (i = 0; i < ARRAY_SIZE; ++i)\\n {\\n TV[i] = atoi (argv[i + 1]);\\n }\\n\\n dct (TV);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.5838466882705688,\n \"alphanum_fraction\": 0.6252566576004028,\n \"avg_line_length\": 17.851612091064453,\n \"blob_id\": \"18c32bf67e5d0826b8b6b5f9a916773d53834442\",\n \"content_id\": \"d71fb49cb8edf2f41686aa028136d1a3d9ba48d7\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 2922,\n \"license_type\": \"no_license\",\n \"max_line_length\": 87,\n \"num_lines\": 155,\n \"path\": \"/benchmarks/dijkstra/dijkstra.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Takes a vector of 36 positive integers as arguments and uses them as edge weights to\\n * calculate the longest shortest path from the root node\\n * in a predefined graph using dijkstra's shortest path algorithm\\n */\\n\\n#define numverts 15\\nconst unsigned int neighbours[numverts][4] =\\n{\\n\\t{1, 4, 5, 10},\\n\\t{0, 2, 6, 11},\\n\\t{1, 3, 7, 12},\\n\\t{2, 4, 8, 13},\\n\\t{0, 3, 9, 14},\\n\\t{0, 6, 9, 10},\\n\\t{1, 5, 7, 11},\\n\\t{2, 6, 8, 12},\\n\\t{3, 7, 9, 13},\\n\\t{4, 5, 8, 14},\\n\\t{0, 5, 11, 14},\\n\\t{1, 6, 10, 12},\\n\\t{2, 7, 11, 13},\\n\\t{3, 8, 12, 14},\\n\\t{4, 9, 10, 13},\\n};\\n\\nint removeFromUnvisited(unsigned int node, int numUnvisited, unsigned int unvisited[])\\n{\\n\\tint i, removed;\\n\\n\\tremoved = 0;\\n\\tfor (i = 0; i < numUnvisited; i++)\\n\\t{\\n\\t\\tif (removed)\\n\\t\\t{\\n\\t\\t\\tunvisited[i - 1] = unvisited[i];\\n\\t\\t}\\n\\t\\telse if (unvisited[i] == node)\\n\\t\\t{\\n\\t\\t\\tremoved = 1;\\n\\t\\t}\\n\\t}\\n\\n\\treturn numUnvisited - removed;\\n}\\n\\nint isUnvisited(int node, unsigned int unvisited[], int numUnvisited)\\n{\\n\\tint i;\\n\\tfor (i = 0; i < numUnvisited; i++)\\n\\t{\\n\\t\\tif (unvisited[i] == node)\\n\\t\\t{\\n\\t\\t\\treturn 1;\\n\\t\\t}\\n\\t}\\n\\treturn 0;\\n}\\n\\nint smallestUnvisited(int distance[], unsigned int unvisited[], int numUnvisited)\\n{\\n\\tint smallestDistance = -1;\\n\\tint smallestIndex = -1;\\n\\tint i;\\n\\tfor (i = 0; i < numverts; i++)\\n\\t{\\n\\t\\tif ( ((distance[i] < smallestDistance && distance[i] >= 0) || smallestDistance < 0)\\n\\t\\t\\t\\t&& (isUnvisited(i, unvisited, numUnvisited) == 1))\\n\\t\\t{\\n\\t\\t\\tsmallestDistance = distance[i];\\n\\t\\t\\tsmallestIndex = i;\\n\\t\\t}\\n\\t}\\n\\n\\treturn smallestIndex;\\n}\\n\\nint dijkstra(int edgeWeights[])\\n{\\n\\tint distance[numverts];\\n\\tunsigned int unvisited[numverts];\\n\\tunsigned int currentNode;\\n\\tint numUnvisited;\\n\\tint newDistance, maxSmallestPath;\\n\\tint i, edgeIndex, neighbourIndex;\\n\\n\\tfor (i = 0; i < numverts; i++)\\n\\t{\\n\\t\\tdistance[i] = -1;\\n\\t\\tunvisited[i] = i;\\n\\t}\\n\\tnumUnvisited = numverts;\\n\\n\\tcurrentNode = 0;\\n\\tdistance[currentNode] = 0;\\n\\n\\tmaxSmallestPath = 0;\\t\\n\\tedgeIndex = 0;\\n\\n\\twhile (numUnvisited > 0)\\n\\t{\\n\\t\\tcurrentNode = smallestUnvisited(distance, unvisited, numUnvisited);\\n\\t\\t\\n\\t\\tfor (i = 0; i < 4; i++)\\n\\t\\t{\\n\\t\\t\\tneighbourIndex = neighbours[currentNode][i];\\n\\t\\t\\tif (isUnvisited(neighbourIndex, unvisited, numUnvisited) == 1)\\n\\t\\t\\t{\\n\\t\\t\\t\\tnewDistance = distance[currentNode] + edgeWeights[edgeIndex];\\n\\t\\t\\t\\tedgeIndex++;\\n\\n\\t\\t\\t\\tif (newDistance < distance[neighbourIndex]\\n\\t\\t\\t\\t\\t|| distance[neighbourIndex] == -1)\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tdistance[neighbourIndex] = newDistance;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t\\tnumUnvisited = removeFromUnvisited(currentNode, numUnvisited, unvisited);\\n\\t\\tif (maxSmallestPath < distance[currentNode])\\n\\t\\t{\\n\\t\\t\\tmaxSmallestPath = distance[currentNode];\\n\\t\\t}\\n\\t}\\n\\n\\treturn maxSmallestPath;\\n}\\n\\nint main(int argc, char *argv[])\\n{\\n\\tint edgeWeights[numverts * 2];\\n\\tint i, result;\\n\\n\\t/*\\n\\t * 60 positive integer values must be supplied\\n\\t */\\n\\tif (argc != ((numverts * 2) + 1))\\n\\t{\\n\\t\\treturn 1;\\n\\t}\\n\\n\\tfor (i = 0; i < numverts * 2; i++)\\n\\t{\\n\\t\\tedgeWeights[i] = atoi(argv[i + 1]);\\n\\t\\tif (edgeWeights[i] < 0)\\n\\t\\t{\\n\\t\\t\\treturn 1;\\n\\t\\t}\\n\\t}\\n\\n\\tresult = dijkstra (edgeWeights);\\n\\n\\treturn 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.44462844729423523,\n \"alphanum_fraction\": 0.5153522491455078,\n \"avg_line_length\": 23.4797306060791,\n \"blob_id\": \"dac02dc270f99aa96295b6373cad944613e61d50\",\n \"content_id\": \"4d00ae04a40f1ff9db2bc4194faf68226eccbca9\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 14493,\n \"license_type\": \"no_license\",\n \"max_line_length\": 136,\n \"num_lines\": 592,\n \"path\": \"/DaikonPathInformation/benchmarks/edn.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"\\n#define ARRAY_SIZE 200\\n#define N 100\\n#define ORDER 50\\n\\nvoid\\nvec_mpy1 (short y[], const short x[], short scaler)\\n{\\n#ifdef CBMC\\n//==========> vec_mpy1 : header 10\\nint __count_10_9 = 0;\\nint __count_10_9_L = 0; //Loop counter\\n//==========> vec_mpy1 : header 8\\nint __count_11 = 0;\\nint __count_10_11 = 0;\\n#endif\\n\\n long int i;\\n\\n #ifdef CBMC\\n __count_10_9_L = 0;\\n #endif\\n for (i = 0; i < 150; i++) // 10\\n {\\n #ifdef CBMC\\n __count_10_9_L++;\\n __count_10_9++;\\n #endif\\n y[i] += ((scaler * x[i]) >> 15);\\n }\\n #ifdef CBMC\\n assert(__count_10_9_L <= 151); // Loop counter property\\n __count_10_11++;\\n __count_11++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_10_9 >= 150); // Lower capacity constraint\\nassert(__count_10_9 <= 150); // Upper capacity constraint\\nassert(__count_11 >= 1); // Lower capacity constraint\\nassert(__count_11 <= 1); // Upper capacity constraint\\nassert(__count_10_11 >= 1); // Lower capacity constraint\\nassert(__count_10_11 <= 1); // Upper capacity constraint\\n#endif\\n\\n}\\n\\n/*****************************************************\\n*\\t\\t\\tDot Product\\t *\\n*****************************************************/\\nlong int\\nmac (const short *a, const short *b, long int sqr, long int *sum)\\n{\\n#ifdef CBMC\\n//==========> mac : header 31\\nint __count_31_30 = 0;\\nint __count_31_30_L = 0; //Loop counter\\n//==========> mac : header 29\\nint __count_32 = 0;\\nint __count_31_32 = 0;\\n#endif\\n\\n long int i;\\n long int dotp = *sum;\\n\\n #ifdef CBMC\\n __count_31_30_L = 0;\\n #endif\\n for (i = 0; i < 150; i++) // 31\\n {\\n #ifdef CBMC\\n __count_31_30_L++;\\n __count_31_30++;\\n #endif\\n dotp += b[i] * a[i];\\n sqr += b[i] * b[i];\\n }\\n #ifdef CBMC\\n assert(__count_31_30_L <= 151); // Loop counter property\\n #endif\\n\\n *sum = dotp;\\n #ifdef CBMC\\n __count_31_32++;\\n __count_32++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_32 >= 1); // Lower capacity constraint\\nassert(__count_32 <= 1); // Upper capacity constraint\\nassert(__count_31_32 >= 1); // Lower capacity constraint\\nassert(__count_31_32 <= 1); // Upper capacity constraint\\nassert(__count_31_30 >= 150); // Lower capacity constraint\\nassert(__count_31_30 <= 150); // Upper capacity constraint\\n#endif\\n\\n return sqr;\\n}\\n\\n\\n/*****************************************************\\n*\\t\\tFIR Filter\\t\\t *\\n*****************************************************/\\nvoid\\nfir (const short array1[], const short coeff[], long int output[])\\n{\\n #ifdef CBMC\\n//==========> fir : header 4\\nint __count_4_3 = 0;\\nint __count_4_3_L = 0; //Loop counter\\n//==========> fir : header 6\\nint __count_4_5 = 0;\\nint __count_6_2 = 0; //Loop counter\\n//==========> fir : header 1\\nint __count_7 = 0;\\nint __count_6_7 = 0;\\n #endif\\n long int i, j, sum;\\n\\n #ifdef CBMC\\n __count_6_2 = 0;\\n #endif\\n for (i = 0; i < N - ORDER; i++) // 6\\n {\\n #ifdef CBMC\\n __count_6_2++;\\n #endif\\n sum = 0;\\n #ifdef CBMC\\n __count_4_3_L = 0;\\n #endif\\n for (j = 0; j < ORDER; j++) // 4\\n {\\n #ifdef CBMC\\n __count_4_3_L++;\\n __count_4_3++;\\n #endif\\n sum += array1[i + j] * coeff[j];\\n }\\n #ifdef CBMC\\n assert(__count_4_3_L <= 51); // Loop counter property\\n __count_4_5++;\\n #endif\\n output[i] = sum >> 15;\\n }\\n #ifdef CBMC\\n assert(__count_6_2 <= 51); // Loop counter property\\n __count_6_7++;\\n __count_7++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_4_3 >= 2500); // Lower capacity constraint\\nassert(__count_4_3 <= 2500); // Upper capacity constraint\\nassert(__count_7 >= 1); // Lower capacity constraint\\nassert(__count_7 <= 1); // Upper capacity constraint\\nassert(__count_4_5 >= 50); // Lower capacity constraint\\nassert(__count_4_5 <= 50); // Upper capacity constraint\\nassert(__count_6_7 >= 1); // Lower capacity constraint\\nassert(__count_6_7 <= 1); // Upper capacity constraint\\n#endif\\n\\n}\\n\\n/****************************************************\\n*\\tFIR Filter with Redundant Load Elimination\\n\\t\\t\\t\\t\\t\\t\\nBy doing two outer loops simultaneously, you can potentially reuse data (depending on the DSP architecture).\\nx and h only need to be loaded once, therefore reducing redundant loads.\\nThis reduces memory bandwidth and power.\\n*****************************************************/\\nvoid\\nfir_no_red_ld (const short x[], const short h[], long int y[])\\n{\\n#ifdef CBMC\\n//==========> fir_no_red_ld : header 36\\nint __count_36_35 = 0;\\nint __count_36_35_L = 0; //Loop counter\\n//==========> fir_no_red_ld : header 38\\nint __count_36_37 = 0;\\nint __count_38_34 = 0; //Loop counter\\n//==========> fir_no_red_ld : header 33\\nint __count_39 = 0;\\nint __count_38_39 = 0;\\n#endif\\n\\n long int i, j;\\n long int sum0, sum1;\\n short x0, x1, h0, h1;\\n\\n #ifdef CBMC\\n __count_38_34 = 0;\\n #endif\\n for (j = 0; j < 100; j += 2) // 38\\n {\\n #ifdef CBMC\\n __count_38_34++;\\n #endif\\n sum0 = 0;\\n sum1 = 0;\\n x0 = x[j];\\n #ifdef CBMC\\n __count_36_35_L = 0;\\n #endif\\n for (i = 0; i < 32; i += 2) // 36\\n {\\n #ifdef CBMC\\n __count_36_35_L++;\\n __count_36_35++;\\n #endif\\n x1 = x[j + i + 1];\\n h0 = h[i];\\n sum0 += x0 * h0;\\n sum1 += x1 * h0;\\n x0 = x[j + i + 2];\\n h1 = h[i + 1];\\n sum0 += x1 * h1;\\n sum1 += x0 * h1;\\n }\\n #ifdef CBMC\\n assert(__count_36_35_L <= 17); // Loop counter property\\n __count_36_37++;\\n #endif\\n y[j] = sum0 >> 15;\\n y[j + 1] = sum1 >> 15;\\n }\\n #ifdef CBMC\\n assert(__count_38_34 <= 51); // Loop counter property\\n __count_38_39++;\\n __count_39++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_38_39 >= 1); // Lower capacity constraint\\nassert(__count_38_39 <= 1); // Upper capacity constraint\\nassert(__count_36_35 >= 800); // Lower capacity constraint\\nassert(__count_36_35 <= 800); // Upper capacity constraint\\nassert(__count_36_37 >= 50); // Lower capacity constraint\\nassert(__count_36_37 <= 50); // Upper capacity constraint\\nassert(__count_39 >= 1); // Lower capacity constraint\\nassert(__count_39 <= 1); // Upper capacity constraint\\n#endif\\n\\n}\\n\\n/*******************************************************\\n* Lattice Synthesis\\t \\n* This function doesn't follow the typical DSP multiply two vector operation, \\n* but it will point out the compiler's flexibility \\n********************************************************/\\nlong int\\nlatsynth (short b[], const short k[], long int n, long int f)\\n{\\n#ifdef CBMC\\n//==========> latsynth : header 14\\nint __count_14_13 = 0;\\nint __count_14_13_L = 0; //Loop counter\\n//==========> latsynth : header 12\\nint __count_15 = 0;\\nint __count_14_15 = 0;\\n#endif\\n\\n long int i;\\n\\n f -= b[n - 1] * k[n - 1];\\n #ifdef CBMC\\n __count_14_13_L = 0;\\n #endif\\n for (i = n - 2; i >= 0; i--) // 14\\n {\\n #ifdef CBMC\\n __count_14_13_L++;\\n __count_14_13++;\\n #endif\\n f -= b[i] * k[i];\\n b[i + 1] = b[i] + ((k[i] * (f >> 16)) >> 16);\\n }\\n #ifdef CBMC\\n assert(__count_14_13_L <= 100); // Loop counter property\\n #endif\\n \\n b[0] = f >> 16;\\n #ifdef CBMC\\n __count_14_15++;\\n __count_15++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_14_13 >= 99); // Lower capacity constraint\\nassert(__count_14_13 <= 99); // Upper capacity constraint\\nassert(__count_14_15 >= 1); // Lower capacity constraint\\nassert(__count_14_15 <= 1); // Upper capacity constraint\\nassert(__count_15 >= 1); // Lower capacity constraint\\nassert(__count_15 <= 1); // Upper capacity constraint\\n#endif\\n\\n return f;\\n}\\n\\n/*****************************************************\\n*\\t\\t\\tIIR Filter\\t\\t *\\n*****************************************************/\\nvoid\\niir1 (const short *coefs, const short *input, long int *optr, long int *state)\\n{\\n#ifdef CBMC\\n//==========> iir1 : header 52\\nint __count_52_51 = 0;\\nint __count_52_51_L = 0; //Loop counter\\n//==========> iir1 : header 50\\nint __count_53 = 0;\\nint __count_52_53 = 0;\\n#endif\\n long int x;\\n long int t;\\n long int n;\\n\\n x = input[0];\\n #ifdef CBMC\\n __count_52_51_L = 0;\\n #endif\\n for (n = 0; n < 50; n++) // 52\\n {\\n #ifdef CBMC\\n __count_52_51_L++;\\n __count_52_51++;\\n #endif\\n t = x + ((coefs[2] * state[0] + coefs[3] * state[1]) >> 15);\\n x = t + ((coefs[0] * state[0] + coefs[1] * state[1]) >> 15);\\n state[1] = state[0];\\n state[0] = t;\\n coefs += 4;\\t/* point to next filter coefs */\\n state += 2;\\t/* point to next filter states */\\n }\\n #ifdef CBMC\\n assert(__count_52_51_L <= 51); // Loop counter property\\n #endif\\n\\n *optr++ = x;\\n #ifdef CBMC\\n __count_52_53++;\\n __count_53++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_52_51 >= 50); // Lower capacity constraint\\nassert(__count_52_51 <= 50); // Upper capacity constraint\\nassert(__count_52_53 >= 1); // Lower capacity constraint\\nassert(__count_52_53 <= 1); // Upper capacity constraint\\nassert(__count_53 >= 1); // Lower capacity constraint\\nassert(__count_53 <= 1); // Upper capacity constraint\\n#endif\\n\\n}\\n\\n/*****************************************************\\n*\\tVocoder Codebook Search \\t *\\n*****************************************************/\\nlong int\\ncodebook (long int mask, long int bitchanged, long int numbasis, long int codeword, long int g, const short *d, short ddim, short theta)\\n{\\n#ifdef CBMC\\n//==========> codebook : header 27\\nint __count_27_26 = 0;\\nint __count_27_26_L = 0; //Loop counter\\n//==========> codebook : header 25\\nint __count_28 = 0;\\nint __count_27_28 = 0;\\n#endif\\n\\n long int j;\\n long int tmpMask;\\n\\n tmpMask = mask << 1;\\n #ifdef CBMC\\n __count_27_26_L = 0;\\n #endif\\n for (j = bitchanged + 1; j <= numbasis; j++) // 27\\n {\\n #ifdef CBMC\\n __count_27_26_L++;\\n __count_27_26++;\\n #endif\\n/*\\t\\t\\n * The following code is removed since it gave a memory access exception.\\n * It is OK since the return value does not control the flow.\\n * The loop always iterates a fixed number of times independent of the loop body.\\n \\n if (theta == !(!(codeword & tmpMask)))\\n\\t\\t\\tg += *(d + bitchanged * ddim + j);\\n\\t\\telse\\n\\t\\t\\tg -= *(d + bitchanged * ddim + j);\\n\\t\\ttmpMask <<= 1;\\n*/\\n }\\n #ifdef CBMC\\n assert(__count_27_26_L <= 17); // Loop counter property\\n __count_27_28++;\\n __count_28++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_27_28 >= 1); // Lower capacity constraint\\nassert(__count_27_28 <= 1); // Upper capacity constraint\\nassert(__count_27_26 >= 16); // Lower capacity constraint\\nassert(__count_27_26 <= 16); // Upper capacity constraint\\nassert(__count_28 >= 1); // Lower capacity constraint\\nassert(__count_28 <= 1); // Upper capacity constraint\\n#endif\\n\\n return g;\\n}\\n\\n\\n/*****************************************************\\n*\\t\\tJPEG Discrete Cosine Transform \\n*****************************************************/\\nvoid\\njpegdct(short *d, short *r)\\n{\\n#ifdef CBMC\\n//==========> jpegdct : header 44\\nint __count_44_43 = 0;\\nint __count_44_43_L = 0; //Loop counter\\n//==========> jpegdct : header 46\\nint __count_44_45 = 0;\\nint __count_46_42 = 0; //Loop counter\\n//==========> jpegdct : header 48\\nint __count_46_47 = 0;\\nint __count_48_41 = 0; //Loop counter\\n//==========> jpegdct : header 40\\nint __count_49 = 0;\\nint __count_48_49 = 0;\\n#endif\\n long int t[12];\\n short i, j, k, m, n, p;\\n \\n #ifdef CBMC\\n __count_48_41 = 0;\\n #endif\\n for (k = 1, m = 0, n = 13, p = 8;\\n k <= 8; \\n k += 7, m += 3, n += 3, p -= 7, d -= 64) // 48\\n {\\n #ifdef CBMC\\n __count_48_41++;\\n #endif\\n\\n #ifdef CBMC\\n __count_46_42 = 0;\\n #endif\\n for (i = 0; i < 8; i++, d += p) // 46\\n {\\n #ifdef CBMC\\n __count_46_42++;\\n #endif\\n\\n #ifdef CBMC\\n __count_44_43_L = 0;\\n #endif\\n for (j = 0; j < 4; j++) // 44\\n {\\n #ifdef CBMC\\n __count_44_43_L++;\\n __count_44_43++;\\n #endif\\n t[j] = d[k * j] + d[k * (7 - j)];\\n\\tt[7 - j] = d[k * j] - d[k * (7 - j)];\\n }\\n #ifdef CBMC\\n assert(__count_44_43_L <= 5); // Loop counter property\\n __count_44_45++;\\n #endif\\n \\n t[8] = t[0] + t[3];\\n t[9] = t[0] - t[3];\\n t[10] = t[1] + t[2];\\n t[11] = t[1] - t[2];\\n d[0] = (t[8] + t[10]) >> m;\\n d[4 * k] = (t[8] - t[10]) >> m;\\n t[8] = (short) (t[11] + t[9]) * r[10];\\n d[2 * k] = t[8] + (short) ((t[9] * r[9]) >> n);\\n d[6 * k] = t[8] + (short) ((t[11] * r[11]) >> n);\\n t[0] = (short) (t[4] + t[7]) * r[2];\\n t[1] = (short) (t[5] + t[6]) * r[0];\\n t[2] = t[4] + t[6];\\n t[3] = t[5] + t[7];\\n t[8] = (short) (t[2] + t[3]) * r[8];\\n t[2] = (short) t[2] * r[1] + t[8];\\n t[3] = (short) t[3] * r[3] + t[8];\\n d[7 * k] = (short) (t[4] * r[4] + t[0] + t[2]) >> n;\\n d[5 * k] = (short) (t[5] * r[6] + t[1] + t[3]) >> n;\\n d[3 * k] = (short) (t[6] * r[5] + t[1] + t[2]) >> n;\\n d[1 * k] = (short) (t[7] * r[7] + t[0] + t[3]) >> n;\\n }\\n #ifdef CBMC\\n assert(__count_46_42 <= 9); // Loop counter property\\n __count_46_47++;\\n #endif\\n }\\n #ifdef CBMC\\n assert(__count_48_41 <= 3); // Loop counter property\\n __count_48_49++;\\n __count_49++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_46_47 >= 2); // Lower capacity constraint\\nassert(__count_46_47 <= 2); // Upper capacity constraint\\nassert(__count_48_49 >= 1); // Lower capacity constraint\\nassert(__count_48_49 <= 1); // Upper capacity constraint\\nassert(__count_44_43 >= 64); // Lower capacity constraint\\nassert(__count_44_43 <= 64); // Upper capacity constraint\\nassert(__count_44_45 >= 16); // Lower capacity constraint\\nassert(__count_44_45 <= 16); // Upper capacity constraint\\nassert(__count_49 >= 1); // Lower capacity constraint\\nassert(__count_49 <= 1); // Upper capacity constraint\\n#endif\\n\\n}\\n\\nint\\nedn (short a[], short b[])\\n{\\n#ifdef CBMC\\n//==========> edn : header 16\\nint __count_24 = 0;\\nint __count_16_17 = 0;\\n#endif\\n\\n short c = 0x3;\\n long int output[200];\\n long int d = 0xAAAA;\\n int e[1] = {0xEEEE};\\n\\n vec_mpy1(a, b, c);\\n c = mac(a, b, (long int) c, (long int *) output);\\n fir(a, b, output);\\n fir_no_red_ld(a, b, output);\\n d = latsynth(a, b, N, d);\\n iir1(a, b, &output[100], output);\\n e[0] = codebook(d, 1, 17, e[0], d, a, c, 1);\\n jpegdct(a, b);\\n \\n #ifdef CBMC\\n __count_16_17++;\\n __count_24++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_24 >= 1); // Lower capacity constraint\\nassert(__count_24 <= 1); // Upper capacity constraint\\nassert(__count_16_17 >= 1); // Lower capacity constraint\\nassert(__count_16_17 <= 1); // Upper capacity constraint\\n#endif\\n\\n return e[0];\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{ \\n short a[ARRAY_SIZE];\\n short b[ARRAY_SIZE];\\n int i;\\n int k;\\n \\n /*\\n * Need two arrays of size ARRAY_SIZE\\n */\\n if (argc != 2*ARRAY_SIZE+1)\\n {\\n return 1;\\n }\\n\\n k = 0;\\n for (i = 0; i < ARRAY_SIZE; ++i)\\n {\\n a[i] = (short) atoi (argv[k + 1]);\\n k++;\\n }\\n\\n for (i = 0; i < ARRAY_SIZE; ++i)\\n {\\n b[i] = (short) atoi (argv[k + 1]);\\n k++;\\n }\\n\\n int val = edn (a, b);\\n printf(\\\"%d\\\", val);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.3844011127948761,\n \"alphanum_fraction\": 0.49227651953697205,\n \"avg_line_length\": 20,\n \"blob_id\": \"d5b2b87dc282476efdb7eac6ff432f55d15eb66d\",\n \"content_id\": \"043b22c9f14cecc5413c957dcb0d9d6ae5e9f30b\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 3949,\n \"license_type\": \"no_license\",\n \"max_line_length\": 74,\n \"num_lines\": 188,\n \"path\": \"/DaikonPathInformation/benchmarks/lcdnum.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * LCD number (lcdnum) program taken from MDH suite and modified by Adam Betts\\n * to consume a test vector supplied on the command line.\\n *\\n * For this program, the test vector is a single hexadecimal digit\\n * The input range is therefore [0..15]\\n */\\n\\nunsigned char\\nlcdnum (unsigned char a)\\n{\\n#ifdef CBMC\\n//==========> lcdnum : header 1\\nint __count_20 = 0;\\nint __count_1_19 = 0;\\nint __count_2_4 = 0;\\nint __count_2_5 = 0;\\nint __count_2_6 = 0;\\nint __count_2_9 = 0;\\nint __count_2_12 = 0;\\nint __count_2_13 = 0;\\nint __count_2_14 = 0;\\nint __count_2_17 = 0;\\nint __count_3_20 = 0;\\nint __count_7_20 = 0;\\nint __count_8_20 = 0;\\nint __count_10_20 = 0;\\nint __count_11_20 = 0;\\nint __count_15_20 = 0;\\nint __count_16_20 = 0;\\nint __count_18_20 = 0;\\n#endif\\n switch (a)\\n {\\n case 0x00: // 3\\n #ifdef CBMC\\n __count_3_20++;\\n __count_20++;\\n #endif\\n return 0; //=0\\n case 0x01: // 4\\n #ifdef CBMC\\n __count_2_4++;\\n __count_20++;\\n #endif\\n return 0x24; //=36\\n case 0x02: // 5\\n #ifdef CBMC\\n __count_2_5++;\\n __count_20++;\\n #endif\\n return 1 + 4 + 8 + 16 + 64; //=93\\n case 0x03: // 6\\n #ifdef CBMC\\n __count_2_6++;\\n __count_20++;\\n #endif\\n return 1 + 4 + 8 + 32 + 64; //=109\\n case 0x04: // 7\\n #ifdef CBMC\\n __count_7_20++;\\n __count_20++;\\n #endif\\n return 2 + 4 + 8 + 32; //=46\\n case 0x05: // 8\\n #ifdef CBMC\\n __count_8_20++;\\n __count_20++;\\n #endif\\n return 1 + 4 + 8 + 16 + 64; //=93\\n case 0x06: // 9\\n #ifdef CBMC\\n __count_2_9++;\\n __count_20++;\\n #endif\\n return 1 + 2 + 8 + 16 + 32 + 64; //=123\\n case 0x07: // 10\\n #ifdef CBMC\\n __count_10_20++;\\n __count_20++;\\n #endif\\n return 1 + 4 + 32; //=37\\n case 0x08: // 11\\n #ifdef CBMC\\n __count_11_20++;\\n __count_20++;\\n #endif\\n return 0x7F; /* light all */ //=127\\n case 0x09: // 12\\n #ifdef CBMC\\n __count_2_12++;\\n __count_20++;\\n #endif\\n return 0x0F + 32 + 64; //=111\\n case 0x0A: // 13\\n #ifdef CBMC\\n __count_2_13++;\\n __count_20++;\\n #endif\\n return 0x0F + 16 + 32; //=63\\n case 0x0B: // 14\\n #ifdef CBMC\\n __count_2_14++;\\n __count_20++;\\n #endif\\n return 2 + 8 + 16 + 32 + 64; //=122\\n case 0x0C: // 15\\n #ifdef CBMC\\n __count_15_20++;\\n __count_20++;\\n #endif\\n return 1 + 2 + 16 + 64; //=83\\n case 0x0D: // 16\\n #ifdef CBMC\\n __count_16_20++;\\n __count_20++;\\n #endif\\n return 4 + 8 + 16 + 32 + 64; //=124\\n case 0x0E: // 17\\n #ifdef CBMC\\n __count_2_17++;\\n __count_20++;\\n #endif\\n return 1 + 2 + 8 + 16 + 64; //=91\\n case 0x0F: // 18\\n #ifdef CBMC\\n __count_18_20++;\\n __count_20++;\\n #endif\\n return 1 + 2 + 8 + 16; //=27\\n }\\n\\n // 19\\n #ifdef CBMC\\n __count_1_19++;\\n __count_20++;\\n #endif\\n \\n #ifdef CBMC\\nassert(__count_2_12 <= 1); // Upper capacity constraint\\nassert(__count_2_13 == 0); // Dead code\\nassert(__count_2_14 == 0); // Dead code\\nassert(__count_18_20 <= 1); // Upper capacity constraint\\nassert(__count_3_20 <= 1); // Upper capacity constraint\\nassert(__count_7_20 == 0); // Dead code\\nassert(__count_8_20 <= 1); // Upper capacity constraint\\nassert(__count_10_20 <= 1); // Upper capacity constraint\\nassert(__count_11_20 <= 1); // Upper capacity constraint\\nassert(__count_15_20 <= 1); // Upper capacity constraint\\nassert(__count_16_20 == 0); // Dead code\\n//assert(__count_1_19 == 0); // Execution dependence\\n#endif\\n\\n return 0;\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n int i;\\n volatile unsigned char OUT;\\n unsigned char a;\\n\\n /*\\n * One integer must be supplied\\n */\\n if (argc != 2)\\n {\\n return 1;\\n }\\n\\n a = atoi (argv[1]);\\n \\n #ifdef CBMC\\n __CPROVER_assume(a >= 0 && a <= 15);\\n #endif\\n\\n for (i = 0; i < 10; i++)\\n {\\n if (i < 5)\\n {\\n a = a & 0x0F;\\n OUT = lcdnum(a);\\n }\\n }\\n\\n return 0;\\n}\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.4095940887928009,\n \"alphanum_fraction\": 0.45387452840805054,\n \"avg_line_length\": 11.88888931274414,\n \"blob_id\": \"eb1103fbea0f3a4b717d20cf4978a6b86dc6ccec\",\n \"content_id\": \"cf16e593e50bf1a9183760bbf052a49f243bbfc4\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 813,\n \"license_type\": \"no_license\",\n \"max_line_length\": 31,\n \"num_lines\": 63,\n \"path\": \"/DaikonPathInformation/benchmarks/fibonacci.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"\\nint \\nfibonacci (int n)\\n{\\n #ifdef CBMC\\n int __count_2_9 = 0;\\n int __count_4_9 = 0;\\n int __count_7_6 = 0;\\n int __count_L7 = 0;\\n #endif\\n\\n if (n == 0) // 1 \\n {\\n #ifdef CBMC\\n __count_2_9++;\\n #endif\\n return 0; // 2\\n }\\n if (n == 1) // 3\\n {\\n #ifdef CBMC\\n __count_4_9++;\\n #endif\\n return 1; // 4\\n }\\n\\n// 5\\n int prevPrev = 0;\\n int prev = 1;\\n int result = 0;\\n int i;\\n\\n for (i = 2; \\n #ifdef CBMC\\n __count_L7++,\\n #endif\\n i <= n; i++) // 7\\n {\\n #ifdef CBMC\\n __count_7_6++;\\n #endif\\n result = prev + prevPrev;\\n prevPrev = prev;\\n prev = result;\\n }\\n return result;\\n}\\n\\nint \\nmain (int argc, char *argv[])\\n{\\n int num;\\n\\n if (argc != 2)\\n {\\n return 1;\\n }\\n \\n num = atoi(argv[1]);\\n int val = fibonacci (num);\\n printf(\\\"%d\\\", val);\\n \\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.5148975849151611,\n \"alphanum_fraction\": 0.5325884819030762,\n \"avg_line_length\": 13.319999694824219,\n \"blob_id\": \"0020d6b7d3d1ccad37ec8ec04ce86cd75026f037\",\n \"content_id\": \"4998669d39bbf02656155670654fc613d4772876\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 2148,\n \"license_type\": \"no_license\",\n \"max_line_length\": 82,\n \"num_lines\": 150,\n \"path\": \"/benchmarks/listops/listops.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Takes a vector of poistive integers and returns a calculated value\\n * the value is dependent on the first integer as a different function is selected\\n * based upon the value of this integer\\n */\\n\\nint max(int ARRAY_SIZE, int a[])\\n{\\n\\tint i;\\n\\tint max = -1;\\n\\tfor (i = 0; i < ARRAY_SIZE; i++)\\n\\t{\\n\\t\\tif(a[i] > max)\\n\\t\\t{\\n\\t\\t\\tmax = a[i];\\n\\t\\t}\\n\\t}\\n\\treturn max;\\n}\\n\\nint min(int ARRAY_SIZE, int a[])\\n{\\n\\tint i;\\n\\tint min = -1;\\n\\tfor (i = 0; i < ARRAY_SIZE; i++)\\n\\t{\\n\\t\\tif(a[i] < min || min == -1)\\n\\t\\t{\\n\\t\\t\\tmin = a[i];\\n\\t\\t}\\n\\t}\\n\\treturn min;\\n}\\n\\nint sum(int ARRAY_SIZE, int a[])\\n{\\n\\tint i;\\n\\tint sum = 0;\\n\\tfor (i = 0; i < ARRAY_SIZE; i++)\\n\\t{\\n\\t\\tsum += a[i];\\n\\t}\\n\\treturn sum;\\n}\\n\\nint product(int ARRAY_SIZE, int a[])\\n{\\n\\tint i;\\n\\tint product = 1;\\n\\tfor (i = 0; i < ARRAY_SIZE; i++)\\n\\t{\\n\\t\\tproduct *= a[i];\\n\\t}\\n\\treturn product;\\n}\\n\\nint mean(int ARRAY_SIZE, int a[])\\n{\\n\\tint i;\\n\\tint mean = 0;\\n\\tfor (i = 0; i < ARRAY_SIZE; i++)\\n\\t{\\n\\t\\tmean += a[i];\\n\\t}\\n\\tmean /= ARRAY_SIZE;\\n\\treturn mean;\\n}\\n\\nint median(int ARRAY_SIZE, int a[])\\n{\\n\\tint pos = 1;\\n\\tint temp;\\n\\t\\n\\twhile (pos < ARRAY_SIZE)\\n\\t{\\n\\t\\tif (a[pos] >= a[pos - 1])\\n\\t\\t{\\n\\t\\t\\tpos++;\\n\\t\\t}\\n\\t\\telse\\n\\t\\t{\\n\\t\\t\\t// Swap a[pos] and a[pos - 1]\\n\\t\\t\\ttemp = a[pos];\\n\\t\\t\\ta[pos] = a[pos - 1];\\n\\t\\t\\ta[pos - 1] = temp;\\n\\n\\t\\t\\tif (pos > 1)\\n\\t\\t\\t{\\n\\t\\t\\t\\tpos--;\\n\\t\\t\\t}\\n\\t\\t\\telse\\n\\t\\t\\t{\\n\\t\\t\\t\\tpos++;\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\\n\\n\\tif (ARRAY_SIZE % 2)\\n\\t{\\n\\t\\treturn a[ARRAY_SIZE / 2];\\n\\t}\\n\\telse\\n\\t{\\n\\t\\treturn (a[ARRAY_SIZE / 2] + a[(ARRAY_SIZE / 2) - 1]) / 2;\\n\\t}\\n}\\n\\nint listops(int ARRAY_SIZE, int a[])\\n{\\n\\tint n = a[0] % 6;\\n\\tint result = 0;\\n\\n\\tswitch (n)\\n\\t{\\n\\t\\tcase 0 : result = max(ARRAY_SIZE, a); break;\\n\\t\\tcase 1 : result = min(ARRAY_SIZE, a); break;\\n\\t\\tcase 2 : result = sum(ARRAY_SIZE, a); break;\\n\\t\\tcase 3 : result = product(ARRAY_SIZE, a); break;\\n\\t\\tcase 4 : result = mean(ARRAY_SIZE, a); break;\\n\\t\\tdefault : result = median(ARRAY_SIZE, a); break;\\n\\t}\\n\\n\\treturn result;\\n}\\n\\nint main (int argc, char *argv[])\\n{\\n\\tconst int ARRAY_SIZE = argc - 1;\\n\\tint TV[ARRAY_SIZE];\\n\\tint i;\\n\\n\\t/*\\n\\t * At least one integer value must be supplied\\n\\t */\\n\\tif (argc == 1)\\n\\t{\\n\\t\\treturn 1;\\n\\t}\\n\\n\\tfor (i = 0; i < argc - 1; i++)\\n\\t{\\n\\t\\tTV[i] = atoi (argv[i + 1]);\\n\\t}\\n\\n\\tint result = listops (ARRAY_SIZE, TV);\\n\\n\\t//printf(\\\"%i\\\\n\\\", result);\\n\\n\\treturn 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.494751900434494,\n \"alphanum_fraction\": 0.5429389476776123,\n \"avg_line_length\": 18.773584365844727,\n \"blob_id\": \"d3b113ebaa353fe6ac6471589f52a969a7c355de\",\n \"content_id\": \"ff48ca655d91d1eec36d394cca5bb77b28021402\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 2096,\n \"license_type\": \"no_license\",\n \"max_line_length\": 131,\n \"num_lines\": 106,\n \"path\": \"/benchmarks/crc/crc.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Cyclic Redundancy Check (CRC) taken from MDH suite and modified by Adam\\n * Betts to consume a test vector supplied on the command line.\\n *\\n * For this program, a one-element test vector is expected.\\n */\\n\\ntypedef unsigned char uchar;\\n#define LOBYTE(x) ((uchar)((x) & 0xFF))\\n#define HIBYTE(x) ((uchar)((x) >> 8))\\n\\nunsigned short\\ncrc1 (unsigned char * lin, unsigned short the_crc, unsigned char onech)\\n{\\n int i;\\n unsigned short ans = (the_crc ^ onech << 8);\\n\\n for (i = 0; i < 8; i++)\\n {\\n if (ans & 0x8000)\\n {\\n ans = (ans <<= 1) ^ 4129;\\n }\\n else\\n {\\n ans <<= 1;\\n }\\n }\\n return ans;\\n}\\n\\nunsigned short\\ncrc (unsigned char * lin, unsigned short the_crc, unsigned long len,\\n short jinit, int jrev)\\n{\\n static unsigned short icrctb[256];\\n static unsigned short init = 0;\\n static uchar rchr[256];\\n static uchar it[16] =\\n {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15};\\n\\n unsigned short tmp1;\\n unsigned short tmp2;\\n unsigned short j;\\n unsigned short cword = the_crc;\\n\\n if (!init)\\n {\\n init = 1;\\n for (j = 0; j <= 255; j++)\\n {\\n icrctb[j] = crc1 (lin, j << 8, (uchar) 0);\\n rchr[j] = (uchar) (it[j & 0xF] << 4 | it[j >> 4]);\\n }\\n }\\n\\n if (jinit >= 0)\\n {\\n cword = ((uchar) jinit) | (((uchar) jinit) << 8);\\n }\\n else if (jrev < 0)\\n {\\n cword = rchr[HIBYTE(cword)] | rchr[LOBYTE(cword)] << 8;\\n }\\n\\n for (j = 1; j <= len; j++)\\n {\\n if (jrev < 0)\\n {\\n tmp1 = rchr[lin[j]] ^ HIBYTE(cword);\\n }\\n else\\n {\\n tmp1 = lin[j] ^ HIBYTE(cword);\\n }\\n cword = icrctb[tmp1] ^ LOBYTE(cword) << 8;\\n }\\n\\n if (jrev >= 0)\\n {\\n tmp2 = cword;\\n }\\n else\\n {\\n tmp2 = rchr[HIBYTE(cword)] | rchr[LOBYTE(cword)] << 8;\\n }\\n return (tmp2);\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n unsigned short i1;\\n unsigned short i2;\\n unsigned long n = 40;\\n unsigned char lin[256] = \\\"asdffeagewaHAFEFaeDsFEawFdsFaefaeerdjgp\\\";\\n\\n lin[n + 1] = 0;\\n i1 = crc (lin, 0, n, (short) 0, 1);\\n lin[n + 1] = HIBYTE(i1);\\n lin[n + 2] = LOBYTE(i1);\\n i2 = crc (lin, i1, n + 2, (short) 0, 1);\\n\\n printf (\\\"%d %d %s\\\\n\\\", i1, i2, lin);\\n\\n return 0;\\n}\\n\"\n },\n {\n \"alpha_fraction\": 0.5779114961624146,\n \"alphanum_fraction\": 0.5794411301612854,\n \"avg_line_length\": 36.28897476196289,\n \"blob_id\": \"bcfba2f715fc5388ce81818349bccfc751e50b57\",\n \"content_id\": \"8f66be09589390ee4bbf468a886324a87ed424da\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 9806,\n \"license_type\": \"no_license\",\n \"max_line_length\": 128,\n \"num_lines\": 263,\n \"path\": \"/DaikonPathInformation/src/vertices.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import edges\\nimport shlex\\nimport collections\\n\\ndummyID = 0\\n\\nclass Vertex:\\n def __init__ (self, vertexID):\\n self.vertexID = vertexID\\n self.predecessors = {}\\n self.successors = {}\\n self.dummy = False\\n \\n def add_predecessor(self, predID, edgeID=None):\\n assert predID not in self.predecessors, \\\"Vertex %d already has predecessor %d\\\" % (self.vertexID, predID)\\n e = edges.Edge(predID, edgeID)\\n self.predecessors[predID] = e\\n \\n def add_predecessor_edge(self, prede):\\n assert prede.vertexID not in self.predecessors, \\\"Vertex %d already has predecessor %d\\\" % (self.vertexID, prede.vertexID)\\n self.predecessors[prede.vertexID] = prede\\n \\n def remove_predecessor(self, predID):\\n assert predID in self.predecessors, \\\"Cannot remove %d as it is not in predecessor of %d\\\" % (predID, self.vertexID)\\n del self.predecessors[predID]\\n \\n def number_of_predecessors(self):\\n return len(self.predecessors)\\n \\n def has_predecessor(self, predID):\\n return predID in self.predecessors.keys()\\n \\n def get_predecessor_edge(self, predID):\\n assert predID in self.predecessors, \\\"Vertex %d is not a predecessor of %d\\\" % (predID, self.vertexID)\\n return self.predecessors[predID]\\n \\n def add_successor(self, succID, edgeID=None):\\n assert succID not in self.successors, \\\"Vertex %d already has successor %d\\\" % (self.vertexID, succID)\\n e = edges.Edge(succID, edgeID)\\n self.successors[succID] = e\\n \\n def add_successor_edge(self, succe):\\n assert succe.vertexID not in self.successors, \\\"Vertex %d already has successor %d\\\" % (self.vertexID, succe.vertexID)\\n self.successors[succe.vertexID] = succe\\n \\n def remove_successor(self, succID):\\n assert succID in self.successors, \\\"Cannot remove %d as it is not in successors of %d\\\" % (succID, self.vertexID)\\n del self.successors[succID]\\n \\n def number_of_successors(self):\\n return len(self.successors)\\n \\n def has_successor(self, succID):\\n return succID in self.successors.keys()\\n \\n def get_successor_edge(self, succID):\\n assert succID in self.successors, \\\"Vertex %d is not a successor of %d\\\" % (succID, self.vertexID)\\n return self.successors[succID]\\n \\n def predecessor_string(self):\\n string = \\\"pred = {\\\"\\n count = 1\\n for predID in sorted(self.predecessors.keys()):\\n string += str(predID)\\n if count < len(self.predecessors):\\n string += \\\",\\\"\\n count = count + 1\\n string += \\\"}\\\"\\n return string\\n \\n def successor_string(self): \\n string = \\\"succ = {\\\"\\n count = 1\\n for succID in sorted(self.successors.keys()):\\n string += str(succID)\\n if count < len(self.successors):\\n string += \\\",\\\"\\n count = count + 1\\n string += \\\"}\\\"\\n return string\\n \\n def __str__(self):\\n return \\\"%d: %s %s\\\\n\\\" % (self.vertexID, self.successor_string(), self.predecessor_string())\\n \\nclass TreeVertex(Vertex):\\n def __init__ (self, vertexID):\\n Vertex.__init__(self, vertexID)\\n self.parentID = dummyID\\n self.level = -1\\n \\nclass HeaderVertex(TreeVertex):\\n def __init__ (self, vertexID, headerID):\\n TreeVertex.__init__(self, vertexID)\\n self.headerID = headerID\\n \\nclass CFGVertex(Vertex):\\n def __init__(self, vertexID, name=None):\\n Vertex.__init__(self, vertexID)\\n self.name = name\\n \\nclass CFGEdge(Vertex):\\n def __init__(self, vertexID, predID, succID, name=None):\\n Vertex.__init__(self, vertexID)\\n self.edge = (predID, succID)\\n self.name = name\\n \\n def __str__(self):\\n return \\\"%s%s\\\\n\\\" % (Vertex.__str__(self), self.edge) \\n\\nclass BasicBlock(CFGVertex):\\n class Instruction: \\n @staticmethod \\n def get_instruction(line):\\n lexemes = shlex.split(line.strip())\\n address = None\\n the_instruction = []\\n opcode_found = False\\n for index, lex in enumerate(lexemes):\\n if index == 0:\\n address = int(lex[:-1], 16)\\n else:\\n if lex == ';':\\n # Comment signifies end of parsing\\n break\\n if not opcode_found:\\n if len(lex) != 4:\\n # Some instruction ops can be hexadecimal numbers\\n opcode_found = True\\n else:\\n try:\\n int(lex, 16)\\n except ValueError:\\n opcode_found = True\\n if opcode_found:\\n the_instruction.append(lex)\\n return BasicBlock.Instruction(address, the_instruction)\\n \\n def __init__ (self, address, the_instruction):\\n self.address = address\\n self.the_instruction = the_instruction\\n \\n def __str__(self):\\n return \\\"%s : %s\\\" % (hex(self.address), ' '.join(self.the_instruction))\\n \\n def __init__ (self, vertexID, name=None):\\n CFGVertex.__init__(self, vertexID, name)\\n self.instructions = []\\n self.originalID = self.vertexID\\n \\nclass CallGraphVertex (Vertex):\\n def __init__ (self, vertexID, name):\\n Vertex.__init__(self, vertexID)\\n self.name = name\\n \\n def add_predecessor(self, predID, call_siteID):\\n if predID not in self.predecessors:\\n the_edge = edges.CallGraphEdge(predID)\\n self.predecessors[predID] = the_edge\\n the_edge = self.predecessors[predID]\\n the_edge.call_sites.add(call_siteID)\\n \\n def add_successor(self, succID, call_siteID):\\n if succID not in self.successors:\\n the_edge = edges.CallGraphEdge(succID)\\n self.successors[succID] = the_edge\\n the_edge = self.successors[succID]\\n the_edge.call_sites.add(call_siteID)\\n \\n def get_successor_with_call_site(self, call_siteID):\\n for succe in self.getSuccessoredges():\\n if call_siteID in succe.getCallSites():\\n return succe.vertexID\\n assert False, \\\"Unable to find successor of context %d with call site %d\\\" % (self._vertexID, call_siteID)\\n \\n def __str__ (self):\\n return \\\"%s\\\\n%s\\\" % (self.name, Vertex.__str__(self))\\n \\nclass SuperBlock(Vertex):\\n def __init__(self, vertexID, headerID):\\n Vertex.__init__(self, vertexID)\\n self.headerID = headerID\\n self.program_points = []\\n self.representative = None\\n self.successor_partitions = collections.OrderedDict()\\n self.exit_edge = False\\n \\nclass PathInformationVertex:\\n def __init__ (self, vertexID, programPoint, headerID):\\n self.vertexID = vertexID\\n self._programPoint = programPoint\\n self._headerID = headerID\\n self._counterForHeaderIDs = set([])\\n self._successors = {}\\n self._successors[edges.PathInformationEdgeType.CAPACITY_BOUNDS] = []\\n self._successors[edges.PathInformationEdgeType.LOOP_BOUNDS] = []\\n self._successors[edges.PathInformationEdgeType.EXCLUSION] = set([])\\n self._successors[edges.PathInformationEdgeType.INCLUSION] = set([])\\n \\n def getProgramPoint (self):\\n return self._programPoint\\n\\n def getHeaderID (self):\\n return self._headerID\\n \\n def setCounterForHeaders (self, headerIDs):\\n assert isinstance(headerIDs, set)\\n self._counterForHeaderIDs = headerIDs\\n \\n def getHeaderIDsForWhichToCount (self):\\n return self._counterForHeaderIDs\\n \\n def isEffectiveHeaderCounter (self):\\n return len(self._counterForHeaderIDs) > 0\\n \\n def addSuccessorEdge (self, succID, edgeType):\\n if edgeType == edges.PathInformationEdgeType.LOOP_BOUNDS:\\n succe = edges.LoopBoundEdge(succID)\\n self._successors[edgeType].append(succe)\\n elif edgeType == edges.PathInformationEdgeType.CAPACITY_BOUNDS:\\n succe = edges.CapacityBoundEdge(succID)\\n self._successors[edgeType].append(succe)\\n else:\\n succe = edges.PathInformationEdge(succID, edgeType)\\n self._successors[edgeType].add(succe)\\n \\n def removeSuccessorEdge (self, succID, edgeType):\\n theEdge = None\\n for succe in self._successors[edgeType]:\\n if succe.vertexID == succID:\\n theEdge = succe\\n break\\n if theEdge:\\n self._successors[edgeType].remove(succe)\\n \\n def hasSuccessorEdge (self, succID, edgeType):\\n for succe in self._successors[edgeType]:\\n if succe.vertexID == succID:\\n return True\\n return False\\n \\n def hasSuccessoredges (self, edgeType):\\n return len(self._successors[edgeType]) > 0\\n \\n def getSuccessorEdge (self, succID, edgeType):\\n for succe in self._successors[edgeType]:\\n if succe.vertexID == succID:\\n return succe\\n assert False\\n \\n def getSuccessoredges (self, edgeType):\\n return self._successors[edgeType]\\n \\n def numberOfSuccessors (self, edgeType=None):\\n if edgeType:\\n return len(self._successors[edgeType])\\n return len(self._successors)\\n \\n def removeAllSuccessors (self):\\n self._successors[edges.PathInformationEdgeType.EXCLUSION] = set([])\\n self._successors[edges.PathInformationEdgeType.INCLUSION] = set([])\\n \\n def __str__ (self):\\n return str(self._programPoint)\"\n },\n {\n \"alpha_fraction\": 0.5173511505126953,\n \"alphanum_fraction\": 0.5593760013580322,\n \"avg_line_length\": 21.589927673339844,\n \"blob_id\": \"1b2e98bd549c82210ccf4069a20b51186b929904\",\n \"content_id\": \"178f5a83f5418d690ed56c23af3fb98242e6663f\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 3141,\n \"license_type\": \"no_license\",\n \"max_line_length\": 91,\n \"num_lines\": 139,\n \"path\": \"/DaikonPathInformation/benchmarks/matrixmultiply.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Matrix multiplication taken from MDH suite and modified by Adam Betts to\\n * consume a test vector supplied on the command line.\\n *\\n * For this program, the test vector consists of 25 integers since there are\\n * two 5*5 matrices to be initialised before multiplication.\\n */\\n\\n#define UPPERLIMIT 5\\ntypedef int matrix[UPPERLIMIT][UPPERLIMIT];\\n\\nint\\nmatrixmultiply (matrix A, matrix B, matrix C)\\n{\\n#ifdef CBMC\\n//==========> matrixmultiply : header 5\\nint __count_5_4 = 0;\\nint __count_5_4_L = 0; //Loop counter\\n//==========> matrixmultiply : header 7\\nint __count_5_6 = 0;\\nint __count_7_3 = 0; //Loop counter\\n//==========> matrixmultiply : header 9\\nint __count_7_8 = 0;\\nint __count_9_2 = 0; //Loop counter\\n//==========> matrixmultiply : header 1\\nint __count_10 = 0;\\nint __count_9_10 = 0;\\n#endif\\n\\n int i, j, k;\\n\\n #ifdef CBMC\\n __count_9_2 = 0;\\n #endif\\n for (i = 0; i < UPPERLIMIT; ++i) // 9\\n {\\n #ifdef CBMC\\n __count_9_2++;\\n #endif\\n\\n #ifdef CBMC\\n __count_7_3 = 0;\\n #endif\\n for (j = 0; j < UPPERLIMIT; ++j) // 7\\n {\\n #ifdef CBMC\\n __count_7_3++;\\n #endif\\n C[i][j] = 0;\\n #ifdef CBMC\\n __count_5_4_L = 0;\\n #endif\\n for (k = 0; k < UPPERLIMIT; ++k) // 5\\n {\\n #ifdef CBMC\\n __count_5_4++;\\n __count_5_4_L++;\\n #endif\\n C[i][j] += A[j][k] * B[k][j];\\n }\\n #ifdef CBMC\\n assert(__count_5_4_L <= 6); // Loop counter property\\n __count_5_6++;\\n #endif\\n }\\n #ifdef CBMC\\n assert(__count_7_3 <= 6); // Loop counter property\\n __count_7_8++;\\n #endif\\n }\\n #ifdef CBMC\\n assert(__count_9_2 <= 6); // Loop counter property\\n __count_9_10++;\\n __count_10++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_5_6 >= 25); // Lower capacity constraint\\nassert(__count_5_6 <= 25); // Upper capacity constraint\\nassert(__count_7_8 >= 5); // Lower capacity constraint\\nassert(__count_7_8 <= 5); // Upper capacity constraint\\nassert(__count_10 >= 1); // Lower capacity constraint\\nassert(__count_10 <= 1); // Upper capacity constraint\\nassert(__count_9_10 >= 1); // Lower capacity constraint\\nassert(__count_9_10 <= 1); // Upper capacity constraint\\nassert(__count_5_4 >= 125); // Lower capacity constraint\\nassert(__count_5_4 <= 125); // Upper capacity constraint\\n#endif\\n\\n return C[0][0];\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n int i, j, k;\\n matrix A, B, C;\\n\\n /*\\n * There are 2 matrices with UPPERLIMIT*UPPERLIMIT dimensions that need to be filled up.\\n * 2*UPPERLIMIT*UPPERLIMIT values need to be passed on the command-line as a consequence.\\n */\\n if (argc != 2*UPPERLIMIT*UPPERLIMIT+1)\\n {\\n return 1;\\n }\\n\\n /*\\n * Initialise matrix A.\\n */\\n k = 0;\\n for (i = 0; i < UPPERLIMIT; ++i)\\n {\\n for (j = 0; j < UPPERLIMIT; ++j)\\n {\\n A[i][j] = atoi (argv[k + 1]);\\n k++;\\n }\\n }\\n\\n /*\\n * Initialise matrix B but do NOT reset the value of k as it now refers\\n * to the 400th element of the command-line.\\n */\\n for (i = 0; i < UPPERLIMIT; ++i)\\n {\\n for (j = 0; j < UPPERLIMIT; ++j)\\n {\\n B[i][j] = atoi (argv[k + 1]);\\n k++;\\n }\\n }\\n\\n int val = matrixmultiply (A, B, C);\\n \\n printf(\\\"%d\\\", val);\\n\\n return 0;\\n}\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.5683327913284302,\n \"alphanum_fraction\": 0.5711506009101868,\n \"avg_line_length\": 41.09321975708008,\n \"blob_id\": \"9cbb727e5fbe6eb5907330a3ed44f6535d76b7e0\",\n \"content_id\": \"d86574079e743f1d79b89eafba7849e6ca13da9a\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 14905,\n \"license_type\": \"no_license\",\n \"max_line_length\": 129,\n \"num_lines\": 354,\n \"path\": \"/GPUTimingAnalysis/src/Trees.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from DirectedGraphs import DirectedGraph, dummyVertexID\\nfrom Vertices import TreeVertex, HeaderVertex, Ipoint\\nimport Debug\\n\\nclass Tree (DirectedGraph):\\n def __init__ (self):\\n DirectedGraph.__init__(self)\\n self._rootID = dummyVertexID\\n \\n def setRootID (self, rootID):\\n assert rootID > dummyVertexID, \\\"Invalid root ID %d. It must be a positive integer\\\" % rootID\\n assert rootID in self.vertices, \\\"Cannot find vertex %d\\\"\\n self._rootID = rootID\\n \\n def getRootID (self):\\n assert self._rootID != dummyVertexID, \\\"Root ID has not yet been set\\\"\\n return self._rootID\\n \\n def addVertex (self, vertexID):\\n assert vertexID not in self.vertices, \\\"Adding vertex %d which is already in tree\\\" % vertexID\\n treev = TreeVertex(vertexID)\\n self.vertices[vertexID] = treev\\n \\n def addEdge (self, predID, succID):\\n DirectedGraph.addEdge(self, predID, succID)\\n succv = self.getVertex(succID)\\n succv.setParentID(predID)\\n \\n def isInternalVertex (self, vertexID):\\n return self.getVertex(vertexID).numberOfSuccessors() > 0\\n \\n def levelIterator (self, up=True):\\n rootv = self.getVertex(self.getRootID())\\n rootv.setLevel(0)\\n queue = [rootv]\\n levelToVertices = {}\\n while queue:\\n v = queue.pop()\\n for succID in v.getSuccessorIDs():\\n queue.insert(0, self.getVertex(succID))\\n \\n if v.getVertexID() == self.getRootID():\\n levelToVertices[0] = [rootv]\\n else:\\n newLevel = self.getVertex(v.getParentID()).getLevel() + 1\\n v.setLevel(newLevel)\\n if newLevel not in levelToVertices.keys():\\n levelToVertices[newLevel] = []\\n levelToVertices[newLevel].append(v)\\n \\n if up:\\n for level in reversed(sorted(levelToVertices.keys())):\\n yield level, levelToVertices[level]\\n else:\\n for level in sorted(levelToVertices.keys()):\\n yield level, levelToVertices[level]\\n \\nclass DepthFirstSearch (Tree):\\n def __init__(self, directedg, rootID):\\n assert rootID in directedg.vertices.keys(), \\\"Unable to find vertex %d from which to initiate depth-first search\\\" % rootID\\n Tree.__init__(self)\\n self.__preorder = []\\n self.__postorder = []\\n self.__preorderID = 1\\n self.__postorderID = 1\\n self.__vertexID2PreID = {}\\n self.__vertexID2PostID = {}\\n self.__backedges = []\\n self.initialise (directedg)\\n self.setRootID(rootID)\\n self.doSearch (directedg, rootID)\\n \\n def initialise (self, directedg):\\n for v in directedg:\\n vertexID = v.getVertexID()\\n self.vertices[vertexID] = TreeVertex(vertexID)\\n self.__vertexID2PreID[vertexID] = 0\\n self.__vertexID2PostID[vertexID] = 0\\n \\n def doSearch (self, directedg, vertexID):\\n self.__vertexID2PreID[vertexID] = self.__preorderID\\n self.__preorder.append(vertexID)\\n self.__preorderID += 1\\n \\n v = directedg.getVertex(vertexID)\\n for succID in v.getSuccessorIDs ():\\n if self.__vertexID2PreID[succID] == 0:\\n self.addEdge(vertexID, succID)\\n self.doSearch(directedg, succID)\\n elif self.__vertexID2PreID[vertexID] < self.__vertexID2PreID[succID]:\\n pass\\n elif self.__vertexID2PostID[succID] == 0:\\n self.__backedges.append([vertexID, succID])\\n \\n self.__vertexID2PostID[vertexID] = self.__postorderID\\n self.__postorder.append(vertexID)\\n self.__postorderID += 1\\n \\n def getPreorder (self):\\n return self.__preorder\\n \\n def getPostorder (self):\\n return self.__postorder\\n \\n def getPreorderVertexID (self, preID):\\n assert preID - 1 < len(self.__postorder), \\\"Pre-order number %d too high\\\" % preID\\n return self.__preorder[preID-1]\\n \\n def getPostorderVertexID (self, postID):\\n assert postID - 1 < len(self.__postorder), \\\"Post-order number %d too high\\\" % postID\\n return self.__postorder[postID-1]\\n \\n def getPreID (self, vertexID):\\n assert vertexID in self.__vertexID2PreID, \\\"Unable to find pre-order numbering for vertex %d\\\" % vertexID\\n return self.__vertexID2PreID[vertexID]\\n \\n def getPostID (self, vertexID):\\n assert vertexID in self.__vertexID2PostID, \\\"Unable to find post-order numbering for vertex %d\\\" % vertexID\\n return self.__vertexID2PostID[vertexID]\\n \\n def isDFSBackedge (self, sourceID, destinationID):\\n return [sourceID, destinationID] in self.__backedges\\n \\nclass Dominators (Tree):\\n def __init__(self, directedg, rootID):\\n assert rootID in directedg.vertices.keys(), \\\"Unable to find vertex %d from which to initiate depth-first search\\\" % rootID\\n Tree.__init__(self)\\n self.__directedg = directedg\\n self.__immediateDom = {}\\n self._initialise (rootID)\\n self._solveDFF ()\\n self._addEdges ()\\n \\n def _initialise (self, rootID):\\n for v in self.__directedg:\\n vertexID = v.getVertexID() \\n self.vertices[vertexID] = TreeVertex(vertexID)\\n if vertexID == rootID:\\n self.__immediateDom[vertexID] = vertexID\\n else:\\n self.__immediateDom[vertexID] = dummyVertexID\\n self.setRootID(rootID)\\n \\n def _solveDFF (self):\\n dfs = DepthFirstSearch(self.__directedg, self._rootID)\\n changed = True\\n while changed:\\n changed = False\\n postID = self.__directedg.numOfVertices()\\n while postID >= 1:\\n vertexID = dfs.getPostorderVertexID(postID)\\n if vertexID != self._rootID:\\n v = self.__directedg.getVertex(vertexID)\\n processedPredID = dummyVertexID\\n newIdomID = dummyVertexID\\n \\n for predID in v.getPredecessorIDs():\\n if self.__immediateDom[predID] != dummyVertexID:\\n processedPredID = predID\\n newIdomID = processedPredID\\n for predID in v.getPredecessorIDs():\\n if predID != processedPredID:\\n if self.__immediateDom[predID] != dummyVertexID:\\n newIdomID = self._intersect(dfs, predID, newIdomID)\\n \\n if newIdomID != dummyVertexID:\\n if self.__immediateDom[vertexID] != newIdomID:\\n changed = True\\n self.__immediateDom[vertexID] = newIdomID\\n postID -= 1\\n \\n def _intersect (self, dfs, left, right):\\n uID = left\\n vID = right\\n while (dfs.getPostID(uID) != dfs.getPostID(vID)):\\n while (dfs.getPostID(uID) < dfs.getPostID(vID)):\\n uID = self.__immediateDom[uID]\\n while (dfs.getPostID(vID) < dfs.getPostID(uID)):\\n vID = self.__immediateDom[vID]\\n return uID\\n \\n def _addEdges (self):\\n for v in self.__directedg:\\n vertexID = v.getVertexID()\\n if vertexID != self._rootID:\\n assert self.__immediateDom[vertexID] != dummyVertexID, \\\"Immediate dominator of %d not set\\\" % vertexID\\n self.addEdge(self.__immediateDom[vertexID], vertexID)\\n \\nclass LoopNests (Tree):\\n def __init__(self, directedg, rootID):\\n assert rootID in directedg.vertices.keys(), \\\"Unable to find vertex %d from which to initiate depth-first search\\\" % rootID\\n Tree.__init__(self)\\n self.__directedg = directedg\\n self.__parent = {}\\n self.__loopBodies = {}\\n self.__loopTails = {}\\n self.__headerVertices = {}\\n self.__loopExits = {}\\n self.__selfLoopHeaders = []\\n self._initialise ()\\n self._findLoops (rootID)\\n self._findExits ()\\n # Set the tree root ID to the header vertex representing the root of the \\n # directed graph\\n self.setRootID(self.__headerVertices[rootID])\\n \\n def _initialise (self):\\n for v in self.__directedg:\\n vertexID = v.getVertexID()\\n self.__parent[vertexID] = vertexID\\n self.vertices[vertexID] = TreeVertex(vertexID)\\n \\n def _findLoops (self, rootID):\\n dfs = DepthFirstSearch (self.__directedg, rootID)\\n for vertexID in reversed(dfs.getPreorder()):\\n v = self.__directedg.getVertex(vertexID)\\n worklist = []\\n for predID in v.getPredecessorIDs():\\n if dfs.isDFSBackedge(predID, vertexID):\\n if predID == vertexID:\\n Debug.debugMessage(\\\"%s => %s is a loop-back edge of trivial loop\\\" % (predID, vertexID), 3)\\n self._addSelfLoop (vertexID)\\n else:\\n Debug.debugMessage(\\\"%s => %s is a loop-back edge of non-trivial loop\\\" % (predID, vertexID), 3)\\n worklist.append(self.__parent[predID])\\n \\n if worklist:\\n self._findLoop (dfs, worklist, vertexID)\\n \\n def _addSelfLoop (self, headerID):\\n newVertexID = self.getNextVertexID()\\n headerv = HeaderVertex(newVertexID, headerID)\\n self.vertices[newVertexID] = headerv\\n self.__headerVertices[headerID] = newVertexID\\n self.__loopTails[headerID] = [headerID]\\n self.__loopBodies[headerID] = [headerID]\\n self.__selfLoopHeaders.append(headerID)\\n self.addEdge(newVertexID, headerID)\\n \\n def _findLoop (self, dfs, worklist, headerID):\\n if headerID not in self.__headerVertices.keys():\\n newVertexID = self.getNextVertexID()\\n headerv = HeaderVertex(newVertexID, headerID)\\n self.vertices[newVertexID] = headerv\\n self.__headerVertices[headerID] = newVertexID\\n self.__loopTails[headerID] = [t for t in worklist]\\n else:\\n self.__loopTails[headerID].extend([t for t in worklist])\\n \\n loopBody = []\\n while worklist:\\n listID = worklist[-1]\\n del worklist[-1]\\n loopBody.append(listID)\\n \\n v = self.__directedg.getVertex(listID)\\n for predID in v.getPredecessorIDs():\\n if not dfs.isDFSBackedge(predID, listID):\\n repID = self.__parent[predID]\\n if repID not in worklist and repID not in loopBody and repID != headerID:\\n worklist.append(repID)\\n \\n if loopBody:\\n parentID = self.__headerVertices[headerID]\\n for vertexID in loopBody:\\n self.__parent[vertexID] = headerID\\n if vertexID in self.__headerVertices.keys():\\n childID = self.__headerVertices[vertexID]\\n self.addEdge(parentID, childID)\\n else:\\n self.addEdge(parentID, vertexID)\\n self.addEdge(parentID, headerID)\\n self.__loopBodies[headerID] = [headerID]\\n self.__loopBodies[headerID].extend([v for v in loopBody])\\n \\n def _findExits (self):\\n for headerID in self.__headerVertices.keys():\\n self.__loopExits[headerID] = []\\n for vertexID in self.__loopBodies[headerID]:\\n v = self.__directedg.getVertex(vertexID)\\n for succID in v.getSuccessorIDs():\\n if succID not in self.__loopBodies[headerID]:\\n if headerID != vertexID and self.isLoopHeader(vertexID):\\n if succID not in self.__loopBodies[vertexID]:\\n self.__loopExits[headerID].append(vertexID)\\n else:\\n self.__loopExits[headerID].append(vertexID)\\n Debug.debugMessage(\\\"Exits of %s = %s\\\" % (headerID, self.__loopExits[headerID]), 4)\\n \\n def __str__ (self):\\n string = \\\"*\\\" * 20 + \\\" LNT Output \\\" + \\\"*\\\" * 20 + \\\"\\\\n\\\"\\n for v in self.vertices.values():\\n string += v.__str__()\\n return string\\n \\n def isLoopHeader (self, vertexID):\\n return vertexID in self.__headerVertices.keys()\\n \\n def getInternalHeaderVertex (self, vertexID):\\n v = self.getVertex(vertexID)\\n assert isinstance(v, HeaderVertex), \\\"Vertex %s of LNT is not an internal header vertex\\\" % vertexID\\n return v\\n \\n def isSelfLoopHeader (self, vertexID):\\n return vertexID in self.__selfLoopHeaders\\n \\n def getHeaderIDs (self):\\n return self.__headerVertices.keys()\\n \\n def getNumberOfHeaders (self):\\n return len(self.__headerVertices.keys())\\n \\n def getNumberOfSelfLoopHeaders (self):\\n return len(self.__selfLoopHeaders)\\n \\n def getSelfLoopHeaderIDs (self):\\n return self.__selfLoopHeaders\\n \\n def getLoopTails (self, headerID):\\n assert headerID in self.__headerVertices.keys(), \\\"Vertex %s is not a loop header\\\" % headerID\\n return self.__loopTails[headerID]\\n \\n def numberOfLoopTails (self, headerID):\\n assert headerID in self.__headerVertices.keys(), \\\"Vertex %s is not a loop header\\\" % headerID\\n return len(self.__loopTails[headerID])\\n \\n def getLoopExits (self, headerID):\\n assert headerID in self.__headerVertices.keys(), \\\"Vertex %s is not a loop header\\\" % headerID\\n return self.__loopExits[headerID]\\n \\n def getLoopBody (self, headerID):\\n assert headerID in self.__headerVertices.keys(), \\\"Vertex %s is not a loop header\\\" % headerID\\n return self.__loopBodies[headerID]\\n \\n def getIpointsInLoopBody (self, headerID):\\n assert headerID in self.__headerVertices.keys(), \\\"Vertex %s is not a loop header\\\" % headerID\\n return [vertexID for vertexID in self.__loopBodies[headerID] \\n if isinstance(self.__directedg.getVertex(vertexID), Ipoint)]\\n \\n def isLoopBackEdge (self, sourceID, destinationID):\\n if destinationID not in self.__headerVertices.keys():\\n return False\\n else:\\n return sourceID in self.__loopTails[destinationID]\\n \\n def isLoopExitOfLoop (self, vertexID, headerID):\\n assert headerID in self.__headerVertices.keys(), \\\"Vertex %s is not a loop header\\\" % headerID\\n return vertexID in self.__loopExits[headerID]\\n \\n def isLoopExit (self, vertexID):\\n for headerID in self.__headerVertices:\\n if self.isLoopExitOfLoop(vertexID, headerID):\\n return True\\n return False\\n \"\n },\n {\n \"alpha_fraction\": 0.4676036238670349,\n \"alphanum_fraction\": 0.5440685749053955,\n \"avg_line_length\": 27.16778564453125,\n \"blob_id\": \"92a411255ecc2210040326e8690d03336ffc3d4d\",\n \"content_id\": \"6cb597f2807b7ed2c797b25b5f73ac9a8b8444a5\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 4198,\n \"license_type\": \"no_license\",\n \"max_line_length\": 73,\n \"num_lines\": 149,\n \"path\": \"/DaikonPathInformation/benchmarks/janne_complex.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Janne Complex taken from MDH suite and modified by Adam Betts to consume a\\n * test vector supplied on the command line.\\n *\\n * For this program, a two-element test vector is expected.\\n */\\n\\nint\\njanne_complex (int a, int b)\\n{\\n#ifdef CBMC\\n//==========> janne_complex : header 9\\nint __count_2_3 = 0;\\nint __count_2_4 = 0;\\nint __count_5_8 = 0;\\nint __count_6_7 = 0;\\nint __count_6_8 = 0;\\nint __count_9_2 = 0; //Loop counter\\n//==========> janne_complex : header 11\\nint __count_9_10 = 0;\\nint __count_11_9 = 0; //Loop counter\\n//==========> janne_complex : header 1\\nint __count_12 = 0;\\nint __count_11_12 = 0;\\n#endif\\n #ifdef CBMC\\n __count_11_9 = 0;\\n #endif\\n while (a < 30) // 11\\n {\\n #ifdef CBMC\\n __count_11_9++;\\n #endif\\n\\n #ifdef CBMC\\n __count_9_2 = 0;\\n #endif\\n while (b < a) // 9\\n {\\n #ifdef CBMC\\n __count_9_2++;\\n #endif\\n if (b > 5) // 2\\n {\\n #ifdef CBMC\\n __count_2_3++;\\n #endif\\n b = b * 3; // 3\\n }\\n else\\n {\\n #ifdef CBMC\\n __count_2_4++;\\n #endif\\n b = b + 2; // 4\\n }\\n \\n if (b >= 10 && b <= 12) // 5, 6\\n {\\n #ifdef CBMC\\n __count_6_7++;\\n #endif\\n a = a + 10; // 7\\n }\\n else\\n {\\n #ifdef CBMC\\n if (b >= 10) __count_6_8++;\\n else __count_5_8++;\\n #endif\\n a = a + 1; // 8\\n }\\n }\\n #ifdef CBMC\\n assert(__count_9_2 <= 7); // Loop counter property\\n __count_9_10++;\\n #endif\\n a = a + 2;\\n b = b - 10;\\n }\\n #ifdef CBMC\\n assert(__count_11_9 <= 11); // Loop counter property\\n __count_11_12++;\\n __count_12++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_12 >= 1); // Lower capacity constraint\\nassert(__count_12 <= 1); // Upper capacity constraint\\nassert(__count_2_3 <= 5); // Upper capacity constraint\\nassert(__count_2_4 <= 7); // Upper capacity constraint\\nassert(__count_5_8 <= 7); // Upper capacity constraint\\nassert(__count_6_8 <= 5); // Upper capacity constraint\\nassert(__count_6_7 == 0); // Dead code\\nassert(__count_9_10 <= 10); // Upper capacity constraint\\nassert(__count_11_12 >= 1); // Lower capacity constraint\\nassert(__count_11_12 <= 1); // Upper capacity constraint\\nassert(__count_2_3 > 0 ==> __count_6_8 > 0); // Mutual inclusion\\nassert(__count_6_8 > 0 ==> __count_2_3 > 0); // Mutual inclusion\\nassert(__count_2_3 > 0 ==> __count_9_10 > 0); // Mutual inclusion\\nassert(__count_9_10 > 0 ==> __count_2_3 > 0); // Mutual inclusion\\nassert(__count_2_4 > 0 ==> __count_5_8 > 0); // Mutual inclusion\\nassert(__count_5_8 > 0 ==> __count_2_4 > 0); // Mutual inclusion\\nassert(__count_6_8 > 0 ==> __count_9_10 > 0); // Mutual inclusion\\nassert(__count_9_10 > 0 ==> __count_6_8 > 0); // Mutual inclusion\\nassert(__count_2_3 > 0 ==> __count_12 > 0); // Execution dependence\\nassert(__count_2_3 > 0 ==> __count_11_12 > 0); // Execution dependence\\nassert(__count_2_4 > 0 ==> __count_12 > 0); // Execution dependence\\nassert(__count_2_4 > 0 ==> __count_2_3 > 0); // Execution dependence\\nassert(__count_2_4 > 0 ==> __count_6_8 > 0); // Execution dependence\\nassert(__count_2_4 > 0 ==> __count_9_10 > 0); // Execution dependence\\nassert(__count_2_4 > 0 ==> __count_11_12 > 0); // Execution dependence\\nassert(__count_5_8 > 0 ==> __count_12 > 0); // Execution dependence\\nassert(__count_5_8 > 0 ==> __count_2_3 > 0); // Execution dependence\\nassert(__count_5_8 > 0 ==> __count_6_8 > 0); // Execution dependence\\nassert(__count_5_8 > 0 ==> __count_9_10 > 0); // Execution dependence\\nassert(__count_5_8 > 0 ==> __count_11_12 > 0); // Execution dependence\\nassert(__count_6_8 > 0 ==> __count_12 > 0); // Execution dependence\\nassert(__count_6_8 > 0 ==> __count_11_12 > 0); // Execution dependence\\nassert(__count_9_10 > 0 ==> __count_12 > 0); // Execution dependence\\nassert(__count_9_10 > 0 ==> __count_11_12 > 0); // Execution dependence\\n#endif\\n\\n return a;\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n /*\\n * Two integer values must be supplied\\n */\\n if (argc != 3)\\n {\\n return 1;\\n }\\n \\n int arg1 = atoi(argv[1]);\\n int arg2 = atoi(argv[2]);\\n \\n #ifdef CBMC\\n __CPROVER_assume(arg1 >= 1 && arg1 <= 50);\\n __CPROVER_assume(arg1 >= 2 && arg2 <= 50);\\n #endif\\n\\n int val = janne_complex (arg1, arg2);\\n\\n return 0;\\n}\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.5290416479110718,\n \"alphanum_fraction\": 0.576153576374054,\n \"avg_line_length\": 20.135713577270508,\n \"blob_id\": \"54760021a0e18850adf531e4e260b4c1f3246ae3\",\n \"content_id\": \"aa42243c065bffa845d1610be25db0a753e024da\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 6198,\n \"license_type\": \"no_license\",\n \"max_line_length\": 80,\n \"num_lines\": 280,\n \"path\": \"/DaikonPathInformation/benchmarks/statistics.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\r\\n * Statistics program taken from MDH suite and modified by Adam Betts to consume a\\r\\n * test vector supplied on the command line.\\r\\n *\\r\\n * For this program, the test vector is a list of doubles.\\r\\n * There must be an even number of doubles on the command line because there are\\r\\n * two arrays to fill, each of the same dimension.\\r\\n *\\r\\n * Unfortunately the 'math' header file is needed for the 'sqrt' function.\\r\\n * To compile and link correctly do:\\r\\n * 'gcc -lm -o st.c'\\r\\n */\\r\\n\\r\\nfloat sqrt(const double x) \\r\\n{\\r\\n#ifdef CBMC\\r\\n//==========> sqrt : header 15\\r\\nint __count_15 = 0;\\r\\n#endif\\r\\n union\\r\\n {\\r\\n int i;\\r\\n double x;\\r\\n } u;\\r\\n\\r\\n u.x = x;\\r\\n u.i = (1<<29) + (u.i >> 1) - (1<<22); \\r\\n #ifdef CBMC\\r\\n __count_15++;\\r\\n #endif\\r\\n\\r\\n#ifdef CBMC\\r\\nassert(__count_15 >= 1); // Lower capacity constraint\\r\\nassert(__count_15 <= 1); // Upper capacity constraint\\r\\n#endif\\r\\n\\r\\n return u.x;\\r\\n} \\r\\n\\r\\ndouble\\r\\nSquare (double x)\\r\\n{\\r\\n#ifdef CBMC\\r\\n//==========> square : header 16\\r\\nint __count_16 = 0;\\r\\n#endif\\r\\n\\r\\n #ifdef CBMC\\r\\n __count_16++;\\r\\n #endif\\r\\n\\r\\n#ifdef CBMC\\r\\nassert(__count_16 >= 1); // Lower capacity constraint\\r\\nassert(__count_16 <= 1); // Upper capacity constraint\\r\\n#endif\\r\\n\\r\\n return x * x;\\r\\n}\\r\\n\\r\\nvoid\\r\\nCalc_Sum_Mean (double Array[], double * Sum, double * Mean, int ARRAY_SIZE)\\r\\n{\\r\\n#ifdef CBMC\\r\\n//==========> calc_sum_mean : header 19\\r\\nint __count_19_18 = 0;\\r\\nint __count_19_18_L = 0; //Loop counter\\r\\n//==========> calc_sum_mean : header 17\\r\\nint __count_20 = 0;\\r\\nint __count_19_20 = 0;\\r\\n#endif\\r\\n\\r\\n int i;\\r\\n\\r\\n *Sum = 0;\\r\\n #ifdef CBMC\\r\\n __count_19_18_L = 0;\\r\\n #endif\\r\\n for (i = 0; i < ARRAY_SIZE; i++)\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_19_18_L++;\\r\\n __count_19_18++;\\r\\n #endif\\r\\n *Sum += Array[i];\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_19_18_L <= 11); // Loop counter property\\r\\n __count_19_20++;\\r\\n #endif\\r\\n\\r\\n *Mean = *Sum / ARRAY_SIZE;\\r\\n \\r\\n #ifdef CBMC\\r\\n __count_20++;\\r\\n #endif\\r\\n\\r\\n\\r\\n#ifdef CBMC\\r\\nassert(__count_19_20 >= 1); // Lower capacity constraint\\r\\nassert(__count_19_20 <= 1); // Upper capacity constraint\\r\\n//assert(__count_19_18 >= 10); // Lower capacity constraint\\r\\nassert(__count_19_18 <= 10); // Upper capacity constraint\\r\\nassert(__count_20 >= 1); // Lower capacity constraint\\r\\nassert(__count_20 <= 1); // Upper capacity constraint\\r\\n#endif\\r\\n}\\r\\n\\r\\nvoid\\r\\nCalc_Var_Stddev (double Array[], double Mean, double * Var, double * Stddev,\\r\\n int ARRAY_SIZE)\\r\\n{\\r\\n#ifdef CBMC\\r\\n//==========> calc_var_stddev : header 24\\r\\nint __count_24_22 = 0;\\r\\nint __count_24_22_L = 0; //Loop counter\\r\\n//==========> calc_var_stddev : header 21\\r\\nint __count_26 = 0;\\r\\nint __count_24_25 = 0;\\r\\n#endif\\r\\n\\r\\n int i;\\r\\n double diffs = 0.0;\\r\\n\\r\\n #ifdef CBMC\\r\\n __count_24_22_L = 0;\\r\\n #endif\\r\\n for (i = 0; i < ARRAY_SIZE; i++)\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_24_22_L++;\\r\\n __count_24_22++;\\r\\n #endif\\r\\n diffs += Square (Array[i] - Mean);\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_24_22_L <= 11); // Loop counter property\\r\\n __count_24_25++;\\r\\n #endif\\r\\n\\r\\n *Var = diffs / ARRAY_SIZE;\\r\\n *Stddev = sqrt (*Var);\\r\\n \\r\\n #ifdef CBMC\\r\\n __count_26++;\\r\\n #endif\\r\\n\\r\\n#ifdef CBMC\\r\\n\\r\\nassert(__count_26 >= 1); // Lower capacity constraint\\r\\nassert(__count_26 <= 1); // Upper capacity constraint\\r\\nassert(__count_24_25 >= 1); // Lower capacity constraint\\r\\nassert(__count_24_25 <= 1); // Upper capacity constraint\\r\\n//assert(__count_24_22 >= 10); // Lower capacity constraint\\r\\nassert(__count_24_22 <= 10); // Upper capacity constraint\\r\\n#endif\\r\\n}\\r\\n\\r\\nvoid\\r\\nCalc_LinCorrCoef (double ArrayA[], double ArrayB[], double MeanA, double MeanB,\\r\\n int ARRAY_SIZE)\\r\\n{\\r\\n#ifdef CBMC\\r\\n//==========> calc_lincorrcoef : header 11\\r\\nint __count_8_9 = 0;\\r\\nint __count_11_8 = 0; //Loop counter\\r\\n//==========> calc_lincorrcoef : header 7\\r\\nint __count_14 = 0;\\r\\nint __count_11_12 = 0;\\r\\n#endif\\r\\n\\r\\n int i;\\r\\n double numerator = 0.0;\\r\\n double Aterm = 0.0;\\r\\n double Bterm = 0.0;\\r\\n double Coef;\\r\\n\\r\\n #ifdef CBMC\\r\\n __count_11_8 = 0;\\r\\n #endif\\r\\n for (i = 0; i < ARRAY_SIZE; i++)\\r\\n {\\r\\n #ifdef CBMC\\r\\n __count_11_8++;\\r\\n __count_8_9++;\\r\\n #endif\\r\\n numerator += (ArrayA[i] - MeanA) * (ArrayB[i] - MeanB);\\r\\n Aterm += Square (ArrayA[i] - MeanA);\\r\\n Bterm += Square (ArrayB[i] - MeanB);\\r\\n }\\r\\n #ifdef CBMC\\r\\n assert(__count_11_8 <= 11); // Loop counter property\\r\\n __count_11_12++;\\r\\n #endif\\r\\n Coef = numerator / (sqrt (Aterm) * sqrt (Bterm));\\r\\n #ifdef CBMC\\r\\n __count_14++;\\r\\n #endif\\r\\n\\r\\n\\r\\n#ifdef CBMC\\r\\n//assert(__count_8_9 >= 10); // Lower capacity constraint\\r\\nassert(__count_8_9 <= 10); // Upper capacity constraint\\r\\nassert(__count_14 >= 1); // Lower capacity constraint\\r\\nassert(__count_14 <= 1); // Upper capacity constraint\\r\\nassert(__count_11_12 >= 1); // Lower capacity constraint\\r\\nassert(__count_11_12 <= 1); // Upper capacity constraint\\r\\n#endif\\r\\n\\r\\n}\\r\\n\\r\\nint\\r\\nstatistics (double ArrayA[], double ArrayB[], int ARRAY_SIZE) \\r\\n{\\r\\n#ifdef CBMC\\r\\n//==========> statistics : header 1\\r\\nint __count_6 = 0;\\r\\nint __count_1_2 = 0;\\r\\n#endif\\r\\n\\r\\n #ifdef CBMC\\r\\n __count_1_2++;\\r\\n #endif\\r\\n\\r\\n double SumA;\\r\\n double SumB;\\r\\n double VarA;\\r\\n double VarB;\\r\\n double MeanA;\\r\\n double MeanB;\\r\\n double StddevA;\\r\\n double StddevB; \\r\\n \\r\\n Calc_Sum_Mean (ArrayA, &SumA, &MeanA, ARRAY_SIZE);\\r\\n Calc_Var_Stddev (ArrayA, MeanA, &VarA, &StddevA, ARRAY_SIZE);\\r\\n Calc_Sum_Mean (ArrayB, &SumB, &MeanB, ARRAY_SIZE);\\r\\n Calc_Var_Stddev (ArrayB, MeanB, &VarB, &StddevB, ARRAY_SIZE);\\r\\n Calc_LinCorrCoef (ArrayA, ArrayB, MeanA, MeanB, ARRAY_SIZE);\\r\\n \\r\\n #ifdef CBMC\\r\\n __count_6++;\\r\\n #endif\\r\\n\\r\\n#ifdef CBMC\\r\\nassert(__count_6 >= 1); // Lower capacity constraint\\r\\nassert(__count_6 <= 1); // Upper capacity constraint\\r\\nassert(__count_1_2 >= 1); // Lower capacity constraint\\r\\nassert(__count_1_2 <= 1); // Upper capacity constraint\\r\\n#endif\\r\\n\\r\\n return ArrayA[0];\\r\\n}\\r\\n\\r\\nint\\r\\nmain (int argc, char *argv[])\\r\\n{\\r\\n const int ELEMENTS = argc - 1;\\r\\n int i;\\r\\n double ArrayA[ELEMENTS/2];\\r\\n double ArrayB[ELEMENTS/2];\\r\\n \\r\\n if (argc == 1 || ELEMENTS % 2 == 1)\\r\\n {\\r\\n return 1;\\r\\n }\\r\\n\\r\\n for (i = 0; i < ELEMENTS/2; i++)\\r\\n {\\r\\n ArrayA[i] = atoi (argv[i + 1]);\\r\\n }\\r\\n for (i = 0; i < ELEMENTS/2; i++)\\r\\n {\\r\\n ArrayB[i] = atoi (argv[i + 1]);\\r\\n }\\r\\n\\r\\n int val = statistics (ArrayA, ArrayB, ELEMENTS/2);\\r\\n \\r\\n printf(\\\"%d\\\", val);\\r\\n\\r\\n return 0;\\r\\n}\\r\\n\"\n },\n {\n \"alpha_fraction\": 0.47782427072525024,\n \"alphanum_fraction\": 0.4945606589317322,\n \"avg_line_length\": 13.397590637207031,\n \"blob_id\": \"398bb36658695e6c5317ca41af302007ee61e055\",\n \"content_id\": \"c572f8c1562cb90a30b21841ba626b1e65e16941\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 1195,\n \"license_type\": \"no_license\",\n \"max_line_length\": 73,\n \"num_lines\": 83,\n \"path\": \"/benchmarks/duff/duff.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\r\\r * Duff's device taken from MDH suite and modified by Adam Betts to consume a\\r\\r * test vector supplied on the command line.\\r\\r * For this program, a one-element test vector is expected which controls\\r\\r * the number of iterations of the loop\\r\\r */\\r\\rvoid\\rduff (char *to, char *from, int count)\\r{\\r int n = (count + 7) / 8;\\r\\r switch (count % 8)\\r {\\r case 0:\\r do\\r {\\r *to++ = *from++;\\r\\r case 7:\\r *to++ = *from++;\\r\\r case 6:\\r *to++ = *from++;\\r\\r case 5:\\r *to++ = *from++;\\r\\r case 4:\\r *to++ = *from++;\\r\\r case 3:\\r *to++ = *from++;\\r\\r case 2:\\r *to++ = *from++;\\r\\r case 1:\\r *to++ = *from++;\\r }\\r while (--n > 0);\\r }\\r}\\r\\rint\\rmain (int argc, char *argv[])\\r{\\r const int ARRAY_SIZE = 100;\\r char source[ARRAY_SIZE];\\r char target[ARRAY_SIZE];\\r int i;\\r int INVOCATION_COUNT;\\r\\r /*\\r\\r * One integer value must be supplied\\r\\r */\\r if (argc != 2)\\r {\\r return 1;\\r }\\r\\r /*\\r\\r * Initialise the source array\\r\\r */\\r for (i = 0; i < ARRAY_SIZE; i++)\\r {\\r source[i] = ARRAY_SIZE - i;\\r }\\r\\r INVOCATION_COUNT = atoi (argv[1]);\\r duff (source, target, INVOCATION_COUNT);\\r\\r return 0;\\r}\\r\"\n },\n {\n \"alpha_fraction\": 0.5542477965354919,\n \"alphanum_fraction\": 0.5561737418174744,\n \"avg_line_length\": 42.23147964477539,\n \"blob_id\": \"d544db9147032c7b8db1995c95727541dce966bb\",\n \"content_id\": \"76caa596f8027b08b7294e40d8cf2b7c53f8fd38\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 4673,\n \"license_type\": \"no_license\",\n \"max_line_length\": 91,\n \"num_lines\": 108,\n \"path\": \"/GPUTimingAnalysis/src/ICFGs.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import CFGs, Vertices, Debug, Trees\\nimport copy\\n\\nclass ICFG (CFGs.CFG):\\n def __init__ (self, cfg):\\n Debug.debugMessage(cfg, 10)\\n CFGs.CFG.__init__(self)\\n self.__branchDivergentEdges = []\\n self.setName(cfg.getName())\\n for bb in cfg:\\n bbID = bb.getVertexID()\\n self.vertices[bbID] = copy.deepcopy(bb)\\n self.__addIpoints()\\n \\n def __addIpoints (self):\\n for bb in self:\\n address, instr = bb.getFirstInstruction()\\n vertexID = self.getNextVertexID ()\\n ipoint = Vertices.Ipoint(vertexID, address)\\n self.vertices[vertexID] = ipoint\\n Debug.debugMessage(\\\"Adding Ipoint %d with ID %s\\\" % (vertexID, hex(address)), 4)\\n self.__linkIpoint(bb, ipoint)\\n \\n def __linkIpoint (self, bb, ipoint):\\n for predID in bb.getPredecessorIDs():\\n predv = self.getVertex(predID)\\n self.addEdge(predID, ipoint.getVertexID())\\n predv.removeSuccessor(bb.getVertexID())\\n bb.removePredecessor(predID)\\n self.addEdge(ipoint.getVertexID(), bb.getVertexID())\\n \\n def isIpoint (self, vertexID):\\n v = self.getVertex(vertexID)\\n return isinstance(v, Vertices.Ipoint)\\n \\n def getIpoint (self, vertexID):\\n v = self.getVertex(vertexID)\\n assert isinstance(v, Vertices.Ipoint), \\\"Vertex %d is not an Ipoint\\\" % vertexID\\n return v\\n \\n def isBranchDivergentEdge (self, predID, succID):\\n return (predID, succID) in self.__branchDivergentEdges\\n \\n def addBranchDivergenceEdges (self, lnt):\\n # Look for forward branches\\n forwardBranches = []\\n for v in self:\\n vertexID = v.getVertexID()\\n if v.numberOfSuccessors () > 1:\\n if not lnt.isLoopHeader(vertexID):\\n backEdge = False\\n for succID in v.getSuccessorIDs():\\n if lnt.isLoopBackEdge(vertexID, succID):\\n backEdge = True\\n if not backEdge:\\n forwardBranches.append(vertexID)\\n else:\\n forLoop = False\\n loopBody = lnt.getLoopBody(vertexID)\\n for succID in v.getSuccessorIDs():\\n if succID not in loopBody:\\n forLoop = True\\n if not forLoop:\\n forwardBranches.append(vertexID) \\n if forwardBranches:\\n self.__solveDFF(forwardBranches) \\n \\n def __solveDFF (self, forwardBranches):\\n # Initialise data structures needed\\n vertexToReachable = {}\\n for v in self:\\n vertexToReachable[v] = set([])\\n \\n # Do a reverse post-order. Avoid the entry vertex\\n dfs = Trees.DepthFirstSearch(self, self._entryID)\\n postID = self.numOfVertices() - 1\\n while postID >= 1:\\n vertexID = dfs.getPostorderVertexID(postID)\\n v = self.getVertex(vertexID)\\n vertexToReachable[v].add(vertexID)\\n for predID in v.getPredecessorIDs():\\n predv = self.getVertex(predID)\\n vertexToReachable[v].add(predID)\\n vertexToReachable[v].update(vertexToReachable[predv])\\n postID -= 1 \\n \\n # Now analyse the immediate post-dominator \\n reverseg = self.getReverseCFG()\\n postdomTree = Trees.Dominators(reverseg, reverseg.getEntryID())\\n for vertexID in forwardBranches:\\n Debug.debugMessage(\\\"Vertex %d is a forward branch\\\" % vertexID, 5)\\n branchv = self.getVertex(vertexID)\\n succSet = set(branchv.getSuccessorIDs())\\n treev = postdomTree.getVertex(vertexID)\\n parentID = treev.getParentID()\\n mergev = self.getVertex(parentID)\\n Debug.debugMessage(\\\"Analysing region (%d, %d)\\\" % (vertexID, parentID), 5)\\n# for succID in branchv.getSuccessorIDs():\\n# if succID != parentID:\\n# self.addEdge(parentID, succID)\\n# self.__branchDivergentEdges.append((parentID, succID))\\n for predID in mergev.getPredecessorIDs():\\n predv = self.getVertex(predID)\\n newsuccs = set.difference(succSet, vertexToReachable[predv]) \\n for newsuccID in newsuccs:\\n if newsuccID not in predv.getSuccessorIDs() and newsuccID != predID:\\n self.addEdge(predID, newsuccID)\\n self.__branchDivergentEdges.append((predID, newsuccID))\\n \"\n },\n {\n \"alpha_fraction\": 0.4825071096420288,\n \"alphanum_fraction\": 0.5679317712783813,\n \"avg_line_length\": 26.886207580566406,\n \"blob_id\": \"30abbd9b6629c72b20d3597c38305bad6d0a86d0\",\n \"content_id\": \"66fc4a3c9468ee588a4ac8cc464701722d54a568\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 8089,\n \"license_type\": \"no_license\",\n \"max_line_length\": 86,\n \"num_lines\": 290,\n \"path\": \"/DaikonPathInformation/benchmarks/crc.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#define TEST_VECTOR_SIZE 39\\n#define LOBYTE(x) ((unsigned char)((x) & 0xFF))\\n#define HIBYTE(x) ((unsigned char)((x) >> 8))\\n\\nunsigned short \\nicrc1 (unsigned short crc, unsigned char onech)\\n{\\n #ifdef CBMC\\n//==========> icrc1 : header 25\\nint __count_21_22 = 0;\\nint __count_21_23 = 0;\\nint __count_25_21 = 0; //Loop counter\\n//==========> icrc1 : header 20\\nint __count_26 = 0;\\nint __count_25_26 = 0;\\n #endif\\n\\n int i;\\n unsigned short ans = (crc^onech << 8);\\n #ifdef CBMC\\n __count_25_21 = 0;\\n #endif\\n for (i=0;i<8;i++) // 25\\n {\\n #ifdef CBMC\\n __count_25_21++;\\n #endif\\n if (ans & 0x8000) // 21\\n {\\n #ifdef CBMC\\n __count_21_22++;\\n #endif\\n // 22\\n ans = (ans <<= 1) ^ 4129;\\n }\\n else\\n {\\n #ifdef CBMC\\n __count_21_23++;\\n #endif\\n // 23\\n ans <<= 1;\\n }\\n }\\n #ifdef CBMC\\n assert(__count_25_21 <= 9); // Loop counter property\\n __count_25_26++;\\n __count_26++;\\n #endif\\n\\n#ifdef CBMC\\nassert(__count_21_22 <= 8); // Upper capacity constraint\\nassert(__count_21_23 <= 8); // Upper capacity constraint\\nassert(__count_26 >= 1); // Lower capacity constraint\\nassert(__count_26 <= 1); // Upper capacity constraint\\nassert(__count_25_26 >= 1); // Lower capacity constraint\\nassert(__count_25_26 <= 1); // Upper capacity constraint\\nassert(__count_21_22 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_21_22 > 0 ==> __count_26 > 0); // Execution dependence\\nassert(__count_21_23 > 0 ==> __count_25_26 > 0); // Execution dependence\\nassert(__count_21_23 > 0 ==> __count_26 > 0); // Execution dependence\\n#endif\\n\\n return ans;\\n}\\n\\nunsigned short \\ncrc (unsigned short crc, unsigned long len, short jinit, int jrev, unsigned char* lin)\\n{\\n#ifdef CBMC\\n//==========> crc : header 15\\nint __count_11_12 = 0;\\nint __count_11_13 = 0;\\nint __count_15_11 = 0; //Loop counter\\n//==========> crc : header 5\\nint __count_3_4 = 0;\\nint __count_5_3 = 0; //Loop counter\\n//==========> crc : header 1\\nint __count_19 = 0;\\nint __count_1_6 = 0;\\nint __count_5_6 = 0;\\nint __count_7_10 = 0;\\nint __count_8_9 = 0;\\nint __count_8_10 = 0;\\nint __count_16_17 = 0;\\nint __count_16_18 = 0;\\n#endif\\n static unsigned short icrctb[256],init=0;\\n static unsigned char rchr[256];\\n unsigned short tmp1, tmp2, j,cword=crc;\\n static unsigned char it[16]={0,8,4,12,2,10,6,14,1,9,5,13,3,11,7,15};\\n\\n if (!init) // 1\\n {\\n init=1;\\n #ifdef CBMC\\n __count_5_3 = 0;\\n #endif\\n for (j=0; j<=255; j++) // 5\\n {\\n #ifdef CBMC\\n __count_5_3++;\\n #endif\\n icrctb[j] = icrc1 (j << 8,(unsigned char)0);\\n rchr[j] = (unsigned char)(it[j & 0xF] << 4 | it[j >> 4]);\\n #ifdef CBMC\\n __count_3_4++;\\n #endif\\n }\\n #ifdef CBMC\\n assert(__count_5_3 <= 257); // Loop counter property\\n __count_5_6++;\\n #endif\\n }\\n #ifdef CBMC\\n else __count_1_6++;\\n #endif\\n \\n if (jinit >= 0) // 6\\n {\\n // 7\\n #ifdef CBMC\\n __count_7_10++;\\n #endif\\n cword=((unsigned char) jinit) | (((unsigned char) jinit) << 8);\\n }\\n else if (jrev < 0) // 8\\n { \\n #ifdef CBMC\\n __count_8_9++;\\n #endif\\n // 9\\n cword=rchr[HIBYTE(cword)] | rchr[LOBYTE(cword)] << 8;\\n }\\n #ifdef CBMC\\n __count_8_10++;\\n #endif\\n \\n #ifdef CBMC\\n __count_15_11 = 0;\\n #endif\\n for (j=1; j<=len; j++) // 15\\n {\\n #ifdef CBMC\\n __count_15_11++;\\n #endif\\n if (jrev < 0) // 11\\n {\\n #ifdef CBMC\\n __count_11_12++;\\n #endif\\n // 12\\n tmp1 = rchr[lin[j]]^ HIBYTE(cword);\\n }\\n else \\n {\\n #ifdef CBMC\\n __count_11_13++;\\n #endif\\n // 13\\n tmp1 = lin[j]^ HIBYTE(cword);\\n }\\n cword = icrctb[tmp1] ^ LOBYTE(cword) << 8;\\n }\\n #ifdef CBMC\\n assert(__count_15_11 <= 43); // Loop counter property\\n #endif\\n \\n if (jrev >= 0) // 16\\n {\\n #ifdef CBMC\\n __count_16_17++;\\n #endif\\n // 17\\n #ifdef CBMC\\n __count_19++;\\n #endif\\n\\n#ifdef CBMC\\n//assert(__count_11_12 == 0); // Dead code\\n//assert(__count_11_13 >= 40); // Lower capacity constraint\\nassert(__count_11_13 <= 42); // Upper capacity constraint\\nassert(__count_16_17 >= 1); // Lower capacity constraint\\nassert(__count_16_17 <= 1); // Upper capacity constraint\\nassert(__count_16_18 == 0); // Dead code\\nassert(__count_19 >= 1); // Lower capacity constraint\\nassert(__count_19 <= 1); // Upper capacity constraint\\nassert(__count_1_6 <= 1); // Upper capacity constraint\\nassert(__count_3_4 <= 256); // Upper capacity constraint\\nassert(__count_5_6 <= 1); // Upper capacity constraint\\nassert(__count_7_10 >= 1); // Lower capacity constraint\\nassert(__count_7_10 <= 1); // Upper capacity constraint\\nassert(__count_8_9 == 0); // Dead code\\nassert(__count_8_10 == 0); // Dead code\\nassert(__count_3_4 > 0 ==> __count_5_6 > 0); // Mutual inclusion\\nassert(__count_5_6 > 0 ==> __count_3_4 > 0); // Mutual inclusion\\nassert(__count_1_6 > 0 ==> __count_19 > 0); // Execution dependence\\nassert(__count_1_6 > 0 ==> __count_7_10 > 0); // Execution dependence\\nassert(__count_1_6 > 0 ==> __count_11_13 > 0); // Execution dependence\\nassert(__count_1_6 > 0 ==> __count_16_17 > 0); // Execution dependence\\nassert(__count_3_4 > 0 ==> __count_19 > 0); // Execution dependence\\nassert(__count_3_4 > 0 ==> __count_7_10 > 0); // Execution dependence\\nassert(__count_3_4 > 0 ==> __count_11_13 > 0); // Execution dependence\\nassert(__count_3_4 > 0 ==> __count_16_17 > 0); // Execution dependence\\nassert(__count_5_6 > 0 ==> __count_19 > 0); // Execution dependence\\nassert(__count_5_6 > 0 ==> __count_7_10 > 0); // Execution dependence\\nassert(__count_5_6 > 0 ==> __count_11_13 > 0); // Execution dependence\\nassert(__count_5_6 > 0 ==> __count_16_17 > 0); // Execution dependence\\n#endif\\n\\n return cword;\\n }\\n else \\n {\\n #ifdef CBMC\\n __count_16_18++;\\n #endif\\n // 18\\n #ifdef CBMC\\n __count_19++;\\n #endif\\n\\n\\n#ifdef CBMC\\n//assert(__count_11_12 == 0); // Dead code\\n//assert(__count_11_13 >= 40); // Lower capacity constraint\\nassert(__count_11_13 <= 42); // Upper capacity constraint\\nassert(__count_16_17 >= 1); // Lower capacity constraint\\nassert(__count_16_17 <= 1); // Upper capacity constraint\\nassert(__count_16_18 == 0); // Dead code\\nassert(__count_19 >= 1); // Lower capacity constraint\\nassert(__count_19 <= 1); // Upper capacity constraint\\nassert(__count_1_6 <= 1); // Upper capacity constraint\\nassert(__count_3_4 <= 256); // Upper capacity constraint\\nassert(__count_5_6 <= 1); // Upper capacity constraint\\nassert(__count_7_10 >= 1); // Lower capacity constraint\\nassert(__count_7_10 <= 1); // Upper capacity constraint\\nassert(__count_8_9 == 0); // Dead code\\nassert(__count_8_10 == 0); // Dead code\\nassert(__count_3_4 > 0 ==> __count_5_6 > 0); // Mutual inclusion\\nassert(__count_5_6 > 0 ==> __count_3_4 > 0); // Mutual inclusion\\nassert(__count_1_6 > 0 ==> __count_19 > 0); // Execution dependence\\nassert(__count_1_6 > 0 ==> __count_7_10 > 0); // Execution dependence\\nassert(__count_1_6 > 0 ==> __count_11_13 > 0); // Execution dependence\\nassert(__count_1_6 > 0 ==> __count_16_17 > 0); // Execution dependence\\nassert(__count_3_4 > 0 ==> __count_19 > 0); // Execution dependence\\nassert(__count_3_4 > 0 ==> __count_7_10 > 0); // Execution dependence\\nassert(__count_3_4 > 0 ==> __count_11_13 > 0); // Execution dependence\\nassert(__count_3_4 > 0 ==> __count_16_17 > 0); // Execution dependence\\nassert(__count_5_6 > 0 ==> __count_19 > 0); // Execution dependence\\nassert(__count_5_6 > 0 ==> __count_7_10 > 0); // Execution dependence\\nassert(__count_5_6 > 0 ==> __count_11_13 > 0); // Execution dependence\\nassert(__count_5_6 > 0 ==> __count_16_17 > 0); // Execution dependence\\n#endif\\n\\n\\n return rchr[HIBYTE(cword)] | rchr[LOBYTE(cword)] << 8;\\n }\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n /*\\n * At least as many integers as the TV size\\n */\\n if (argc != TEST_VECTOR_SIZE + 1)\\n {\\n return 1;\\n }\\n \\n unsigned char lin[256];\\n int i;\\n for (i = 0; i < argc-1; ++i)\\n {\\n lin[i] = argv[i + 1][0];\\n }\\n\\n unsigned short i1,i2;\\n unsigned long n = TEST_VECTOR_SIZE + 1;\\n lin[n+1] = 0;\\n i1 = crc(0,n,(short)0,1, lin);\\n lin[n+1] = HIBYTE(i1);\\n lin[n+2] = LOBYTE(i1);\\n i2 = crc(i1,n+2,(short)0,1, lin);\\n \\n printf(\\\"%d\\\", i2);\\n \\n return 0;\\n}\\n\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.47537609934806824,\n \"alphanum_fraction\": 0.5034074783325195,\n \"avg_line_length\": 19.571428298950195,\n \"blob_id\": \"9338fbfd2bf1c4e2c90081e506209bd45a14baa0\",\n \"content_id\": \"40bf12ccbe163fc41c88febd596756b97d9ce041\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 7777,\n \"license_type\": \"no_license\",\n \"max_line_length\": 99,\n \"num_lines\": 378,\n \"path\": \"/benchmarks/newtonMethod/newtonMethod.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * \\n * \\n * The algorithm is an adapted version of the 'Globally Convergent Newton Method'\\n * algorithm found on pages 480-483 in the book \\\"Numerical Recipes The Art Of Scientific Computing\\\"\\n * Third Edition by William H. Press et al\\n */\\n\\n#include \\n#include \\n#include \\n#include \\n\\n#define XSIZE 3\\n\\ntypedef struct {\\n\\tint n;\\n\\tdouble lu[XSIZE][XSIZE];\\n\\tint indx[XSIZE];\\n\\tdouble d;\\n} LUdcmp;\\n\\ndouble maxDoub(double a, double b)\\n{\\n\\tif(a > b)\\n\\t{\\n\\t\\treturn a;\\n\\t}\\n\\treturn b;\\n}\\n\\nLUdcmp initialiseLUdcmp(double a[XSIZE][XSIZE]) {\\n\\tLUdcmp newLUdcmp;\\n\\tnewLUdcmp.n = XSIZE;\\n\\t\\n\\tint i, j;\\n\\tfor (i = 0; i < XSIZE; i++) {\\n\\t\\tfor (j = 0; j < XSIZE; j++) {\\n\\t\\t\\tnewLUdcmp.lu[i][j] = a[i][j];\\n\\t\\t}\\n\\t}\\n\\n\\tconst double TINY = 1.0e-40;\\n\\tint imax, k;\\n\\tdouble big, temp;\\n\\tdouble vv[XSIZE];\\n\\tnewLUdcmp.d = 1.0;\\n\\n\\tfor (i = 0; i < newLUdcmp.n; i++) {\\n\\t\\tbig = 0.0;\\n\\t\\tfor (j = 0; j < newLUdcmp.n; j++) {\\n\\t\\t\\tif ((temp = fabs(newLUdcmp.lu[i][j])) > big) {big = temp;}\\n\\t\\t}\\n\\t\\tif (big == 0.0) { exit(1);}\\n\\t\\tvv[i] = 1.0 / big;\\n\\t}\\n\\t\\n\\tfor (k = 0; k < newLUdcmp.n; k++) {\\n\\t\\tbig = 0.0;\\n\\t\\tfor (i = k; i < newLUdcmp.n; i++) {\\n\\t\\t\\ttemp = vv[i] * fabs(newLUdcmp.lu[i][k]);\\n\\t\\t\\tif (temp > big) {\\n\\t\\t\\t\\tbig = temp;\\n\\t\\t\\t\\timax = i;\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t\\tif (k != imax) {\\n\\t\\t\\tfor (j = 0; j < newLUdcmp.n; j++) {\\n\\t\\t\\t\\ttemp = newLUdcmp.lu[imax][j];\\n\\t\\t\\t\\tnewLUdcmp.lu[imax][j] = newLUdcmp.lu[k][j];\\n\\t\\t\\t\\tnewLUdcmp.lu[k][j] = temp;\\n\\t\\t\\t}\\n\\t\\t\\tnewLUdcmp.d = -newLUdcmp.d;\\n\\t\\t\\tvv[imax] = vv[k];\\n\\t\\t}\\n\\t\\tnewLUdcmp.indx[k] = imax;\\n\\t\\tif (newLUdcmp.lu[k][k] == 0.0) {newLUdcmp.lu[k][k] = TINY;}\\n\\n\\t\\tfor (i = k + 1; i < newLUdcmp.n; i++) {\\n\\t\\t\\ttemp = newLUdcmp.lu[i][k] /= newLUdcmp.lu[k][k];\\n\\t\\t\\tfor (j = k + 1; j < newLUdcmp.n; j++) {\\n\\t\\t\\t\\tnewLUdcmp.lu[i][j] -= temp * newLUdcmp.lu[k][j];\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\\n\\treturn newLUdcmp;\\n}\\n\\nvoid solveLUdcmp(LUdcmp l, double b[], double x[]) {\\n\\tint i, ii = 0, ip, j;\\n\\tdouble sum;\\n\\n\\t//if (b.size() != l.n || x.size() != l.n)\\n\\t//\\texit(1);\\n\\n\\tfor (i = 0; i < l.n; i++) {\\n\\t\\tx[i] = b[i];\\n\\t}\\n\\n\\tfor (i = 0; i < l.n; i++) {\\n\\t\\tip = l.indx[i];\\n\\t\\tsum = x[ip];\\n\\t\\tx[ip] = x[i];\\n\\t\\tif (ii != 0) {\\n\\t\\t\\tfor (j = ii-1; j < i; j++) {\\n\\t\\t\\t\\tsum -= l.lu[i][j] * x[j];\\n\\t\\t\\t}\\n\\t\\t} else if (sum != 0.0) {\\n\\t\\t\\tii = i + 1;\\n\\t\\t}\\n\\t\\tx[i] = sum;\\n\\t}\\n\\n\\tfor (i = l.n - 1; i >= 0 ; i--) {\\n\\t\\tsum = x[i];\\n\\t\\tfor (j = i + 1; j < l.n; j++) {\\n\\t\\t\\tsum -= l.lu[i][j] * x[j];\\n\\t\\t}\\n\\t\\tx[i] = sum / l.lu[i][i];\\n\\t}\\n}\\n\\n/*\\n\\tThe routine requires a user-supplied function or functor that computes\\n\\tthe vector of functions to be zeroed. Its declaration as a function is:\\n\\tVecDoub vecfunc(VecDoub_I x);\\n\\t(The name vecfunc is arbitrary.) The declaration as a functor is similar\\n\\n\\tThe vector of functions to be zeroed, called fvec[0..n-1] in the routine below,\\n\\tis returned by the user-supplied function or functor vecfunc.\\n */\\ndouble funcValues[XSIZE];\\ndouble* vecfunc(double x[]) {\\n\\tint i;\\n\\t\\n\\tfuncValues[0] = (x[0] * 3) - 18;\\n\\tfuncValues[1] = (x[1] * x[1] * x[1]) + (-5 * (x[1] * x[1])) + (2 * x[1]) + 8;\\n\\tfuncValues[2] = (x[2] * x[2]) + (-5 * x[2]) + 6;\\n\\t/*for (i = 0; i < XSIZE; i++) {\\n\\t\\tfuncValues[i] = (x[i] * (i + 1)) - (i + 1);\\n\\t}*/\\n\\n\\treturn funcValues;\\n}\\n\\ndouble fvec[XSIZE];\\n// Returns f = 0.5F.F at x. ALso stores value of F in fvec\\ndouble NRfmin(double x[]) {\\n\\tint n = XSIZE;\\n\\tdouble sum = 0;\\n\\tint i;\\n\\tdouble *fvectmp;\\n\\n\\tfvectmp = vecfunc(x);\\n\\tfor (i = 0; i < n; i++) {\\n\\t\\tfvec[i] = fvectmp[i];\\n\\t}\\n\\tfor (i = 0; i < n; i++) {\\n\\t\\t//sum += SQR(fvec[i]);\\t\\n\\t\\tsum += (fvec[i] * fvec[i]);\\n\\t}\\n\\treturn 0.5 * sum;\\n}\\n\\nvoid NRfdjac(double x[], double fvecIn[], double df[XSIZE][XSIZE]) {\\n\\tconst double EPS = 1.0e-8;\\n\\tint n = XSIZE;\\n\\tint i, j;\\n\\n\\tdouble xh[XSIZE];\\n\\tfor(i = 0; i < XSIZE; i++) {\\n\\t\\txh[i] = x[i];\\n\\t}\\n\\n\\tfor(j = 0; j < n; j++) {\\n\\t\\tdouble temp = xh[j];\\n\\t\\tdouble h = EPS * fabs(temp);\\n\\t\\tif (h == 0.0) h = EPS;\\n\\t\\txh[j] = temp + h;\\n\\t\\th = xh[j] - temp;\\n\\t\\tdouble *f = vecfunc(xh);\\n\\t\\txh[j] = temp;\\n\\t\\tfor (i = 0; i < n; i++) {\\n\\t\\t\\tdf[i][j] = (f[i] - fvecIn[i]) / h;\\n\\t\\t}\\n\\t}\\n}\\n\\nvoid lnsearch(double xold[], const double fold, double g[], double p[],\\n\\t\\t\\tdouble x[], double *f, const double stpmax, int *check) {\\n\\tconst double ALF = 1.0e-4;\\n\\t// Library use DBL_EPSILON\\n\\tconst double TOLX = DBL_EPSILON;\\n\\n\\tdouble a, alam, alam2 = 2.0, alamin, b, disc, f2 = 0.0;\\n\\tdouble rhs1, rhs2, slope = 0.0, sum = 0.0, temp, test, tmplam;\\n\\tint i, n = XSIZE;\\n\\n\\t*check = 0;\\n\\tfor (i = 0; i < n; i++) {\\n\\t\\tsum += p[i] * p[i];\\n\\t}\\n\\t// Library use: sqrt\\n\\tsum = sqrt(sum);\\n\\tif (sum > stpmax) {\\n\\t\\tfor (i = 0; i < n; i++) {\\n\\t\\t\\tp[i] *= stpmax / sum;\\n\\t\\t}\\n\\t}\\n\\n\\tfor (i = 0; i < n; i++) {\\n\\t\\tslope += g[i] * p[i];\\n\\t}\\n\\tif (slope >= 0.0) { exit (1); }\\n\\n\\ttest = 0.0;\\n\\tfor (i = 0; i < n; i++) {\\n\\t\\ttemp = fabs(p[i]) / maxDoub(fabs(xold[i]), 1.0);\\n\\t\\tif (temp > test) {test = temp;}\\n\\t}\\n\\n\\talamin = TOLX / test;\\n\\talam = 1.0;\\n\\tfor(;;) {\\n\\t\\tfor (i = 0; i < n; i++) x[i] = xold[i] + alam * p[i];\\n\\t\\t*f = NRfmin(x);\\n\\t\\t\\n\\t\\tif (alam < alamin) {\\n\\t\\t\\tfor (i = 0; i < n; i++) x[i] = xold[i];\\n\\t\\t\\t*check = 1;\\n\\t\\t\\treturn;\\n\\t\\t} else if (*f <= fold + ALF * alam * slope) {\\n\\t\\t\\treturn;\\n\\t\\t} else {\\n\\t\\t\\tif (alam == 1.0) {\\n\\t\\t\\t\\ttmplam = -slope / (2.0 * (*f - fold - slope));\\n\\t\\t\\t} else {\\n\\t\\t\\t\\trhs1 = *f - fold - alam * slope;\\n\\t\\t\\t\\trhs2 = f2 - fold - alam2 * slope;\\n\\t\\t\\t\\ta = (rhs1 / (alam * alam) - rhs2 / (alam2 * alam2)) / (alam - alam2);\\n\\t\\t\\t\\tb = (-alam2 * rhs1 / (alam * alam) + alam * rhs2 / (alam2 * alam2)) / (alam - alam2);\\n\\t\\t\\t\\tif (a == 0.0) {\\n\\t\\t\\t\\t\\ttmplam = -slope / (2.0 * b);\\n\\t\\t\\t\\t} else {\\n\\t\\t\\t\\t\\tdisc = b * b - 3.0 * a * slope;\\n\\t\\t\\t\\t\\tif (disc < 0.0) tmplam = 0.5 * alam;\\n\\t\\t\\t\\t\\telse if (b <= 0.0) tmplam = (-b + sqrt(disc)) / (3.0 * a);\\n\\t\\t\\t\\t\\telse tmplam = -slope / (b + sqrt(disc));\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tif (tmplam > 0.5 * alam) {\\n\\t\\t\\t\\t\\ttmplam = 0.5 * alam;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\talam2 = alam;\\n\\t\\tf2 = *f;\\n\\t\\talam = maxDoub(tmplam, 0.1 * alam);\\n\\t}\\n}\\n\\nvoid newtonMethod(double x[], int *check) {\\n\\tconst int MAXITS = 200;\\n\\tconst double TOLF = 1.0e-8, TOLMIN = 1.0e-12, STPMX = 100.0;\\n\\t// Library use DBL_EPSILON\\n\\tconst double TOLX = DBL_EPSILON;\\n\\n\\tint i, j, its, n = XSIZE;\\n\\tdouble den, f, fold, stpmax, sum, temp, test;\\n\\tdouble g[XSIZE], p[XSIZE], xold[XSIZE];\\n\\tdouble fjac[XSIZE][XSIZE];\\n\\n\\tf = NRfmin(x);\\n\\ttest = 0.0;\\n\\n\\tfor (i = 0; i < n; i++) {\\n\\t\\tif (fabs(fvec[i]) > test) test = fabs(fvec[i]);\\n\\t}\\n\\tif (test < 0.01 * TOLF) {\\n\\t\\t*check = 0;\\n\\t\\treturn;\\n\\t}\\n\\n\\tsum = 0.0;\\n\\tfor (i = 0; i < n; i++) sum += x[i] * x[i];\\n\\tstpmax = STPMX * maxDoub(sqrt(sum), (double)n);\\n\\t\\n\\tfor (its = 0; its < MAXITS; its++) {\\n\\t\\tNRfdjac(x, fvec, fjac);\\n\\t\\tfor (i = 0; i < n; i++) {\\n\\t\\t\\tsum = 0.0;\\n\\t\\t\\tfor (j = 0; j < n; j++) {\\n\\t\\t\\t\\tsum += fjac[j][i] * fvec[j];\\n\\t\\t\\t}\\n\\t\\t\\tg[i] = sum;\\n\\t\\t}\\n\\t\\t\\n\\t\\tfor (i = 0; i < n; i++) xold[i] = x[i];\\n\\t\\tfold = f;\\n\\t\\tfor (i = 0; i < n; i++) p[i] = -fvec[i];\\n\\t\\t\\n\\t\\tLUdcmp alu = initialiseLUdcmp(fjac);\\n\\t\\tsolveLUdcmp(alu, p, p);\\n\\n\\t\\tlnsearch(xold, fold, g, p, x, &f, stpmax, check);\\n\\t\\ttest = 0.0;\\n\\t\\tfor (i = 0; i < n; i++) {\\n\\t\\t\\tif (fabs(fvec[i]) > test) test = fabs(fvec[i]);\\n\\t\\t}\\n\\t\\tif (test < TOLF) {\\t\\t\\t\\n\\t\\t\\t*check = 0;\\n\\t\\t\\treturn;\\n\\t\\t}\\n\\t\\tif (*check) {\\n\\t\\t\\ttest = 0.0;\\n\\t\\t\\tden = maxDoub(f, 0.5 * n);\\n\\t\\t\\tfor (i = 0; i < n; i++) {\\n\\t\\t\\t\\ttemp = fabs(g[i]) * maxDoub(fabs(x[i]), 1.0) / den;\\n\\t\\t\\t\\tif (temp > test) test = temp;\\n\\t\\t\\t}\\n\\t\\t\\tif (test < TOLMIN)\\n\\t\\t\\t{\\n\\t\\t\\t\\t*check = 1;\\n\\t\\t\\t}\\n\\t\\t\\telse\\n\\t\\t\\t{\\n\\t\\t\\t\\t*check = 0;\\n\\t\\t\\t}\\n\\t\\t\\treturn;\\n\\t\\t}\\n\\t\\t\\n\\t\\ttest = 0.0;\\n\\t\\tfor (i = 0; i < n; i++) {\\n\\t\\t\\ttemp = (fabs(x[i] - xold[i])) / maxDoub(fabs(x[i]), 1.0);\\n\\t\\t\\tif (temp > test) test = temp;\\n\\t\\t}\\n\\t\\tif (test < TOLX) {\\t\\n\\t\\t\\treturn;\\n\\t\\t}\\n\\t}\\n\\texit(1);\\n}\\n\\nint\\nmain (int argc, char *argv[])\\n{\\n const int ARRAY_SIZE = argc - 1;\\n double TV[ARRAY_SIZE];\\n int i;\\n int check = 0;\\n\\n /*\\n * Expecting XSIZE arguments\\n */\\n if (argc != (XSIZE + 1))\\n {\\n return 1;\\n }\\n\\n for (i = 0; i < argc - 1; ++i)\\n {\\n TV[i] = atof (argv[i + 1]);\\n }\\n\\n newtonMethod(TV, &check);\\n\\n/*\\n printf(\\\"Check value = %i\\\\n\\\", check);\\n\\n for (i = 0; i < argc - 1; ++i)\\n {\\n printf(\\\"%lf \\\", TV[i]);\\n }\\n printf(\\\"\\\\n\\\");\\n*/\\n\\n return 0;\\n}\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.5222866535186768,\n \"alphanum_fraction\": 0.5278832912445068,\n \"avg_line_length\": 43.625,\n \"blob_id\": \"946f90d83d404040b7625b33b3a7b021bf8daac0\",\n \"content_id\": \"7343ead99d6033ad2217c21eb6280efb2d448f36\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 5003,\n \"license_type\": \"no_license\",\n \"max_line_length\": 107,\n \"num_lines\": 112,\n \"path\": \"/DaikonPathInformation/src/program_input_output.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import directed_graphs\\nimport debug\\nimport programs\\nimport vertices\\nimport shlex\\nimport re\\n\\ncfg_lexeme = \\\"cfg\\\"\\nbasic_block_lexeme = \\\"bb\\\"\\nsuccessors_lexeme = \\\"succ\\\"\\ninstructions_lexeme = \\\"instructions\\\"\\n\\nname_regex = re.compile(\\\"[\\\\d\\\\w]+\\\")\\nint_regex = re.compile(r\\\"\\\\d+\\\")\\nedges_regex = re.compile(r\\\"\\\\([\\\\w\\\\d\\\\s,]+\\\\)\\\")\\nedge_tuple_regex = re.compile(r\\\"[\\\\w\\\\d]+\\\")\\n\\ndef write_disassembled_program_to_file(program, disassembly_filename):\\n filename = disassembly_filename[:-4] + '.txt'\\n with open(filename, 'w') as the_file:\\n for cfg in program.cfgs.values():\\n the_file.write(\\\"%s: %s\\\\n\\\" % (cfg_lexeme, cfg.name))\\n for v in cfg:\\n the_file.write(\\\"%s: %d\\\\n\\\" % (basic_block_lexeme, v.vertexID))\\n the_file.write(\\\"%s: \\\" % successors_lexeme)\\n if cfg.get_exitID() != v.vertexID:\\n for succID in v.successors.keys():\\n the_file.write(\\\"(%s, %d)\\\" % (cfg.name, succID))\\n callee_name = cfg.is_call_site(v.vertexID)\\n if callee_name is not None:\\n the_file.write(\\\"(%s, %d)\\\" % (callee_name, program.cfgs[callee_name].get_entryID()))\\n the_file.write(\\\"\\\\n\\\")\\n the_file.write(\\\"%s\\\\n\\\" % instructions_lexeme)\\n for instruction in v.instructions:\\n the_file.write(\\\"[0x%08X]\\\" % instruction.address)\\n for field in instruction.the_instruction:\\n the_file.write(\\\" [%s] \\\" % field)\\n the_file.write(\\\"\\\\n\\\")\\n the_file.write(\\\"\\\\n\\\" * 2) \\n\\ndef first_pass(filename):\\n # Partially build call graph\\n program = programs.Program()\\n with open(filename) as the_file:\\n for line in the_file:\\n line = line.lower()\\n if line.startswith(cfg_lexeme):\\n names = name_regex.findall(line)\\n assert len(names) == 2, \\\"Too many names found '%s'\\\" % ' '.join(names)\\n cfg = directed_graphs.CFG()\\n cfg.name = names[1]\\n debug.debug_message(\\\"Found new CFG '%s'\\\" % cfg.name, __name__, 1)\\n program.addCFG(cfg)\\n return program\\n\\ndef second_pass(filename, program):\\n # Build the CFGs\\n cfg = None\\n bb = None\\n instructions = False\\n with open(filename) as the_file:\\n for line in the_file:\\n line = line.lower()\\n if line.startswith(cfg_lexeme):\\n names = name_regex.findall(line)\\n assert len(names) == 2, \\\"Too many names found '%s'\\\" % ' '.join(names)\\n cfg = program.cfgs[names[1]]\\n elif line.startswith(basic_block_lexeme):\\n assert cfg, \\\"Found basic block but current CFG is null\\\"\\n ids = int_regex.findall(line) \\n assert len(ids) == 1, \\\"Too many identifiers found '%s'\\\" % ' '.join(ids)\\n assert ids[0].isdigit(), \\\"Vertex identifier '%s' is not an integer\\\" % ids[0]\\n bb = vertices.BasicBlock(int(ids[0]))\\n cfg.addVertex(bb)\\n elif line.startswith(successors_lexeme):\\n assert bb, \\\"Found edge but current basic block is null\\\"\\n edges = edges_regex.findall(line)\\n for edge in edges:\\n a_tuple = edge_tuple_regex.findall(edge)\\n assert len(a_tuple) == 2, \\\"Too many components in edge tuple: %s\\\" % edge\\n assert a_tuple[1].isdigit(), \\\"Successor identifier '%s' is not an integer\\\" % a_tuple[1]\\n if a_tuple[0] == cfg.name:\\n bb.add_successor(int(a_tuple[1])) \\n else:\\n program.callg.addEdge(cfg.name, a_tuple[0], bb.vertexID)\\n cfg.add_call_site(bb.vertexID, a_tuple[0]) \\n elif line.startswith(instructions_lexeme):\\n instructions = True\\n # Ignore lines consisting of whitespace only\\n elif instructions and not re.match(r'\\\\s+', line):\\n assert bb, \\\"Found instruction but current basic block is null\\\"\\n lexemes = shlex.split(line)\\n address = None\\n fields = []\\n for index, lex in enumerate(lexemes):\\n if index == 0:\\n address = int(lex[1:-1], 16)\\n else:\\n fields.append(lex[1:-1])\\n assert address is not None, \\\"No address found in instruction %s\\\" % line\\n instruction = vertices.BasicBlock.Instruction(address, fields)\\n bb.instructions.append(instruction)\\n\\ndef read_file(filename):\\n program = first_pass(filename)\\n second_pass(filename, program)\\n program.callg.find_and_set_root()\\n for cfg in program.cfgs.values():\\n cfg.add_predecessor_edges()\\n cfg.set_entry_and_exit()\\n cfg.set_edgeIDs()\\n return program \\n\"\n },\n {\n \"alpha_fraction\": 0.5750219821929932,\n \"alphanum_fraction\": 0.5767809748649597,\n \"avg_line_length\": 30.236263275146484,\n \"blob_id\": \"46ad13c5cd3a55bbae865b64fde4d0873b4df98a\",\n \"content_id\": \"3472bd4b0e62add85102e853f8547162de2925c6\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 5685,\n \"license_type\": \"no_license\",\n \"max_line_length\": 79,\n \"num_lines\": 182,\n \"path\": \"/GPUTimingAnalysis/src/UDrawGraph.py\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import CFGs, IPGs, Trees, Vertices, ICFGs\\nfrom Main import opts\\n\\nfileNameSuffix = \\\".udraw\\\"\\nbeginGraph = \\\"[\\\\n\\\"\\nendGraph = \\\"]\\\\n\\\"\\nendVertex = \\\"])),\\\"\\nnewEdge = \\\"\\\\ne(\\\\\\\"tEdge\\\\\\\",\\\"\\nendEdge = \\\")\\\"\\nbeginAttributes = \\\"[\\\"\\nendAttibutes = \\\"],\\\"\\nnewLine = \\\"\\\\\\\\n\\\"\\n\\nclass COLOR:\\n RED = \\\"red\\\"\\n YELLOW = \\\"yellow\\\" \\n BLUE = \\\"blue\\\"\\n GREEN = \\\"green\\\"\\n BLACK = \\\"black\\\"\\n \\nclass SHAPE:\\n BOX = \\\"box\\\" \\n CIRCLE = \\\"circle\\\"\\n ELLIPSE = \\\"ellipse\\\" \\n RHOMBUS = \\\"rhombus\\\" \\n TRIANGLE = \\\"triangle\\\"\\n \\nclass EDGESHAPE:\\n SOLID = \\\"solid\\\"\\n DASHED = \\\"dashed\\\"\\n DOTTED = \\\"dotted\\\"\\n\\ndef newVertex (vertexID):\\n return \\\"l(\\\\\\\"v\\\" + str(vertexID) + \\\"\\\\\\\",n(\\\\\\\"tVertex\\\\\\\",\\\"\\n\\ndef edgeLink (vertexID):\\n return \\\"r(\\\\\\\"v\\\" + str(vertexID) + \\\"\\\\\\\")\\\"\\n\\ndef setName (name):\\n return \\\"a(\\\\\\\"OBJECT\\\\\\\", \\\\\\\"\\\" + name + \\\"\\\\\\\"),\\\"\\n\\ndef setColor (color):\\n return \\\"a(\\\\\\\"COLOR\\\\\\\", \\\\\\\"\\\" + color + \\\"\\\\\\\"),\\\"\\n\\ndef setShape (shape):\\n return \\\"a(\\\\\\\"_GO\\\\\\\", \\\\\\\"\\\" + shape + \\\"\\\\\\\"),\\\"\\n\\ndef setToolTip (tooltip):\\n return \\\"a(\\\\\\\"INFO\\\\\\\", \\\\\\\"\\\" + tooltip + \\\"\\\\\\\"),\\\"\\n\\ndef setEdgePattern (shape, width):\\n return \\\"a(\\\\\\\"EDGEPATTERN\\\\\\\", \\\\\\\"single;\\\" + shape + \\\";\\\" + str(width) + \\\";1\\\\\\\"),\\\"\\n\\ndef setEdgeColor (color):\\n return \\\"a(\\\\\\\"EDGECOLOR\\\\\\\", \\\\\\\"\\\" + color + \\\"\\\\\\\"),\\\"\\n\\ndef makeUdrawFile (g, basepath, fileNamePrefix):\\n import os\\n if opts.udraw: \\n filename = basepath + os.sep + fileNamePrefix + fileNameSuffix\\n with open(filename, 'w') as f:\\n f.write(beginGraph)\\n # CFG or Instrumented CFG\\n if isinstance(g, CFGs.CFG):\\n for v in g:\\n writeCFGVertex(g, v.getVertexID(), f) \\n # Loop-Nesting Tree\\n elif isinstance(g, Trees.LoopNests):\\n for v in g:\\n writeTreeVertex(g, v.getVertexID(), f)\\n # IPG\\n elif isinstance(g, IPGs.IPG):\\n for v in g:\\n writeIPGVertex(g, v.getVertexID(), f)\\n else:\\n for v in g:\\n writeVertex(g, v.getVertexID(), f)\\n f.write(endGraph) \\n \\ndef writeVertex (g, vertexID, f):\\n v = g.getVertex(vertexID)\\n \\n f.write(newVertex(vertexID))\\n f.write(beginAttributes)\\n f.write(setName(str(vertexID)))\\n f.write(endAttibutes)\\n \\n f.write(beginAttributes)\\n for succID in v.getSuccessorIDs():\\n f.write(newEdge)\\n f.write(beginAttributes)\\n f.write(setName(str(succID)))\\n f.write(endAttibutes)\\n f.write(edgeLink(succID))\\n f.write(endEdge + \\\",\\\\n\\\")\\n f.write(endVertex + \\\"\\\\n\\\")\\n \\ndef writeCFGVertex (cfg, vertexID, f):\\n v = cfg.getVertex(vertexID)\\n \\n f.write(newVertex(vertexID))\\n f.write(beginAttributes)\\n f.write(setName(str(vertexID)))\\n if isinstance(v, Vertices.Ipoint):\\n f.write(setShape(SHAPE.CIRCLE))\\n f.write(setColor(COLOR.YELLOW))\\n f.write(setToolTip(\\\"Ipoint ID = 0x%04X\\\" % v.getIpointID()))\\n else:\\n string = \\\"\\\"\\n for address, instr in v.getInstructions ():\\n string += instr.__str__() + newLine\\n f.write(setToolTip(string[:-len(newLine)]))\\n f.write(endAttibutes)\\n \\n f.write(beginAttributes)\\n for succID in v.getSuccessorIDs():\\n f.write(newEdge)\\n f.write(beginAttributes)\\n if isinstance(cfg, ICFGs.ICFG):\\n if cfg.isBranchDivergentEdge(vertexID, succID):\\n f.write(setEdgePattern(EDGESHAPE.DASHED, 4))\\n f.write(setEdgeColor(COLOR.RED))\\n f.write(setToolTip(\\\"Branch divergent edge\\\"))\\n f.write(setName(str(succID)))\\n f.write(endAttibutes)\\n f.write(edgeLink(succID))\\n f.write(endEdge + \\\",\\\\n\\\")\\n f.write(endVertex + \\\"\\\\n\\\")\\n \\ndef writeTreeVertex (tree, vertexID, f):\\n v = tree.getVertex(vertexID)\\n f.write(newVertex(vertexID))\\n f.write(beginAttributes)\\n f.write(setName(str(vertexID)))\\n if isinstance(v, Vertices.HeaderVertex):\\n f.write(setShape(SHAPE.CIRCLE))\\n f.write(setColor(COLOR.YELLOW))\\n f.write(setToolTip(\\\"Header ID = %s\\\" % v.getHeaderID()))\\n if isinstance(tree, Trees.LoopNests):\\n if tree.isLoopExit(vertexID):\\n f.write(setShape(SHAPE.TRIANGLE))\\n f.write(setColor(COLOR.RED))\\n f.write(setToolTip(\\\"Loop Exit\\\"))\\n f.write(endAttibutes)\\n \\n f.write(beginAttributes)\\n for succID in v.getSuccessorIDs():\\n f.write(newEdge)\\n f.write(beginAttributes)\\n f.write(setName(str(succID)))\\n f.write(endAttibutes)\\n f.write(edgeLink(succID))\\n f.write(endEdge + \\\",\\\\n\\\")\\n f.write(endVertex + \\\"\\\\n\\\")\\n\\ndef writeIPGVertex (ipg, vertexID, f): \\n v = ipg.getVertex(vertexID)\\n f.write(newVertex(vertexID))\\n f.write(beginAttributes)\\n f.write(setName(str(vertexID)))\\n f.write(setShape(SHAPE.CIRCLE))\\n f.write(setColor(COLOR.YELLOW))\\n f.write(setToolTip(\\\"Ipoint ID = 0x%04X\\\" % v.getIpointID()))\\n f.write(endAttibutes)\\n \\n f.write(beginAttributes)\\n for succID in v.getSuccessorIDs():\\n succe = v.getSuccessorEdge(succID)\\n f.write(newEdge)\\n f.write(beginAttributes)\\n f.write(setName(str(succe.getEdgeID())))\\n f.write(setToolTip(', '.join(str(v) for v in succe.getEdgeLabel())))\\n if succe.isIterationEdge():\\n f.write(setEdgePattern(EDGESHAPE.SOLID, 2))\\n if ipg.isBranchDivergentEdge(vertexID, succID):\\n f.write(setEdgePattern(EDGESHAPE.DASHED, 4))\\n f.write(setEdgeColor(COLOR.RED))\\n f.write(setToolTip(\\\"Branch divergent edge\\\")) \\n f.write(endAttibutes)\\n f.write(edgeLink(succID))\\n f.write(endEdge + \\\",\\\\n\\\")\\n f.write(endVertex + \\\"\\\\n\\\")\\n\"\n },\n {\n \"alpha_fraction\": 0.5006570219993591,\n \"alphanum_fraction\": 0.5177398324012756,\n \"avg_line_length\": 12.120689392089844,\n \"blob_id\": \"2f3a873fe873ae9c7c7f6ad3aefa6f8ce7d59671\",\n \"content_id\": \"aace59af7c2a72fc65ad60656e9038bc3478a137\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C\",\n \"length_bytes\": 761,\n \"license_type\": \"no_license\",\n \"max_line_length\": 84,\n \"num_lines\": 58,\n \"path\": \"/benchmarks/gnomesort/gnomesort.c\",\n \"repo_name\": \"jiankangren/Projects\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*\\n * Takes a vector of integers as arguments and sorts the vector into ascending order\\n * using the gnome sort algorihtm\\n */\\n\\nvoid gnomesort (int ARRAY_SIZE, int a[])\\n{\\n\\tint pos = 1;\\n\\tint temp;\\n\\t\\n\\twhile (pos < ARRAY_SIZE)\\n\\t{\\n\\t\\tif (a[pos] >= a[pos - 1])\\n\\t\\t{\\n\\t\\t\\tpos++;\\n\\t\\t}\\n\\t\\telse\\n\\t\\t{\\n\\t\\t\\t// Swap a[pos] and a[pos - 1]\\n\\t\\t\\ttemp = a[pos];\\n\\t\\t\\ta[pos] = a[pos - 1];\\n\\t\\t\\ta[pos - 1] = temp;\\n\\n\\t\\t\\tif (pos > 1)\\n\\t\\t\\t{\\n\\t\\t\\t\\tpos--;\\n\\t\\t\\t}\\n\\t\\t\\telse\\n\\t\\t\\t{\\n\\t\\t\\t\\tpos++;\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\\n}\\n\\nint main (int argc, char *argv[])\\n{\\n\\tconst int ARRAY_SIZE = argc - 1;\\n\\tint TV[ARRAY_SIZE];\\n\\tint i;\\n\\n\\t/*\\n\\t * At least one integer value must be supplied\\n\\t */\\n\\tif (argc == 1)\\n\\t{\\n\\t\\treturn 1;\\n\\t}\\n\\n\\tfor (i = 0; i < argc - 1; i++)\\n\\t{\\n\\t\\tTV[i] = atoi (argv[i + 1]);\\n\\t}\\n\\n\\tgnomesort (ARRAY_SIZE, TV);\\n\\n\\treturn 0;\\n}\\n\"\n }\n]"},"num_files":{"kind":"number","value":96,"string":"96"}}},{"rowIdx":2981295,"cells":{"repo_name":{"kind":"string","value":"aleksandr-hilko/flask-vue-application-"},"repo_url":{"kind":"string","value":"https://github.com/aleksandr-hilko/flask-vue-application-"},"snapshot_id":{"kind":"string","value":"8e448b14cb3d405b91b1a1ca83303f262fb5231c"},"revision_id":{"kind":"string","value":"1bd79fac1f3181a4d68d1a3642b357a2db284662"},"directory_id":{"kind":"string","value":"acf23742eedac002e71f699611e8b0bf102302bf"},"branch_name":{"kind":"string","value":"refs/heads/master"},"visit_date":{"kind":"timestamp","value":"2022-09-18T09:09:30.706029","string":"2022-09-18T09:09:30.706029"},"revision_date":{"kind":"timestamp","value":"2020-03-04T08:05:52","string":"2020-03-04T08:05:52"},"committer_date":{"kind":"timestamp","value":"2020-03-04T08:05:52","string":"2020-03-04T08:05:52"},"github_id":{"kind":"number","value":240526873,"string":"240,526,873"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_pushed_at":{"kind":"null"},"gha_language":{"kind":"null"},"files":{"kind":"list like","value":[{"alpha_fraction":0.5666418671607971,"alphanum_fraction":0.5718540549278259,"avg_line_length":28.19565200805664,"blob_id":"f26131b8046dc18b0c79de891731da9965f280c2","content_id":"082cc9fad3d5c0ea266abfc7574eea36e2ced4bd","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":1343,"license_type":"no_license","max_line_length":76,"num_lines":46,"path":"/app/helpers.py","repo_name":"aleksandr-hilko/flask-vue-application-","src_encoding":"UTF-8","text":"import os\nfrom flask import request, make_response, jsonify\nfrom functools import wraps\n\n\ndef get_env_variable(name):\n try:\n return os.environ[name]\n except KeyError:\n message = \"Expected environment variable '{}' not set.\".format(name)\n raise Exception(message)\n\n\ndef check_token(f):\n \"\"\"\n Wrapper around view to verify that valid token is provided with request.\n \"\"\"\n from app.models import User\n from flask import g\n\n @wraps(f)\n def decorated(*args, **kwargs):\n # get the auth token\n auth_header = request.headers.get(\"Authorization\")\n if auth_header:\n auth_token = auth_header.split(\" \")[1]\n else:\n auth_token = \"\"\n if auth_token:\n resp = User.decode_auth_token(auth_token)\n if not isinstance(resp, str):\n user = User.query.filter_by(id=resp).first()\n g.current_user = user\n\n return f(*args, **kwargs)\n\n responseObject = {\"status\": \"fail\", \"message\": resp}\n return make_response(jsonify(responseObject)), 401\n else:\n responseObject = {\n \"status\": \"fail\",\n \"message\": \"Provide a valid auth token.\",\n }\n return make_response(jsonify(responseObject)), 401\n\n return decorated\n"},{"alpha_fraction":0.6500236392021179,"alphanum_fraction":0.6585423350334167,"avg_line_length":31.015151977539062,"blob_id":"3cb85e52c627d48943f51df6d9b1f69150509dca","content_id":"4e53a72d6de86f22ce61167d05e84f913c919db2","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":4226,"license_type":"no_license","max_line_length":88,"num_lines":132,"path":"/app/api/projects.py","repo_name":"aleksandr-hilko/flask-vue-application-","src_encoding":"UTF-8","text":"from app.api import bp\nfrom app import db\nfrom app.api.serializers import project_schema, projects_schema\nfrom flask import request, jsonify\nfrom marshmallow import ValidationError\nfrom app.models import Project, Customer\nimport os\nfrom flask import current_app as app\nimport random\nimport tempfile\nfrom sqlalchemy import desc, asc\nfrom drive import upload_to_google_drive\nfrom app.helpers import check_token\n\n\n@bp.route(\"/projects//upload_contract\", methods=[\"POST\"])\n@check_token\ndef upload_contract(pk):\n \"\"\" Upload file to google drive and \n set project model contract field to the link to the uploaded file. \"\"\"\n if \"file\" in request.files:\n project = Project.query.get_or_404(pk)\n file_ = request.files[\"file\"]\n filename = project.name\n with tempfile.TemporaryDirectory() as tmpdirname:\n file_path = os.path.join(tmpdirname, filename)\n file_.save(file_path)\n\n try:\n drive_file = upload_to_google_drive(file_path, filename, file_.mimetype)\n except Exception as e:\n return {\"message\": f\"Failed to upload: {e}\"}, 400\n project.contract = drive_file[\"alternateLink\"]\n db.session.commit()\n return \"File is uploaded successfully\"\n else:\n return {\"message\": \"No file is provided\"}, 400\n\n\n@bp.route(\"/projects\", methods=[\"POST\"])\n@check_token\ndef create_project():\n json_data = request.get_json()\n if not json_data:\n return {\"message\": \"No input data provided\"}, 400\n try:\n project = project_schema.load(json_data)\n except ValidationError as err:\n return err.messages, 400\n # This is needed to prevent saving contract field\n # in the model without uploading the file\n project.contract = None\n db.session.add(project)\n db.session.commit()\n result = project_schema.dump(\n Project.query.filter(Project.name == project.name).first()\n )\n return jsonify(result)\n\n\n@bp.route(\"/projects\", methods=[\"GET\"])\n@check_token\ndef get_projects():\n params = request.args\n order_params = params.get(\"order\")\n query = Project.query.join(Customer)\n query = filter_query(query, params)\n if order_params:\n order_column, order_dir = order_params.split(\":\")\n order = asc(order_column) if order_dir == \"asc\" else desc(order_column)\n projects = query.order_by(order).all()\n else:\n projects = query.all()\n projects = projects_schema.dump(projects, many=True)\n return jsonify(projects)\n\n\ndef filter_query(query, params):\n work_started = params.get(\"work_started\")\n has_plan = params.get(\"has_plan\")\n has_contract = params.get(\"has_contract\")\n min_price = params.get(\"min_price\")\n max_price = params.get(\"max_price\")\n customer_name = params.get(\"customer_name\")\n\n if work_started:\n query = query.filter(Project.work_started == True)\n if has_plan:\n query = query.filter(Project.has_plan == True)\n if has_contract:\n query = query.filter(Project.has_contract == True)\n if customer_name:\n query = query.filter(Customer.customer_name == customer_name)\n if min_price:\n query = query.filter(Project.price >= min_price)\n if max_price:\n query = query.filter(Project.price <= max_price)\n\n return query\n\n\n@bp.route(\"/projects/\", methods=[\"GET\"])\n@check_token\ndef get_project(pk):\n project = Project.query.get_or_404(pk)\n project = project_schema.dump(project)\n return jsonify(project)\n\n\n@bp.route(\"/projects/\", methods=[\"PUT\"])\n@check_token\ndef update_project(pk):\n project = Project.query.get_or_404(pk)\n json_data = request.get_json()\n if not json_data:\n return {\"message\": \"No input data provided\"}, 400\n errors = project_schema.validate(json_data, partial=True, session=db.session)\n if errors:\n return errors, 400\n project.update(**json_data)\n db.session.commit()\n result = project_schema.dump(project)\n return jsonify(result), 201\n\n\n@bp.route(\"/projects/\", methods=[\"DELETE\"])\n@check_token\ndef delete_project(pk):\n project = Project.query.get_or_404(pk)\n db.session.delete(project)\n db.session.commit()\n return \"\", 204\n"},{"alpha_fraction":0.6006984710693359,"alphanum_fraction":0.6332945227622986,"avg_line_length":22.86111068725586,"blob_id":"b646e121ae82fd7f2c561fefd27b15874fef6b76","content_id":"7a2ebfc812789a2872f3ac3acc8d5e3a708025a7","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":859,"license_type":"no_license","max_line_length":83,"num_lines":36,"path":"/migrations/versions/2f05fd2f65a2_.py","repo_name":"aleksandr-hilko/flask-vue-application-","src_encoding":"UTF-8","text":"\"\"\"empty message\n\nRevision ID: 2f05fd2f65a2\nRevises: 7fb9174b3115\nCreate Date: 2020-02-12 15:54:21.515249\n\n\"\"\"\nfrom alembic import op\nimport sqlalchemy as sa\nfrom sqlalchemy.dialects import postgresql\n\n# revision identifiers, used by Alembic.\nrevision = \"2f05fd2f65a2\"\ndown_revision = \"7fb9174b3115\"\nbranch_labels = None\ndepends_on = None\n\n\ndef upgrade():\n # ### commands auto generated by Alembic - please adjust! ###\n op.drop_column(\"customer\", \"customer_type\")\n # ### end Alembic commands ###\n\n\ndef downgrade():\n # ### commands auto generated by Alembic - please adjust! ###\n op.add_column(\n \"customer\",\n sa.Column(\n \"customer_type\",\n postgresql.ENUM(\"organization\", \"individual\", name=\"customertypeenum\"),\n autoincrement=False,\n nullable=False,\n ),\n )\n # ### end Alembic commands ###\n"},{"alpha_fraction":0.6730462312698364,"alphanum_fraction":0.6889952421188354,"avg_line_length":27.5,"blob_id":"2aecc5513a8d8ea22bebc535ab0c4e0bf99e7ba0","content_id":"18f9c205a1382dd96c9b2501cb02d35594bed266","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":1881,"license_type":"no_license","max_line_length":87,"num_lines":66,"path":"/app/api/customers.py","repo_name":"aleksandr-hilko/flask-vue-application-","src_encoding":"UTF-8","text":"from app.api import bp\nfrom app import db\nfrom app.api.serializers import customer_schema\nfrom flask import request, jsonify\nfrom marshmallow import ValidationError\nfrom app.models import Customer\nfrom app.helpers import check_token\n\n\n@bp.route(\"/customers\", methods=[\"POST\"])\n@check_token\ndef create_customer():\n json_data = request.get_json()\n if not json_data:\n return {\"message\": \"No input data provided\"}, 400\n try:\n customer = customer_schema.load(json_data)\n except ValidationError as err:\n return err.messages, 400\n db.session.add(customer)\n db.session.commit()\n result = customer_schema.dump(\n Customer.query.filter(Customer.customer_name == customer.customer_name).first()\n )\n return jsonify(result), 201\n\n\n@bp.route(\"/customers\", methods=[\"GET\"])\n@check_token\ndef get_customers():\n customers = Customer.query.all()\n customers = customer_schema.dump(customers, many=True)\n return jsonify(customers)\n\n\n@bp.route(\"/customers/\", methods=[\"GET\"])\n@check_token\ndef get_customer(pk):\n customer = Customer.query.get_or_404(pk)\n customer = customer_schema.dump(customer)\n return jsonify(customer)\n\n\n@bp.route(\"/customers/\", methods=[\"PUT\"])\n@check_token\ndef update_customer(pk):\n customer = Customer.query.get_or_404(pk)\n json_data = request.get_json()\n if not json_data:\n return {\"message\": \"No input data provided\"}, 400\n errors = customer_schema.validate(json_data, partial=True)\n if errors:\n return errors, 400\n customer.update(**json_data)\n db.session.commit()\n result = customer_schema.dump(customer)\n return jsonify(result), 201\n\n\n@bp.route(\"/customers/\", methods=[\"DELETE\"])\n@check_token\ndef delete_customer(pk):\n customer = Customer.query.get_or_404(pk)\n db.session.delete(customer)\n db.session.commit()\n return \"\", 204\n"},{"alpha_fraction":0.6591702103614807,"alphanum_fraction":0.6684761643409729,"avg_line_length":32.93421173095703,"blob_id":"a79f5885e71ef6b2db688176a5b1691d01ea5855","content_id":"b6d7a3bf8376f32548e1a840dfe16dff645305a3","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":2579,"license_type":"no_license","max_line_length":70,"num_lines":76,"path":"/tests/test_customers.py","repo_name":"aleksandr-hilko/flask-vue-application-","src_encoding":"UTF-8","text":"import pytest\nfrom app.models import Customer\nfrom .common import fake\n\n\ndef generate_customer_data():\n customer_data = {\n \"customer_name\": fake.name(),\n \"payment_account\": str(fake.ipv4()),\n \"email\": fake.email(),\n \"phone\": fake.phone_number(),\n }\n return customer_data\n\n\n@pytest.fixture\ndef customer(create_db):\n data = generate_customer_data()\n customer = Customer(**data)\n create_db.session.add(customer)\n create_db.session.commit()\n customer = Customer.query.filter(\n Customer.customer_name == customer.customer_name\n ).first()\n return customer\n\n\ndef test_get_customers(client, customer):\n response = client.get(\"/api/customers\")\n assert response.status_code == 200\n resp_json = response.json\n assert len(resp_json) == 1\n assert customer.customer_name == resp_json[0][\"customer_name\"]\n assert customer.payment_account == resp_json[0][\"payment_account\"]\n assert customer.email == resp_json[0][\"email\"]\n assert customer.phone == resp_json[0][\"phone\"]\n\n\ndef test_get_customer(client, customer):\n response = client.get(f\"/api/customers/{customer.id}\")\n assert response.status_code == 200\n resp_json = response.json\n assert customer.customer_name == resp_json[\"customer_name\"]\n assert customer.payment_account == resp_json[\"payment_account\"]\n assert customer.email == resp_json[\"email\"]\n assert customer.phone == resp_json[\"phone\"]\n\n\ndef test_create_customer(client, create_db):\n data = generate_customer_data()\n resp = client.post(\"/api/customers\", json=data)\n assert resp.status_code == 201\n resp_json = resp.json\n assert resp_json[\"customer_name\"] == data[\"customer_name\"]\n assert resp_json[\"payment_account\"] == data[\"payment_account\"]\n assert resp_json[\"email\"] == data[\"email\"]\n assert resp_json[\"phone\"] == data[\"phone\"]\n\n\ndef test_update_customer(client, customer):\n data = generate_customer_data()\n resp = client.put(f\"/api/customers/{customer.id}\", json=data)\n assert resp.status_code == 201\n resp = client.get(f\"/api/customers/{customer.id}\")\n resp_json = resp.json\n assert resp_json[\"customer_name\"] == data[\"customer_name\"]\n assert resp_json[\"payment_account\"] == data[\"payment_account\"]\n assert resp_json[\"email\"] == data[\"email\"]\n assert resp_json[\"phone\"] == data[\"phone\"]\n\n\ndef test_delete_customer(client, customer):\n resp = client.delete(f\"/api/customers/{customer.id}\")\n assert resp.status_code == 204\n resp = client.get(f\"/api/customers/{customer.id}\")\n assert resp.status_code == 404\n"},{"alpha_fraction":0.651260495185852,"alphanum_fraction":0.651260495185852,"avg_line_length":34.70000076293945,"blob_id":"ca39cede1021a474518e195515ba8ad507730d98","content_id":"4bb56a85b9df1c47ce340f6a90844dd4fb2c8434","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":714,"license_type":"no_license","max_line_length":88,"num_lines":20,"path":"/drive.py","repo_name":"aleksandr-hilko/flask-vue-application-","src_encoding":"UTF-8","text":"from pydrive.auth import GoogleAuth\nfrom pydrive.drive import GoogleDrive\n\n\ndef upload_to_google_drive(filepath, filename, mimetype):\n settings_path = \"settings.yaml\"\n gauth = GoogleAuth(settings_file=settings_path)\n drive = GoogleDrive(gauth)\n file_list = drive.ListFile({\"q\": \"'root' in parents\"}).GetList()\n try:\n for file_ in file_list:\n if file_[\"title\"] == filename:\n file_.Delete()\n except:\n pass\n drive_file = drive.CreateFile({\"title\": filename, \"mimeType\": mimetype})\n drive_file.SetContentFile(filepath)\n drive_file.Upload()\n drive_file.InsertPermission({\"type\": \"anyone\", \"value\": \"anyone\", \"role\": \"reader\"})\n return drive_file\n"},{"alpha_fraction":0.7108168005943298,"alphanum_fraction":0.7119205594062805,"avg_line_length":24.16666603088379,"blob_id":"ff8f4897141c5cc5eca1be2e72949e8cd6216e21","content_id":"9b12f844bbe3015a38bab17605f5c43fb7fdd33b","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":906,"license_type":"no_license","max_line_length":113,"num_lines":36,"path":"/config.py","repo_name":"aleksandr-hilko/flask-vue-application-","src_encoding":"UTF-8","text":"from app.helpers import get_env_variable\nfrom pathlib import Path\n\nPOSTGRES_URL = get_env_variable(\"POSTGRES_URL\")\nPOSTGRES_USER = get_env_variable(\"POSTGRES_USER\")\nPOSTGRES_PW = get_env_variable(\"POSTGRES_PW\")\nPOSTGRES_DB = get_env_variable(\"POSTGRES_DB\")\n\n\nclass Config(object):\n DEBUG = False\n TESTING = False\n CSRF_ENABLED = True\n SECRET_KEY = get_env_variable(\"SECRET_KEY\")\n SQLALCHEMY_TRACK_MODIFICATIONS = False\n SQLALCHEMY_DATABASE_URI = f\"postgresql+psycopg2://{POSTGRES_USER}:{POSTGRES_PW}@{POSTGRES_URL}/{POSTGRES_DB}\"\n UPLOAD_FOLDER = f\"{Path().absolute()}/static/uploaded_projects\"\n\n\nclass ProductionConfig(Config):\n DEBUG = False\n\n\nclass StagingConfig(Config):\n DEVELOPMENT = True\n DEBUG = True\n\n\nclass DevelopmentConfig(Config):\n DEVELOPMENT = True\n DEBUG = True\n\n\nclass TestingConfig(Config):\n TESTING = True\n SQLALCHEMY_DATABASE_URI = \"sqlite://\"\n"},{"alpha_fraction":0.5035971403121948,"alphanum_fraction":0.70103919506073,"avg_line_length":16.619718551635742,"blob_id":"e76a6315f2a9cc54addd4649ebc1bbd53d619120","content_id":"02113e52a5dfe1686ab0339188f04244e12b9bd2","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Text","length_bytes":1251,"license_type":"no_license","max_line_length":32,"num_lines":71,"path":"/requirements.txt","repo_name":"aleksandr-hilko/flask-vue-application-","src_encoding":"UTF-8","text":"alembic==1.4.0\naniso8601==8.0.0\nappdirs==1.4.3\naspy.yaml==1.3.0\nattrs==19.3.0\nbcrypt==3.1.7\ncachetools==4.0.0\ncertifi==2019.11.28\ncffi==1.14.0\ncfgv==3.0.0\nchardet==3.0.4\nClick==7.0\nfactory-boy==2.12.0\nFaker==4.0.0\nfilelock==3.0.12\nFlask==1.1.1\nFlask-Bcrypt==0.7.1\nFlask-Cors==3.0.4\nflask-marshmallow==0.11.0\nFlask-Migrate==2.5.2\nFlask-RESTful==0.3.8\nFlask-SQLAlchemy==2.4.1\ngoogle-api-python-client==1.7.11\ngoogle-auth==1.11.2\ngoogle-auth-httplib2==0.0.3\ngoogle-auth-oauthlib==0.4.1\nhttplib2==0.17.0\nidentify==1.4.11\nidna==2.8\nimportlib-metadata==1.5.0\nitsdangerous==1.1.0\nJinja2==2.11.1\nMako==1.1.1\nMarkupSafe==1.1.1\nmarshmallow==3.4.0\nmarshmallow-sqlalchemy==0.22.2\nmore-itertools==8.2.0\nnodeenv==1.3.5\noauth2client==4.1.3\noauthlib==3.1.0\npackaging==20.1\npluggy==0.13.1\npre-commit==2.0.1\npsycopg2==2.8.4\npy==1.8.1\npyasn1==0.4.8\npyasn1-modules==0.2.8\npycparser==2.19\nPyDrive==1.3.1\nPyJWT==1.7.1\npyparsing==2.4.6\npytest==5.3.5\npytest-flask==0.15.1\npython-dateutil==2.8.1\npython-dotenv==0.11.0\npython-editor==1.0.4\npytz==2019.3\nPyYAML==5.3\nrequests==2.22.0\nrequests-oauthlib==1.3.0\nrsa==4.0\nsix==1.14.0\nSQLAlchemy==1.3.13\ntext-unidecode==1.3\ntoml==0.10.0\nuritemplate==3.0.1\nurllib3==1.25.8\nvirtualenv==20.0.1\nwcwidth==0.1.8\nWerkzeug==1.0.0\nzipp==2.2.0\n"},{"alpha_fraction":0.6864563822746277,"alphanum_fraction":0.6864563822746277,"avg_line_length":17.586206436157227,"blob_id":"8a13f267c3d1a03e09256c917867fdd926d4e443","content_id":"4e329ccfd3e09a4e8835a3b3078aa1fe64e1552a","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":539,"license_type":"no_license","max_line_length":64,"num_lines":29,"path":"/tests/conftest.py","repo_name":"aleksandr-hilko/flask-vue-application-","src_encoding":"UTF-8","text":"import pytest\nfrom app import create_app, db\nfrom config import TestingConfig\n\n\n@pytest.fixture(scope=\"session\")\ndef app():\n flask_app = create_app(TestingConfig)\n\n # Establish an application context before running the tests.\n ctx = flask_app.app_context()\n ctx.push()\n\n yield flask_app\n\n ctx.pop()\n\n\n@pytest.fixture(scope=\"session\")\ndef client(app):\n testing_client = app.test_client()\n yield testing_client\n\n\n@pytest.fixture(scope=\"session\")\ndef create_db(app):\n db.create_all()\n yield db\n db.drop_all()\n"},{"alpha_fraction":0.6250787377357483,"alphanum_fraction":0.6402016282081604,"avg_line_length":28.38888931274414,"blob_id":"0fe1768a04babc3a7d459088a8054d928666092c","content_id":"fe13b63aee8b87232aa584a3bb9b2e4097aebda8","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":1587,"license_type":"no_license","max_line_length":85,"num_lines":54,"path":"/migrations/versions/b0c1692627cf_.py","repo_name":"aleksandr-hilko/flask-vue-application-","src_encoding":"UTF-8","text":"\"\"\"empty message\n\nRevision ID: b0c1692627cf\nRevises: 2f05fd2f65a2\nCreate Date: 2020-02-13 10:23:24.658938\n\n\"\"\"\nfrom alembic import op\nimport sqlalchemy as sa\nfrom sqlalchemy.dialects import postgresql\n\n# revision identifiers, used by Alembic.\nrevision = \"b0c1692627cf\"\ndown_revision = \"2f05fd2f65a2\"\nbranch_labels = None\ndepends_on = None\n\n\ndef upgrade():\n # ### commands auto generated by Alembic - please adjust! ###\n op.add_column(\n \"project\", sa.Column(\"contract\", sa.String(length=200), nullable=True)\n )\n op.add_column(\"project\", sa.Column(\"has_contract\", sa.Boolean(), nullable=True))\n op.add_column(\"project\", sa.Column(\"has_plan\", sa.Boolean(), nullable=True))\n op.add_column(\"project\", sa.Column(\"price\", sa.Integer(), nullable=True))\n op.alter_column(\n \"project\",\n \"expiration_date\",\n existing_type=postgresql.TIMESTAMP(),\n nullable=True,\n )\n op.alter_column(\n \"project\", \"start_date\", existing_type=postgresql.TIMESTAMP(), nullable=True\n )\n # ### end Alembic commands ###\n\n\ndef downgrade():\n # ### commands auto generated by Alembic - please adjust! ###\n op.alter_column(\n \"project\", \"start_date\", existing_type=postgresql.TIMESTAMP(), nullable=False\n )\n op.alter_column(\n \"project\",\n \"expiration_date\",\n existing_type=postgresql.TIMESTAMP(),\n nullable=False,\n )\n op.drop_column(\"project\", \"price\")\n op.drop_column(\"project\", \"has_plan\")\n op.drop_column(\"project\", \"has_contract\")\n op.drop_column(\"project\", \"contract\")\n # ### end Alembic commands ###\n"},{"alpha_fraction":0.7727272510528564,"alphanum_fraction":0.7727272510528564,"avg_line_length":21,"blob_id":"d62ed28eb825d0e2a01af976919b65e9b2730a1e","content_id":"56403bdcd78c5449301f95d6e7056689ad80963c","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":176,"license_type":"no_license","max_line_length":31,"num_lines":8,"path":"/app/api/__init__.py","repo_name":"aleksandr-hilko/flask-vue-application-","src_encoding":"UTF-8","text":"from flask import Blueprint\nfrom flask_restful import Api\n\nbp = Blueprint(\"api\", __name__)\n\nfrom app.api import customers\nfrom app.api import projects\nfrom app.api import auth\n"},{"alpha_fraction":0.5541161894798279,"alphanum_fraction":0.5633096694946289,"avg_line_length":37.59677505493164,"blob_id":"efd519c94971878ce0798350f0774f3bf1723df1","content_id":"f37ffcb50b230b1a1df3facfd554f571e4d6d18c","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":2393,"license_type":"no_license","max_line_length":85,"num_lines":62,"path":"/app/api/auth.py","repo_name":"aleksandr-hilko/flask-vue-application-","src_encoding":"UTF-8","text":"from app.api import bp\nfrom app import db, bcrypt\nfrom flask import request, make_response, jsonify\nfrom app.models import User, BlacklistToken\n\n\n@bp.route(\"/auth/login\", methods=[\"POST\"])\ndef login():\n post_data = request.get_json()\n try:\n user = User.query.filter_by(email=post_data.get(\"email\")).first()\n if user and bcrypt.check_password_hash(\n user.password, post_data.get(\"password\")\n ):\n auth_token = user.encode_auth_token(user.id)\n if auth_token:\n responseObject = {\n \"status\": \"success\",\n \"message\": \"Successfully logged in.\",\n \"auth_token\": auth_token.decode(),\n }\n return make_response(jsonify(responseObject)), 200\n else:\n responseObject = {\"status\": \"fail\", \"message\": \"User does not exist.\"}\n return make_response(jsonify(responseObject)), 404\n except Exception as e:\n print(e)\n responseObject = {\"status\": \"fail\", \"message\": \"Try again\"}\n return make_response(jsonify(responseObject)), 500\n\n\n@bp.route(\"/auth/logout\", methods=[\"POST\"])\ndef logout():\n # get auth token\n auth_header = request.headers.get(\"Authorization\")\n if auth_header:\n auth_token = auth_header.split(\" \")[1]\n else:\n auth_token = \"\"\n if auth_token:\n resp = User.decode_auth_token(auth_token)\n if not isinstance(resp, str):\n # mark the token as blacklisted\n blacklist_token = BlacklistToken(token=auth_token)\n try:\n # insert the token\n db.session.add(blacklist_token)\n db.session.commit()\n responseObject = {\n \"status\": \"success\",\n \"message\": \"Successfully logged out.\",\n }\n return make_response(jsonify(responseObject)), 200\n except Exception as e:\n responseObject = {\"status\": \"fail\", \"message\": e}\n return make_response(jsonify(responseObject)), 200\n else:\n responseObject = {\"status\": \"fail\", \"message\": resp}\n return make_response(jsonify(responseObject)), 401\n else:\n responseObject = {\"status\": \"fail\", \"message\": \"Provide a valid auth token.\"}\n return make_response(jsonify(responseObject)), 403\n"},{"alpha_fraction":0.7432432174682617,"alphanum_fraction":0.7432432174682617,"avg_line_length":17.25,"blob_id":"076a0c69d8cb462090a166b7dad6f9d9f66c55a5","content_id":"a2639cf083cab6208cef4f1eeee82c003eb75c86","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":74,"license_type":"no_license","max_line_length":26,"num_lines":4,"path":"/wsgi.py","repo_name":"aleksandr-hilko/flask-vue-application-","src_encoding":"UTF-8","text":"# backend/wsgi.py\n\nfrom app import create_app\napplication = create_app()\n\n"},{"alpha_fraction":0.6148914098739624,"alphanum_fraction":0.6235780715942383,"avg_line_length":32.344825744628906,"blob_id":"1f75f90cea9160c8298b5aec6c7e458d37d2c56d","content_id":"72910603c3f60126f9d4f385f4f628adc13883e2","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":4835,"license_type":"no_license","max_line_length":84,"num_lines":145,"path":"/app/models.py","repo_name":"aleksandr-hilko/flask-vue-application-","src_encoding":"UTF-8","text":"from app import db, bcrypt\nfrom flask import current_app\nimport datetime\nimport jwt\n\n\nclass AddressMixin:\n email = db.Column(db.String(120), nullable=True)\n phone = db.Column(db.String(120), nullable=True)\n address = db.Column(db.String(120), nullable=True)\n\n\nclass UpdateModelMixin:\n def update(self, **kwargs):\n for key, value in kwargs.items():\n setattr(self, key, value)\n\n\nclass Employee(AddressMixin, db.Model):\n id = db.Column(db.Integer, primary_key=True)\n first_name = db.Column(db.String(50), nullable=False)\n last_name = db.Column(db.String(50), nullable=False)\n patronymic = db.Column(db.String(50), nullable=True)\n profession = db.Column(db.String(50), nullable=False)\n is_manager = db.Column(db.Boolean, default=False)\n\n def __repr__(self):\n return f\"\"\n\n\nclass Customer(AddressMixin, UpdateModelMixin, db.Model):\n id = db.Column(db.Integer, primary_key=True)\n customer_name = db.Column(db.String(50), unique=True, nullable=False)\n payment_account = db.Column(db.String(20), unique=True, nullable=False)\n\n projects = db.relationship(\"Project\", backref=\"customer\", passive_deletes=True)\n\n def __repr__(self):\n return f\"\"\n\n\nclass Project(UpdateModelMixin, db.Model):\n id = db.Column(db.Integer, primary_key=True)\n name = db.Column(db.String(50), unique=True, nullable=False)\n customer_id = db.Column(\n db.Integer, db.ForeignKey(\"customer.id\", ondelete=\"CASCADE\"), nullable=False\n )\n has_contract = db.Column(db.Boolean, default=False, nullable=True)\n has_plan = db.Column(db.Boolean, default=False, nullable=True)\n price = db.Column(db.Integer, nullable=True)\n\n contract = db.Column(db.String(200), nullable=True)\n\n work_started = db.Column(db.Boolean, default=False, nullable=True)\n expiration_date = db.Column(db.Date, nullable=True)\n\n def __repr__(self):\n return f\"\"\n\n\nclass User(db.Model):\n \"\"\" User Model for storing user related details \"\"\"\n\n __tablename__ = \"users\"\n\n id = db.Column(db.Integer, primary_key=True, autoincrement=True)\n email = db.Column(db.String(255), unique=True, nullable=False)\n password = db.Column(db.String(255), nullable=False)\n registered_on = db.Column(db.DateTime, nullable=False)\n admin = db.Column(db.Boolean, nullable=False, default=False)\n\n def __init__(self, email, password, admin=False):\n self.email = email\n self.password = bcrypt.generate_password_hash(\n password, current_app.config.get(\"BCRYPT_LOG_ROUNDS\")\n ).decode()\n self.registered_on = datetime.datetime.now()\n self.admin = admin\n\n def encode_auth_token(self, user_id):\n \"\"\"\n Generates the Auth Token\n :return: string\n \"\"\"\n try:\n payload = {\n \"exp\": datetime.datetime.utcnow()\n + datetime.timedelta(\n days=0, seconds=current_app.config.get(\"JWT_LIFE\", 600)\n ),\n \"iat\": datetime.datetime.utcnow(),\n \"sub\": user_id,\n }\n return jwt.encode(\n payload, current_app.config.get(\"SECRET_KEY\"), algorithm=\"HS256\"\n )\n except Exception as e:\n return e\n\n @staticmethod\n def decode_auth_token(auth_token):\n \"\"\"\n Validates the auth token\n :param auth_token:\n :return: integer|string\n \"\"\"\n try:\n payload = jwt.decode(auth_token, current_app.config.get(\"SECRET_KEY\"))\n is_blacklisted_token = BlacklistToken.check_blacklist(auth_token)\n if is_blacklisted_token:\n return \"Token blacklisted. Please log in again.\"\n else:\n return payload[\"sub\"]\n except jwt.ExpiredSignatureError:\n return \"Signature expired. Please log in again.\"\n except jwt.InvalidTokenError:\n return \"Invalid token. Please log in again.\"\n\n\nclass BlacklistToken(db.Model):\n \"\"\"\n Token Model for storing JWT tokens\n \"\"\"\n\n __tablename__ = \"blacklist_tokens\"\n\n id = db.Column(db.Integer, primary_key=True, autoincrement=True)\n token = db.Column(db.String(500), unique=True, nullable=False)\n blacklisted_on = db.Column(db.DateTime, nullable=False)\n\n def __init__(self, token):\n self.token = token\n self.blacklisted_on = datetime.datetime.now()\n\n def __repr__(self):\n return \"/upload_contract\\\", methods=[\\\"POST\\\"])\\n@check_token\\ndef upload_contract(pk):\\n \\\"\\\"\\\" Upload file to google drive and \\n set project model contract field to the link to the uploaded file. \\\"\\\"\\\"\\n if \\\"file\\\" in request.files:\\n project = Project.query.get_or_404(pk)\\n file_ = request.files[\\\"file\\\"]\\n filename = project.name\\n with tempfile.TemporaryDirectory() as tmpdirname:\\n file_path = os.path.join(tmpdirname, filename)\\n file_.save(file_path)\\n\\n try:\\n drive_file = upload_to_google_drive(file_path, filename, file_.mimetype)\\n except Exception as e:\\n return {\\\"message\\\": f\\\"Failed to upload: {e}\\\"}, 400\\n project.contract = drive_file[\\\"alternateLink\\\"]\\n db.session.commit()\\n return \\\"File is uploaded successfully\\\"\\n else:\\n return {\\\"message\\\": \\\"No file is provided\\\"}, 400\\n\\n\\n@bp.route(\\\"/projects\\\", methods=[\\\"POST\\\"])\\n@check_token\\ndef create_project():\\n json_data = request.get_json()\\n if not json_data:\\n return {\\\"message\\\": \\\"No input data provided\\\"}, 400\\n try:\\n project = project_schema.load(json_data)\\n except ValidationError as err:\\n return err.messages, 400\\n # This is needed to prevent saving contract field\\n # in the model without uploading the file\\n project.contract = None\\n db.session.add(project)\\n db.session.commit()\\n result = project_schema.dump(\\n Project.query.filter(Project.name == project.name).first()\\n )\\n return jsonify(result)\\n\\n\\n@bp.route(\\\"/projects\\\", methods=[\\\"GET\\\"])\\n@check_token\\ndef get_projects():\\n params = request.args\\n order_params = params.get(\\\"order\\\")\\n query = Project.query.join(Customer)\\n query = filter_query(query, params)\\n if order_params:\\n order_column, order_dir = order_params.split(\\\":\\\")\\n order = asc(order_column) if order_dir == \\\"asc\\\" else desc(order_column)\\n projects = query.order_by(order).all()\\n else:\\n projects = query.all()\\n projects = projects_schema.dump(projects, many=True)\\n return jsonify(projects)\\n\\n\\ndef filter_query(query, params):\\n work_started = params.get(\\\"work_started\\\")\\n has_plan = params.get(\\\"has_plan\\\")\\n has_contract = params.get(\\\"has_contract\\\")\\n min_price = params.get(\\\"min_price\\\")\\n max_price = params.get(\\\"max_price\\\")\\n customer_name = params.get(\\\"customer_name\\\")\\n\\n if work_started:\\n query = query.filter(Project.work_started == True)\\n if has_plan:\\n query = query.filter(Project.has_plan == True)\\n if has_contract:\\n query = query.filter(Project.has_contract == True)\\n if customer_name:\\n query = query.filter(Customer.customer_name == customer_name)\\n if min_price:\\n query = query.filter(Project.price >= min_price)\\n if max_price:\\n query = query.filter(Project.price <= max_price)\\n\\n return query\\n\\n\\n@bp.route(\\\"/projects/\\\", methods=[\\\"GET\\\"])\\n@check_token\\ndef get_project(pk):\\n project = Project.query.get_or_404(pk)\\n project = project_schema.dump(project)\\n return jsonify(project)\\n\\n\\n@bp.route(\\\"/projects/\\\", methods=[\\\"PUT\\\"])\\n@check_token\\ndef update_project(pk):\\n project = Project.query.get_or_404(pk)\\n json_data = request.get_json()\\n if not json_data:\\n return {\\\"message\\\": \\\"No input data provided\\\"}, 400\\n errors = project_schema.validate(json_data, partial=True, session=db.session)\\n if errors:\\n return errors, 400\\n project.update(**json_data)\\n db.session.commit()\\n result = project_schema.dump(project)\\n return jsonify(result), 201\\n\\n\\n@bp.route(\\\"/projects/\\\", methods=[\\\"DELETE\\\"])\\n@check_token\\ndef delete_project(pk):\\n project = Project.query.get_or_404(pk)\\n db.session.delete(project)\\n db.session.commit()\\n return \\\"\\\", 204\\n\"\n },\n {\n \"alpha_fraction\": 0.6006984710693359,\n \"alphanum_fraction\": 0.6332945227622986,\n \"avg_line_length\": 22.86111068725586,\n \"blob_id\": \"b646e121ae82fd7f2c561fefd27b15874fef6b76\",\n \"content_id\": \"7a2ebfc812789a2872f3ac3acc8d5e3a708025a7\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 859,\n \"license_type\": \"no_license\",\n \"max_line_length\": 83,\n \"num_lines\": 36,\n \"path\": \"/migrations/versions/2f05fd2f65a2_.py\",\n \"repo_name\": \"aleksandr-hilko/flask-vue-application-\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"\\\"\\\"\\\"empty message\\n\\nRevision ID: 2f05fd2f65a2\\nRevises: 7fb9174b3115\\nCreate Date: 2020-02-12 15:54:21.515249\\n\\n\\\"\\\"\\\"\\nfrom alembic import op\\nimport sqlalchemy as sa\\nfrom sqlalchemy.dialects import postgresql\\n\\n# revision identifiers, used by Alembic.\\nrevision = \\\"2f05fd2f65a2\\\"\\ndown_revision = \\\"7fb9174b3115\\\"\\nbranch_labels = None\\ndepends_on = None\\n\\n\\ndef upgrade():\\n # ### commands auto generated by Alembic - please adjust! ###\\n op.drop_column(\\\"customer\\\", \\\"customer_type\\\")\\n # ### end Alembic commands ###\\n\\n\\ndef downgrade():\\n # ### commands auto generated by Alembic - please adjust! ###\\n op.add_column(\\n \\\"customer\\\",\\n sa.Column(\\n \\\"customer_type\\\",\\n postgresql.ENUM(\\\"organization\\\", \\\"individual\\\", name=\\\"customertypeenum\\\"),\\n autoincrement=False,\\n nullable=False,\\n ),\\n )\\n # ### end Alembic commands ###\\n\"\n },\n {\n \"alpha_fraction\": 0.6730462312698364,\n \"alphanum_fraction\": 0.6889952421188354,\n \"avg_line_length\": 27.5,\n \"blob_id\": \"2aecc5513a8d8ea22bebc535ab0c4e0bf99e7ba0\",\n \"content_id\": \"18f9c205a1382dd96c9b2501cb02d35594bed266\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 1881,\n \"license_type\": \"no_license\",\n \"max_line_length\": 87,\n \"num_lines\": 66,\n \"path\": \"/app/api/customers.py\",\n \"repo_name\": \"aleksandr-hilko/flask-vue-application-\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from app.api import bp\\nfrom app import db\\nfrom app.api.serializers import customer_schema\\nfrom flask import request, jsonify\\nfrom marshmallow import ValidationError\\nfrom app.models import Customer\\nfrom app.helpers import check_token\\n\\n\\n@bp.route(\\\"/customers\\\", methods=[\\\"POST\\\"])\\n@check_token\\ndef create_customer():\\n json_data = request.get_json()\\n if not json_data:\\n return {\\\"message\\\": \\\"No input data provided\\\"}, 400\\n try:\\n customer = customer_schema.load(json_data)\\n except ValidationError as err:\\n return err.messages, 400\\n db.session.add(customer)\\n db.session.commit()\\n result = customer_schema.dump(\\n Customer.query.filter(Customer.customer_name == customer.customer_name).first()\\n )\\n return jsonify(result), 201\\n\\n\\n@bp.route(\\\"/customers\\\", methods=[\\\"GET\\\"])\\n@check_token\\ndef get_customers():\\n customers = Customer.query.all()\\n customers = customer_schema.dump(customers, many=True)\\n return jsonify(customers)\\n\\n\\n@bp.route(\\\"/customers/\\\", methods=[\\\"GET\\\"])\\n@check_token\\ndef get_customer(pk):\\n customer = Customer.query.get_or_404(pk)\\n customer = customer_schema.dump(customer)\\n return jsonify(customer)\\n\\n\\n@bp.route(\\\"/customers/\\\", methods=[\\\"PUT\\\"])\\n@check_token\\ndef update_customer(pk):\\n customer = Customer.query.get_or_404(pk)\\n json_data = request.get_json()\\n if not json_data:\\n return {\\\"message\\\": \\\"No input data provided\\\"}, 400\\n errors = customer_schema.validate(json_data, partial=True)\\n if errors:\\n return errors, 400\\n customer.update(**json_data)\\n db.session.commit()\\n result = customer_schema.dump(customer)\\n return jsonify(result), 201\\n\\n\\n@bp.route(\\\"/customers/\\\", methods=[\\\"DELETE\\\"])\\n@check_token\\ndef delete_customer(pk):\\n customer = Customer.query.get_or_404(pk)\\n db.session.delete(customer)\\n db.session.commit()\\n return \\\"\\\", 204\\n\"\n },\n {\n \"alpha_fraction\": 0.6591702103614807,\n \"alphanum_fraction\": 0.6684761643409729,\n \"avg_line_length\": 32.93421173095703,\n \"blob_id\": \"a79f5885e71ef6b2db688176a5b1691d01ea5855\",\n \"content_id\": \"b6d7a3bf8376f32548e1a840dfe16dff645305a3\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 2579,\n \"license_type\": \"no_license\",\n \"max_line_length\": 70,\n \"num_lines\": 76,\n \"path\": \"/tests/test_customers.py\",\n \"repo_name\": \"aleksandr-hilko/flask-vue-application-\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import pytest\\nfrom app.models import Customer\\nfrom .common import fake\\n\\n\\ndef generate_customer_data():\\n customer_data = {\\n \\\"customer_name\\\": fake.name(),\\n \\\"payment_account\\\": str(fake.ipv4()),\\n \\\"email\\\": fake.email(),\\n \\\"phone\\\": fake.phone_number(),\\n }\\n return customer_data\\n\\n\\n@pytest.fixture\\ndef customer(create_db):\\n data = generate_customer_data()\\n customer = Customer(**data)\\n create_db.session.add(customer)\\n create_db.session.commit()\\n customer = Customer.query.filter(\\n Customer.customer_name == customer.customer_name\\n ).first()\\n return customer\\n\\n\\ndef test_get_customers(client, customer):\\n response = client.get(\\\"/api/customers\\\")\\n assert response.status_code == 200\\n resp_json = response.json\\n assert len(resp_json) == 1\\n assert customer.customer_name == resp_json[0][\\\"customer_name\\\"]\\n assert customer.payment_account == resp_json[0][\\\"payment_account\\\"]\\n assert customer.email == resp_json[0][\\\"email\\\"]\\n assert customer.phone == resp_json[0][\\\"phone\\\"]\\n\\n\\ndef test_get_customer(client, customer):\\n response = client.get(f\\\"/api/customers/{customer.id}\\\")\\n assert response.status_code == 200\\n resp_json = response.json\\n assert customer.customer_name == resp_json[\\\"customer_name\\\"]\\n assert customer.payment_account == resp_json[\\\"payment_account\\\"]\\n assert customer.email == resp_json[\\\"email\\\"]\\n assert customer.phone == resp_json[\\\"phone\\\"]\\n\\n\\ndef test_create_customer(client, create_db):\\n data = generate_customer_data()\\n resp = client.post(\\\"/api/customers\\\", json=data)\\n assert resp.status_code == 201\\n resp_json = resp.json\\n assert resp_json[\\\"customer_name\\\"] == data[\\\"customer_name\\\"]\\n assert resp_json[\\\"payment_account\\\"] == data[\\\"payment_account\\\"]\\n assert resp_json[\\\"email\\\"] == data[\\\"email\\\"]\\n assert resp_json[\\\"phone\\\"] == data[\\\"phone\\\"]\\n\\n\\ndef test_update_customer(client, customer):\\n data = generate_customer_data()\\n resp = client.put(f\\\"/api/customers/{customer.id}\\\", json=data)\\n assert resp.status_code == 201\\n resp = client.get(f\\\"/api/customers/{customer.id}\\\")\\n resp_json = resp.json\\n assert resp_json[\\\"customer_name\\\"] == data[\\\"customer_name\\\"]\\n assert resp_json[\\\"payment_account\\\"] == data[\\\"payment_account\\\"]\\n assert resp_json[\\\"email\\\"] == data[\\\"email\\\"]\\n assert resp_json[\\\"phone\\\"] == data[\\\"phone\\\"]\\n\\n\\ndef test_delete_customer(client, customer):\\n resp = client.delete(f\\\"/api/customers/{customer.id}\\\")\\n assert resp.status_code == 204\\n resp = client.get(f\\\"/api/customers/{customer.id}\\\")\\n assert resp.status_code == 404\\n\"\n },\n {\n \"alpha_fraction\": 0.651260495185852,\n \"alphanum_fraction\": 0.651260495185852,\n \"avg_line_length\": 34.70000076293945,\n \"blob_id\": \"ca39cede1021a474518e195515ba8ad507730d98\",\n \"content_id\": \"4bb56a85b9df1c47ce340f6a90844dd4fb2c8434\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 714,\n \"license_type\": \"no_license\",\n \"max_line_length\": 88,\n \"num_lines\": 20,\n \"path\": \"/drive.py\",\n \"repo_name\": \"aleksandr-hilko/flask-vue-application-\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from pydrive.auth import GoogleAuth\\nfrom pydrive.drive import GoogleDrive\\n\\n\\ndef upload_to_google_drive(filepath, filename, mimetype):\\n settings_path = \\\"settings.yaml\\\"\\n gauth = GoogleAuth(settings_file=settings_path)\\n drive = GoogleDrive(gauth)\\n file_list = drive.ListFile({\\\"q\\\": \\\"'root' in parents\\\"}).GetList()\\n try:\\n for file_ in file_list:\\n if file_[\\\"title\\\"] == filename:\\n file_.Delete()\\n except:\\n pass\\n drive_file = drive.CreateFile({\\\"title\\\": filename, \\\"mimeType\\\": mimetype})\\n drive_file.SetContentFile(filepath)\\n drive_file.Upload()\\n drive_file.InsertPermission({\\\"type\\\": \\\"anyone\\\", \\\"value\\\": \\\"anyone\\\", \\\"role\\\": \\\"reader\\\"})\\n return drive_file\\n\"\n },\n {\n \"alpha_fraction\": 0.7108168005943298,\n \"alphanum_fraction\": 0.7119205594062805,\n \"avg_line_length\": 24.16666603088379,\n \"blob_id\": \"ff8f4897141c5cc5eca1be2e72949e8cd6216e21\",\n \"content_id\": \"9b12f844bbe3015a38bab17605f5c43fb7fdd33b\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 906,\n \"license_type\": \"no_license\",\n \"max_line_length\": 113,\n \"num_lines\": 36,\n \"path\": \"/config.py\",\n \"repo_name\": \"aleksandr-hilko/flask-vue-application-\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from app.helpers import get_env_variable\\nfrom pathlib import Path\\n\\nPOSTGRES_URL = get_env_variable(\\\"POSTGRES_URL\\\")\\nPOSTGRES_USER = get_env_variable(\\\"POSTGRES_USER\\\")\\nPOSTGRES_PW = get_env_variable(\\\"POSTGRES_PW\\\")\\nPOSTGRES_DB = get_env_variable(\\\"POSTGRES_DB\\\")\\n\\n\\nclass Config(object):\\n DEBUG = False\\n TESTING = False\\n CSRF_ENABLED = True\\n SECRET_KEY = get_env_variable(\\\"SECRET_KEY\\\")\\n SQLALCHEMY_TRACK_MODIFICATIONS = False\\n SQLALCHEMY_DATABASE_URI = f\\\"postgresql+psycopg2://{POSTGRES_USER}:{POSTGRES_PW}@{POSTGRES_URL}/{POSTGRES_DB}\\\"\\n UPLOAD_FOLDER = f\\\"{Path().absolute()}/static/uploaded_projects\\\"\\n\\n\\nclass ProductionConfig(Config):\\n DEBUG = False\\n\\n\\nclass StagingConfig(Config):\\n DEVELOPMENT = True\\n DEBUG = True\\n\\n\\nclass DevelopmentConfig(Config):\\n DEVELOPMENT = True\\n DEBUG = True\\n\\n\\nclass TestingConfig(Config):\\n TESTING = True\\n SQLALCHEMY_DATABASE_URI = \\\"sqlite://\\\"\\n\"\n },\n {\n \"alpha_fraction\": 0.5035971403121948,\n \"alphanum_fraction\": 0.70103919506073,\n \"avg_line_length\": 16.619718551635742,\n \"blob_id\": \"e76a6315f2a9cc54addd4649ebc1bbd53d619120\",\n \"content_id\": \"02113e52a5dfe1686ab0339188f04244e12b9bd2\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Text\",\n \"length_bytes\": 1251,\n \"license_type\": \"no_license\",\n \"max_line_length\": 32,\n \"num_lines\": 71,\n \"path\": \"/requirements.txt\",\n \"repo_name\": \"aleksandr-hilko/flask-vue-application-\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"alembic==1.4.0\\naniso8601==8.0.0\\nappdirs==1.4.3\\naspy.yaml==1.3.0\\nattrs==19.3.0\\nbcrypt==3.1.7\\ncachetools==4.0.0\\ncertifi==2019.11.28\\ncffi==1.14.0\\ncfgv==3.0.0\\nchardet==3.0.4\\nClick==7.0\\nfactory-boy==2.12.0\\nFaker==4.0.0\\nfilelock==3.0.12\\nFlask==1.1.1\\nFlask-Bcrypt==0.7.1\\nFlask-Cors==3.0.4\\nflask-marshmallow==0.11.0\\nFlask-Migrate==2.5.2\\nFlask-RESTful==0.3.8\\nFlask-SQLAlchemy==2.4.1\\ngoogle-api-python-client==1.7.11\\ngoogle-auth==1.11.2\\ngoogle-auth-httplib2==0.0.3\\ngoogle-auth-oauthlib==0.4.1\\nhttplib2==0.17.0\\nidentify==1.4.11\\nidna==2.8\\nimportlib-metadata==1.5.0\\nitsdangerous==1.1.0\\nJinja2==2.11.1\\nMako==1.1.1\\nMarkupSafe==1.1.1\\nmarshmallow==3.4.0\\nmarshmallow-sqlalchemy==0.22.2\\nmore-itertools==8.2.0\\nnodeenv==1.3.5\\noauth2client==4.1.3\\noauthlib==3.1.0\\npackaging==20.1\\npluggy==0.13.1\\npre-commit==2.0.1\\npsycopg2==2.8.4\\npy==1.8.1\\npyasn1==0.4.8\\npyasn1-modules==0.2.8\\npycparser==2.19\\nPyDrive==1.3.1\\nPyJWT==1.7.1\\npyparsing==2.4.6\\npytest==5.3.5\\npytest-flask==0.15.1\\npython-dateutil==2.8.1\\npython-dotenv==0.11.0\\npython-editor==1.0.4\\npytz==2019.3\\nPyYAML==5.3\\nrequests==2.22.0\\nrequests-oauthlib==1.3.0\\nrsa==4.0\\nsix==1.14.0\\nSQLAlchemy==1.3.13\\ntext-unidecode==1.3\\ntoml==0.10.0\\nuritemplate==3.0.1\\nurllib3==1.25.8\\nvirtualenv==20.0.1\\nwcwidth==0.1.8\\nWerkzeug==1.0.0\\nzipp==2.2.0\\n\"\n },\n {\n \"alpha_fraction\": 0.6864563822746277,\n \"alphanum_fraction\": 0.6864563822746277,\n \"avg_line_length\": 17.586206436157227,\n \"blob_id\": \"8a13f267c3d1a03e09256c917867fdd926d4e443\",\n \"content_id\": \"4e329ccfd3e09a4e8835a3b3078aa1fe64e1552a\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 539,\n \"license_type\": \"no_license\",\n \"max_line_length\": 64,\n \"num_lines\": 29,\n \"path\": \"/tests/conftest.py\",\n \"repo_name\": \"aleksandr-hilko/flask-vue-application-\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import pytest\\nfrom app import create_app, db\\nfrom config import TestingConfig\\n\\n\\n@pytest.fixture(scope=\\\"session\\\")\\ndef app():\\n flask_app = create_app(TestingConfig)\\n\\n # Establish an application context before running the tests.\\n ctx = flask_app.app_context()\\n ctx.push()\\n\\n yield flask_app\\n\\n ctx.pop()\\n\\n\\n@pytest.fixture(scope=\\\"session\\\")\\ndef client(app):\\n testing_client = app.test_client()\\n yield testing_client\\n\\n\\n@pytest.fixture(scope=\\\"session\\\")\\ndef create_db(app):\\n db.create_all()\\n yield db\\n db.drop_all()\\n\"\n },\n {\n \"alpha_fraction\": 0.6250787377357483,\n \"alphanum_fraction\": 0.6402016282081604,\n \"avg_line_length\": 28.38888931274414,\n \"blob_id\": \"0fe1768a04babc3a7d459088a8054d928666092c\",\n \"content_id\": \"fe13b63aee8b87232aa584a3bb9b2e4097aebda8\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 1587,\n \"license_type\": \"no_license\",\n \"max_line_length\": 85,\n \"num_lines\": 54,\n \"path\": \"/migrations/versions/b0c1692627cf_.py\",\n \"repo_name\": \"aleksandr-hilko/flask-vue-application-\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"\\\"\\\"\\\"empty message\\n\\nRevision ID: b0c1692627cf\\nRevises: 2f05fd2f65a2\\nCreate Date: 2020-02-13 10:23:24.658938\\n\\n\\\"\\\"\\\"\\nfrom alembic import op\\nimport sqlalchemy as sa\\nfrom sqlalchemy.dialects import postgresql\\n\\n# revision identifiers, used by Alembic.\\nrevision = \\\"b0c1692627cf\\\"\\ndown_revision = \\\"2f05fd2f65a2\\\"\\nbranch_labels = None\\ndepends_on = None\\n\\n\\ndef upgrade():\\n # ### commands auto generated by Alembic - please adjust! ###\\n op.add_column(\\n \\\"project\\\", sa.Column(\\\"contract\\\", sa.String(length=200), nullable=True)\\n )\\n op.add_column(\\\"project\\\", sa.Column(\\\"has_contract\\\", sa.Boolean(), nullable=True))\\n op.add_column(\\\"project\\\", sa.Column(\\\"has_plan\\\", sa.Boolean(), nullable=True))\\n op.add_column(\\\"project\\\", sa.Column(\\\"price\\\", sa.Integer(), nullable=True))\\n op.alter_column(\\n \\\"project\\\",\\n \\\"expiration_date\\\",\\n existing_type=postgresql.TIMESTAMP(),\\n nullable=True,\\n )\\n op.alter_column(\\n \\\"project\\\", \\\"start_date\\\", existing_type=postgresql.TIMESTAMP(), nullable=True\\n )\\n # ### end Alembic commands ###\\n\\n\\ndef downgrade():\\n # ### commands auto generated by Alembic - please adjust! ###\\n op.alter_column(\\n \\\"project\\\", \\\"start_date\\\", existing_type=postgresql.TIMESTAMP(), nullable=False\\n )\\n op.alter_column(\\n \\\"project\\\",\\n \\\"expiration_date\\\",\\n existing_type=postgresql.TIMESTAMP(),\\n nullable=False,\\n )\\n op.drop_column(\\\"project\\\", \\\"price\\\")\\n op.drop_column(\\\"project\\\", \\\"has_plan\\\")\\n op.drop_column(\\\"project\\\", \\\"has_contract\\\")\\n op.drop_column(\\\"project\\\", \\\"contract\\\")\\n # ### end Alembic commands ###\\n\"\n },\n {\n \"alpha_fraction\": 0.7727272510528564,\n \"alphanum_fraction\": 0.7727272510528564,\n \"avg_line_length\": 21,\n \"blob_id\": \"d62ed28eb825d0e2a01af976919b65e9b2730a1e\",\n \"content_id\": \"56403bdcd78c5449301f95d6e7056689ad80963c\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 176,\n \"license_type\": \"no_license\",\n \"max_line_length\": 31,\n \"num_lines\": 8,\n \"path\": \"/app/api/__init__.py\",\n \"repo_name\": \"aleksandr-hilko/flask-vue-application-\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from flask import Blueprint\\nfrom flask_restful import Api\\n\\nbp = Blueprint(\\\"api\\\", __name__)\\n\\nfrom app.api import customers\\nfrom app.api import projects\\nfrom app.api import auth\\n\"\n },\n {\n \"alpha_fraction\": 0.5541161894798279,\n \"alphanum_fraction\": 0.5633096694946289,\n \"avg_line_length\": 37.59677505493164,\n \"blob_id\": \"efd519c94971878ce0798350f0774f3bf1723df1\",\n \"content_id\": \"f37ffcb50b230b1a1df3facfd554f571e4d6d18c\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 2393,\n \"license_type\": \"no_license\",\n \"max_line_length\": 85,\n \"num_lines\": 62,\n \"path\": \"/app/api/auth.py\",\n \"repo_name\": \"aleksandr-hilko/flask-vue-application-\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from app.api import bp\\nfrom app import db, bcrypt\\nfrom flask import request, make_response, jsonify\\nfrom app.models import User, BlacklistToken\\n\\n\\n@bp.route(\\\"/auth/login\\\", methods=[\\\"POST\\\"])\\ndef login():\\n post_data = request.get_json()\\n try:\\n user = User.query.filter_by(email=post_data.get(\\\"email\\\")).first()\\n if user and bcrypt.check_password_hash(\\n user.password, post_data.get(\\\"password\\\")\\n ):\\n auth_token = user.encode_auth_token(user.id)\\n if auth_token:\\n responseObject = {\\n \\\"status\\\": \\\"success\\\",\\n \\\"message\\\": \\\"Successfully logged in.\\\",\\n \\\"auth_token\\\": auth_token.decode(),\\n }\\n return make_response(jsonify(responseObject)), 200\\n else:\\n responseObject = {\\\"status\\\": \\\"fail\\\", \\\"message\\\": \\\"User does not exist.\\\"}\\n return make_response(jsonify(responseObject)), 404\\n except Exception as e:\\n print(e)\\n responseObject = {\\\"status\\\": \\\"fail\\\", \\\"message\\\": \\\"Try again\\\"}\\n return make_response(jsonify(responseObject)), 500\\n\\n\\n@bp.route(\\\"/auth/logout\\\", methods=[\\\"POST\\\"])\\ndef logout():\\n # get auth token\\n auth_header = request.headers.get(\\\"Authorization\\\")\\n if auth_header:\\n auth_token = auth_header.split(\\\" \\\")[1]\\n else:\\n auth_token = \\\"\\\"\\n if auth_token:\\n resp = User.decode_auth_token(auth_token)\\n if not isinstance(resp, str):\\n # mark the token as blacklisted\\n blacklist_token = BlacklistToken(token=auth_token)\\n try:\\n # insert the token\\n db.session.add(blacklist_token)\\n db.session.commit()\\n responseObject = {\\n \\\"status\\\": \\\"success\\\",\\n \\\"message\\\": \\\"Successfully logged out.\\\",\\n }\\n return make_response(jsonify(responseObject)), 200\\n except Exception as e:\\n responseObject = {\\\"status\\\": \\\"fail\\\", \\\"message\\\": e}\\n return make_response(jsonify(responseObject)), 200\\n else:\\n responseObject = {\\\"status\\\": \\\"fail\\\", \\\"message\\\": resp}\\n return make_response(jsonify(responseObject)), 401\\n else:\\n responseObject = {\\\"status\\\": \\\"fail\\\", \\\"message\\\": \\\"Provide a valid auth token.\\\"}\\n return make_response(jsonify(responseObject)), 403\\n\"\n },\n {\n \"alpha_fraction\": 0.7432432174682617,\n \"alphanum_fraction\": 0.7432432174682617,\n \"avg_line_length\": 17.25,\n \"blob_id\": \"076a0c69d8cb462090a166b7dad6f9d9f66c55a5\",\n \"content_id\": \"a2639cf083cab6208cef4f1eeee82c003eb75c86\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 74,\n \"license_type\": \"no_license\",\n \"max_line_length\": 26,\n \"num_lines\": 4,\n \"path\": \"/wsgi.py\",\n \"repo_name\": \"aleksandr-hilko/flask-vue-application-\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# backend/wsgi.py\\n\\nfrom app import create_app\\napplication = create_app()\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.6148914098739624,\n \"alphanum_fraction\": 0.6235780715942383,\n \"avg_line_length\": 32.344825744628906,\n \"blob_id\": \"1f75f90cea9160c8298b5aec6c7e458d37d2c56d\",\n \"content_id\": \"72910603c3f60126f9d4f385f4f628adc13883e2\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 4835,\n \"license_type\": \"no_license\",\n \"max_line_length\": 84,\n \"num_lines\": 145,\n \"path\": \"/app/models.py\",\n \"repo_name\": \"aleksandr-hilko/flask-vue-application-\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from app import db, bcrypt\\nfrom flask import current_app\\nimport datetime\\nimport jwt\\n\\n\\nclass AddressMixin:\\n email = db.Column(db.String(120), nullable=True)\\n phone = db.Column(db.String(120), nullable=True)\\n address = db.Column(db.String(120), nullable=True)\\n\\n\\nclass UpdateModelMixin:\\n def update(self, **kwargs):\\n for key, value in kwargs.items():\\n setattr(self, key, value)\\n\\n\\nclass Employee(AddressMixin, db.Model):\\n id = db.Column(db.Integer, primary_key=True)\\n first_name = db.Column(db.String(50), nullable=False)\\n last_name = db.Column(db.String(50), nullable=False)\\n patronymic = db.Column(db.String(50), nullable=True)\\n profession = db.Column(db.String(50), nullable=False)\\n is_manager = db.Column(db.Boolean, default=False)\\n\\n def __repr__(self):\\n return f\\\"\\\"\\n\\n\\nclass Customer(AddressMixin, UpdateModelMixin, db.Model):\\n id = db.Column(db.Integer, primary_key=True)\\n customer_name = db.Column(db.String(50), unique=True, nullable=False)\\n payment_account = db.Column(db.String(20), unique=True, nullable=False)\\n\\n projects = db.relationship(\\\"Project\\\", backref=\\\"customer\\\", passive_deletes=True)\\n\\n def __repr__(self):\\n return f\\\"\\\"\\n\\n\\nclass Project(UpdateModelMixin, db.Model):\\n id = db.Column(db.Integer, primary_key=True)\\n name = db.Column(db.String(50), unique=True, nullable=False)\\n customer_id = db.Column(\\n db.Integer, db.ForeignKey(\\\"customer.id\\\", ondelete=\\\"CASCADE\\\"), nullable=False\\n )\\n has_contract = db.Column(db.Boolean, default=False, nullable=True)\\n has_plan = db.Column(db.Boolean, default=False, nullable=True)\\n price = db.Column(db.Integer, nullable=True)\\n\\n contract = db.Column(db.String(200), nullable=True)\\n\\n work_started = db.Column(db.Boolean, default=False, nullable=True)\\n expiration_date = db.Column(db.Date, nullable=True)\\n\\n def __repr__(self):\\n return f\\\"\\\"\\n\\n\\nclass User(db.Model):\\n \\\"\\\"\\\" User Model for storing user related details \\\"\\\"\\\"\\n\\n __tablename__ = \\\"users\\\"\\n\\n id = db.Column(db.Integer, primary_key=True, autoincrement=True)\\n email = db.Column(db.String(255), unique=True, nullable=False)\\n password = db.Column(db.String(255), nullable=False)\\n registered_on = db.Column(db.DateTime, nullable=False)\\n admin = db.Column(db.Boolean, nullable=False, default=False)\\n\\n def __init__(self, email, password, admin=False):\\n self.email = email\\n self.password = bcrypt.generate_password_hash(\\n password, current_app.config.get(\\\"BCRYPT_LOG_ROUNDS\\\")\\n ).decode()\\n self.registered_on = datetime.datetime.now()\\n self.admin = admin\\n\\n def encode_auth_token(self, user_id):\\n \\\"\\\"\\\"\\n Generates the Auth Token\\n :return: string\\n \\\"\\\"\\\"\\n try:\\n payload = {\\n \\\"exp\\\": datetime.datetime.utcnow()\\n + datetime.timedelta(\\n days=0, seconds=current_app.config.get(\\\"JWT_LIFE\\\", 600)\\n ),\\n \\\"iat\\\": datetime.datetime.utcnow(),\\n \\\"sub\\\": user_id,\\n }\\n return jwt.encode(\\n payload, current_app.config.get(\\\"SECRET_KEY\\\"), algorithm=\\\"HS256\\\"\\n )\\n except Exception as e:\\n return e\\n\\n @staticmethod\\n def decode_auth_token(auth_token):\\n \\\"\\\"\\\"\\n Validates the auth token\\n :param auth_token:\\n :return: integer|string\\n \\\"\\\"\\\"\\n try:\\n payload = jwt.decode(auth_token, current_app.config.get(\\\"SECRET_KEY\\\"))\\n is_blacklisted_token = BlacklistToken.check_blacklist(auth_token)\\n if is_blacklisted_token:\\n return \\\"Token blacklisted. Please log in again.\\\"\\n else:\\n return payload[\\\"sub\\\"]\\n except jwt.ExpiredSignatureError:\\n return \\\"Signature expired. Please log in again.\\\"\\n except jwt.InvalidTokenError:\\n return \\\"Invalid token. Please log in again.\\\"\\n\\n\\nclass BlacklistToken(db.Model):\\n \\\"\\\"\\\"\\n Token Model for storing JWT tokens\\n \\\"\\\"\\\"\\n\\n __tablename__ = \\\"blacklist_tokens\\\"\\n\\n id = db.Column(db.Integer, primary_key=True, autoincrement=True)\\n token = db.Column(db.String(500), unique=True, nullable=False)\\n blacklisted_on = db.Column(db.DateTime, nullable=False)\\n\\n def __init__(self, token):\\n self.token = token\\n self.blacklisted_on = datetime.datetime.now()\\n\\n def __repr__(self):\\n return \\\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"handGesture.hpp\"\n#include \"myImage.hpp\"\n\nusing namespace cv;\n\n\n#define ORIGCOL2COL CV_BGR2HLS\n#define COL2ORIGCOL CV_HLS2BGR\n#define NSAMPLES 7\n#define PI 3.14159\n\nHandGesture getHG2();\nvoid findHand2(MyImage *m);\nvoid setupFindHand2(MyImage *m);\n\n\n#endif\n"},{"alpha_fraction":0.5938736796379089,"alphanum_fraction":0.6286855936050415,"avg_line_length":30.876178741455078,"blob_id":"ea2f521ddfa3fcd27783a9392111b9a9a7b3d66b","content_id":"c0bfb13f99e9dc31a8057c3eb436e75634757fef","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":27031,"license_type":"no_license","max_line_length":137,"num_lines":848,"path":"/RedLegoDetector.cpp","repo_name":"Logan-Peters/UCLA-REU-Code","src_encoding":"UTF-8","text":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"main.hpp\"\n#include \n#include \"myImage.hpp\"\n#include \"handGesture.hpp\"\n#include \"main2.hpp\"\n#include \"PointPolygonInteresector.hpp\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace cv;\nusing namespace std;\nusing namespace chrono;\n\nint fast = 0;\nint fine = 0;\nint still = 0;\ndouble memorizeTime;\nvector height;\nvector height2;\nint numOfLegos = 0;\nint iterationOfExperiment = 0;\nbool foundLegosYet = false;\nauto start =\n\t\tduration_cast(system_clock::now().time_since_epoch()).count();\n\n//A structure containing data about the hand used to manipulate the legos\nstruct Hand {\n\tbool found;\n\tPoint prevHand;\n\tHandGesture hand;\n};\n\n//A structures containing all the statistics for lego's once they've appeared\nstruct foundLego {\n\tdouble startTime;\n\tdouble variationDistance;\n\tdouble variationAngle;\n\tdouble closestDistance;\n\tdouble closestAngle;\n\tdouble height;\n\tRotatedRect currentPos;\n};\n\nenum {\n\tSTILL, FINE, SPEEDY\n};\n\n//Given x,y coordinates from each camera of an ROI returns estimated depth in inches\nfloat* get3DCoords(float* l, float* r) {\n\tdouble b = 100.0 / 25.4 * 2;\n\tdouble f = (8.1259257941370424 + 8.1351812555998572) / 4 * 100 / 25.4 / .022\n\t\t\t/ 1.3; //Constants for our webcam\n\tint xl = l[0], xr = r[0], yi;\n\tyi = (l[1] + r[1]) / 2;\n\tint d = abs(xl - xr);\n\tdouble z = ((b * f / d));\n\tdouble x = z * xl / f;\n\tdouble y = z * yi / f;\n\tfloat* p = new float[3];\n\tp[0] = x;\n\tp[1] = y;\n\tp[2] = z;\n\treturn p;\n}\nbool tempor = true;\n\nint n = 0;\nint sockfd = 0;\n\n//Establishes the connection to the rasberry pi\nvoid setUpRasberry() {\n\tstruct sockaddr_in serv_addr;\n\n\tif ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {\n\t\tcout << \"Error : Could not create socket\" << endl;\n\t\treturn;\n\t}\n\tserv_addr.sin_family = AF_INET;\n\tserv_addr.sin_port = htons(65432);\n\tserv_addr.sin_addr.s_addr = inet_addr(\"172.20.10.6\");\n\n\tif (connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr))\n\t\t\t< 0) {\n\t\tcout << \"Error : Connect Failed\" << endl;\n\t\treturn;\n\t}\n\treturn;\n}\n\n//Sends whether the hand is in frame to the PI and receives whether or not the PI thinks a lego might\n//have been placed\nbool sendHandToRasberryPI(bool found) {\n\tchar * buffer = \"no\";\n\tif (found) {\n\t\tbuffer = \"yes\";\n\t}\n\n\tn = write(sockfd, buffer, strlen(buffer));\n\n\tstring output(1024, 0);\n\tread(sockfd, &output[0], 1024);\n\tif (strcmp(output.c_str(), \"placed\") == 0) {\n\t\tcout << \"placed\" << endl;\n\t\treturn true;\n\t}\n\tcout << \"not placed \" << endl;\n\treturn false;\n}\n\n//Processes the image to find the edges of the legos\nMat legoImageProcessing(Mat baseImage) {\n\tMat grid = Mat::zeros(baseImage.size(), CV_32F); //Creates an image to copy onto\n\timwrite(\"Base.jpg\", baseImage); //Saves base image\n\tMat temp = Mat::zeros(baseImage.size(), CV_32F); //a blank image to threshold onto\n\tGaussianBlur(baseImage, baseImage, Size(3, 3), 0, 0); //blurs the image to get rid of irregularities\n\tcvtColor(baseImage, baseImage, CV_BGR2HSV); //Swaps color space from BGR to HSV\n\tinRange(baseImage, Scalar(0, 50, 60), Scalar(10, 300, 300), temp); //Threshold the image\n\tinRange(baseImage, Scalar(170, 50, 60), Scalar(190, 300, 300), baseImage); //Threshold the image\n\taddWeighted(baseImage, 1.0, temp, 1.0, 0.0, grid); //Combines the two thresholds since red is on both ends of the hue values\n\n\timwrite(\"thresh.jpg\", grid); // Saves threshholded image\n\n\t//Dilates and then erodes the thresholded image consolidate parts\n\tdilate(grid, grid, getStructuringElement(MORPH_ELLIPSE, Size(35, 35)));\n\terode(grid, grid, getStructuringElement(MORPH_ELLIPSE, Size(35, 35)));\n\n\timwrite(\"de.jpg\", grid);\n\n\t//Erodes then dilates the thresholded image\n\terode(grid, grid, getStructuringElement(MORPH_ELLIPSE, Size(20, 20)));\n\tdilate(grid, grid, getStructuringElement(MORPH_ELLIPSE, Size(20, 20)));\n\n\t//Displays the thresholded image\n\tstring s = \"\";\n\tif (tempor) {\n\t\ts = \"thresh1\";\n\t} else {\n\t\ts = \"thresh2\";\n\t}\n\ttempor = !tempor;\n\timshow(s, grid);\n\timwrite(\"ed.jpg\", grid);\n\n\t//Detects the edges of the thresholded image\n\tCanny(grid, grid, 100, 200, 3);\n\treturn grid;\n}\n\n//Gets the contours of the legos\nvector> getContours(Mat processedImage) {\n\tvector hierarchy;\n\tvector> contours;\n\tfindContours(processedImage, contours, hierarchy, RETR_EXTERNAL,\n\t\t\tCV_CHAIN_APPROX_SIMPLE, Point(0, 0)); //Calculates the contours and ignores hierarchy\n\treturn contours;\n}\n\n//Draws a gray rectangle to represent the hand\nvoid drawHandRectangle(Hand *h, Mat *imgToDraw) {\n\tif (h->hand.bRect.area() < 80000) { //Only draws hand if bigger than a certain size\n\t\th->found = false;\n\t\treturn;\n\t}\n\trectangle(*imgToDraw, h->hand.bRect, Scalar(100, 100, 100), 2, 8, 0); //Draws a gray rectangle\n\th->found = true;\n}\n\n//updates current hand based on new frame\nvoid updateHand(Hand *h, HandGesture newHand) {\n\th->prevHand = Point(h->hand.bRect.x + h->hand.bRect.width / 2,\n\t\t\th->hand.bRect.y + h->hand.bRect.height / 2); //Updates prevHand\n\th->hand = newHand; //saves the new hand\n}\n\n//Calculates the hand movement type: STILL = hand off screen, FAST = hand on screen in rapid motion, FINE = slow hand movement\nint handMovementTracking(Hand h) {\n\tif (!h.found) { //If the hand isn't found\n\t\treturn STILL;\n\t}\n\tif (norm(\n\t\t\tPoint(h.hand.bRect.x + h.hand.bRect.width / 2,\n\t\t\t\t\th.hand.bRect.y + h.hand.bRect.height / 2) - h.prevHand)\n\t\t\t< 75) { //If the hand moved less than 75 pixels\n\t\treturn FINE;\n\t}\n\treturn SPEEDY;\n}\n\n//Transforms legos so that it is ordered so that the closest legos are at the same index as in firstLegos\nvoid maximizeCloseness(vector *legos,\n\t\tvector *firstLegos) {\n\tvector pos;\n\tvector distance;\n\tint newPos;\n\tint minDist = 1000000;\n\tint replaced = 0;\n\n\t//loops through legos and first legos\n\tfor (int i = 0; i < legos->size(); i++) {\n\t\tnewPos = i - replaced; //so that legos is bigger than firstLegos it'll just be put it at the end\n\t\tfor (int j = 0; j < firstLegos->size(); j++) {\n\t\t\tif (norm(legos->at(i).center - firstLegos->at(j).center)\n\t\t\t\t\t< minDist) { //if firstLegos->at(j) is the closest lego yet\n\t\t\t\tif (find(pos.begin(), pos.end(), j) == pos.end()) { //if no other lego has this as it's closest\n\t\t\t\t\tminDist = norm(\n\t\t\t\t\t\t\tlegos->at(i).center - firstLegos->at(j).center);\n\t\t\t\t\tnewPos = j;\n\t\t\t\t} else if (norm(legos->at(i).center - firstLegos->at(j).center)\n\t\t\t\t\t\t< distance[((find(pos.begin(), pos.end(), j)\n\t\t\t\t\t\t\t\t- pos.begin()))]) { //if this lego is closer than the other lego that has it as it's closest\n\t\t\t\t\tptrdiff_t a =\n\t\t\t\t\t\t\t(find(pos.begin(), pos.end(), j) - pos.begin());\n\t\t\t\t\tlegos->push_back(legos->at(a)); //re-adds the lego that this lego replaced\n\t\t\t\t\tpos[find(pos.begin(), pos.end(), j) - pos.begin()] = -1; //sets the pos position to -1 so it never get's found\n\t\t\t\t\tminDist = norm(\n\t\t\t\t\t\t\tlegos->at(i).center - firstLegos->at(j).center);\n\t\t\t\t\tnewPos = j;\n\t\t\t\t\treplaced++; //keeps track of how many -1's there are\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tpos.push_back(newPos);\n\t\tdistance.push_back(minDist);\n\t\tminDist = 1000000;\n\t}\n\tvector temp;\n\n\t//Reorders legos based on results from previous loop\n\tfor (int i = 0; i < legos->size() - replaced; i++) {\n\t\ttemp.push_back(\n\t\t\t\tlegos->at(\n\t\t\t\t\t\t(int) (find(pos.begin(), pos.end(), i) - pos.begin())));\n\t}\n\t*legos = temp;\n}\n\n//draws best fit rotated rectangle for the legos\nvoid drawLegos(RotatedRect cur, Mat toDraw, Scalar colorToDraw) {\n\tcv::Point2f pts2[4];\n\tcur.points(pts2);\n\tline(toDraw, pts2[0], pts2[1], colorToDraw, 2, 8, 0);\n\tline(toDraw, pts2[1], pts2[2], colorToDraw, 2, 8, 0);\n\tline(toDraw, pts2[2], pts2[3], colorToDraw, 2, 8, 0);\n\tline(toDraw, pts2[3], pts2[0], colorToDraw, 2, 8, 0);\n}\n\n//updates statistics for each lego\nvoid updateFoundLegosStatistics(vector *prevLego,\n\t\tvector *firstLegos, vector *foundLegos,\n\t\tbool legoPlaced) {\n\tif (firstLegos->size() < prevLego->size()) {\n\t\tcout << \"Seems like there are more legos placed than you started with\"\n\t\t\t\t<< endl;\n\t\treturn;\n\t}\n\tfor (int i = 0; i < prevLego->size(); i++) {\n\t\tif (!foundLegosYet || foundLegos->size() <= i) { //if it's the first time through or foundLegos size is less than i\n\t\t\tfoundLego l;\n\t\t\tfoundLegosYet = true;\n\t\t\tint minLoc = 0;\n\t\t\tint minDistance = 10000000;\n\t\t\tfor (int j = 0; j < firstLegos->size(); j++) { //finds closest lego\n\t\t\t\tif (norm(firstLegos->at(j).center - prevLego->at(i).center)\n\t\t\t\t\t\t< minDistance) {\n\t\t\t\t\tminLoc = j;\n\t\t\t\t\tminDistance = norm(\n\t\t\t\t\t\t\tfirstLegos->at(j).center - prevLego->at(i).center);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tnumOfLegos++;\n\t\t\tcout << \"New\" << endl;\n\t\t\t//updates the statistics\n\t\t\tl.closestAngle = abs(\n\t\t\t\t\tfirstLegos->at(minLoc).angle - prevLego->at(i).angle);\n\t\t\tl.closestDistance = minDistance;\n\t\t\tl.startTime = duration_cast(\n\t\t\t\t\tsystem_clock::now().time_since_epoch()).count();\n\t\t\tl.variationAngle = 0;\n\t\t\tl.variationDistance = 0;\n\t\t\tl.currentPos = prevLego->at(i);\n\t\t\tfoundLegos->push_back(l);\n\t\t} else {\n\t\t\t//Way to keep track of how many legos there are(not perfect)\n\t\t\tif ((foundLegos->at(i).height - height[i] > 1.2\n\t\t\t\t\t|| prevLego->at(i).size.area()\n\t\t\t\t\t\t\t- foundLegos->at(i).currentPos.size.area() > 1250)) {\n\t\t\t\tcout << \"new lego\" << endl;\n\t\t\t\tnumOfLegos++;\n\t\t\t}\n\t\t\tif (foundLegos->at(i).height - height[i] > .2) {\n\t\t\t\tcout << \"why...\";\n\t\t\t}\n\t\t\tif (prevLego->at(i).size.area()\n\t\t\t\t\t- foundLegos->at(i).currentPos.size.area() > 1000) {\n\t\t\t\tcout << \"...\";\n\t\t\t}\n\t\t\tcout << numOfLegos << endl;\n\n\t\t\tif (foundLegos->at(i).closestAngle\n\t\t\t\t\t> fmod(\n\t\t\t\t\t\t\tabs(\n\t\t\t\t\t\t\t\t\tfoundLegos->at(i).currentPos.angle\n\t\t\t\t\t\t\t\t\t\t\t- firstLegos->at(i).angle), 45)) {\n\t\t\t\tfoundLegos->at(i).closestAngle = fmod(\n\t\t\t\t\t\tabs(\n\t\t\t\t\t\t\t\tfoundLegos->at(i).currentPos.angle\n\t\t\t\t\t\t\t\t\t\t- firstLegos->at(i).angle), 45);\n\t\t\t}\n\t\t\tif (foundLegos->at(i).closestDistance\n\t\t\t\t\t> norm(\n\t\t\t\t\t\t\tfoundLegos->at(i).currentPos.center\n\t\t\t\t\t\t\t\t\t- firstLegos->at(i).center)) {\n\t\t\t\tfoundLegos->at(i).closestDistance = norm(\n\t\t\t\t\t\tfoundLegos->at(i).currentPos.center\n\t\t\t\t\t\t\t\t- firstLegos->at(i).center);\n\t\t\t}\n\t\t\tif (norm(\n\t\t\t\t\tfoundLegos->at(i).currentPos.center\n\t\t\t\t\t\t\t- prevLego->at(i).center) > 5) {\n//\t\t\t\tcout\n//\t\t\t\t<< norm(\n//\t\t\t\t\t\tfoundLegos->at(i).currentPos.center\n//\t\t\t\t\t\t- prevLego->at(i).center) << endl;\n\n\t\t\t\tfoundLegos->at(i).variationDistance += norm(\n\t\t\t\t\t\tfoundLegos->at(i).currentPos.center\n\t\t\t\t\t\t\t\t- prevLego->at(i).center);\n\t\t\t}\n\t\t\tif (fmod(\n\t\t\t\t\tabs(\n\t\t\t\t\t\t\tfoundLegos->at(i).currentPos.angle\n\t\t\t\t\t\t\t\t\t- prevLego->at(i).angle), 45) > 3) {\n//\t\t\t\tcout\n//\t\t\t\t\t\t<< fmod(\n//\t\t\t\t\t\t\t\tabs(\n//\t\t\t\t\t\t\t\t\t\tfoundLegos->at(i).currentPos.angle\n//\t\t\t\t\t\t\t\t\t\t\t\t- prevLego->at(i).angle), 45)\n//\t\t\t\t\t\t<< endl;\n\t\t\t\tfoundLegos->at(i).variationAngle += fmod(\n\t\t\t\t\t\tabs(\n\t\t\t\t\t\t\t\tfoundLegos->at(i).currentPos.angle\n\t\t\t\t\t\t\t\t\t\t- prevLego->at(i).angle), 45);\n\t\t\t}\n\t\t\tfoundLegos->at(i).currentPos = prevLego->at(i);\n\n\t\t}\n\t}\n\n}\n\n//Finds corresponding legos and calculate distance based on stereovision techniques. Prints out guess.\nvoid stereoVision(vector legos, vector legos2,\n\t\tvector *color, vector *color2, Mat imageToDraw) {\n\tint a = 0;\n\tint b = 0;\n\tfor (int i = 0; i < min(legos.size() - a, legos2.size() + b); i++) {\n\t\tif (i + a >= legos.size()) {\n\t\t\tbreak;\n\t\t} else if (i + b >= legos2.size()) {\n\t\t\tbreak;\n\t\t}\n\n\t\t//checks if the y difference is greater than 50\n\t\tif (abs(legos[i + a].center.y - legos2[i + b].center.y) > 50) {\n\t\t\tif (legos[i + a].center.y < legos2[i + b].center.y) { //depending on which one was on the bottom it removes it and then continues loop\n\t\t\t\tlegos.erase(legos.begin() + i + a);\n\t\t\t\ta++;\n\t\t\t} else {\n\t\t\t\tlegos2.erase(legos2.begin() + i + b);\n\t\t\t\tb++;\n\t\t\t}\n\t\t\ti--;\n\t\t\tcontinue;\n\t\t}\n\n\t\t//checks that if the x values are too far away from each other\n\t\tif (abs(legos[i + a].center.x - legos[i + b].center.x) > 1000) {\n\t\t\tif (legos[i + a].center.y < legos2[i + b].center.y) { //depending on which one was on the bottom it removes it and then continues loop\n\t\t\t\tlegos.erase(legos.begin() + i + a);\n\t\t\t\ta++;\n\t\t\t} else {\n\t\t\t\tlegos2.erase(legos2.begin() + i + b);\n\t\t\t\tb++;\n\t\t\t}\n\t\t\ti--;\n\t\t\tcontinue;\n\t\t}\n\n\t\t//passed previous two conditions so must be the same lego\n\n\t\tcolor2->at(i + b) = color->at(i + a); //sets them to be the same color\n\t\tline(imageToDraw, legos[i + a].center,\n\t\t\t\tPoint(legos2[i + b].center.x + imageToDraw.cols / 2,\n\t\t\t\t\t\tlegos2[i + b].center.y), Scalar(255, 255, 255), 2, 8,\n\t\t\t\t0); //draws a line between them\n\t\tint q = legos2[i + b].center.x - legos[i + a].center.x;\n\t\tstring s = \"Offset: \" + to_string(q);\n\t\tputText(imageToDraw, s,\n\t\t\t\tcvPoint(\n\t\t\t\t\t\tlegos[i + a].center.x / 2 + imageToDraw.cols / 4\n\t\t\t\t\t\t\t\t+ legos2[i + b].center.x / 2,\n\t\t\t\t\t\tlegos[i + a].center.y / 2 - 15\n\t\t\t\t\t\t\t\t+ legos2[i + b].center.y / 2),\n\t\t\t\tFONT_HERSHEY_COMPLEX_SMALL, 1.4, cvScalar(255, 255, 255), 1,\n\t\t\t\tCV_AA); //writes offset\n\t\tfloat left[2] = { legos[i + a].center.x, legos[i + a].center.y };\n\t\tfloat right[2] = { legos2[i + a].center.x, legos2[i + a].center.y };\n\t\tfloat* coord = get3DCoords(left, right);\n\t\theight.push_back(coord[2]);\n\t\tputText(imageToDraw, to_string(coord[2]),\n\t\t\t\tcvPoint(legos2[i + b].center.x - 10 + imageToDraw.cols / 2,\n\t\t\t\t\t\tlegos2[i + b].center.y + 40),\n\t\t\t\tFONT_HERSHEY_COMPLEX_SMALL, 1.4, cvScalar(255, 255, 255), 1,\n\t\t\t\tCV_AA); //writes distance\n\t\tputText(imageToDraw, to_string(coord[2]),\n\t\t\t\tcvPoint(legos[i + a].center.x - 10, legos[i + a].center.y + 40),\n\t\t\t\tFONT_HERSHEY_COMPLEX_SMALL, 1.4, cvScalar(255, 255, 255), 1,\n\t\t\t\tCV_AA); //writes distance\n\t}\n}\n\n//Displays the original placement of legos in green and the placement of the legos in\n//red. Also prints out and saves a number of metrics to be used as input for HMM.\nvoid showCorrected(vector firstLegos2, vector legos2,\n\t\tvector firstLegos, vector legos,\n\t\tMat leftCorrection, Mat rightCorrection, long start2,\n\t\tvector foundLegos, vector foundLegos2) {\n\tdouble dist = 0;\n\tdouble angle = 0;\n\tint legoNumber = 0;\n\tofstream file;\n\tfile.open(\"Data.txt\", std::ios::app);\n\tfile << fixed;\n\tcout << iterationOfExperiment << endl;\n\tfile << iterationOfExperiment << \", \";\n\n\tmaximizeCloseness(&legos, &firstLegos);\n\n\t//finds each legos distance and angle difference and draws them\n\tfor (int q = 0; q < legos.size(); q++) {\n\t\tPoint2f pts2[4];\n\t\tlegos[q].points(pts2);\n\t\tline(leftCorrection, pts2[0], pts2[1], Scalar(0, 255, 0), 2, 8, 0);\n\t\tline(leftCorrection, pts2[1], pts2[2], Scalar(0, 255, 0), 2, 8, 0);\n\t\tline(leftCorrection, pts2[2], pts2[3], Scalar(0, 255, 0), 2, 8, 0);\n\t\tline(leftCorrection, pts2[3], pts2[0], Scalar(0, 255, 0), 2, 8, 0);\n\n\t\tfirstLegos[q].points(pts2);\n\t\tline(leftCorrection, pts2[0], pts2[1], Scalar(0, 0, 255), 2, 8, 0);\n\t\tline(leftCorrection, pts2[1], pts2[2], Scalar(0, 0, 255), 2, 8, 0);\n\t\tline(leftCorrection, pts2[2], pts2[3], Scalar(0, 0, 255), 2, 8, 0);\n\t\tline(leftCorrection, pts2[3], pts2[0], Scalar(0, 0, 255), 2, 8, 0);\n\t\tfile << norm(legos[q].center - firstLegos[q].center) << \", \";\n\t\tfile << fmod(abs(legos[q].angle - firstLegos[q].angle), 45) << \", \";\n\t\tcout << \"Lego Number \" << legoNumber << \" distance \"\n\t\t\t\t<< norm(legos[q].center - firstLegos[q].center) << endl;\n\t\tcout << \"Lego Number \" << legoNumber << \" angle \"\n\t\t\t\t<< fmod(abs(legos[q].angle - firstLegos[q].angle), 45) << endl;\n\t\tdist += norm(legos[q].center - firstLegos[q].center);\n\t\tangle += fmod(abs(legos[q].angle - firstLegos[q].angle), 45);\n\t\tlegoNumber++;\n\t}\n\n\tdouble dist2 = 0;\n\tdouble angle2 = 0;\n\n\t//finds each legos distance and angle difference and draws them\n\tmaximizeCloseness(&legos2, &firstLegos2);\n\tlegoNumber = 0;\n\tfor (int q = 0; q < legos2.size(); q++) {\n\t\tPoint2f pts2[4];\n\t\tlegos2[q].points(pts2);\n\t\tline(rightCorrection, pts2[0], pts2[1], Scalar(0, 255, 0), 2, 8, 0);\n\t\tline(rightCorrection, pts2[1], pts2[2], Scalar(0, 255, 0), 2, 8, 0);\n\t\tline(rightCorrection, pts2[2], pts2[3], Scalar(0, 255, 0), 2, 8, 0);\n\t\tline(rightCorrection, pts2[3], pts2[0], Scalar(0, 255, 0), 2, 8, 0);\n\n\t\tfirstLegos2[q].points(pts2);\n\t\tline(rightCorrection, pts2[0], pts2[1], Scalar(0, 0, 255), 2, 8, 0);\n\t\tline(rightCorrection, pts2[1], pts2[2], Scalar(0, 0, 255), 2, 8, 0);\n\t\tline(rightCorrection, pts2[2], pts2[3], Scalar(0, 0, 255), 2, 8, 0);\n\t\tline(rightCorrection, pts2[3], pts2[0], Scalar(0, 0, 255), 2, 8, 0);\n\t\tfile << norm(legos2[q].center - firstLegos2[q].center) << \", \";\n\t\tfile << fmod(abs(legos2[q].angle - firstLegos2[q].angle), 45) << \", \";\n\t\tcout << \"Lego Number \" << legoNumber << \" distance \"\n\t\t\t\t<< norm(legos2[q].center - firstLegos2[q].center) << endl;\n\t\tcout << \"Lego Number \" << legoNumber << \" angle \"\n\t\t\t\t<< fmod(abs(legos2[q].angle - firstLegos2[q].angle), 45)\n\t\t\t\t<< endl;\n\t\tlegoNumber++;\n\n\t\tdist2 += norm(legos2[q].center - firstLegos2[q].center);\n\t\tangle2 += fmod(abs(legos2[q].angle - firstLegos2[q].angle), 45);\n\t}\n\n\t//writes all the statistics\n\tfile << (dist + dist2) / 2 << \", \";\n\tfile << (angle + 2) / 2 << \", \";\n\tfile << still << \", \";\n\tfile << fine << \", \";\n\tfile << fast << \", \";\n\tcout << \"Distance Difference: \" << (dist + dist2) / 2 << endl;\n\tcout << \"Angle Difference: \" << (angle + angle2) / 2 << endl;\n\tfile\n\t\t\t<< (duration_cast(\n\t\t\t\t\tsystem_clock::now().time_since_epoch()).count() - start2)\n\t\t\t\t\t/ 1000000000.0 << \", \";\n\tfile << memorizeTime << \", \";\n\tfile << start2 - memorizeTime << \", \";\n\tcout << start2 - memorizeTime << endl;\n\t;\n\tfile\n\t\t\t<< duration_cast(\n\t\t\t\t\tsystem_clock::now().time_since_epoch()).count() << \", \";\n\tcout\n\t\t\t<< duration_cast(\n\t\t\t\t\tsystem_clock::now().time_since_epoch()).count() << endl;\n\tcout << \"Time to Memorize: \" << memorizeTime << endl;\n\tcout << \"Time to Place: \"\n\t\t\t<< (duration_cast(\n\t\t\t\t\tsystem_clock::now().time_since_epoch()).count() - start2)\n\t\t\t<< endl;\n\tcout << \"Still: \" << still << endl;\n\tcout << \"Fast: \" << fast << endl;\n\tcout << \"Fine: \" << fine << endl;\n\tlegoNumber = 0;\n\tfor (int i = 0; i < min(foundLegos.size(), foundLegos2.size()); i++) {\n\t\tcout << \"Lego Number \" << legoNumber << \" Variation Angle: \"\n\t\t\t\t<< (foundLegos[i].variationAngle + foundLegos2[i].variationAngle)\n\t\t\t\t\t\t/ 2 << endl;\n\t\tcout << \"Lego Number \" << legoNumber << \" Variation Distance: \"\n\t\t\t\t<< (foundLegos[i].variationDistance\n\t\t\t\t\t\t+ foundLegos2[i].variationDistance) / 2 << endl;\n\t\tcout << \"Lego Number \" << legoNumber << \" Closest Angle: \"\n\t\t\t\t<< (foundLegos[i].closestAngle + foundLegos2[i].closestAngle)\n\t\t\t\t\t\t/ 2 << endl;\n\t\tcout << \"Lego Number \" << legoNumber << \" Closest Distance: \"\n\t\t\t\t<< (foundLegos[i].closestDistance\n\t\t\t\t\t\t+ foundLegos2[i].closestDistance) / 2 << endl;\n\n\t\tcout << \"Lego Number \" << legoNumber << \" Initial Placement Time: \"\n\t\t\t\t<< (foundLegos[i].startTime - start2) << endl;\n\n\t\tfile\n\t\t\t\t<< (foundLegos[i].variationAngle + foundLegos2[i].variationAngle)\n\t\t\t\t\t\t/ 2 << \", \";\n\t\tfile\n\t\t\t\t<< (foundLegos[i].variationDistance\n\t\t\t\t\t\t+ foundLegos2[i].variationDistance) / 2 << \", \";\n\t\tfile << (foundLegos[i].closestAngle + foundLegos2[i].closestAngle) / 2\n\t\t\t\t<< \", \";\n\t\tfile\n\t\t\t\t<< (foundLegos[i].closestDistance\n\t\t\t\t\t\t+ foundLegos2[i].closestDistance) / 2 << \", \";\n\n\t\tfile << (foundLegos[i].startTime - start2) << \", \";\n\t\tlegoNumber++;\n\t}\n\tfile << endl;\n\timshow(\"Left Correction\", leftCorrection);\n\timshow(\"Right Correction\", rightCorrection);\n\twaitKey(0);\n}\n\nint main(int argc, char** argv) {\n\tcout << fixed;\n\t//setUpRasberry();\n\tvector firstlegos;\n\tvector firstlegos2;\n\twhile (true) {\n\t\tVideoCapture cap(0);\n\t\tVideoCapture cap2(1);\n\t\titerationOfExperiment++;\n\t\tvector foundLegos;\n\t\tvector foundLegos2;\n\t\tint count = 0;\n\t\tMyImage m(0);\n\t\tMyImage m2(1);\n\t\tHand hand;\n\t\tHand hand2;\n\t\tMat imgTmp;\n\t\tMat imgTmp2;\n\t\tsetupFindHand(&m);\n\t\tsetupFindHand2(&m2);\n\t\tcap2.read(imgTmp2);\n\t\tcap.read(imgTmp);\n\t\tbool newLegoPossible = false;\n\t\tvector prevLegos;\n\t\tvector prevLegos2;\n\t\tvector legos;\n\t\tvector legos2;\n\t\tvector color;\n\t\tvector prevColor;\n\t\tvector color2;\n\t\tvector prevColor2;\n\t\tbool legoPlaced;\n\t\twhile (true) {\n\t\t\tMat lines = Mat::zeros(imgTmp.size(), CV_8U);\n\t\t\tMat lines2 = Mat::zeros(imgTmp.size(), CV_8U);\n\t\t\tcvtColor(lines, lines, CV_GRAY2BGR);\n\t\t\tcvtColor(lines2, lines2, CV_GRAY2BGR);\n\n\t\t\tMat imgTmp;\n\t\t\tMat imgTmp2;\n\t\t\tcap.read(imgTmp);\n\t\t\tcap2.read(imgTmp2);\n\t\t\tMat grid = legoImageProcessing(imgTmp);\n\t\t\tMat grid2 = legoImageProcessing(imgTmp2);\n\n\t\t\timwrite(\"canny.jpg\", grid2);\n\n\t\t\tvector> contours = getContours(grid);\n\t\t\tvector> contours2 = getContours(grid2);\n\n\t\t\tvector color;\n\t\t\tvector color2;\n\n\t\t\t//Finds hand and draws\n\t\t\tfindHand(&m);\n\t\t\tfindHand2(&m2);\n\t\t\tupdateHand(&hand, getHG());\n\t\t\tupdateHand(&hand2, getHG2());\n\t\t\tdrawHandRectangle(&hand, &lines);\n\t\t\tdrawHandRectangle(&hand2, &lines2);\n\n\t\t\t//records movement types\n\t\t\tint movement = handMovementTracking(hand);\n\t\t\tif (movement == FINE) {\n\t\t\t\tfine++;\n\t\t\t} else if (movement == STILL) {\n\t\t\t\tstill++;\n\t\t\t} else if (movement == SPEEDY) {\n\t\t\t\tfast++;\n\t\t\t}\n\t\t\tbool temp = movement;\n\t\t\tmovement = handMovementTracking(hand2);\n\t\t\tif (movement == FINE) {\n\t\t\t\tfine++;\n\t\t\t} else if (movement == STILL) {\n\t\t\t\tstill++;\n\t\t\t} else if (movement == SPEEDY) {\n\t\t\t\tfast++;\n\t\t\t}\n\n\t\t\t//sends whether hand is in frame and receives whether the PI thinks a lego has been placed\n\t\t\t//legoPlaced = sendHandToRasberryPI(\n\t\t\t//\t\tmovement != STILL && temp != STILL);\n\t\t\t//if the hand isn't found then finds legos and calculates distance\n\t\t\tif (movement == STILL && temp == STILL) {\n\t\t\t\tif (!newLegoPossible) {\n\t\t\t\t\tnewLegoPossible = true;\n\t\t\t\t}\n\n\t\t\t\tfor (int i = 0; i < contours.size(); i++) {\n\t\t\t\t\tRotatedRect cur = minAreaRect(Mat(contours[i]));\n\t\t\t\t\tlegos.push_back(cur);\n\t\t\t\t}\n\t\t\t\tmaximizeCloseness(&legos, &prevLegos);\n\n\t\t\t\tfor (int i = 0; i < legos.size(); i++) {\n\t\t\t\t\tif (i >= prevLegos.size()) {\n\t\t\t\t\t\tScalar colorToDraw = Scalar(rand() % 205 + 50,\n\t\t\t\t\t\t\t\trand() % 205 + 50, rand() % 205 + 50);\n\t\t\t\t\t\tdrawLegos(legos[i], lines, colorToDraw);\n\t\t\t\t\t\tcolor.push_back(colorToDraw);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tdrawLegos(legos[i], lines, prevColor[i]);\n\t\t\t\t\t\tcolor.push_back(prevColor[i]);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tfor (int i = 0; i < contours2.size(); i++) {\n\t\t\t\t\tRotatedRect cur = minAreaRect(Mat(contours2[i]));\n\t\t\t\t\tlegos2.push_back(cur);\n\t\t\t\t}\n\n\t\t\t\tmaximizeCloseness(&legos2, &prevLegos2);\n\n\t\t\t\tfor (int i = 0; i < legos2.size(); i++) {\n\t\t\t\t\tif (i >= prevLegos2.size()) {\n\t\t\t\t\t\tScalar colorToDraw = Scalar(rand() % 205 + 50,\n\t\t\t\t\t\t\t\trand() % 205 + 50, rand() % 205 + 50);\n\t\t\t\t\t\tdrawLegos(legos2[i], lines2, colorToDraw);\n\t\t\t\t\t\tcolor2.push_back(colorToDraw);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tdrawLegos(legos2[i], lines2, prevColor2[i]);\n\t\t\t\t\t\tcolor2.push_back(prevColor2[i]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n//\t\t\tputText(lines2,\n//\t\t\t\t\t\"guess: \"\n//\t\t\t\t\t\t\t+ to_string(\n//\t\t\t\t\t\t\t\t\t0.04676397\n//\t\t\t\t\t\t\t\t\t\t\t+ (177802.6 - 0.04676397)\n//\t\t\t\t\t\t\t\t\t\t\t\t\t/ (1\n//\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t+ pow(\n//\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t((cur.size.area())\n//\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t/ 0.00005175283),\n//\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t0.5001077))),\n//\t\t\t\t\tcvPoint(legos2[i].center.x - 10, legos2[i].center.y - 10),\n//\t\t\t\t\tFONT_HERSHEY_COMPLEX_SMALL, 1.4, cvScalar(255, 255, 255), 1,\n//\t\t\t\t\tCV_AA);\n\n\t\t\timwrite(\"rects.jpg\", lines2);\n\t\t\tMat im3(lines.rows, lines.cols * 2, CV_8UC3);\n\t\t\tMat left(im3, Rect(0, 0, lines.cols, lines.rows));\n\t\t\tlines.copyTo(left);\n\t\t\tMat right(im3, Rect(lines.cols, 0, lines.cols, lines.rows));\n\t\t\tlines2.copyTo(right);\n\t\t\tstereoVision(legos, legos2, &color, &color2, im3);\n\n\t\t\t//updates vectors of legos\n\t\t\tif (movement == STILL && temp == STILL) {\n\t\t\t\tprevLegos = legos;\n\t\t\t\tprevColor = color;\n\t\t\t\tprevLegos2 = legos2;\n\t\t\t\tprevColor2 = color2;\n\t\t\t}\n\t\t\t//updates statistics\n\t\t\tif (count > 1 && newLegoPossible) {\n\t\t\t\tupdateFoundLegosStatistics(&prevLegos, &firstlegos, &foundLegos,\n\t\t\t\t\t\tlegoPlaced);\n\t\t\t\tupdateFoundLegosStatistics(&prevLegos2, &firstlegos2,\n\t\t\t\t\t\t&foundLegos2, legoPlaced);\n\t\t\t\tnewLegoPossible = false;\n\t\t\t}\n\t\t\tMat im4(im3.rows / 2, im3.cols / 2, CV_8UC3);\n\t\t\tresize(im3, im4, im4.size(), 0, 0, INTER_LINEAR);\n\n\t\t\tMat eraser(lines.rows, lines.cols, CV_8UC3);\n\n\t\t\tMat eraser2(lines.rows, lines.cols, CV_8UC3);\n\t\t\tMat rightCorrection(lines.rows, lines.cols, CV_8UC3);\n\t\t\tMat leftCorrection(lines.rows, lines.cols, CV_8UC3);\n\n\t\t\timwrite(\"cloud.jpg\", im4);\n\t\t\timshow(\"Cloud\", im4);\n\t\t\tif (waitKey(50) == char('q')) { //says user is finished placing legos\n\t\t\t\tshowCorrected(firstlegos, legos, firstlegos2, legos2,\n\t\t\t\t\t\tleftCorrection, rightCorrection, start, foundLegos,\n\t\t\t\t\t\tfoundLegos2);\n\n\t\t\t\tcout\n\t\t\t\t\t\t<< duration_cast(\n\t\t\t\t\t\t\t\tsystem_clock::now().time_since_epoch()).count()\n\t\t\t\t\t\t<< endl;\n\t\t\t\tfast = 0;\n\t\t\t\tfine = 0;\n\t\t\t\tstill = 0;\n\t\t\t\tfoundLegosYet = false;\n\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (count == 0) { //first time through loop waits for start\n\t\t\t\tauto memorizeTimeStart = duration_cast(\n\t\t\t\t\t\tsystem_clock::now().time_since_epoch()).count();\n\t\t\t\tprevLegos.clear();\n\t\t\t\tprevLegos2.clear();\n\t\t\t\tprevColor.clear();\n\t\t\t\tprevColor2.clear();\n\t\t\t\tif (iterationOfExperiment != 1) { //if it's not the first time through then wait 10 seconds\n\n\t\t\t\t\tcout\n\t\t\t\t\t\t\t<< duration_cast(\n\t\t\t\t\t\t\t\t\tsystem_clock::now().time_since_epoch()).count()\n\t\t\t\t\t\t\t<< endl;\n\t\t\t\t\tstart = duration_cast(\n\t\t\t\t\t\t\tsystem_clock::now().time_since_epoch()).count();\n\t\t\t\t\twaitKey(10000);\n\t\t\t\t\tcout << \"Begin\" << endl;\n\t\t\t\t} else { //calculates time to memorize\n\t\t\t\t\twaitKey(0);\n\t\t\t\t\tmemorizeTime = duration_cast(\n\t\t\t\t\t\t\tsystem_clock::now().time_since_epoch()).count()\n\t\t\t\t\t\t\t- memorizeTimeStart;\n\t\t\t\t\t;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t//only on the first round records initial setup\n\t\t\tif (count == 1 && iterationOfExperiment == 1) {\n\t\t\t\tfor (int s = 0; s < legos.size(); s++) {\n\t\t\t\t\tfirstlegos.push_back(legos[s]);\n\t\t\t\t}\n\t\t\t\tfor (int s = 0; s < legos2.size(); s++) {\n\t\t\t\t\tfirstlegos2.push_back(legos2[s]);\n\t\t\t\t}\n\t\t\t\twaitKey(15000);\n\n\t\t\t\tstart = duration_cast(\n\t\t\t\t\t\tsystem_clock::now().time_since_epoch()).count();\n\t\t\t\tcout << \"Begin\" << endl;\n\t\t\t\tprevLegos.clear();\n\t\t\t\tprevLegos2.clear();\n\t\t\t\tprevColor.clear();\n\t\t\t\tprevColor2.clear();\n\t\t\t}\n\t\t\tcount++;\n\t\t\tcolor.clear();\n\t\t\tlegos.clear();\n\t\t\tcolor2.clear();\n\t\t\tlegos2.clear();\n\t\t\theight.clear();\n//\t\tcout << \"Time: \"\n//\t\t\t\t<< chrono::milliseconds(end2 - start2).count() / 1000000000.0\n//\t\t\t\t<< endl;\n\t\t}\n\t\tcvDestroyAllWindows();\n\t}\n\treturn 0;\n}\n"},{"alpha_fraction":0.5602589845657349,"alphanum_fraction":0.6114541888237,"avg_line_length":26.356948852539062,"blob_id":"e5d0ebb4801676794410d6eff14870fbe037e31a","content_id":"a68f0b15cff5c3b544f2f4109715290554ed8bed","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":10040,"license_type":"no_license","max_line_length":101,"num_lines":367,"path":"/main2.cpp","repo_name":"Logan-Peters/UCLA-REU-Code","src_encoding":"UTF-8","text":"#include \"main2.hpp\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"handGesture.hpp\"\n#include \"myImage.hpp\"\n#include \"roi.hpp\"\n\nusing namespace cv;\nusing namespace std;\n\n/* Global Variables */\nint fontFace2 = FONT_HERSHEY_PLAIN;\nint square_len2;\nint avgColor2[NSAMPLES][3];\nint c_lower2[NSAMPLES][3];\nint c_upper2[NSAMPLES][3];\nint avgBGR2[3];\nint nrOfDefects2;\nint iSinceKFInit2;\nHandGesture hg2;\nstruct dim2 {\n\tint w;\n\tint h;\n} boundingDim2;\nVideoWriter out2;\nMat edges2;\nMy_ROI roi12, roi22, roi32, roi42, roi52, roi62;\nvector roi222;\nvector kf2;\nvector > measurement2;\n\n/* end global variables */\n\nvoid init2(MyImage *m) {\n\tsquare_len2 = 20;\n\tiSinceKFInit2 = 0;\n}\n\n// change a color from one space to another\nvoid col2origCol2(int hsv[3], int bgr[3], Mat src) {\n\tMat avgBGRMat = src.clone();\n\tfor (int i = 0; i < 3; i++) {\n\t\tavgBGRMat.data[i] = hsv[i];\n\t}\n\tcvtColor(avgBGRMat, avgBGRMat, COL2ORIGCOL);\n\tfor (int i = 0; i < 3; i++) {\n\t\tbgr[i] = avgBGRMat.data[i];\n\t}\n}\n\nvoid printText2(Mat src, string text) {\n\tint fontFace = FONT_HERSHEY_PLAIN;\n\tputText(src, text, Point(src.cols / 2, src.rows / 10), fontFace, 1.2f,\n\t\t\tScalar(200, 0, 0), 2);\n}\n\nvoid waitForPalmCover2(MyImage* m) {\n\tm->cap >> m->src;\n\tflip(m->src, m->src, 1);\n\troi222.push_back(\n\t\t\tMy_ROI(Point(m->src.cols / 3, m->src.rows / 6),\n\t\t\t\t\tPoint(m->src.cols / 3 + square_len2,\n\t\t\t\t\t\t\tm->src.rows / 6 + square_len2), m->src));\n\troi222.push_back(\n\t\t\tMy_ROI(Point(m->src.cols / 4, m->src.rows / 2),\n\t\t\t\t\tPoint(m->src.cols / 4 + square_len2,\n\t\t\t\t\t\t\tm->src.rows / 2 + square_len2), m->src));\n\troi222.push_back(\n\t\t\tMy_ROI(Point(m->src.cols / 3, m->src.rows / 1.5),\n\t\t\t\t\tPoint(m->src.cols / 3 + square_len2,\n\t\t\t\t\t\t\tm->src.rows / 1.5 + square_len2), m->src));\n\troi222.push_back(\n\t\t\tMy_ROI(Point(m->src.cols / 2, m->src.rows / 2),\n\t\t\t\t\tPoint(m->src.cols / 2 + square_len2,\n\t\t\t\t\t\t\tm->src.rows / 2 + square_len2), m->src));\n\troi222.push_back(\n\t\t\tMy_ROI(Point(m->src.cols / 2.5, m->src.rows / 2.5),\n\t\t\t\t\tPoint(m->src.cols / 2.5 + square_len2,\n\t\t\t\t\t\t\tm->src.rows / 2.5 + square_len2), m->src));\n\troi222.push_back(\n\t\t\tMy_ROI(Point(m->src.cols / 2, m->src.rows / 1.5),\n\t\t\t\t\tPoint(m->src.cols / 2 + square_len2,\n\t\t\t\t\t\t\tm->src.rows / 1.5 + square_len2), m->src));\n\troi222.push_back(\n\t\t\tMy_ROI(Point(m->src.cols / 2.5, m->src.rows / 1.8),\n\t\t\t\t\tPoint(m->src.cols / 2.5 + square_len2,\n\t\t\t\t\t\t\tm->src.rows / 1.8 + square_len2), m->src));\n\n\tfor (int i = 0; i < 50; i++) {\n\t\tm->cap >> m->src;\n\t\tflip(m->src, m->src, 1);\n\t\tfor (int j = 0; j < NSAMPLES; j++) {\n\t\t\troi222[j].draw_rectangle(m->src);\n\t\t}\n\t\tstring imgText = string(\"Cover rectangles with palm\");\n\t\tprintText2(m->src, imgText);\n\n\t\tif (i == 30) {\n\t\t\t//\timwrite(\"./images/waitforpalm1.jpg\",m->src);\n\t\t}\n\n\t\timshow(\"img1\", m->src);\n\t\tout2 << m->src;\n\t\tif (cv::waitKey(30) >= 0)\n\t\t\tbreak;\n\t}\n}\n\nint getMedian2(vector val) {\n\tint median;\n\tsize_t size = val.size();\n\tsort(val.begin(), val.end());\n\tif (size % 2 == 0) {\n\t\tmedian = val[size / 2 - 1];\n\t} else {\n\t\tmedian = val[size / 2];\n\t}\n\treturn median;\n}\n\nvoid getAvgColor2(MyImage *m, My_ROI roi, int avg[3]) {\n\tMat r;\n\troi.roi_ptr.copyTo(r);\n\tvector hm;\n\tvector sm;\n\tvector lm;\n\t// generate vectors\n\tfor (int i = 2; i < r.rows - 2; i++) {\n\t\tfor (int j = 2; j < r.cols - 2; j++) {\n\t\t\thm.push_back(r.data[r.channels() * (r.cols * i + j) + 0]);\n\t\t\tsm.push_back(r.data[r.channels() * (r.cols * i + j) + 1]);\n\t\t\tlm.push_back(r.data[r.channels() * (r.cols * i + j) + 2]);\n\t\t}\n\t}\n\tavg[0] = getMedian2(hm);\n\tavg[1] = getMedian2(sm);\n\tavg[2] = getMedian2(lm);\n}\n\nvoid average2(MyImage *m) {\n\tm->cap >> m->src;\n\tflip(m->src, m->src, 1);\n\tfor (int i = 0; i < 30; i++) {\n\t\tm->cap >> m->src;\n\t\tflip(m->src, m->src, 1);\n\t\tcvtColor(m->src, m->src, ORIGCOL2COL);\n\t\tfor (int j = 0; j < NSAMPLES; j++) {\n\t\t\tgetAvgColor2(m, roi222[j], avgColor2[j]);\n\t\t\troi222[j].draw_rectangle(m->src);\n\t\t}\n\t\tcvtColor(m->src, m->src, COL2ORIGCOL);\n\t\tstring imgText = string(\"Finding average color of hand\");\n\t\tprintText2(m->src, imgText);\n\t\timshow(\"img1\", m->src);\n\t\tif (cv::waitKey(30) >= 0)\n\t\t\tbreak;\n\t}\n}\n\nvoid initTrackbars2() {\n\tfor (int i = 0; i < NSAMPLES; i++) {\n\t\tc_lower2[i][0] = 12;\n\t\tc_upper2[i][0] = 7;\n\t\tc_lower2[i][1] = 30;\n\t\tc_upper2[i][1] = 40;\n\t\tc_lower2[i][2] = 80;\n\t\tc_upper2[i][2] = 80;\n\t}\n\tcreateTrackbar(\"lower1\", \"trackbars\", &c_lower2[0][0], 255);\n\tcreateTrackbar(\"lower2\", \"trackbars\", &c_lower2[0][1], 255);\n\tcreateTrackbar(\"lower3\", \"trackbars\", &c_lower2[0][2], 255);\n\tcreateTrackbar(\"upper1\", \"trackbars\", &c_upper2[0][0], 255);\n\tcreateTrackbar(\"upper2\", \"trackbars\", &c_upper2[0][1], 255);\n\tcreateTrackbar(\"upper3\", \"trackbars\", &c_upper2[0][2], 255);\n}\n\nvoid normalizeColors2(MyImage * myImage) {\n\t// copy all boundries read from trackbar\n\t// to all of the different boundries\n\tfor (int i = 1; i < NSAMPLES; i++) {\n\t\tfor (int j = 0; j < 3; j++) {\n\t\t\tc_lower2[i][j] = c_lower2[0][j];\n\t\t\tc_upper2[i][j] = c_upper2[0][j];\n\t\t}\n\t}\n\t// normalize all boundries so that\n\t// threshold is whithin 0-255\n\tfor (int i = 0; i < NSAMPLES; i++) {\n\t\tif ((avgColor2[i][0] - c_lower2[i][0]) < 0) {\n\t\t\tc_lower2[i][0] = avgColor2[i][0];\n\t\t}\n\t\tif ((avgColor2[i][1] - c_lower2[i][1]) < 0) {\n\t\t\tc_lower2[i][1] = avgColor2[i][1];\n\t\t}\n\t\tif ((avgColor2[i][2] - c_lower2[i][2]) < 0) {\n\t\t\tc_lower2[i][2] = avgColor2[i][2];\n\t\t}\n\t\tif ((avgColor2[i][0] + c_upper2[i][0]) > 255) {\n\t\t\tc_upper2[i][0] = 255 - avgColor2[i][0];\n\t\t}\n\t\tif ((avgColor2[i][1] + c_upper2[i][1]) > 255) {\n\t\t\tc_upper2[i][1] = 255 - avgColor2[i][1];\n\t\t}\n\t\tif ((avgColor2[i][2] + c_upper2[i][2]) > 255) {\n\t\t\tc_upper2[i][2] = 255 - avgColor2[i][2];\n\t\t}\n\t}\n}\n\nHandGesture getHG2(){\n\treturn hg2;\n}\n\nvoid produceBinaries2(MyImage *m) {\n\tMat foo;\n\t\tm->bwList.push_back(Mat(m->srcLR.rows, m->srcLR.cols, CV_8U));\n\t\tinRange(m->srcLR, Scalar(80, 20, 20), Scalar(220, 260, 260), m->bwList[0]);\n\n\n\tm->bwList[0].copyTo(m->bw);\n\tm->bw += m->bwList[0];\n\tmedianBlur(m->bw, m->bw, 7);\n}\n\nvoid initWindows2(MyImage m) {\n\tnamedWindow(\"trackbars\", CV_WINDOW_KEEPRATIO);\n\tnamedWindow(\"img1\", CV_WINDOW_FULLSCREEN);\n}\n\nvoid showWindows2(MyImage m) {\n\tpyrDown(m.bw, m.bw);\n\tpyrDown(m.bw, m.bw);\n\tRect roi(Point(3 * m.src.cols / 4, 0), m.bw.size());\n\tvector channels;\n\tMat result;\n\tfor (int i = 0; i < 3; i++)\n\t\tchannels.push_back(m.bw);\n\tmerge(channels, result);\n\tresult.copyTo(m.src(roi));\n\timshow(\"img2\", m.src);\n}\n\nint findBiggestContour2(vector > contours) {\n\tint indexOfBiggestContour = -1;\n\tint sizeOfBiggestContour = 0;\n\tfor (int i = 0; i < contours.size(); i++) {\n\t\tif (contours[i].size() > sizeOfBiggestContour) {\n\t\t\tsizeOfBiggestContour = contours[i].size();\n\t\t\tindexOfBiggestContour = i;\n\t\t}\n\t}\n\treturn indexOfBiggestContour;\n}\n\nvoid myDrawContours2(MyImage *m, HandGesture *hg) {\n\tdrawContours(m->src, hg->hullP, hg->cIdx, cv::Scalar(200, 0, 0), 2, 8,\n\t\t\tvector(), 0, Point());\n\n\trectangle(m->src, hg->bRect.tl(), hg->bRect.br(), Scalar(0, 0, 200));\n\tvector::iterator d = hg->defects[hg->cIdx].begin();\n\tint fontFace = FONT_HERSHEY_PLAIN;\n\n\tvector channels;\n\tMat result;\n\tfor (int i = 0; i < 3; i++)\n\t\tchannels.push_back(m->bw);\n\tmerge(channels, result);\n\t//\tdrawContours(result,hg->contours,hg->cIdx,cv::Scalar(0,200,0),6, 8, vector(), 0, Point());\n\tdrawContours(result, hg->hullP, hg->cIdx, cv::Scalar(0, 0, 250), 10, 8,\n\t\t\tvector(), 0, Point());\n\n\twhile (d != hg->defects[hg->cIdx].end()) {\n\t\tVec4i& v = (*d);\n\t\tint startidx = v[0];\n\t\tPoint ptStart(hg->contours[hg->cIdx][startidx]);\n\t\tint endidx = v[1];\n\t\tPoint ptEnd(hg->contours[hg->cIdx][endidx]);\n\t\tint faridx = v[2];\n\t\tPoint ptFar(hg->contours[hg->cIdx][faridx]);\n\t\tfloat depth = v[3] / 256;\n\t\t/*\n\t\t line( m->src, ptStart, ptFar, Scalar(0,255,0), 1 );\n\t\t line( m->src, ptEnd, ptFar, Scalar(0,255,0), 1 );\n\t\t circle( m->src, ptFar, 4, Scalar(0,255,0), 2 );\n\t\t circle( m->src, ptEnd, 4, Scalar(0,0,255), 2 );\n\t\t circle( m->src, ptStart, 4, Scalar(255,0,0), 2 );\n\t\t */\n\t\tcircle(result, ptFar, 9, Scalar(0, 205, 0), 5);\n\n\t\td++;\n\n\t}\n//\timwrite(\"./images/contour_defects_before_eliminate.jpg\",result);\n\n}\n\nvoid makeContours2(MyImage *m, HandGesture* hg) {\n\tMat aBw;\n\tpyrUp(m->bw, m->bw);\n\tm->bw.copyTo(aBw);\n\tfindContours(aBw, hg->contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);\n\thg->initVectors();\n\thg->cIdx = findBiggestContour2(hg->contours);\n\tif (hg->cIdx != -1) {\n//\t\tapproxPolyDP( Mat(hg->contours[hg->cIdx]), hg->contours[hg->cIdx], 11, true );\n\t\thg->bRect = boundingRect(Mat(hg->contours[hg->cIdx]));\n\t\tconvexHull(Mat(hg->contours[hg->cIdx]), hg->hullP[hg->cIdx], false,\n\t\t\t\ttrue);\n\t\tconvexHull(Mat(hg->contours[hg->cIdx]), hg->hullI[hg->cIdx], false,\n\t\t\t\tfalse);\n\t\tapproxPolyDP(Mat(hg->hullP[hg->cIdx]), hg->hullP[hg->cIdx], 18, true);\n\t\tif (hg->contours[hg->cIdx].size() > 3) {\n\t\t\tconvexityDefects(hg->contours[hg->cIdx], hg->hullI[hg->cIdx],\n\t\t\t\t\thg->defects[hg->cIdx]);\n\t\t\thg->eleminateDefects(m);\n\t\t}\n\t\tbool isHand = hg->detectIfHand();\n\t\thg->printGestureInfo(m->src);\n\t\tif (isHand) {\n\t\t\thg->getFingerTips(m);\n\t\t\thg->drawFingerTips(m);\n\t\t\tmyDrawContours2(m, hg);\n\t\t}\n\t}\n\telse{\n\t\thg->bRect = Rect(0,0,0,0);\n\t}\n}\n\nvoid setupFindHand2(MyImage *m) {\n\tinit2(m);\n}\n\nvoid findHand2(MyImage *m){\n\thg2.frameNumber++;\n\tflip(m->src, m->src, 1);\n\tm->cap >> m->src;\n\tpyrDown(m->src, m->srcLR);\n\tblur(m->srcLR, m->srcLR, Size(3, 3));\n\tcvtColor(m->srcLR, m->srcLR, ORIGCOL2COL);\n\tproduceBinaries2(m);\n\tcvtColor(m->srcLR, m->srcLR, COL2ORIGCOL);\n\tmakeContours2(m, &hg2);\n\thg2.getFingerNumber(m);\n\tshowWindows2(*m);\n\tout2 << m->src;\n\n}\n"},{"alpha_fraction":0.6086224317550659,"alphanum_fraction":0.6406197547912598,"avg_line_length":29.285715103149414,"blob_id":"884c821805ed4eb862be4f19a0feeca8dcb7a76b","content_id":"4aab53da2d7e6f81464d19337e3223ea16b56598","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":2969,"license_type":"no_license","max_line_length":76,"num_lines":98,"path":"/PointPolygonInteresector.cpp","repo_name":"Logan-Peters/UCLA-REU-Code","src_encoding":"UTF-8","text":"// A C++ program to check if a given cv::Point lies inside a given polygon\n\n#include \"PointPolygonInteresector.hpp\"\n\n#include \n#include \n\nusing namespace cv;\n\nusing namespace std;\n// Define Infinite (Using INT_MAX caused overflow problems)\n#define INF 10000\n\n// Given three colinear cv::Points p, q, r, the function checks if\n// cv::Point q lies on line segment 'pr'\nbool onSegment(cv::Point p, cv::Point q, cv::Point r) {\n\tif (q.x <= max(p.x, r.x) && q.x >= min(p.x, r.x) && q.y <= max(p.y, r.y)\n\t\t\t&& q.y >= min(p.y, r.y))\n\t\treturn true;\n\treturn false;\n}\n\n// To find orientation of ordered triplet (p, q, r).\n// The function returns following values\n// 0 --> p, q and r are colinear\n// 1 --> Clockwise\n// 2 --> Counterclockwise\nint orientation(cv::Point p, cv::Point q, cv::Point r) {\n\tint val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);\n\n\tif (val == 0)\n\t\treturn 0; // colinear\n\treturn (val > 0) ? 1 : 2; // clock or counterclock wise\n}\n\n// The function that returns true if line segment 'p1q1'\n// and 'p2q2' intersect.\nbool doIntersect(cv::Point p1, cv::Point q1, cv::Point p2, cv::Point q2) {\n\t// Find the four orientations needed for general and\n\t// special cases\n\tint o1 = orientation(p1, q1, p2);\n\tint o2 = orientation(p1, q1, q2);\n\tint o3 = orientation(p2, q2, p1);\n\tint o4 = orientation(p2, q2, q1);\n\n\t// General case\n\tif (o1 != o2 && o3 != o4)\n\t\treturn true;\n\n\t// Special Cases\n\t// p1, q1 and p2 are colinear and p2 lies on segment p1q1\n\tif (o1 == 0 && onSegment(p1, p2, q1))\n\t\treturn true;\n\n\t// p1, q1 and p2 are colinear and q2 lies on segment p1q1\n\tif (o2 == 0 && onSegment(p1, q2, q1))\n\t\treturn true;\n\n\t// p2, q2 and p1 are colinear and p1 lies on segment p2q2\n\tif (o3 == 0 && onSegment(p2, p1, q2))\n\t\treturn true;\n\n\t// p2, q2 and q1 are colinear and q1 lies on segment p2q2\n\tif (o4 == 0 && onSegment(p2, q1, q2))\n\t\treturn true;\n\n\treturn false; // Doesn't fall in any of the above cases\n}\n\n// Returns true if the cv::Point p lies inside the polygon[] with n vertices\nbool isInside(cv::Point polygon[], int n, cv::Point p) {\n\t// There must be at least 3 vertices in polygon[]\n\tif (n < 3)\n\t\treturn false;\n\t// Create a cv::Point for line segment from p to infinite\n\tcv::Point extreme = cv::Point(INF, p.y);\n\n\t// Count intersections of the above line with sides of polygon\n\tint count = 0, i = 0;\n\tdo {\n\t\tint next = (i + 1) % n;\n\n\t\t// Check if the line segment from 'p' to 'extreme' intersects\n\t\t// with the line segment from 'polygon[i]' to 'polygon[next]'\n\t\tif (doIntersect(polygon[i], polygon[next], p, extreme)) {\n\t\t\t// If the cv::Point 'p' is colinear with line segment 'i-next',\n\t\t\t// then check if it lies on segment. If it lies, return true,\n\t\t\t// otherwise false\n\t\t\tif (orientation(polygon[i], p, polygon[next]) == 0)\n\t\t\t\treturn onSegment(polygon[i], p, polygon[next]);\n\n\t\t\tcount++;\n\t\t}\n\t\ti = next;\n\t} while (i != 0);\n\t// Return true if count is odd, false otherwise\n\treturn count & 1; // Same as (count%2 == 1)\n}\n\n"},{"alpha_fraction":0.7533039450645447,"alphanum_fraction":0.757709264755249,"avg_line_length":16.384614944458008,"blob_id":"b0d9bb0c539e9eba65067a89b3b69685cbcf5e4a","content_id":"a76dfa888cde36cd33a842a912c0425425a7d628","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":227,"license_type":"no_license","max_line_length":55,"num_lines":13,"path":"/PointPolygonInteresector.hpp","repo_name":"Logan-Peters/UCLA-REU-Code","src_encoding":"UTF-8","text":"#ifndef _POINTPOLYGONINTERSECTOR_HEADER_\n#define _POINTPOLYGONINTERSECTOR_HEADER_\n\n#include \n\nusing namespace std;\nusing namespace cv;\n\n\nbool isInside(cv::Point polygon[], int n, cv::Point p);\n\n\n#endif\n\n"}],"string":"[\n {\n \"alpha_fraction\": 0.7831687331199646,\n \"alphanum_fraction\": 0.7848862409591675,\n \"avg_line_length\": 290.125,\n \"blob_id\": \"46f7a57652925f69c2b281ca3e20faa02ebb8b59\",\n \"content_id\": \"1316d7053fd79852442c346e3bacd97eea0a0849\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Markdown\",\n \"length_bytes\": 2329,\n \"license_type\": \"no_license\",\n \"max_line_length\": 1240,\n \"num_lines\": 8,\n \"path\": \"/README.md\",\n \"repo_name\": \"Logan-Peters/UCLA-REU-Code\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# UCLA-REU-Code\\n## Purpose: Collect data on upper limb tasks using camera's, a gyroscope and an accelerometer. This data can then be fed into a hidden markov model to train a model to help humans learn upper body skills with applications in physical therapy, training and education.\\n### The python file, main.py, is meant to be run a RasberryPI with an attached gyroscope and accelerometer. \\n### The c++ code and the python code communicate with each other through sockets and use their IP addresses to identify each other. Therefore both devices must connected to the same network(note some networks that scramble IP addresses such as eduroam will not work for this) and the IP address in the c++ file must be changed to the IP address of the RasberryPI.\\n### The c++ code does a significant amount of it's work using 2 web cameras set up in parellel 3 centimeters apart.\\n### The current experimental setup is a RasberryPI with a gyroscope and accelerometer attached onto the participants wrist and two cameras 35 centimeters above a grid of white squares, this is to help the participant remember lego locations and the program does not use this. The task is for the participant, after looking at the memorizing the initial setup, to put the legos back in the same positions after fifteen seconds. To run the experiment start the RasberryPI's code first, then place the legos on the grid, making sure the legos are in both cameras field of view. Now run c++ code and let the participant memorize the legos for as long as they like. When they say they are done click any key while in the program. Immediately remove the legos and wait for the program to print \\\"Begin\\\". When it does let the participant place the legos back in the grid. When they say they are done press 'q' in thr program. Now it should display the results of the run and display the initial legos position in green and the end positions in red. Now click any key and remove the legos from the grid. Wait until the program prints \\\"Begin\\\" and let the participant place legos. Repeat to preference. Terminate the program when finished.\\n### Data from each run is stored in Data.txt in comma seperated format\\n### To disable RasberryPI connectivity comment out: legoPlaced = sendHandToRasberryPI(movement != STILL && temp != STILL); and setUpRasberry();\\n\"\n },\n {\n \"alpha_fraction\": 0.5611575245857239,\n \"alphanum_fraction\": 0.5957637429237366,\n \"avg_line_length\": 27.168067932128906,\n \"blob_id\": \"c26e210bbdbfae2057f9fd9798a047af768fc3fc\",\n \"content_id\": \"4a0bc9502e765b3cbfb682fa87ad7a427971e0fe\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 3352,\n \"license_type\": \"no_license\",\n \"max_line_length\": 179,\n \"num_lines\": 119,\n \"path\": \"/main.py\",\n \"repo_name\": \"Logan-Peters/UCLA-REU-Code\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import time\\nimport IMU\\nimport sys\\nimport math\\nimport datetime\\nimport os\\nimport thread\\nimport socket\\nhandInView = False\\nlegoPlaced = False\\nsum = 0\\ndef receieveHandInView():\\n Host = '0.0.0.0'\\n global sum\\n timerWhileHandInFrame = 0\\n global handInView\\n global legoPlaced\\n Port = 65432\\n #print(\\\"...\\\") \\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n s.bind((Host, Port))\\n while True:\\n s.listen(5)\\n conn, addr = s.accept()\\n \\n print('connected by', addr)\\n while True:\\n data = conn.recv(1024)\\n if data == 'yes':\\n handInView = True\\n if data == 'no':\\n handInView = False\\n if(handInView and timerWhileHandInFrame == 0):\\n timerWhileHandInFrame = int(round(time.time()))\\n else:\\n if(sum != 0 and 0 != (int(round(time.time())) - timerWhileHandInFrame)):\\n if(sum/(int(round(time.time())) - timerWhileHandInFrame) > 30000):\\n legoPlaced = True\\n print(sum/(int(round(time.time())) - timerWhileHandInFrame))\\n timerWhileHandInFrame = 0\\n sum = 0\\n if(legoPlaced):\\n conn.sendall(\\\"placed\\\")\\n print(\\\"placed\\\")\\n legoPlaced = False\\n else:\\n conn.sendall(\\\"not placed\\\")\\n if not data:\\n break\\n\\n\\n\\nRAD_TO_DEG = 57.29578\\nM_PI = 3.14159265358979323846\\nG_GAIN = 0.070 \\t# [deg/s/LSB] If you change the dps for gyro, you need to update this value accordingly\\nAA = 0.40 \\t\\t# Complementary filter constant\\n#detect accelerometer and gyroscope\\nIMU.detectIMU()\\nIMU.initIMU()\\n#opens file data.txt to append to it\\nfilename = \\\"data.txt\\\"\\nfile = open(filename, \\\"a\\\")\\nthread.start_new_thread(receieveHandInView,() )\\nrate_gyr_x = 0.0\\nrate_gyr_y = 0.0\\nrate_gyr_z = 0.0\\ngyroXangle = 0.0\\ngyroYangle = 0.0\\ngyroZangle = 0.0\\na = datetime.datetime.now()\\nprevAccX = 0\\nprevAccY = 0\\nprevAccZ = 0\\ntimer = 0\\nstate = 0\\n\\nwhile True:\\n\\tACCx = IMU.readACCx()\\n\\tACCy = IMU.readACCy()\\n\\tACCz = IMU.readACCz()\\n\\tGYRx = IMU.readGYRx()\\n\\tGYRy = IMU.readGYRy()\\n\\tGYRz = IMU.readGYRz()\\n\\n\\t#LP is the loop period which is how long between gyro reads\\n\\tb = datetime.datetime.now() - a\\n a = datetime.datetime.now()\\n \\tLP = b.microseconds/(1000000*1.0)\\n\\t#gets UNIX time\\n \\tmillis = int(round(time.time()*1000))\\n\\n\\t#Convert Gyro raw to degrees per second\\n\\trate_gyr_x = GYRx * G_GAIN\\n\\trate_gyr_y = GYRy * G_GAIN\\n\\trate_gyr_z = GYRz * G_GAIN\\n\\n\\t#Calculate the angles from the gyro.\\n\\tgyroXangle+=rate_gyr_x*LP\\n \\tgyroYangle+=rate_gyr_y*LP\\n \\tgyroZangle+=rate_gyr_z*LP\\n\\n\\t#Convert acceleration from mg/LSB to m/s^2\\n\\tAx = ACCx\\n\\tAy = ACCy\\n\\tAz = ACCz\\n \\n if(handInView and abs(Ax - prevAccX) + abs(Ay - prevAccY) + abs(Az - prevAccZ) + sum > 800):\\n sum = abs(Ax - prevAccX) + abs(Ay - prevAccY) + abs(Az - prevAccZ) + sum\\n\\n \\n\\t#print writes to console reminder to delete later when things look good\\n\\t#file.write() writes to data.txt\\n prevAccX = Ax\\n prevAccY = Ay\\n prevAccZ = Az\\n\\n\\tfile.write(\\\"Time Stamp %i %3.3f %3.3f %3.3f %3.3f %3.3f %3.3f %3.3f %3.3f %3.3f \\\\n\\\" %(millis,gyroXangle,gyroYangle,gyroZangle,rate_gyr_x,rate_gyr_y,rate_gyr_z,Ax,Ay,Az))\\n\\ttime.sleep(0.03)\\nfile.close()\\n\"\n },\n {\n \"alpha_fraction\": 0.7194148898124695,\n \"alphanum_fraction\": 0.7526595592498779,\n \"avg_line_length\": 19.88888931274414,\n \"blob_id\": \"3e55b5c621f90159703b2bdecbbdc1df1f2eea34\",\n \"content_id\": \"eae73ddef95a534ab544dcd6e7c1f859f2558d60\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C++\",\n \"length_bytes\": 752,\n \"license_type\": \"no_license\",\n \"max_line_length\": 36,\n \"num_lines\": 36,\n \"path\": \"/main2.hpp\",\n \"repo_name\": \"Logan-Peters/UCLA-REU-Code\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#ifndef _MAIN2_HEADER_\\n#define _MAIN2_HEADER_\\n\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\\"handGesture.hpp\\\"\\n#include \\\"myImage.hpp\\\"\\n\\nusing namespace cv;\\n\\n\\n#define ORIGCOL2COL CV_BGR2HLS\\n#define COL2ORIGCOL CV_HLS2BGR\\n#define NSAMPLES 7\\n#define PI 3.14159\\n\\nHandGesture getHG2();\\nvoid findHand2(MyImage *m);\\nvoid setupFindHand2(MyImage *m);\\n\\n\\n#endif\\n\"\n },\n {\n \"alpha_fraction\": 0.5938736796379089,\n \"alphanum_fraction\": 0.6286855936050415,\n \"avg_line_length\": 30.876178741455078,\n \"blob_id\": \"ea2f521ddfa3fcd27783a9392111b9a9a7b3d66b\",\n \"content_id\": \"c0bfb13f99e9dc31a8057c3eb436e75634757fef\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C++\",\n \"length_bytes\": 27031,\n \"license_type\": \"no_license\",\n \"max_line_length\": 137,\n \"num_lines\": 848,\n \"path\": \"/RedLegoDetector.cpp\",\n \"repo_name\": \"Logan-Peters/UCLA-REU-Code\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\\"main.hpp\\\"\\n#include \\n#include \\\"myImage.hpp\\\"\\n#include \\\"handGesture.hpp\\\"\\n#include \\\"main2.hpp\\\"\\n#include \\\"PointPolygonInteresector.hpp\\\"\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n\\nusing namespace cv;\\nusing namespace std;\\nusing namespace chrono;\\n\\nint fast = 0;\\nint fine = 0;\\nint still = 0;\\ndouble memorizeTime;\\nvector height;\\nvector height2;\\nint numOfLegos = 0;\\nint iterationOfExperiment = 0;\\nbool foundLegosYet = false;\\nauto start =\\n\\t\\tduration_cast(system_clock::now().time_since_epoch()).count();\\n\\n//A structure containing data about the hand used to manipulate the legos\\nstruct Hand {\\n\\tbool found;\\n\\tPoint prevHand;\\n\\tHandGesture hand;\\n};\\n\\n//A structures containing all the statistics for lego's once they've appeared\\nstruct foundLego {\\n\\tdouble startTime;\\n\\tdouble variationDistance;\\n\\tdouble variationAngle;\\n\\tdouble closestDistance;\\n\\tdouble closestAngle;\\n\\tdouble height;\\n\\tRotatedRect currentPos;\\n};\\n\\nenum {\\n\\tSTILL, FINE, SPEEDY\\n};\\n\\n//Given x,y coordinates from each camera of an ROI returns estimated depth in inches\\nfloat* get3DCoords(float* l, float* r) {\\n\\tdouble b = 100.0 / 25.4 * 2;\\n\\tdouble f = (8.1259257941370424 + 8.1351812555998572) / 4 * 100 / 25.4 / .022\\n\\t\\t\\t/ 1.3; //Constants for our webcam\\n\\tint xl = l[0], xr = r[0], yi;\\n\\tyi = (l[1] + r[1]) / 2;\\n\\tint d = abs(xl - xr);\\n\\tdouble z = ((b * f / d));\\n\\tdouble x = z * xl / f;\\n\\tdouble y = z * yi / f;\\n\\tfloat* p = new float[3];\\n\\tp[0] = x;\\n\\tp[1] = y;\\n\\tp[2] = z;\\n\\treturn p;\\n}\\nbool tempor = true;\\n\\nint n = 0;\\nint sockfd = 0;\\n\\n//Establishes the connection to the rasberry pi\\nvoid setUpRasberry() {\\n\\tstruct sockaddr_in serv_addr;\\n\\n\\tif ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {\\n\\t\\tcout << \\\"Error : Could not create socket\\\" << endl;\\n\\t\\treturn;\\n\\t}\\n\\tserv_addr.sin_family = AF_INET;\\n\\tserv_addr.sin_port = htons(65432);\\n\\tserv_addr.sin_addr.s_addr = inet_addr(\\\"172.20.10.6\\\");\\n\\n\\tif (connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr))\\n\\t\\t\\t< 0) {\\n\\t\\tcout << \\\"Error : Connect Failed\\\" << endl;\\n\\t\\treturn;\\n\\t}\\n\\treturn;\\n}\\n\\n//Sends whether the hand is in frame to the PI and receives whether or not the PI thinks a lego might\\n//have been placed\\nbool sendHandToRasberryPI(bool found) {\\n\\tchar * buffer = \\\"no\\\";\\n\\tif (found) {\\n\\t\\tbuffer = \\\"yes\\\";\\n\\t}\\n\\n\\tn = write(sockfd, buffer, strlen(buffer));\\n\\n\\tstring output(1024, 0);\\n\\tread(sockfd, &output[0], 1024);\\n\\tif (strcmp(output.c_str(), \\\"placed\\\") == 0) {\\n\\t\\tcout << \\\"placed\\\" << endl;\\n\\t\\treturn true;\\n\\t}\\n\\tcout << \\\"not placed \\\" << endl;\\n\\treturn false;\\n}\\n\\n//Processes the image to find the edges of the legos\\nMat legoImageProcessing(Mat baseImage) {\\n\\tMat grid = Mat::zeros(baseImage.size(), CV_32F); //Creates an image to copy onto\\n\\timwrite(\\\"Base.jpg\\\", baseImage); //Saves base image\\n\\tMat temp = Mat::zeros(baseImage.size(), CV_32F); //a blank image to threshold onto\\n\\tGaussianBlur(baseImage, baseImage, Size(3, 3), 0, 0); //blurs the image to get rid of irregularities\\n\\tcvtColor(baseImage, baseImage, CV_BGR2HSV); //Swaps color space from BGR to HSV\\n\\tinRange(baseImage, Scalar(0, 50, 60), Scalar(10, 300, 300), temp); //Threshold the image\\n\\tinRange(baseImage, Scalar(170, 50, 60), Scalar(190, 300, 300), baseImage); //Threshold the image\\n\\taddWeighted(baseImage, 1.0, temp, 1.0, 0.0, grid); //Combines the two thresholds since red is on both ends of the hue values\\n\\n\\timwrite(\\\"thresh.jpg\\\", grid); // Saves threshholded image\\n\\n\\t//Dilates and then erodes the thresholded image consolidate parts\\n\\tdilate(grid, grid, getStructuringElement(MORPH_ELLIPSE, Size(35, 35)));\\n\\terode(grid, grid, getStructuringElement(MORPH_ELLIPSE, Size(35, 35)));\\n\\n\\timwrite(\\\"de.jpg\\\", grid);\\n\\n\\t//Erodes then dilates the thresholded image\\n\\terode(grid, grid, getStructuringElement(MORPH_ELLIPSE, Size(20, 20)));\\n\\tdilate(grid, grid, getStructuringElement(MORPH_ELLIPSE, Size(20, 20)));\\n\\n\\t//Displays the thresholded image\\n\\tstring s = \\\"\\\";\\n\\tif (tempor) {\\n\\t\\ts = \\\"thresh1\\\";\\n\\t} else {\\n\\t\\ts = \\\"thresh2\\\";\\n\\t}\\n\\ttempor = !tempor;\\n\\timshow(s, grid);\\n\\timwrite(\\\"ed.jpg\\\", grid);\\n\\n\\t//Detects the edges of the thresholded image\\n\\tCanny(grid, grid, 100, 200, 3);\\n\\treturn grid;\\n}\\n\\n//Gets the contours of the legos\\nvector> getContours(Mat processedImage) {\\n\\tvector hierarchy;\\n\\tvector> contours;\\n\\tfindContours(processedImage, contours, hierarchy, RETR_EXTERNAL,\\n\\t\\t\\tCV_CHAIN_APPROX_SIMPLE, Point(0, 0)); //Calculates the contours and ignores hierarchy\\n\\treturn contours;\\n}\\n\\n//Draws a gray rectangle to represent the hand\\nvoid drawHandRectangle(Hand *h, Mat *imgToDraw) {\\n\\tif (h->hand.bRect.area() < 80000) { //Only draws hand if bigger than a certain size\\n\\t\\th->found = false;\\n\\t\\treturn;\\n\\t}\\n\\trectangle(*imgToDraw, h->hand.bRect, Scalar(100, 100, 100), 2, 8, 0); //Draws a gray rectangle\\n\\th->found = true;\\n}\\n\\n//updates current hand based on new frame\\nvoid updateHand(Hand *h, HandGesture newHand) {\\n\\th->prevHand = Point(h->hand.bRect.x + h->hand.bRect.width / 2,\\n\\t\\t\\th->hand.bRect.y + h->hand.bRect.height / 2); //Updates prevHand\\n\\th->hand = newHand; //saves the new hand\\n}\\n\\n//Calculates the hand movement type: STILL = hand off screen, FAST = hand on screen in rapid motion, FINE = slow hand movement\\nint handMovementTracking(Hand h) {\\n\\tif (!h.found) { //If the hand isn't found\\n\\t\\treturn STILL;\\n\\t}\\n\\tif (norm(\\n\\t\\t\\tPoint(h.hand.bRect.x + h.hand.bRect.width / 2,\\n\\t\\t\\t\\t\\th.hand.bRect.y + h.hand.bRect.height / 2) - h.prevHand)\\n\\t\\t\\t< 75) { //If the hand moved less than 75 pixels\\n\\t\\treturn FINE;\\n\\t}\\n\\treturn SPEEDY;\\n}\\n\\n//Transforms legos so that it is ordered so that the closest legos are at the same index as in firstLegos\\nvoid maximizeCloseness(vector *legos,\\n\\t\\tvector *firstLegos) {\\n\\tvector pos;\\n\\tvector distance;\\n\\tint newPos;\\n\\tint minDist = 1000000;\\n\\tint replaced = 0;\\n\\n\\t//loops through legos and first legos\\n\\tfor (int i = 0; i < legos->size(); i++) {\\n\\t\\tnewPos = i - replaced; //so that legos is bigger than firstLegos it'll just be put it at the end\\n\\t\\tfor (int j = 0; j < firstLegos->size(); j++) {\\n\\t\\t\\tif (norm(legos->at(i).center - firstLegos->at(j).center)\\n\\t\\t\\t\\t\\t< minDist) { //if firstLegos->at(j) is the closest lego yet\\n\\t\\t\\t\\tif (find(pos.begin(), pos.end(), j) == pos.end()) { //if no other lego has this as it's closest\\n\\t\\t\\t\\t\\tminDist = norm(\\n\\t\\t\\t\\t\\t\\t\\tlegos->at(i).center - firstLegos->at(j).center);\\n\\t\\t\\t\\t\\tnewPos = j;\\n\\t\\t\\t\\t} else if (norm(legos->at(i).center - firstLegos->at(j).center)\\n\\t\\t\\t\\t\\t\\t< distance[((find(pos.begin(), pos.end(), j)\\n\\t\\t\\t\\t\\t\\t\\t\\t- pos.begin()))]) { //if this lego is closer than the other lego that has it as it's closest\\n\\t\\t\\t\\t\\tptrdiff_t a =\\n\\t\\t\\t\\t\\t\\t\\t(find(pos.begin(), pos.end(), j) - pos.begin());\\n\\t\\t\\t\\t\\tlegos->push_back(legos->at(a)); //re-adds the lego that this lego replaced\\n\\t\\t\\t\\t\\tpos[find(pos.begin(), pos.end(), j) - pos.begin()] = -1; //sets the pos position to -1 so it never get's found\\n\\t\\t\\t\\t\\tminDist = norm(\\n\\t\\t\\t\\t\\t\\t\\tlegos->at(i).center - firstLegos->at(j).center);\\n\\t\\t\\t\\t\\tnewPos = j;\\n\\t\\t\\t\\t\\treplaced++; //keeps track of how many -1's there are\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\tpos.push_back(newPos);\\n\\t\\tdistance.push_back(minDist);\\n\\t\\tminDist = 1000000;\\n\\t}\\n\\tvector temp;\\n\\n\\t//Reorders legos based on results from previous loop\\n\\tfor (int i = 0; i < legos->size() - replaced; i++) {\\n\\t\\ttemp.push_back(\\n\\t\\t\\t\\tlegos->at(\\n\\t\\t\\t\\t\\t\\t(int) (find(pos.begin(), pos.end(), i) - pos.begin())));\\n\\t}\\n\\t*legos = temp;\\n}\\n\\n//draws best fit rotated rectangle for the legos\\nvoid drawLegos(RotatedRect cur, Mat toDraw, Scalar colorToDraw) {\\n\\tcv::Point2f pts2[4];\\n\\tcur.points(pts2);\\n\\tline(toDraw, pts2[0], pts2[1], colorToDraw, 2, 8, 0);\\n\\tline(toDraw, pts2[1], pts2[2], colorToDraw, 2, 8, 0);\\n\\tline(toDraw, pts2[2], pts2[3], colorToDraw, 2, 8, 0);\\n\\tline(toDraw, pts2[3], pts2[0], colorToDraw, 2, 8, 0);\\n}\\n\\n//updates statistics for each lego\\nvoid updateFoundLegosStatistics(vector *prevLego,\\n\\t\\tvector *firstLegos, vector *foundLegos,\\n\\t\\tbool legoPlaced) {\\n\\tif (firstLegos->size() < prevLego->size()) {\\n\\t\\tcout << \\\"Seems like there are more legos placed than you started with\\\"\\n\\t\\t\\t\\t<< endl;\\n\\t\\treturn;\\n\\t}\\n\\tfor (int i = 0; i < prevLego->size(); i++) {\\n\\t\\tif (!foundLegosYet || foundLegos->size() <= i) { //if it's the first time through or foundLegos size is less than i\\n\\t\\t\\tfoundLego l;\\n\\t\\t\\tfoundLegosYet = true;\\n\\t\\t\\tint minLoc = 0;\\n\\t\\t\\tint minDistance = 10000000;\\n\\t\\t\\tfor (int j = 0; j < firstLegos->size(); j++) { //finds closest lego\\n\\t\\t\\t\\tif (norm(firstLegos->at(j).center - prevLego->at(i).center)\\n\\t\\t\\t\\t\\t\\t< minDistance) {\\n\\t\\t\\t\\t\\tminLoc = j;\\n\\t\\t\\t\\t\\tminDistance = norm(\\n\\t\\t\\t\\t\\t\\t\\tfirstLegos->at(j).center - prevLego->at(i).center);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\n\\t\\t\\tnumOfLegos++;\\n\\t\\t\\tcout << \\\"New\\\" << endl;\\n\\t\\t\\t//updates the statistics\\n\\t\\t\\tl.closestAngle = abs(\\n\\t\\t\\t\\t\\tfirstLegos->at(minLoc).angle - prevLego->at(i).angle);\\n\\t\\t\\tl.closestDistance = minDistance;\\n\\t\\t\\tl.startTime = duration_cast(\\n\\t\\t\\t\\t\\tsystem_clock::now().time_since_epoch()).count();\\n\\t\\t\\tl.variationAngle = 0;\\n\\t\\t\\tl.variationDistance = 0;\\n\\t\\t\\tl.currentPos = prevLego->at(i);\\n\\t\\t\\tfoundLegos->push_back(l);\\n\\t\\t} else {\\n\\t\\t\\t//Way to keep track of how many legos there are(not perfect)\\n\\t\\t\\tif ((foundLegos->at(i).height - height[i] > 1.2\\n\\t\\t\\t\\t\\t|| prevLego->at(i).size.area()\\n\\t\\t\\t\\t\\t\\t\\t- foundLegos->at(i).currentPos.size.area() > 1250)) {\\n\\t\\t\\t\\tcout << \\\"new lego\\\" << endl;\\n\\t\\t\\t\\tnumOfLegos++;\\n\\t\\t\\t}\\n\\t\\t\\tif (foundLegos->at(i).height - height[i] > .2) {\\n\\t\\t\\t\\tcout << \\\"why...\\\";\\n\\t\\t\\t}\\n\\t\\t\\tif (prevLego->at(i).size.area()\\n\\t\\t\\t\\t\\t- foundLegos->at(i).currentPos.size.area() > 1000) {\\n\\t\\t\\t\\tcout << \\\"...\\\";\\n\\t\\t\\t}\\n\\t\\t\\tcout << numOfLegos << endl;\\n\\n\\t\\t\\tif (foundLegos->at(i).closestAngle\\n\\t\\t\\t\\t\\t> fmod(\\n\\t\\t\\t\\t\\t\\t\\tabs(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tfoundLegos->at(i).currentPos.angle\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t- firstLegos->at(i).angle), 45)) {\\n\\t\\t\\t\\tfoundLegos->at(i).closestAngle = fmod(\\n\\t\\t\\t\\t\\t\\tabs(\\n\\t\\t\\t\\t\\t\\t\\t\\tfoundLegos->at(i).currentPos.angle\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t- firstLegos->at(i).angle), 45);\\n\\t\\t\\t}\\n\\t\\t\\tif (foundLegos->at(i).closestDistance\\n\\t\\t\\t\\t\\t> norm(\\n\\t\\t\\t\\t\\t\\t\\tfoundLegos->at(i).currentPos.center\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t- firstLegos->at(i).center)) {\\n\\t\\t\\t\\tfoundLegos->at(i).closestDistance = norm(\\n\\t\\t\\t\\t\\t\\tfoundLegos->at(i).currentPos.center\\n\\t\\t\\t\\t\\t\\t\\t\\t- firstLegos->at(i).center);\\n\\t\\t\\t}\\n\\t\\t\\tif (norm(\\n\\t\\t\\t\\t\\tfoundLegos->at(i).currentPos.center\\n\\t\\t\\t\\t\\t\\t\\t- prevLego->at(i).center) > 5) {\\n//\\t\\t\\t\\tcout\\n//\\t\\t\\t\\t<< norm(\\n//\\t\\t\\t\\t\\t\\tfoundLegos->at(i).currentPos.center\\n//\\t\\t\\t\\t\\t\\t- prevLego->at(i).center) << endl;\\n\\n\\t\\t\\t\\tfoundLegos->at(i).variationDistance += norm(\\n\\t\\t\\t\\t\\t\\tfoundLegos->at(i).currentPos.center\\n\\t\\t\\t\\t\\t\\t\\t\\t- prevLego->at(i).center);\\n\\t\\t\\t}\\n\\t\\t\\tif (fmod(\\n\\t\\t\\t\\t\\tabs(\\n\\t\\t\\t\\t\\t\\t\\tfoundLegos->at(i).currentPos.angle\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t- prevLego->at(i).angle), 45) > 3) {\\n//\\t\\t\\t\\tcout\\n//\\t\\t\\t\\t\\t\\t<< fmod(\\n//\\t\\t\\t\\t\\t\\t\\t\\tabs(\\n//\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfoundLegos->at(i).currentPos.angle\\n//\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t- prevLego->at(i).angle), 45)\\n//\\t\\t\\t\\t\\t\\t<< endl;\\n\\t\\t\\t\\tfoundLegos->at(i).variationAngle += fmod(\\n\\t\\t\\t\\t\\t\\tabs(\\n\\t\\t\\t\\t\\t\\t\\t\\tfoundLegos->at(i).currentPos.angle\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t- prevLego->at(i).angle), 45);\\n\\t\\t\\t}\\n\\t\\t\\tfoundLegos->at(i).currentPos = prevLego->at(i);\\n\\n\\t\\t}\\n\\t}\\n\\n}\\n\\n//Finds corresponding legos and calculate distance based on stereovision techniques. Prints out guess.\\nvoid stereoVision(vector