text:
\section{Introduction}\label{sec:Introduction}
Obfuscation is a program transformation technique that renders a program unreadable to a human while preserving its semantics. A software developer uses static code obfuscation techniques to secure code and data from reverse engineering attacks. There are three types of obfuscation- lexical, data and control flow obfuscation. Lexical obfuscation replaces class, field and method identifiers with new random identifiers or words from a dictionary. Data obfuscation modifies data structures used by a program. Control flow obfuscation (CFO) alters the control flow path of a program. Malware authors use obfuscation to impede security analysts from reverse engineering their code or to evade automated program analyzers.

In this paper, we focus on control flow obfuscation techniques. While existing literature proposes several techniques, the differences between them is unclear. What is also unknown is if there is a disparity in the theory and practice of CFO. This knowledge can aid software developers to decide on the best techniques to use to secure their code. Commercial obfuscator developers and researchers can use this knowledge to advance the state-of-the-art and steer research in this area.

There are a few existing surveys on control flow obfuscation \cite{RefJ26},\cite{RefJ19},\cite{RefJ27}, \cite{RefJ24},\cite{RefJ11} \cite{RefJ16}. Colberg et al. propose groundbreaking work on the taxonomy of obfuscating transformations. They classify 15 control flow transformations into four types - Opaque Predicate, Computation Transformation, Aggregation Transformation and Ordering Transformations. However, their classification is based on theoretical foundations alone. Schrittwieser et al. \cite{RefJ16} classifies obfuscation techniques into three categories- data obfuscation, static code rewriting and dynamic code rewriting. They survey literature to analyze the strength of obfuscation against common adverserial goals.

Balakrishnan et al. \cite{RefJ24} presents a literature survey of all code obfuscation techniques used to thwart static analysis and program disassembly. However, all the CFO techniques they propose is also discussed by Colberg et al. \cite{RefJ26}. You et al. \cite{RefJ11} discusses a survey of obfuscation techniques in Windows malware binaries. Majumdar et al. \cite{RefJ27} survey the strengths and weaknesses of two CFO techniques - control flow flattening and opaque predicates. Xu et al. \cite{RefJ57} compares and contrasts code-oriented and model-oriented obfuscation techniques to conclude that there are no secure and usable obfuscation techniques. Lim \cite{RefJ54} evaluates various code obfuscation techniques and measures performance of each. Low et al. \cite{RefJ19} discusses ways to create resilient and stealthy opaque predicates.

In this paper, we systematize knowledge of control flow obfuscation on Java programs by studying the techniques proposed in the literature and those implemented by obfuscation tools. We assemble a list of known techniques into a single study and classify it into 5 categories based on the component (or level) of a program on which the transformation is applied. Though we use the taxonomy proposed by Colberg et al. \cite{RefJ26} as the basis of our research, we deviate substantially in our classification. We evaluate 13 obfuscation tools and determine that only 6 are viable for analysis. The remaining obfuscators were either unavailable for download, end-of-lived or had unresolvable program errors that made it unusable. Obfuscators used for Android programs can also be used for Java applications. However, certain Android obfuscators will not work on Java bytecode. Hence we evaluate tools that can obfuscate Java programs only.

In order to evaluate obfuscators, we choose a sample set of 16 programs with varying control flow properties. Each obfuscator is repeatedly applied to the 16 sample programs by varying their configuration parameters. The bytecode of the obfuscated program is then manually analyzed and compared with that of the original program to tabulate our findings. Wherever possible, we confirm our results with any documentation provided by the tool. We apply no lexical or data obfuscation and restrict our analysis to CFO only.

From our study, we identified a total of 43 unique techniques, 36 from literature and 7 from tools. Of the 36 techniques from literature, 12 are not implemented in any of the tools. Three of the most popular commercial obfuscators implement only 13 of the 36 techniques from the literature. Thus there appears to be a gap between the theory and practice of CFO. We assess the potency of each technique from the perspective of a human analyst and a program decompiler. We determine that techniques that are applied on a basic block are the most potent. However, majority of the techniques do not implement them, thus defeating the reliability of obfuscation. We identify the most popular techniques in tools and identify those that are incorrectly cited as control flow obfuscating. In the end, we discuss our findings from this study.

To summarize, we make the following contributions:
\begin{itemize}
    \item We survey literature for CFO techniques and identify 36 unique techniques from literature. We furnish examples of select techniques and identify those that are incorrectly cited as control flow obfuscating.
    \item We evaluate 13 obfuscators and identify the 6 viable tools that can control flow obfuscate Java programs.
    \item We evaluate each tool on a set of 16 programs with varying software characteristics by repeated application of each obfuscator with varying configuration parameters. We identify 7 novel techniques. Three of the most popular commercial obfuscators implement only 13 of the 36 techniques. Thus there appears to be a gap between the theory and practice of CFO.  We also identify the most commonly applied obfuscation techniques in tools.
    \item We propose a classification of the 43 techniques based on the component of a program that is transformed. We discuss the potency of the techniques, and identify those that are resilient to decompilers. We determine that majority of the obfuscators do not implement these techniques, thus defeating its purpose.
\end{itemize}

\section{Running Example}\label{sec:Runningeg}
Listing \ref{code:running} is an iterative implementation of a binary search program in Java. The program will be used as the running example for the remainder of this paper. The example has all the components present in a typical program such as \textit{if-else} condition, loop etc. The function \textit{binarySearch} takes two parameters as input - an array and the element to be searched. It returns the index at which the element was found and $-1$ otherwise.

\section{Techniques in Literature}\label{sec:TechfrmLit}
In this section we discuss techniques found in the literature grouped by the obfuscating paradigm used. Wherever possible, we provide examples of each technique using the running example. The code snippet on the left shows the original code. Obfuscated code is on the right. Examples for some techniques have been omitted when it is similar to already stated techniques or when there are other literature that cites them.

\begin{lstlisting}[caption=Running Example, label={code:running}] code
class FindElement{
   static int binarySearch(int arr[], int x){
       int l = 0, r = arr.length - 1;
       while (l <= r){
           int m = l + (r-l)/2;
           if (arr[m] == x)  // Check if x is present at mid
               return m+1;
           if (arr[m] < x) // If x greater, ignore left half
               l = m + 1;
           else // If x is smaller, ignore right half
               r = m - 1;
       }
       return -1;
   }
}
class BinarySearch extends FindElement{
    public void printResult(int result,boolean isPresent) {
       if(isPresent==false)
           System.out.println("Element not present");
       else
           System.out.println("Element was found at index " + result);
   }
   public static void main(String args[]){
       FindElement ob1=new FindElement();
       BinarySearch ob2=new BinarySearch();
       boolean isPresent=false;
       int arr[] = new int[args.length];
       if (args == null) return;
       for (int i = 0; i < args.length; i++)
         arr[i] = Integer.parseInt(args[i]);

       //print the array
       for (int i =0; i < arr.length; i++)
           System.out.println(arr[i]);
       int index = ob1.binarySearch(arr, 10);
       if(index!=-1){
           isPresent=true;
           ob2.printResult(index,isPresent);
       }
       else
           ob2.printResult(index,isPresent);
   }
}
\end{lstlisting}

\subsection{Using Opaque Predicates}
An opaque predicate is a predicate whose value is known apriori to the obfuscator. There are several ways in which an opaque predicate can be used to obfuscate a program \cite{RefJ1}, \cite{RefJ2}, \cite{RefJ3}, \cite{RefJ4}, \cite{RefJ5}, \cite{RefJ10}, \cite{RefJ12}, \cite{RefJ13}, \cite{RefJ16}, \cite{RefJ17}, \cite{RefJ21}, \cite{RefJ26}, \cite{RefJ27}, \cite{RefJ28}, \cite{RefJ29}, \cite{RefJ30}, \cite{RefJ40}, \cite{RefJ41}, \cite{RefJ42}, \cite{RefJ43}, \cite{RefJ47}, \cite{RefJ48}, \cite{RefJ49}, \cite{RefJ50}, \cite{RefJ54}. Below we discuss the techniques that use opaque predicates. Existing literature also proposes algebraic techniques to create resilient opaque predicates; however, we do not study resilience of predicates in this work.

\begin{enumerate}
    \item \textit{Extending conditionals.} An opaque predicate is inserted into a conditional expression of either an \textit{if-else} statement or a loop. Here inserting the opaque predicate does not alter the evaluation of the expression \cite{RefJ25}, \cite{RefJ26}.
    \item \textit{Adding Redundant Operands.} Opaque variables or expressions are added as operands to arithmetic expressions \cite{RefJ25}, \cite{RefJ26}.
    \item \textit{Dead Code Insertion.} An opaque predicate that guards a set of statements is inserted into the program in such a way that the code block guarded by the predicate is never executed (dead code) \cite{RefJ7}, \cite{RefJ10}, \cite{RefJ11}, \cite{RefJ15}, \cite{RefJ16}, \cite{RefJ20}, \cite{RefJ26}, \cite{RefJ46}, \cite{RefJ47}, \cite{RefJ50}.
\end{enumerate}

The example below shows all three techniques discussed above. In the obfuscated program, the original \textit{if} statement is modified by adding an opaquely \textit{false} predicate denoted by the variable \textit{bool}. The arithmetic expression of the \textit{return} statement is changed to also use a redundant operand called \textit{redop}. The obfuscated code also contains an additional \textit{if} statement guarded by the predicate \textit{bool} whose consequent never gets executed.

\noindent\begin{minipage}{.48\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-2-1, numbers=none]{Deadcode}
if (arr[m] == x)
    return m+1;
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.48\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-2-2,numbers=none]{Deadcode}
boolean bool;
int redop = 1;
if (arr[m] == x && !bool)
    if(bool){
        /*deadcode*/
        return 0;
    }
    return (m+1) * redop;
}
\end{lstlisting}
\end{minipage}

\subsection{Irrelevant Code Insertion}
In this technique, the obfuscator inserts a set of irrelevant statements into the program \cite{RefJ16}. Unlike \textit{Dead Code Insertion}, the program executes the inserted statements. However, they may be irrelevant to it, or not present in the original program. The string variable \textit{str} is the irrelevant code in the example.

\noindent\begin{minipage}{.48\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-3-1, numbers=none]{Exprreo}
if (isPresent == false)
   System.out.println("Element
                 not present");
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.48\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-3-2,numbers=none]{Exprreo}
if (isPresent == false) {
   String str="Hello World!";
   System.out.println("Element
                 not present");
}
\end{lstlisting}
\end{minipage}

\subsection{Ordering obfuscation.}
Ordering obfuscation changes the order of evaluation of expressions, loops, statements or methods while preserving dependencies \cite{RefJ10}, \cite{RefJ16}, \cite{RefJ18}, \cite{RefJ25}, \cite{RefJ26}, \cite{RefJ54}.

\begin{enumerate}
    \item \textit{Reordering Expressions.} This technique changes the order of evaluation of sub-expressions without changing its valuation. The example below shows how to obfuscate a conditional of the \textit{if} statement.

    \begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-4-1,numbers=none]{Exprreo}
