Question: I have to do a refactoring in an advanced search method with 500 lines. I split this method using closures in small parts, and now I have a lot of closures but I want to invoke them dynamically. 

For example:

```
def listCriteria={ ... }
def textCriteria={ ... }
def booleanCriteria={ ... }

criteria.listDistinct {
    criteries.eachWithIndex { crit, i->
        def criteriaType="${crit.type}Criteria"
        ...
    }
}

```

How can I do that?

Answer: 
When the `J condition` is not satisfied, the cycles are

1. `Opcode fetch (4 T states)`
2. `Memory read (3 T states)` of the lower byte specified, while simultaneously checking the flag condition.

If the condition isn't satisfied, the `processor ends` this instruction cycle after these 2 machine cycles and `4+3 = 7 T states.`
According to [this instruction set reference](http://www.phy.davidson.edu/fachome/dmb/py310/EMAC_Primer/8085.InstructionSet.full.pdf), a conditional branch on the 8085 takes 9 T-states (2 M-cycles) if the branch isn't taken, and 18 T-states (5 M-cycles) if the branch is taken.

A T-state equals one clock cycle on the 8085 as far as I know. An M-cycle is made up of several (3 to 6) T-states. Examples of M-cycles are "Opcode Fetch" (which always is the first M-cycle of every instruction); "Memory Read" and "Memory Write".  
You can read more about the 8085's states and cycles [in this document](http://www.newagepublishers.com/samplechapter/000495.pdf).