Self-modifying code is used for both good and bad. Software companies use it as a means of hiding a program's internals. This can allow them to prevent hackers from “cracking” the authentication on their software. Self-modifying code is also used in malware to avoid being detected by malware analysts and anti-virus software. It is created when programs write to their own instruction memory space. The power of self-modifying code comes from being difficult to analyze, because traditional analysis tools don’t account for changing instruction space. In this project, we implement an algorithm proposed by Anckaert et al.[1] to track self-modification. This algorithm can be used to generate a new type of control flow graph which represents a conservative estimate of all possible execution paths of a program. We implement this algorithm with the goal of identifying its strengths and weaknesses. We also produce visualizations of the resulting control flow graphs that show both positive and negative aspects of this algorithm. Using our visualizations, we have identified levels of sophistication the code in a program can possess for a useful visualization to be generated. We have defined sophistication in code to be related to the amount of jump and write instructions, and programs that have more complex sequences of interrelated jumps and writes yield far less useful graphs. On the other hand, programs that contain simple sequences of jumps and writes, or none at all, are easily visualized to the full understanding of the program’s internals.