if (arr[m] < x)
    l = m + 1;
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-4-2,numbers=none]{Exprreo}
if (x >= arr[m])
    l = m + 1;
\end{lstlisting}
\end{minipage}

    \item \textit{Reordering Loop.} The example shows how to change the evaluation of a loop index.

\noindent\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-5-1,numbers=none]{Loopreo}
for(int i=0;i<arr.length;i++)
    System.out.println(arr[i]);
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-5-2,numbers=none]{Loopreo}
for(int i=arr.length-1;i>=0;i--)
    System.out.println(arr[i]);
\end{lstlisting}
\end{minipage}

    \item \textit{Reordering Statements.} In this technique, an obfuscator reorders statements within a basic block to preserve dependencies \cite{RefJ46}, \cite{RefJ50}.

\iffalse
In the example, the statements are reordered to print the array after the invocation to the \textit{binarySearch} function.
\noindent\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-6-1]{Statreo}
for (int i=0; i<arr.length;i++)
    System.out.println(arr[i]);
int index=ob1.binarySearch(arr,10);
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-6-2]{Statreo}
int index=ob1.binarySearch(arr,10);
for (int i=0; i<arr.length;i++)
    System.out.println(arr[i]);
\end{lstlisting}
\end{minipage}
\fi
\item \textit{Reordering Code Blocks.} This technique reorders basic blocks while preserving dependencies.

\item \textit{Reordering Methods.} This techniques changes the order of its subroutines \cite{RefJ11}, \cite{RefJ46}. This technique can generate n! different variants of a program, where n is the number of subroutines. This approach moves the structural position of the method in a file.

\end{enumerate}

\subsection{Instruction Substitution.}
In this technique, the obfuscator replaces a sequence of instructions with an alternate sequence of semantically equivalent instructions \cite{RefJ7}, \cite{RefJ11}, \cite{RefJ20}, \cite{RefJ46}. For instance, the \textit{goto} at line 47 is replaced with \textit{iload\_2} and \textit{ifeq} instructions.

\noindent\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-7-1,numbers=none]{Instrsub}
47 : goto 107
50 : iload_1
107: return
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.50\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-7-2,numbers=none]{Instrsub}
66  : iload_2
67  : ifeq 129
70  : iload_1
129 : return
\end{lstlisting}
\end{minipage}

A specific implementation of this technique has been mentioned in \cite{RefJ59} called the \textit{Replacing Goto} obfuscation. In this technique \textit{goto} instructions are replaced with conditional branch instructions.

\subsection{Control Flow Flattening}
This technique works by first flattening the control flow graph of a program such that all the basic blocks have the same successor and predecessor. A dispatcher variable is then introduced to guide the control flow of the program \cite{RefJ2}, \cite{RefJ4}, \cite{RefJ5}, \cite{RefJ7}, \cite{RefJ100}, \cite{RefJ12}, \cite{RefJ13}, \cite{RefJ14}, \cite{RefJ21}, \cite{RefJ22}, \cite{RefJ25}, \cite{RefJ40}, \cite{RefJ41}, \cite{RefJ43}, \cite{RefJ44}, \cite{RefJ45}, \cite{RefJ56}. In the example, the original code snippet has two basic blocks. The control flow flattened program encapsulates both the basic blocks into a \textit{switch} block with each basic block forming a \textit{case} statement. The dispatcher variable here is \textit{var}. When \textit{var = 2}, control flow enters the second case statement that contains the first basic block.

\noindent\begin{minipage}{.48\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-8-1, numbers=none]{CFF}
int arr[] = {2, 3, 4, 10, 40};
for (int i =0; i < arr.length; i++)
    System.out.println(arr[i]);
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.48\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-8-2,numbers=none]{CFF}
int var=2;
while(var!=0){
 switch(var){
  case 1:
     for(int i =0;i<arr.length;i++)
       System.out.println(arr[i]);
     var=0;
     break;
  case 2:
     int arr[] = {2, 3, 4, 10, 40};
     var=1;
     break;
  default:break;
  }
}
\end{lstlisting}
\end{minipage}

\subsection{Method Transformation}
This technique obscures method invocations. There are four types of transformation:

\begin{enumerate}
\item \textit{Inline Methods.} The technique replaces a method invocation with the body of the method \cite{RefJ1}, \cite{RefJ6}, \cite{RefJ10}, \cite{RefJ15}, \cite{RefJ18}, \cite{RefJ24}, \cite{RefJ26}, \cite{RefJ50}, \cite{RefJ54}. For instance, the body of the function \textit{printResult} replaces its invocation (line 17) in the running example.

\item \textit{Outline Methods.} This technique is the inverse of inlining; it replaces a sequence of statements with a function call \cite{RefJ1}, \cite{RefJ6}, \cite{RefJ10}, \cite{RefJ24}, \cite{RefJ26}, \cite{RefJ50}, \cite{RefJ54}.

\item \textit{Clone Methods.} This obfuscation modifies a method's call site by invoking clones of the same method \cite{RefJ1}, \cite{RefJ16}, \cite{RefJ24}, \cite{RefJ26}. The call to \textit{binarySearch} is obfuscated by inserting clones of the same function.

\noindent\begin{minipage}{.43\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-9-1,numbers=none]{Clone}
int result = binarySearch(arr, 10);
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.48\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-9-2,numbers=none]{Clone}
int choice=1;
int result;
if(choice==1)
  result = binarySearch1(arr, 10);
else
  result = binarySearch2(arr, 10);
\end{lstlisting}
\end{minipage}

\item \textit{Interleave Methods.} The technique merges two separate methods into a single method \cite{RefJ1},  \cite{RefJ26}.
\end{enumerate}
\subsection{Replacing if(non) null instructions with try-catch blocks}
The instructions \textit{ifnull} and \textit{ifnonnull} are used for obfuscation. The \textit{ifnull} instruction checks if the topmost element on the stack is null, whereas the \textit{ifnonnull} instruction checks if the top most instruction is non-null. These instructions then jump to a location as specified by a label. These instructions are replaced by \textit{try-catch} constructs to alter the control flow. This may be done either by inserting a statement that will cause an exception or by explicitly throwing an exception \cite{RefJ37}. Below is an example of the former.

\noindent\begin{minipage}{.48\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-10-1, numbers=none]{Trycatch}
if (args == null) return;
for (int i = 0; i < args.length; i++)
  arr[i] = Integer.parseInt(args[i]);

\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.48\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-10-2,numbers=none]{Trycatch}
try {
  for (int i = 0; i < args.length; i++)
    arr[i] = Integer.parseInt(args[i]);
} catch (NullPointerException ne) {
  return;
}
\end{lstlisting}
\end{minipage}

\subsection{Loop Transformations}
These transformations manipulate loops without changing their behaviour \cite{RefJ16}, \cite{RefJ26}. It is of four types.

\begin{enumerate}
    \item \textit{Loop Fission.} The technique splits a loop into multiple loops \cite{RefJ21}. For instance, the \textit{for} loop in the original program is split into two by causing the loops to iterate only half the array.

\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-11-1,numbers=none]{Loopfis}
for(int i=1;i<arr.length;i++)
    System.out.println(arr[i]);
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-11-2,numbers=none]{Loopfis}
for(int i=1;i< arr.length/2;i++)
    System.out.println(arr[i]);
for(int i=arr.length/2;
    i< arr.length;i++)
    System.out.println(arr[i]);
\end{lstlisting}
\end{minipage}

\item \textit{Loop Blocking.} This is a well-known optimization technique used by compilers for caching. Here, a loop is partitioned into small blocks. For instance, the loop in the original program is blocked by a block of size 2.

\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-12-1,numbers=none]{Loopbloc}
for(int i=0;i< arr.length;i++)
    System.out.println(arr[i]);
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-12-2,numbers=none]{Loopbloc}
for (int j=0;j<arr.length;j+=2)
 for(int i=j; j< min(
    arr.length, j+2); i++)
     System.out.println(arr[i]);
\end{lstlisting}
\end{minipage}

\item \textit{Loop Unrolling.} Also known as \textit{loop unwinding}, this is yet another compiler optimization that trades space for execution speed\cite{RefJ6}, \cite{RefJ10}, \cite{RefJ54}. It reduces the number of iterations of a loop by increasing the size of the program.  For instance, in the obfuscated program, the \textit{print} statement is unrolled.

\noindent\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-13-1,numbers=none]{LoopUnrol}
for (int i =0; i < arr.length; i++)
   System.out.println(arr[i]);
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb, label=code:example-13-2,numbers=none]{LoopUnrol}
for (int i=0;i<arr.length; i=i+3) {
    System.out.print(arr[i]);
    System.out.println(arr[i+1]);
    System.out.println(arr[i+2]);
}
\end{lstlisting}
\end{minipage}

\item \textit{Replace with Equivalent Codes.} This obfuscation inserts, modifies or removes statements, identifiers, and literals \cite{RefJ38}. This is also called as Code Clone III. In the example below, the elemet \textit{arr[i]} is assigned to another variable \textit{num}.

\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-23-1,numbers=none]{Clone3}
for (int i =0; i < arr.length; i++) {
   System.out.println(arr[i]);
}
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb, label=code:example-23-2,numbers=none]{Clone3}
for (int i =0; i < arr.length; i++){
   int num = arr[i];
   System.out.println(num);
}
\end{lstlisting}
\end{minipage}

\item \textit{Code Clone-Type IV.} Here code snippets are modified to produce syntactically different, yet semantically identical variants \cite{RefJ38}. For instance, an obfuscator replaces a  \textit{for} loop with a \textit{while} loop.

\iffalse
\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-15-1]{Clone4}
for (int i =0; i < arr.length; i++)
   System.out.println(arr[i]);
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.46\textwidth}
\begin{lstlisting}[frame=tlrb, label=code:example-15-2]{Clone4}
int i=0;
while(i < arr.length){
   System.out.println(arr[i]);
   i++;
}
\end{lstlisting}
\end{minipage}
\fi

\item \textit{Inserting Dummy Loop.} In this technique empty loops are inserted into the code. An alternative implementation is combining basic blocks into a loop.

\item \textit{Intersecting Loops.}This approach inserts intersecting loops into the control flow and guarded by an opaque predicate to skip the loop \cite{RefJ59}. The opaque predicate causes the the inserted code to act like dead code.

\end{enumerate}

\subsection{Basic Block Fission}
This technique splits the chosen code blocks into finer pieces and inserts opaque predicates and \textit{goto} instructions in them \cite{RefJ59}. The use of \textit{goto} may cause the decompiler to fail in this case.

\subsection{Remove Library and Program Idioms}
The technique uses obfuscated version of library functions and removes/replaces programming idioms from the original program \cite{RefJ16}, \cite{RefJ25}, \cite{RefJ26}. For example, \textit{System.out.println} library call is replaced with a semantically equivalent implementation that use \textit{BufferedWriter}.

\noindent\begin{minipage}{.48\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-16-1,numbers=none]{Remlib}
System.out.println("Element not
present");
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.48\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-16-2,numbers=none]{Remlib}
BufferedWriter bw = new
BufferedWriter(new
OutputStreamWriter(System.out));
bw.write("Element not present");
\end{lstlisting}
\end{minipage}

\subsection{Convert a Reducible to Non-Reducible Flow-graph}
In this technique, instructions that have no direct correspondence with the source language is used to obfuscate a program. This makes the transformation language-breaking or non-reducible \cite{RefJ26}. A commonly used approach is to use the \textit{goto} statement to express arbitrary control flow. This makes it a non-reducible flow-graph as the Java language itself can only express structured control flow (reducible flow-graph). This can easily be done by inserting a bogus jump to the middle of the body of a \textit{while} loop using an opaque predicate that will never get executed. When the loop has multiple headers or entry points, it no longer becomes structured and hence will become non-reducible.

\iffalse
\noindent\begin{minipage}{.48\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-17-1,numbers=none]{Remlib}
System.out.println("Element not
present");
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.48\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-17-2,numbers=none]{Remlib}
BufferedWriter bw = new
BufferedWriter(new
OutputStreamWriter(System.out));
bw.write("Element not present");
\end{lstlisting}
\end{minipage}
\fi
\subsection{Table Interpretation}
This technique is also called as \textit{Virtualization} \cite{RefJ8}, \cite{RefJ9}, \cite{RefJ23}, \cite{RefJ48}, \cite{RefJ26}. A program's bytecode is converted into a custom instruction set that is executed by a VM interpreter included within the obfuscated application. This transformation induces additional runtime over head and hence is reserved only for extremely sensitive portions of an application.
\subsection{Parallelizing the Code}
\label{sec:11}
In this technique, multiple processes are created to execute code blocks that have no data dependencies. This may be done either by creating dummy processes and running them in parallel with the instructions of the program or by splitting a sequential section of the application into multiple sections that can be executed in parallel. Code block that have data dependencies can be parallelized using synchronizing functions \cite{RefJ15}, \cite{RefJ16}, \cite{RefJ25}, \cite{RefJ26}.

\renewcommand{\arraystretch}{1.2}
\begin{table}
\caption{List of Control Flow Obfuscators in the Study}
\label{tab:listoftools}
\scriptsize
\begin{tabular}{p{2.7cm}p{1.6cm}p{2.2cm}p{2.5cm}p{1.5cm}}
\hline\noalign{\smallskip}
Obfuscator & Software Version & Availability & Input & Evaluated \\
\noalign{\smallskip}\hline\noalign{\smallskip}
Zelix Klassmaster & 6.1 & Paid version & Bytecode & Y \\
Allatori & 6.4 & Trial version & Bytecode & Y  \\
DashO  & 8.3.0 & Trial version & Bytecode & Y  \\
JBCO & 2.5.0 & Not-Available & Bytecode & N \\
JMOT & 3.0 & Open-source & Bytecode & Y \\
Sandmark & 2.1 & Open-source & Bytecode & Y \\
Jfuscator & Unspecified & Trial version & Byte/Sourcecode & Y\\
JOAD & 2.1 & Open-source & Bytecode & N\\
JShield & Unspecified & Not available & Source code & N\\
Arxan & Unspecified & Paid version & Bytecode & N\\
Cloakware & Unspecified & Not available & Sourcecode & N\\
Smokescreen & 3.11 & Not available & Bytecode & N\\
Codeshield & 2.0 & Not available & Bytecode & N\\
\noalign{\smallskip}\hline
\end{tabular}
\end{table}

\section{Tools Evaluation}\label{sec:ToolEval}
We identify 13 tools as listed in table \ref{tab:listoftools} that support control flow obfuscation. We restrict our evaluation to control flow obfuscators and exclude lexical and data obfuscators such as Proguard. Of the 13 tools Only 6 tools are viable - DashO, Allatori, Zelix Klassmaster, Sandmark, JMOT, and JFuscator. JBCO is the only tool which we could not evaluate, yet is included since they furnish a detailed documentation of their techniques. For those that were not evaluated, we indicate why. In case of paid proprietary tools, we use their trial versions for evaluation, except for Zelix Klassmaster, for which we acquired a licensed version.

In order to conduct the study, we use a set of 16 synthetic programs with and without control flow constructs. We intended the programs to contain a heterogeneous mix of properties. The programs have one or more of the following characteristics: 1) non-nested \textit{if} statements 2) non-nested \textit{if-else} statements 3) one/many \textit{for} or \textit{while} loops 4) \textit{switch-case} statements 5) nested conditional statements 6) nested \textit{try-catch} blocks 7) use of complex data structures such as \textit{hashmaps} 8) variable number of methods 9) accepts user inputs. In a case where the conditionals are nested, we introduce a nesting level of up to 3 levels.

The source/bytecode of each of the 16 programs are repeatedly supplied as input to each control flow obfuscator for different obfuscator parameters. We manually manually examine the bytecode output to identify the differences between the original and the transformed programs using the \textit{javap} command. This is because, the decompiled output of a program may vary depending on the decompiler used. Certain obfuscations also produce programs that cannot be decompiled.  Lastly, while some of the techniques do not appear to alter the control flow of the program from the perspective of source code, it is still a control flow obfuscation if it alters the control flow of the bytecode. We use \textit{JD-GUI} decompiler wherever possible to verify our findings.

Table \ref{tab:techniquesintools} details the list of obfuscation techniques supported by each tool.

\iffalse
\begin{figure}[h]
\centering
\includegraphics[height=0.30\textwidth]{venn.png}
\caption{Summary of Findings}
\end{figure}
\fi

\subsection{Zelix Klassmaster}
Zelix supports 3 levels of control flow obfuscation- light, normal and aggressive, and data obfuscation. Zelix uses only techniques proposed by the literature. They using static boolean variables as opaque predicates and insert emtpty \textit{if} statements guarded by opaquely false predicates. Zelix also reorders the constant pool index, which is a structural obfuscation technique.

\subsection{Allatori}
This obfuscator is available as a plugin for Eclipse. It supports incremental obfuscation of code to allow for consistency with the previous obfuscated versions of a program.

\iftrue
\renewcommand{\arraystretch}{1.3}
\begin{table}[ht!]
\caption{List of Techniques from Tools}
\label{tab:techniquesintools}
\scriptsize
\noindent\begin{minipage}[b]{0.30\linewidth}
\begin{tabular}{p{1.5cm}p{4.2cm}}
\hline\noalign{\smallskip}
Obfuscator & Obfuscation Technique  \\
\noalign{\smallskip}\hline\noalign{\smallskip}
Zelix  &  Irrelevant Code Insertion\\
                  &  Extending Conditionals\\
                  &  Opaque Branch Insertion \\
                  & Opaque Predicate Insertion \\
                  &  Dead Code Insertion\\
                  &  Instruction Substitution \\
                  &  Convert Reducible to Irreducible Flowgraph \\
                  &  Replacing if(non) Null Instructions with TCB \\
                  &  Reordering Statements \\
Allatori  &  Method Reordering \\
          &  Instruction Substitution\\
          &  Reordering Statements\\
          &  Replacing if(non) Null Instructions with TCB\\
          &  Code Clone Type IV \\
          &  Using Opaque Predicate\\
          &  Dead Code Insertion\\
          &  Branch Inversion\\
DashO  &  Opaque Branch Insertion \\
       &  Dead Code Insertion \\
       &  Reordering Statements\\
       &  Goto Instruction Augmentation\\
       & Insert Dummy Loop \\
          &  Replacing if(non) Null Instructions with TCB\\
JMOT  &   Data Sanitization  \\
JFuscator &  Irrelevant Code Insertion \\
          &  Instruction Substitution\\

\noalign{\smallskip}\hline
\end{tabular}
\label{tab:test3}
\end{minipage}
\hspace{9em}
\begin{minipage}[b]{0.30\linewidth}
\centering
\begin{tabular}{p{1.5cm}p{4.2cm}}
\hline\noalign{\smallskip}
Obfuscator & Obfuscation Technique  \\
\noalign{\smallskip}\hline\noalign{\smallskip}
JBCO &  Reordering the load instructions above the if instructions\\
          &  Replacing if(non) Null Instructions with TCB\\
     &  Adding Dead Code Switch Stmt.\\
     &  Building API Buffer Methods\\
     &  Building Lib Buffer Classes\\
     &  Goto Instruction Augmentation\\
     &  Converting Branches to jsr Instns.\\
     &  Finding and Reusing Duplicate Sequences \\
     &  Disobeying Constructor Conventions \\
     & Partially Trapping Switch Stmts. \\
     & Combining Try Blocks with Catch Blocks \\
     & Indirecting if Instructions \\
Sandmark  &  Boolean Splitter \\
          &  Reordering Expressions \\
          &  Building API Buffer Methods \\
          &  Split Objects \\
           &  Class Splitter  \\
           &  Interleave Methods \\
          &  Inline Methods \\
          &  Convert Reducible to Irreducible Flow Graph \\
          &  Reordering Statements \\
          &  Opaque Branch Insertion \\
          &  Dynamic Inliner \\
          &  Dead Code Insertion \\
\noalign{\smallskip}\hline
\end{tabular}
\label{tab:4}
\end{minipage}
\hfill

\end{table}
\fi

\subsection{JBCO}
JBCO \cite{RefJ51}, \cite{RefJ58} is an obfuscator developed by Sable Group, KTH University, that proposes a set of techniques specifically for bytecode obfuscation. The tool is  a part of the \textit{Soot} framework. We were not able to successfully evaluate all the techniques due to dependency errors while running the tool. However, the techniques they have created have been discussed in detail with examples in \cite{RefJ58}. One thing to note is that depending on the specification of the virtual machine in which bytecode is run, some techniques may  cease to work.
\begin{enumerate}
\item \textit{Reordering load instruction above if instructions.} This technique moves a local variable common to both the \textit{if} and \textit{else} condition to outside the \textit{if-else} statement, thus removing redundant code along the branches.

\item \textit{Adding Dead Code Switch Statements.} It inserts a \textit{switch} statement using an opaquely false predicate.

\item \textit{Finding and Reusing Duplicate Sequences.} This technique manipulates the fact that duplicate bytecode sequences occur in various parts of the code. The code sequences can be replaced with a single switched instance, thus altering the control flow as well as reducing the code size.

\item \textit{Partially Trapping Switch Statements.} Traps are conceptually similar to exception handlers, except that they are specific to bytecode. One way to obfuscate using trap handlers is to encapsulate a sequence of bytecode instructions that may belong to disparate set of code blocks, into a single trap handler. For instance, code blocks belonging to case statements of a switch-case block can be handled by a single trap handler.

\item \textit{Disobeying Constructor Conventions.} This technique manipulates invocations to super class constructor calls. For instance, invocation to a super class constructor is placed inside a try-catch block.

\item \textit{Combining Try Blocks with Catch Blocks.} While the try block must be followed by the catch block in the source code, at the bytecode, the ordering of the blocks is irrelevant. For the same reason, multiple try-catch blocks maybe combined, or a catch block may precede a try block.

\item \textit{Indirecting if Instructions.} In this technique, the \textit{if} branch is indirected through a \textit{goto} instruction. To avoid the \textit{goto} from being removed by the compiler, it is enclosed within a try-catch block.

\item \textit{Building API Buffer Methods.} In this technique, a buffer method is inserted between the caller and the invocation to a Java API call.

\item \textit{Building Library Buffer Classes.} The obfuscator inserts a buffer class (with methods) in between a caller and the callee library class, thus introducing another level of indirection.

\item \textit{ Goto Instruction Augmentation.} It splits a method into two sequential parts, uses \textit{goto} to change the control flow of the program. The parts may optionally be reordered.

\item \textit{Converting branches to jsr instructions.} \textit{jsr} instruction is similar to \textit{goto} the only difference being that jsr pushes a return address to the stack. In this technique,  \textit{if} and \textit{goto} targets are replaced with \textit{jsr} instructions.  The return address is saved in a register for use after returning from a jsr jump.
 \textit{jsr} is supported only in \textit{Java} version 6.0 and below as per the Oracle Documentation. In our experimental evaluation, we were unable to reproduce this obfuscation technique despite lowering the Java version.
\end{enumerate}

\subsection{DashO}
DashO extensively uses \textit{try-catch} blocks for altering the control flow of a program. The number of \textit{try-catch} blocks can be varied from 1 to 10. It does not obfuscate compiler-generated classes such as the default constructor. DashO also uses \textit{nop} instructions to increase code size.
\subsection{JMOT}
JMOT supports 4 levels of obfuscation - Light, Normal, Heavy and Insane. The tool has no control flow obfuscation techniques, and only supports \textit{data sanitization} to protect strings used in the program. Strings are passed through a series of function calls named as hax0, hax1 \ldots hax7. However, this in effect alters the control flow of a program. We mention this for completeness here.

\noindent\begin{minipage}{.45\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-22-1,numbers=none]{gotoaug}
public void printResult(int
       result,boolean isPresent){
if(isPresent==false)
  System.out.println("Element not
                      present");
...
}
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.45\textwidth}
\begin{lstlisting}[frame=tlrb, label=code:example-22-2,numbers=none]{gotoaug}
if (isPresent==false) {
  System.out.println(
  BinarySearch.hax0(
  BinarySearch.hax1(
  ...
  BinarySearch.hax7(
  "Element not present")))))))));
  ...
}
\end{lstlisting}
\end{minipage}

\subsection{JFuscator}
JFuscator is the only obfuscator that gives the developer the choice to obfuscate specific methods or the program as a whole.
\iffalse
\begin{enumerate}
\item \textit{Instruction Substitution}
\item \textit{Irrelevant Code Insertion}
\end{enumerate}
\fi

\subsection{Sandmark}
Sandmark is an open source tool developed by University of Arizona that can obfuscate Java programs. Though the tool has been discontinued since JDK version 1.4 (in 2004), we ported the tool to support JDK 1.8.
To obfuscate, Sandmark provides a list of techniques to choose from. From a total of 15 techniques, we identify 4 that are novel. Given below are the techniques previously seen in literature, but noted below due to minor implementation differences.

\begin{enumerate}
\item \textit{Interleave Methods.} (Called as \textit{Method Merger in Sandmark}). In the tool, this is implemented as two different techniques - one that interleaves \textit{public static} methods with the same signature and the other that interleaves all methods.
\item \textit{Inline Methods.} (Called as \textit{Inliner} in Sandmark). In the tool only \textit{static} methods are inlined.
\item \textit{Simple Opaque Predicate.} This is a composition of the techniques \textit{Extending Conditionals} and \textit{Adding Redundant Operands}.
\item \textit{Static Method Bodies.} This is same as \textit{Building API Buffer Methods}, the difference being that it splits all non-static methods into a \textit{static} helper method that will be invoked by a non-static stub.
\item \textit{Branch Inversion.} This technique is a specific implementation of the technique called \textit{Reordering Expressions}, where the conditional expression of an \textit{if} statement is negated.
\item \textit{Buggy Code.} Similar to \textit{Dead Code Insertion}, except that a copy of a basic block is taken to introduce a bug which is then guarded by an opaquely false predicate
\end{enumerate}

The following techniques are novel:
\begin{enumerate}
\item \textit{Dynamic Inliner} (Similar to Inline Methods) This technique uses \textit{instanceof} checks to perform method inlining at runtime.
\item \textit{Boolean Splitter.} It modifies all uses and definitions of \textit{boolean} variables and arrays. In the example below, the boolean \textit{isPresent} is obfuscated.

\begin{minipage}{.43\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-14-1, numbers=none]{booleansplitter}
public void printResult(int result,
            boolean isPresent){
  if(isPresent==false)
  ...
}
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.43\textwidth}
\begin{lstlisting}[frame=tlrb, label=code:example-14-2, numbers=none]{booleansplitter}
public void printResult(int arg1,
                boolean arg2){
  boolean bool1 = (int)
        (Math.random() * 2.0D);
  boolean arg1=false;
  if (!(arg1 ^ bool1))
  ...
}
\end{lstlisting}
\end{minipage}

\item \textit{Split Objects.} An object of a class is split into two and are linked together by a field. In the example below, the \textit{FindElement} object \textit{ob1} is split. In the obfuscated program, another object called \textit{next0} is created.

\noindent\begin{minipage}{.43\textwidth}
\begin{lstlisting}[frame=tlrb,basicstyle=\scriptsize,label=code:example-20-1, numbers=none]{splitclasses}
class BinarySearch extends
                FindElement{
 main(){
  FindElement ob1=new
             FindElement();
  ...
} }
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.43\textwidth}
\begin{lstlisting}[frame=tlrb,basicstyle=\scriptsize, label=code:example-20-2, numbers=none]{splitclasses}
class FindElement{
  public FindElement0 next0;
  public FindElement(){
    if (this.next0 == null)
      this.next0 =
            new FindElement0();
}
\end{lstlisting}
\end{minipage}

\item \textit{Class Splitter.} The body of a class is split in such a way that methods and fields of the class are moved into its superclass. In the example, the \textit{printResult} method of \textit{BinarySearch} class is moved to its superclass.

\begin{minipage}{.43\textwidth}
\begin{lstlisting}[frame=tlrb,basicstyle=\scriptsize,label=code:example-32-1, numbers=none]{branchinversion}
class FindElement {
  ...
}
class BinarySearch
        extends FindElement{
  public void printResult(...){
  ...
} }
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.43\textwidth}
\begin{lstlisting}[frame=tlrb,basicstyle=\scriptsize, label=code:example-32-2, numbers=none]{branchinversion}
class FindElement {
  public void printResult(...){
  ...
} }
class BinarySearch
        extends FindElement{
}\end{lstlisting}
\end{minipage}

\iffalse
\item \textit{Split Classes.} There are two different implementations for this in Sandmark. It splits a class into two reorganizing its fields and methods. Below is an example of one approach. Another way to do this is to split every object into two and link it by an irrelevant field.

\noindent\begin{minipage}{.45\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-21-1, numbers=none]{branchinversion}
class FindElement{
  ...
}
class BinarySearch extends
              FindElement{
 ...
 public static void main(String
                        args[]){
  ...
  FindElement ob1=new FindElement();
  boolean isPresent=false;
  ...
 }
}
\end{lstlisting}
\end{minipage}\hfill
\begin{minipage}{.45\textwidth}
\begin{lstlisting}[frame=tlrb,label=code:example-21-2, numbers=none]{branchinversion}
class FindElement{
  public FindElement0 next0;
  public static boolean isPresent;
  FindElement(){
   isPresent=false;
   if (this.next0 == null){
    this.next0 = new FindElement0();
   }
   this.next0.isPresent=false;
  ...
  }
class BinarySearch extends
                    FindElement{
 BinarySearch(){
   super();
 }
 ...
 public static void main(String
                       args[]){
 ...
 }
}
public class FindElement0{
 public static boolean isPresent;
 ...
}
\end{lstlisting}
\end{minipage}
\fi

\end{enumerate}

\section{Discussion}

From our study we identified 36 unique techniques from literature and 7 from tools. Three of the most popular and well-supported commercial obfuscators Zelix, Allatori and DashO implement only 13 of the 36 techniques. Thus there appears to be a gap between the theory and practice of CFO.
\renewcommand{\arraystretch}{1.2}
\begin{table}[htp!]
\caption{Classification \& Analysis Overview}
\label{tab:1}
\scriptsize
\begin{tabular}{p{.2cm}p{1.6cm}p{4.6cm}p{1.1cm}p{1.1cm}p{1.1cm}p{1.1cm}p{2.4cm}}
\hline\noalign{\smallskip}
 &Component & Obfuscation Technique & Liter. & Tools & Both & DR & Level \\
\noalign{\smallskip}\hline\noalign{\smallskip}
1. & Expression & Extending Conditionals & \ding{51} & \ding{51} &\ding{51} & N &Opaque Predicate\\
& &Adding Redundant Operands & \ding{51} & \ding{51} &\ding{51} & N & Opaque Predicate\\
& &Reordering Expressions & \ding{51} & \ding{51} & \ding{51} & N & Ordering\\
2.& Statement & Reordering Statements & \ding{51} & \ding{51} & \ding{51} & N & Ordering\\
& &Remove Lib. and Program Idioms&\ding{51} & \ding{51} & \ding{51} & N & Substitution\\
& &Instruction Substitution&\ding{51} & \ding{51} & \ding{51} & N & Substitution \\
 & &Replacing \textit{if(Non) Null} Instructions With \textit{Try-Catch}  Block & \ding{51} & \ding{51} & \ding{51} & N & Substitution\\
& &Converting Branches to \textit{jsr} Instr. & \ding{51} & \ding{51} & \ding{51} & N & Substitution\\
3.& Basic Block & Opaque Branch Insertion& \ding{55} & \ding{51} & \ding{55} & N & Opaque Predicate \\
& &Dead Code Insertion & \ding{51} & \ding{51} & \ding{51} & N & Opaque Predicate\\
& &Adding Dead Code Switch Stmts. & \ding{51} & \ding{51} & \ding{51} & N & Opaque Predicate\\
 & &Reordering Loops & \ding{51} & \ding{55} & \ding{55} & N & Ordering \\
 & & Reordering Code Blocks & \ding{51} & \ding{55} & \ding{55} & N & Ordering \\
 & & Finding and Reusing Duplicate Seq. & \ding{51} & \ding{51} & \ding{51} & N & Ordering \\
 & &Reorder Load Instrs. Above \textit{if} Instr.& \ding{51} & \ding{51} & \ding{51} & N & Ordering\\
& &Loop Fission & \ding{51} & \ding{55} & \ding{55} & N & Loop Transf.\\
& &Loop Blocking & \ding{51} & \ding{55} & \ding{55} & N & Loop Transf. \\
& &Loop Unrolling & \ding{51} & \ding{55} & \ding{55} & N & Loop Transf. \\
& &Intersecting Loop & \ding{51} & \ding{55} & \ding{55} & Y &  Loop Transf.\\
& &Replace with Equivalent Codes & \ding{51} & \ding{51} & \ding{51} & N &  Substitution\\
& & Code Clone Type IV & \ding{51} & \ding{51} & \ding{51} & N & Substitution\\
& &Basic Block Fission & \ding{51} & \ding{55} & \ding{55} & Y & Code Insertion\\
& &Insert Dummy Loop & \ding{51} & \ding{51} & \ding{51} & N & Code Insertion \\
& & Goto Instruction Augmentation & \ding{51} & \ding{51} & \ding{51} & Y & Code Insertion\\
& & Irrelevant Code Insertion & \ding{51}  & \ding{51} & \ding{51} & N & Code Insertion \\
& &Control Flow Flattening& \ding{51} & \ding{55} & \ding{55} & N & Code Insertion\\
& &Boolean Splitter&\ding{55} & \ding{51} & \ding{55} & N & Code Insertion\\
& & Convert Reducible to Non-reducible Flowgraph & \ding{51} & \ding{51} &\ding{51} & Y & Code Insertion\\
& & Partially Trapping Switch Stmts & \ding{51} & \ding{51} & \ding{51} & Y &  Code Insertion \\
& & Disobeying Constructor Conventions & \ding{51} & \ding{51} & \ding{51} & Y & Code Insertion \\
& & Combining Try Blocks with Their Catch Blocks & \ding{51} & \ding{51} & \ding{51} & N & Code Insertion \\
& & Indirecting if Instructions & \ding{55} & \ding{51} & \ding{55} & Y & Code Insertion \\
4.& Method & Inline method & \ding{51} & \ding{51} & \ding{51} & N & Method Transf.\\
& & Outline Method & \ding{51} & \ding{55} & \ding{55} & N & Method Transf.\\
& & Clone Method & \ding{51} & \ding{55} & \ding{55} & N & Method Transf. \\
& & Interleave Methods & \ding{51} & \ding{51} &\ding{51} & N & Method Transf.\\
& & Dynamic Inliner& \ding{55} & \ding{51} & \ding{55} & N & Method Transf.\\
& & Building API Buffer Methods& \ding{55} & \ding{51} & \ding{55} & N & Method Transf.\\
& &Table Interpretation  & \ding{51} & \ding{55} & \ding{55} & Y & Method  Transf.\\
& &Parallelizing the Code & \ding{51} & \ding{55} & \ding{55} & N & Method Transf.\\

5.& Class  & Split Objects & \ding{55} & \ding{51} & \ding{55} & N & Class Transf.\\
& & Class Splitter & \ding{55} & \ding{51} & \ding{55} & N & Class Transf.\\

& & Building Library Buffer Classes& \ding{51}  & \ding{51} & \ding{51} & N &  Class Transf.\\

\noalign{\smallskip}\hline
\end{tabular}
\end{table}

Table \ref{tab:1} furnishes a classification of the techniques based on the component (or level) of a program at which an obfuscation transformation is applied. We identify 5 different components (or levels) of a program (column 1) - Expression (such as conditional expressions), Statement, Basic Block, Method, Class. We indicate whether the technique is proposed in the literature, tools or both (columns 3-5). In column 6, we note whether these techniques allow a program to be decompiled into a source code equivalent, thus facilitating reverse engineering. Finally, we also note the obfuscating paradigm used in column 7. The foundation for the paradigms is obtained from a prior study by Colberg et al. on taxonomy of obfuscating transformations \cite{RefJ26}.

We assess the potency of these techniques. Colberg et al. \cite{RefJ26} defines potency as a measure of how difficult it is for a human reader to understand the obfuscated program. We augment that measure to include the ability of a decompiler to decompile an obfuscated bytecode into its equivalent source. This is because such techniques will inherently lack structure and thus will be unreadable. We determine that Table Interpretation (Virtualization) is the most potent as the knowledge of how the interpreter will execute the program is with the developer of the obfuscator itself. However, implementing such an obfuscator incurs a huge overhead. In all the other techniques, manual disassembly of the program can leak (at least partially) its proprietary knowledge.

12 techniques proposed in the literature is not available in any of the tools. 8 of those are transformations applied to a basic block. Basic block transformations are difficult to implement due to the challenge entailed in preserving inter-block dependencies. However, they are also the most potent. Any technique that generates a non-structured control flow at the bytecode level cannot be decompiled. We identify that the following 7 techniques causes a decompiler to fail - \textit{Goto Instruction Augmentation, Conversion of Reducible to Irreducible Flow Graphs, Intersecting Loops, Basic Block Fission, Partially Trapping Switch Statements, Disobeying Constructor Conventions} and \textit{Indirecting if Instructions}. \textit{Loop blocking}, though it can be decompiled, is potent, as it makes use of nested loops. Nested loops make use of nested \textit{labels} and \textit{gotos} that deters the readability of a program for a human analyst.

All the other techniques that use ordering, substitution, class and method transformation paradigms are effective to create variants of a program, but does not deter the readability of a program. Literature cites method reordering as a CFO technique. However, method reordering only alters the class structurally and does not alter its control flow. Hence this cannot be classified as a CFO technique. We however list it here for completeness. Transformations on expressions and statements are the most common and easiest to implement. \textit{Opaque predicates} can be potent if the predicate used to secure a conditional is potent.

None of the techniques can be deobfuscated without the original program. However, techniques that use opaque predicates such as dead code, opaque branch insertion, redundant operand etc. are common compiler optimizations that can be used to deobfuscate. A deobfuscator can also remove control flow edges that generate non-reducible flow graphs, to generate structured programs so as to enable a decompiler to generate source code.

Of the 6 tools we evaluated, Zelix, Allatori, DashO and JMOT can be used by software developers to control flow obfuscate their code. We determine that Zelix is the most potent as it is the only tool that implements language breaking transformations. Though Allatori and DashO are comparable in their implementations, programs generated by Allatori mask their obfuscation techniques well. DashO relies on try-catch blocks (TCB). They insert a varying number of TCBs depending on the level of obfuscation. This approach does not substantially mar the readability of a program. Although Sandmark provides the most number of techniques, it is not a practically viable tool for commercial purposes. This is because, the tool is no longer supported and not tested for versions of Java greater than 1.4. Each tool has a unique way of inserting dead code, which is useful to identify the obfuscator. Though JBCO has a good lineup of techniques, it has a broken code base at the time of writing this paper and hence not usable. JMOT is a purely command-line tool, does not support control flow obfuscation

The following techniques are common to most tools - \textit{Extending Conditionals, Adding Redundant Operands, Opaque Predicate Insertion, Dead Code Insertion, Irrelevant Code Insertion, Reordering Expressions, Reordering Statements, Replacing \textit{if}(non)null instructions with \textit{try-catch} blocks, and Goto Augmentation}. Aside from the 8 techniques that are decompiler resistant, none of the other techniques provide enough security to prevent reverse engineering attacks. However, majority of the tools implement none of those techniques, allowing an adversary to defeat obfuscation.

\section{Conclusion}\label{sec:Conclusion}
In this research, we have surveyed existing literature and evaluated 13 tools to identify the different control flow obfuscation techniques and their implementations. We have identified 36 unique techniques from literature and 7 from tools. The three most popular commercial tools use only 13 of the 36 techniques, thus showing a lag between the theory and practice of control flow of obfuscation. We classify the 43 techniques into 5 types based on the component of a program on which obfuscation is applied. We also discuss the obfuscating paradigm used. Based on our analysis, we determine that transformations on a basic block are the most potent. We identify 8 techniques that renders a program unreadable both to a human analyst and a program decompiler. 7 of those techniques use language breaking transformations to make a program unstructured. All the other obfuscations are effective to create semantic variants and does not deter readability of a program. Most of the obfuscators do not implement potent techniques defeating the reliability of obfuscation. Each tool inserts their own proprietary dead code, which a deobfuscator can use as a feature to detect the tool. We identify the most commonly used techniques in tools and also flag those that are not implemented. When using a composition of obfuscations, there is a drastic increase in code size and complexity. Hence determining the optimal amount of obfuscation such that the  run-time performance and code complexity is also optimal while preserving potency is an area that requires further work.

redpajama_set_name: RedPajamaArXiv


Sparkling water Handle/ Bubbles Tap Handle by divreig is licensed under the Creative Commons - Attribution - Non-Commercial license.
Made this one for Sparkling water we carbonate in the kegerator. Wish I Could get it truly clear any advices on this point would be help full.


Non-epileptic attack disorder (NEAD) poses diagnostic and therapeutic challenges to neurological and psychological professionals. Existing theories suggest that non-epileptic seizures may be related to an individual's non-recognition of internal affective states. However, one of the challenges associated with this line of inquiry is demonstrating the potential influence of constructs that are hypothetically outside of an individual's awareness or willingness to report. Implicit measurement methodologies have yet to be used in seizure research. This on-going study aims to improve differential diagnosis and offer a novel relational frame perspective on the psychological mechanisms underlying NEAD.


Thank you for your interest in Sparta Athletic Club. We understand that each person who enters our club has different health and fitness needs.Recognizing this allows us to design a program specifically for you, to obtain the results you are looking for. At Sparta Athletic Club, we believe fitness is a journey and not a destination. Maintaining an active lifestyle and engaging in healthy eating habits are the best road maps for staying healthy. We price ourselves in our ability to motivate and retain members by showing them outstanding results. This level of service and commitment is accomplished by employing certified and professional staff that have a caring attitude.
Membership includes 40,000 square foot health, fitness and tennis complex.
Over 50 pieces of cardiovascular equipment.
Selectorized strength equipment in a large weight training area.
Over 70 Group Fitness Classes offered weekly.
Private Cycling Studio with 22 Spin bikes.
Kids Care service for ages 2 months to 13 yrs.
Better community- SAC values the relationship with its member community and is active in supporting the Sparta and greater Sussex County community for 45 years.
OR Stop in for a FREE WEEK to try the gym.


The Turners know in their hearts that they're anything but normal. Jenna is a high-schooler dressed in black who is fascinated with breaking into her neighbors' homes, security systems be damned. Everett genuinely believes he loves his wife . . . he just loves having a continuing stream of mistresses more. JT is a genius kid with Asperger's who moves from one obsession to the next. And Kate tries to manage her family, manage her mother (who lives down the street), and avoid wondering why her life is passing her by.
And now everything is changing for them. Jenna suddenly finds herself in a boy-next-door romance she never could have predicted. Everett's secrets are beginning to unravel on him. JT is getting his first taste of success at navigating the world. And Kate is facing truths about her husband, her mother, and her father that she might have preferred not to face.
Life on Pine Road has never been more challenging for the Turners. That's what happens when you're practicing normal.
I often say that I'd like to read about the everyday lives of well-developed characters simply because people are interesting and the way that they interact with the world is intriguing. This book brought me that in a satisfying way, though it had a distinct plot as well.
While reading this book, I truly got to know Kate and her daughter Jenna. I came to understand Everett and the way that he thought. And I came to appreciate and adore JT with his Asperger's and his unique way of viewing the world. The family itself is very insular, but I got to know secondary characters too through the ways that they interacted with the family.
Jenna was my favourite character--she has a tendency to break into houses and came to know many of her neighbours in that fashion. She's also quite intelligent and aware of what's going on. I loved the way she was vulnerable as she started exploring romance despite the cynicism of her grandmother.
And her grandmother, wow, she definitely kept things moving and provided a source of much of the conflict within this book. Her character also raised important questions of depression and the way we treat the elderly that I found to be quite poignant.
The plot wasn't quite interesting--if I described it to you, I'm not sure that it would persuade you to read this. In theory, it focused on a mystery of birth, and in Kate's sister trying to find their long-gone father. But instead, the strength of this book came from more of an exploration of characters as they navigated certain situations.
Nonetheless, this book was quite enjoyable, and I'm looking forward to more from Achterberg.


Our mission is to provide an unparalleled systematic, accessible information source- the world's only centralized, comprehensive, and definitive resource for this musical-cultural heritage.
access representative samples of this historic synagogue music.
learn about its historic, social, and cultural context.
observe, wherever possible, visual documentation from the relevant period and place.
view the notated music of their selections.
Development of interactive website capability for the advancement and dissemination of this major musical-cultural tradition.
The Jewish Music Heritage Project differs from other Jewish music projects in that it systematically and comprehensively archives the largest and most significant part of the Jewish musical heritage. This has never before been attempted. The end product will be a collection of everything necessary to recreate the tradition in the future.


Песня: Desert Rose. I dream of rain. I dream of gardens in the desert sand. I wake in pain. I dream of love as time runs through my hand. I dream of fire these dreams are tied to a horse that will never tire.


text:
angular
	.module('svg-interactive.zoomable', ['svg-interactive.utilities'])
	.directive('zoomable', ['utilities', function (utilities) {
		return {
			restrict: 'A',
			link: function(scope, element, attrs) {
			// Default zoom rate
			var zoomRate = 1.1;
			var enabled = true;

			attrs.$observe('zoomRate', function(value) {
			  if (angular.isDefined(value)) {
				  zoomRate = parseFloat(value);
			  }
			});
			attrs.$observe('zoomable', function(value) {
			  if (angular.isDefined(value)) {
				  if (value === 'false') {
				    enabled = false;
				  } else {
				    enabled = true;
				  }
			  }
			});

            element.on('mousewheel', function (event) {
              if (enabled) {
                event.preventDefault();
                var viewBoxValues = attrs.viewbox.split(' ').map(function(value) {
                  return parseInt(value, 10);
                }),
					initialPoint = element[0].createSVGPoint(),
					afterZoomPoint;

				// Transform clicked point into SVG coordinate
				initialPoint = utilities.translateCoordinatesScreenToSVG(element, event.clientX, event.clientY);

                // Manipulate viewbox based on zoom in/out
                if (event.wheelDelta < 0) {
                    viewBoxValues[2] *= zoomRate;
                    viewBoxValues[3] *= zoomRate;
                } else if (event.wheelDelta > 0) {
                    viewBoxValues[2] /= zoomRate;
                    viewBoxValues[3] /= zoomRate;
                }

                // Apply new viewbox
                attrs.$set('viewbox', viewBoxValues.join(' '));

                // This centers the zoom on the mouse for a nicer effect
                // New position of mouse on svg document
				afterZoomPoint = utilities.translateCoordinatesScreenToSVG(element, event.clientX, event.clientY);

                // Determine change in location and offset viewbox by that
                viewBoxValues[0] += parseInt(initialPoint.x - afterZoomPoint.x, 10);
				viewBoxValues[1] += parseInt(initialPoint.y - afterZoomPoint.y, 10);

                // Apply new viewbox pan values
				attrs.$set('viewbox', viewBoxValues.join(' '));

                return false;
              }
            });
			}
		};
    }]);

redpajama_set_name: RedPajamaGithub


text:
The Secret to Manufacturing in the United States
Whitman Kwok
I'm a big fan of "The Arsenal of Democracy" by A.J. Baime. The book documents the historic WWII effort behind manufacturing the B-24 Liberator bomber at scale. In 1941, President Roosevelt recognized America's industrial might was critical to repel the Nazi invasion of Britain. Ford responded to the call by creating a mile-long production line at Willow Creek. The factory was just the beginning though. The logistics of rallying workers from upwards of 100 miles away required building a small city to make production practical. Zoom and telecommuting weren't options. The efforts paid off handsomely. The Willow Creek Factory churned out a B-24 every 63 minutes and contributed to success on both the European and Pacific fronts.
With every discussion of trade and tariffs, there's an accompanying stream of articles on overseas manufacturing trends. High US labor costs are frequently cited as justification by the press and executives alike. While true, the narrative is inherently simplistic. We always wanted to manufacture our helmets here in the United States. To truly innovate, design and manufacturing had to be next to each other*. The question remained, "Is it practical to manufacture in the States?" The reality is that manufacturing requires the right mix of competitive advantages, consistency and motivation.
Competitive Advantages. Skilled labor is a significant factor but so is the supplier ecosystem. Suppliers located themselves around Willow Creek to simplify logistics and facilitate collaboration. You see the modern equivalent with automotive factories clustered in Detroit, Kentucky and Ohio. The B-24 went through variants E through H at Willow Creek. These included improvements like adding a second turret but also refinements to improve production and reliability.
Consistency. The ability to deliver a game-changing product is necessary but insufficient. Each customer expects an equally high-quality experience with their product. Traditionally Japanese manufacturers mastered this through a combination of engineering excellence, culture and Kaizen. The latter is the mindset and process for iterative improvements. These qualities are not uniquely Japanese. Honda and Toyota produce high-quality automobiles in their Kentucky plants. Since 2015, domestic brands have topped the JD Power awards. The notion of iterative improvements is a core value at KAV.
Motivation. The most subjective attribute, but the most significant. Who hasn't watched the movie Miracle chronicling the 1980 USA vs. Soviet Union triumph? With a motivated team, all of the above fall into place. The workers at Willow Creek knew the importance of their work. The planes would carry their neighbors, sons and friends to fight an enemy bent on subjugating the world. The same Ford company brought mass production mainstream with the Model T. It provided salaries twice the norm so that workers and the company alike would thrive.
So why are we building our helmets in Redwood City, CA:
We're on a mission to accelerate safety and performance through personalization. We believe that this is not only an engineering problem but one of adoption and therefore design. Every employee has an ownership stake in participating in both the financial and societal benefits. An employee at a contract manufacturer 10,000 miles away doesn't have the same motivation.
It's easier to achieve outstanding quality of a custom product domestically. That over time, our expertise in software and automation will lead the industry in quality. Our proximity to our customers, and knowing them by name, motivates us to add a personal touch to each unique helmet.
Our proprietary manufacturing process doesn't exist anywhere else in the world. So unlike injection molding, there's no inherent advantage in manufacturing overseas. We have domestic suppliers for our raw materials, 3d printer components and develop all our software to run production. So when we started, it was a level playing field. Of course, that's not the case anymore - we're uniquely positioned to deliver a one of a kind experience to you.
* https://www.wired.com/story/teslas-secret-second-floor/
Back to Personal Best Journal

redpajama_set_name: RedPajamaCommonCrawl


Of course a swimming pool is necessary to make your holiday complete. You can nicely cool off in our heated open air swimming pool or sit with your little ones in our 20 centimetres deep paddle pool during the summer months. At the swimming pool there are reclining chairs, so you can enjoy the sun while your children are having fun in the pool.
The heated open air swimming pool is opened with good weather from mid-May till mid-September.


text:
Okex Exchange Delisted 28 Tokens
During the "cleaning of altcoins" during the bear market, the Okex trading platform announced that it plans to delist certain pairs of tokens. In total, the lis...
The British Crypto Futures Platform Will Issue Contracts for Bitcoin Cash
The British crypto futures exchange Crypto Facilities, which acts as a partner to one of the largest North American financial derivatives markets of the CME Gro...
The Patent Presented by Coinbase Will Provide Protection in Bitcoin Transactions
The recently published patent of the company Coinbase is designed to provide protection in bitcoin-payments. In the document published by the company, the metho...
Thai SEC Clears Seven Cryptocurrency Operators to Serve Clients, Reviews Two More
Thai regulators announced Thursday, August 16, that they have so far approved seven business entities to conduct cryptocurrency operations as part of the formal...
A Branch of Another Cryptocurrency Trading Platform Will Be Opened in Malta
Now, another cryptocurrency company decided to open an office in Malta. As is known, the island state has recently got great popularity among companies that are...
Blockchain Pantera Capital Launched a Cryptocurrency Fund for More Than 71 Million USD
Investment company Blockchain Pantera Capital has launched a new cryptocurrency fund, the capital of which exceeds $71 million. Based on the data in the publish...
The Coinbase Buys Distributed Systems Inc. Startup
The Coinbase Exchange has acquired San Francisco-based startup Distributed Systems Inc., the leading developer of a decentralized user identification solution. ...
Investor Files Lawsuit Against AT&T Over Hack That Allegedly Lost Him $24 Mln in Crypto
An U.S. investor has filed a $224 million lawsuit against telecoms giant AT&T over alleged negligence that he claims caused him to lose $24 million in crypto, C...
Tyler Winklevoss: 'It Will Take Time' for Wall Street to Make Crypto Jump
Crypto exchange Gemini CEO Tyler believes "it will take time" for the majority of Wall Street to enter the cryptocurrency sector.
Binance Cryptocurrency Exchange Launches Platform
Binance Exchange has officially announced the beta launch of its educational platform - Binance Academy. This platform is a perfect solution for all investors w...
Ex-Paypal CEO Labels Cryptocurrency 'A Cult' That's 'Headed Straight to Zero'
Today, PayPal CEO Bill Harris debuted on CNBC's Fast Money where he provided a no holds barred lambast of bitcoin and other cryptocurrencies.
WEX Exchange Adds New Currencies
Probably, almost every person who is interested in cryptocurrencies is following the situation with the WEX trading platform. As you know, in June there was inf...
Joseph Lubin: the Cryptocurrency Market Has Already Seen Six "Bubbles"
One of the founders of Ethereum and CEO of ConsenSys Inc. Joseph Lubin, during an interview for the publication of Bloomberg, said that despite the fall of the ...
Kaspersky Lab: in Q2 of 2018, Cryptocurrency Hackers Stole $2.3 Million
Kaspersky Lab published a new report, "Spam and Phishing," which says that in the second quarter of this year, more than $2.3 million was stolen by crypto scamm...
SEC Slaps 'Fraudulent' ICO Founder With $30K Fine, Lifetime Ban
The U.S. Securities and Exchange Commission (SEC) announced Tuesday that it had secured new prohibitions against the founder of a company behind an allegedly fr...
Capitalization of Cryptocurrency Market Fell Below $200 Billion
Over the past 24 hours, the cryptocurrency market has lost 23 billion dollars of capitalization, having fallen from the level of 217 billion to 194 billion US d...
Jamaica Stock Exchange to Trade Crypto Assets in 2018
The Jamaica Stock Exchange (JSE) will soon be offer cryptocurrencies as tradeable assets for clients.
Venezuela Will Be the First Country With a Central Crypto Bank
As it became known, the National Assembly of Venezuela plans to create a central cryptocurrency bank in the country. This information was read out by one of the...
Despite the Internal Ban, the Korean Island Jeju is Trying to Become the Center of ICO Projects
The South Korean island of Jeju is seeking to become a free zone for ICO projects. If the plan is approved at the legislative level, it will allow the cryptocur...


Hearty, thick, and warming, Tuscan Bean and Vegetable soup is typically made in the fall – olive harvest time in Italy – as it calls for freshly pressed olive oil drizzled on top. Perfect for the cooler days and nights of autumn!
Imported from Tuscany, our Moretti Extra Virgin Olive Oil is a thick, rich, and deep-green oil – and exactly what the soup was made for!
The night before, soak the dried beans in cold water that covers the beans by about an extra inch. The next day, drain the beans and cook them in a large, deep pot with 10-12 cups of lightly salted water. Simmer with a lid slightly ajar until the beans are tender, at least one hour. Drain but reserve the cooking water.
In a large, deep pot or Dutch oven, warm the olive oil and sauté the chopped onion, carrot and celery until they are soft and translucent, about 10-15 minutes. Add the tomato and cook for another 5-10 minutes.
While the vegetables are sautéing, set aside about ½ cup of the beans and put the rest in a food processor and puree. When the tomato is cooked, add the puree to the vegetables along with about 8 cups of the cooking water and bring to a boil. When it is boiling add the garlic, remaining vegetables, the herbs and a few generous grindings of pepper. Cook over medium heat for ¾ to 1 hour, with the lid slightly ajar. The soup is dense and gets thicker as it cools. Add more salt and pepper to taste.
Just before you are ready to serve the soup, add the remaining whole beans. Cut the bread in slices and grill or toast them. Then lightly rub the garlic clove on each slice of bread. Put a slice of bread in the bottom of each bowl, drizzle a bit of Moretti Extra Virgin Olive Oil on the bread, ladle in soup and finish with another couple of teaspoons of oil on top of each soup.
Recommended Wine: We recommend the soup be served with Moretti Rosso Mio or Grenache.


text:
Back to Incident Main Menu
Searching for an Existing IT Incident
There are two ways to search for an existing incident in the system, using the Search for box or using the Advanced Search function.
To search for a single incident, type the incident ID number into the Search for box and then click Go. That will pull up the incident form.
To search for multiple incidents, click on the Advanced Search link.
Using the Advanced Search
The Advanced Search allows you to filter for incidents at your assigned Locations by selecting options in any of the available search fields (Location, Assigned To, Problem Type, etc.).
Click on the Advanced Search link.
To make a selection, click on an option in the desired field. You will see that option highlighted in blue. To make multiple selections in a single field; make the first selection, hold the CTRL key on your keyboard, and then click on the next selection.
Once all of the necessary selections have been made, click on the Search Now button at the bottom of the page.
From these search results, you can access a incident by clicking on the incident ID number, you can print an individual incident by clicking on the printer icon next to it, or you can print the entire list as either a PDF or Excel document by using the icons at the bottom of the page.


Looking for 2019 Wedding Dates? You're in luck, we're offering specials for Summer and Fall Dates in 2019. Contact us to find out more!
The Briarcliff Manor is an elegant mansion-style wedding venue located in Westchester, New York. Surrounded by manicured gardens and green pastures, this historic plantation site features breathtaking views of the Hudson River. Built in 1902, this venue has been recently renovated to be a stunning atmosphere where old-world charm meets contemporary elegance. For the awe-inspiring plantation-style wedding of your dreams, inquire about The Briarcliff Manor today!
Featuring both indoor and outdoor event spaces, The Briarcliff Manor can accommodate up to 175 guests. Built in 1902, this historic venue features classic plantation home décor including stunning light fixtures, rich mahogany floors and charming vintage accents. The white columns atop the brick staircase out front create a stunning backdrop for unforgettable wedding photos. Old-World charm meets modern sophistication at every turn at The Briarcliff Manor!
My wife and I got married at The Briarcliff Manor in October 2018. I'm writing to offer an enthusiastic recommendation for the venue and the team that runs it.
Perry, Emily, Vincenza and the crew at The Briarcliff Manor brought enthusiasm, professionalism, and thoughtfulness to the process, and this ultimately led to a wonderful event that we will absolutely never forget. My wife and I live outside the NY area, so our schedules were a bit tricky to deal with, but the team was always accommodating and made time for us whenever questions arose.
Then when the big day came, we were totally overwhelmed by how lovely everything was. Our guests were so complimentary of the food, the venue, the decor, the professionalism and attentiveness of the staff, everything. When the party was over, Perry and Emily were there to shake our hands, wish us well, and ensure that all our guests were comfortable. I thought that was such a meaningful and sincere gesture.
Our families are so very thankful for The Briarcliff Manor team's partnership and professionalism. The venue is beautiful, the food was delicious and plentiful, and the people really care. Couldn't ask for more.
Having our wedding at The Briarcliff Manor was the best decision we ever made and our guests thought so too! The venue is beautiful, the food delicious and the staff very professional and attentive. The in house florist, Vincenza, did such a wonderful job with the centerpieces and bouquets. Our pictures look amazing! The Paparazzi photos the staff at the venue took were a pleasant surprise.
We picked our wedding date last minute, the whole thing was planned in just a few weeks. Everyone thought we were crazy but Perry, Vincenza and Emily made it all possible and in the end it was what my husband and I had always hoped for.
From the moment my wife walked through the doors of The Briarcliff Manor she knew that this was going to be the host of our reception. From the beautiful interior to the charming exterior, it was the perfect place for us. They were very helpful in all of our decision making and helped guide us through the entire process. Everyone complimented the food and atmosphere that The Briarcliff Manor provided. Would definitely recommened!
Book a Spring or Summer 2019 Wedding at The Briarcliff Manor with the event date happening before Labor Day ( 9/2/19) and save big!
Book a Wedding with a minimum of 120 people or more and save $2,000.
Book a Wedding with a minimum of 150 people or more and save $3,000.
Our clients love THE BRIARCLIFF MANOR, if you are looking for elegant venue with a view look no further! The ambiance, food and staff are amazing.
Wonderful elegant setting located in the beautiful Hudson Valley. Jamie and the staff are great to work with for your future event.
Playing the bagpipe is my profession and I enjoy piping weddings at the Briarcliff Manor mansion...the house is lovely and the grounds beautiful...an elegant spot for your ceremony!


text:
Q: Recursively print all the nodes in a tree in java I want to print out everything in a tree (not a binary tree) from left to right. I have the following tree class and its methods:
public class Tree
{
    Node root;

    public Tree(String rootData)
    {
        root = new Node();
        root.data = rootData;
        root.children = new ArrayList<Node>();
    }

    public static class Node
    {
        private String data;
        private Node parent;
        private List<Node> children;

        public Node(){}

        public Node(String newNodeData, Node newNodeParent)
        {
            data = newNodeData;
            parent = newNodeParent;
        }
    }

    public void print(Node curNode)
    {
        int index = 0;
        while(curNode.children.get(index) != null)
        {
            print(curNode.children.get(index));
            System.out.println(curNode.children.get(index).data);
        }
    }

It throws a Null Pointer Exception at the print(curNode.childred.get(index)); line and I dont quite understand why. When print is first called, the tree's root node is passed to it. Am I oversimplifying the print method, or is there a generally better way to do this? Everything i've found online was for binary search trees and I couldnt figure out how to make it apply to this.
I also am open to doing this iteratively, but I wouldn't know where to start with that, and I know it would be way more complex then doing it recursively. Or if i'm wrong in saying so let me know.

A: your Node(String newNodeData, Node newNodeParent) constructor does not initialize children, hence its null. you only ever initialize the children array for the root node.
also, when iteratin over children, either compare index to children.getSize() or switch to the newer for(Node n : children) syntax
as a final sidenote - youre accessing Node filds from the Tree constructor. direct field access from a different class is generally frowned upon in java.

redpajama_set_name: RedPajamaStackExchange


Kolkata (West Bengal), [India], Feb 4 (ANI): Accusing Prime Minister Narendra Modi of plotting a coup, West Bengal Chief Minister Mamata Banerjee along with Kolkata Police Commissioner Rajeev Kumar continue to sit on 'Save the Constitution' dharna even after midnight here at Metro Channel.
A full-blown face-off between West Bengal's Mamata Banerjee government and the Centre erupted as a CBI team moved to arrest Kumar, which in turn were unceremoniously denied entry to Kolkata Police chief's residence and then detained.
Escalating her confrontation with the Centre, Banerjee started a sit-in on Sunday night to protest, in what her Trinamool Congress party called a "coup" by the Modi government.
Extending support to Mamata, her party workers also staged a 'rail roko protest' in Rishra and Asansol over the ongoing issue. The TMC workers have also burnt an effigy of Prime Minister Narendra Modi in Asansol.
CBI interim director M Nageshwar Rao has said that the CBI will approach the Supreme Court on Monday accusing the Bengal government of impeding the investigation of a court-ordered probe into the chit fund scams. The CBI officials are also planning to meet state Governor Keshari Nath Tripathi, however, the investigative agency has sought some time from him to discuss the matter.
While speaking to ANI, Rao alleged that the state Police Commissioner had hampered evidence in the chit fund scam and the CBI has evidence to prove the same.
Several Opposition leaders including Samajwadi Party (SP) president Akhilesh Yadav, National Conference leader and former Jammu and Kashmir chief minister Omar Abdullah, Dravida Munnetra Kazhagan president MK Stalin came together to support Mamata Banerjee.
Congress president Rahul Gandhi also extend his support to TMC supremo stating that what is happening in Bengal is a part of the unrelenting attack on India's institutions by Prime Minister Narendra Modi and the BJP.
"I spoke with Mamata Di tonight and told her we stand shoulder to shoulder with her. The happenings in Bengal are a part of the unrelenting attack on India's institutions by Mr Modi & the BJP. The entire opposition will stand together & defeat these fascist forces." the Congress chief wrote on his Twitter handle.
Meanwhile, Maharashtra Navnirman Sena chief Raj Thackeray took to his Twitter handle and applauded Mamata for her 'save democracy' stand.
"We applaud and support the stand taken by Mamta Banerjee against the autocracy and tyranny of the Central government. The Maharashtra Navnirman Sena firmly stands behind her and the fight against this tyranny, " he wrote.


text:
Mauricio Angee
Hal Brands
Marten Brienen
Ed Cabrera
Anthony Clayton
Sebastián Antonino Cutrona
Maria Donoso
R. Evan Ellis
Mauro Gilli
Eric Golnick
Victor J. Hinojosa
Gabriela Hoberman
Hanna S. Kassab
Mark Kirton
Barnett S. Koven
Cynthia McClintock
Keith Noble
Orlando Perez
Francisco Thoumi
Roberto Zepeda Martínez
Barnett S. Koven is a Senior Researcher at the University of Maryland's National Consortium for the Study of Terrorism and Responses to Terrorism (START), a U.S. Department of Homeland Security Center of Excellence. He is also an Affiliated Scholar at the Jack D. Gordon Institute for Public Policy at Florida International University. Koven received his Ph.D., M.Phil. and M.A. in Political Science at the George Washington University, and a B.A. in International Affairs and Latin American and Hemispheric Studies. He also holds a Certificate in Conflict Analysis from the United States Institute of Peace and a Certificate in Advanced Security in the Field from the United Nations System Staff College.
His dissertation examined under what conditions development assistance reduces or exacerbates insurgent violence, both where it is implemented and in geographically proximate areas. This research, which involved extensive archival investigation, practitioner interviews, fieldwork and the construction of original quantitative datasets, covered Iraq, Peru and Colombia. This inquiry, including over a year of overseas fieldwork, was funded by two grants from The Horowitz Foundation for Social Policy and a third from the George Washington University. In addition to his dissertation research, Koven also works on other issues pertaining to gray zone conflict, counterinsurgency, counterterrorism, countering violent extremism, counter-narcotics, security cooperation, weapons availability and conflict onset, post-conflict reconstruction and the material and non-material sources of military power. A complete list of journal articles, book chapters and policy publications can be found on his personal website: barnettkoven.weebly.com.
Beyond academia, Koven is also the Vice President and Director of Events at the Godparents of the Children of Instituto Mundo Libre, a non-profit organization providing safe housing, rehabilitation and vocational training to homeless children in Peru. In addition, he is an Advisor at Concordia, a non-profit organization dedicated to expanding public-private partnerships. Finally, Koven is a Board Member at Mindot, a non-profit educational platform for developing the next generation of local leaders and agents of social change.


text:
Q: Instagram API using Python and collecting comments from each caption I am currently trying out to use Instagram API using Python. I manage to collect comments from each caption, but I can only manage to collect a maximum of 8 comments from each caption. Some of the caption have 30+ comments, but I only collect the last 8 comments out of those 30+ comments.
Is there anything wrong with my code? Is there anyway to collect more than 8 comments per caption?
My codes are:
from instagram.client import InstagramAPI
import re

access_token = "XXX"
client_secret = "XXX"

api = InstagramAPI(access_token=access_token, client_secret=client_secret)
recent_media, next_ = api.user_recent_media(user_id="476132155")

for media in recent_media:
    try:
        comments = media.comments

        for i in comments:
            print i.text, " --> ", i.user.username
            print ""

except (UnicodeEncodeError, AttributeError, SyntaxError):
    pass

A: Your code is correct if you wanted to fetch the Media Objects only. If you're specifically targeting the comments, you'll have to fetch them with information from each Media Object individually.
From The Docs: Use the id of a Media Object to call the comments-api. In order to do that you should retrieve each id in your for-loop:
for media in recent_media:
  comments = api.media_comments(media.id)
  # do something with comments here


Susan Inglett Gallery is pleased to present Rabbit Hole, an exhibition of new work by Beverly Semmes, from 4 February to 12 March 2016. A reception for the artist will be held Thursday evening 4 February, from 6 to 8 PM.
Beverly Semmes's second exhibition with Susan Inglett Gallery probes the powers of a landmark modernist sculpture by an iconic feminist artist: Meret Oppenheim's Object (aka the fur lined tea cup) of 1936. As Semmes heads down the rabbit hole of artistic inspiration she takes artist Erle Loran's 1943 book, Cezanne's Compositions as her guide: Loran's attempts to diagram and unlock the powers of Cezanne's paintings are a touching artifact of pure formalism and ardor. How to get closer to an object that inspires—the art one loves—is a profound and perverse question at the heart of this installation.


DUBLIN, April 9, 2019 /CNW/ -- UBiqube, the leading infrastructure Automation and Orchestration vendor, welcomes NTT COMWARE (NTT's system integration arm) as the lead investor in a newly launched Series B funding round.
In light of the growing market demand for the integration and automation of processes over multi-vendor and multi-domain network and security technologies, fueled by disruptive transformations (such as cloud, 5G, smart cities and IoT, security automation, AI, etc.), UBiqube shareholders have decided to launch a 20 M$ Series B to accelerate the company's expansion plans.
UBiqube's orchestration software, the MSActivator™, empowers the industry with an evergreen vendor and domain-neutral DevOps platform for the design of Integrated Automation processes, spanning the entire infrastructure continuum, from cloud to core, to edge.
Automation workflows have already been designed and deployed using the MSActivator™ in a wide variety of domains and use cases, from managed security services, security automation (auto-remediation), cloud orchestration, SDWAN, Smart City applications, network orchestration, and many more.
The MSActivator™ enables Integrated Automation through Orchestration Continuum and breaks the vendor and domain silos' chasm that has plagued the industry for decades.
UBiqube's global expansion will rely entirely on an ecosystem of strategic channel partners, whose certified engineers will design the required automation solution for the different verticals and customers they are addressing, over the MSActivator™.
A prominent example of the MSActivator's potential as an integration engine for complex infrastructure-based projects is the newly announced Las Vegas Smart City project which involves a broad ecosystem of tchnology vendors integrated by NTT Data Services in charge of the final solution delivery for the city of Las Vegas. NTT COMWARE acts as the multi Orchestration developer using MSActivator™ for building the solution in support of one of the most ambitious smart city projects to date.
The compelling impact of the MSActivator™ on the delivery and future operations of this strategic project, coupled with the solid vendor neutrality and independence of UBiqube, have convinced NTT and NTT COMWARE to lead UBiqube's Series B round.
"NTT COMWARE, as one of the leading integrators in Japan, with global reach via the NTT group, strives to provide its customers with the most innovative solutions which will assist them in their digital transformation while dramatically improving their operations through automation. UBiqube is key to our strategy on the matter and as a strong believer in their vision, we are eager to support their global expansion via this strategic investment."
"It is a privilege to have, yet again, an entity of the NTT group invest in our venture. This is a testimony to how compelling the MSActivator has become in a wide continuum of applications and use cases, making it the perfect technology for whoever is intending to navigate the digital transformation seas, without ever being vendor-locked and limited in integration scope. We look forward to having NTT COMWARE on our board of Directors."
"The global emergence of SmartCity initiatives is among the many tangible indicators illustrating the rapid digitalization of our society. NTT's strategic ambition is to act as a global preferred value partner for its customers and partners, providing them with the extended expertise and technology know-how of the entire NTT group to ensure best in class migration towards a new intelligent secure and automated digital era. As part of our continued quest for strategic technologies enabling this transition, we have chosen UBiqube's industry-leading multi-domain orchestration platform. I am hence enthusiastic to see our tighter business relationship materialize through this investment round."


text:
Printing Press Beats Debt Ceiling
Suppose that debt ceiling Armageddon comes to pass. The government is barred from issuing debt and what it's legally required to spend exceeds what it's legally allowed to produce. But since it's the federal government, there's still a way to get money. Ben Bernanke in 2002:
But the U.S. government has a technology, called a printing press (or, today, its electronic equivalent), that allows it to produce as many U.S. dollars as it wishes at essentially no cost. By increasing the number of U.S. dollars in circulation, or even by credibly threatening to do so, the U.S. government can also reduce the value of a dollar in terms of goods and services, which is equivalent to raising the prices in dollars of those goods and services. We conclude that, under a paper-money system, a determined government can always generate higher spending and hence positive inflation.
Of course, Bernanke was talking about ways to fight against deflation, not ways to avert debt ceiling catastrophe. But right now we're in a time with dangerously low inflation leading to ridiculously high unemployment. There's no better time to print some money.
yoyo said...
This its not a Serious proposal.
Platinum Coin Seigniorage Sounds Awesome
A Day At The Beach In Israel
Pessimistic Historical Revisionism
Anders Behring Breivik And Osama Bin Laden
The Future of Pot
Spotify: First Impressions
Offer Concessions They Won't Accept. Then Hit The...
Playing a Bad Hand Well, Continued
Weird Al Yankovic Explains President Obama's Debt ...
The Gang of Five is Dead! Long Live The Gang of Six!
I'm Glad I Gave These People Money
PPP Pennsylvania Polling
DSCC Solicits the Koch family for contributions
$150,000 is a lot of F***ing Money Outside of a Ha...
Michelle Bachmann and the Polls
Stealth Social Security Benefit Cuts on the Table
Fatalism: It's Been Tried (and failed) Before
In Defense of the Perp Walk
Age Ain't Nothing But A Number Way To Engage In Su...


We are learning a lot about Sardinian culture!
On the 16th and 17th January, in several Sardinian towns will be celebrated the S.Antonio Abate's day and the suggestive fires lit up the night. The celebrations mark the beginning of the one of the most important events in Sardinia: the traditional Carnival. The typical Sardinian masks show up for the first time in the year and all around the bonfires there will be dances and songs together with a good glass of wine.
After the blessing of the wood, the fire flares up and lights up the night, the flashing goes up to the sky and seems to mingle with the stars: then people gather, dance and drink the best wine and eat the sweets made for the occasion.
In some towns , as the fire burns out and the wood starts to cool a bit, people get the black embers with the hands and it could happen that somebody fondles your face with hands dirty of soot...don't worry it means that they are wishing you good luck.
In other places, especially where the fire is lit as a votive offering, people keep the embers as relics wich should turn away the bad luck.