anchor.diff:  end
   ~~~
   
  -#### Skipping a Section
  -
  -An additional method <code>skip</code> is available to skip over a section, this
  -would normally be qualified by one of the other flow control methods:
  -
  -~~~ruby
  -# Don't bother running the hot vreg flow if the device already received it at probe
  -func :rd_hot_sort2_passcode, softbin: 50, vdd: :nom, id: :hot_sort2_done
  -skip if_passed: :hot_sort2_done do
  -  if_job "FH" do
  -    import "components/vreg"
  -  end
  -end
  -~~~
  +#### Conditions Based Applied to Groups
  +
  +Groups can also be used to implement AND/OR logic, here is an example of how you
  +might implement a speed binning flow:
  +
  +~~~ruby
  +group "200Mhz", id: :spec200 do
  +  func :test1_200
  +  func :test2_200
  +end
  +
  +# Bin out to bin 1 if passed at 200 Mhz, here if_passed will apply to all tests in the group
  +pass 1, if_passed: :spec200
  +
  +group "100Mhz", id: :spec100 do
  +  func :test1_100
  +  func :test2_100
  +end
  +
  +# Bin out to bin 2 if passed at 100 Mhz, here if_passed will apply to all tests in the group
  +pass 2, if_passed: :spec100
  +
  +# Otherwise we have failed
  +bin 3
  +~~~
  +
  +#### Manually Setting and Referencing Flags
  +
  +It may be sometimes be necessary to react on a flag that is controlled by a 3rd party and
  +which will be passed into an Origen-based test block, or to set a flag which a 3rd
  +party test block will later reference.
  +
  +An API exists to manually set and react to flags in these situations:
  +
  +~~~ruby
  +log "Example of manual flag setting upon pass or fail"
  +test :test1, on_pass: { set_flag: :my_pass_flag }, on_fail: { set_flag: :my_fail_flag }, continue: true
  +
  +# Execute only if the above pass flag was set
  +test :test2, if_flag: :my_pass_flag
  +
  +# Execute only if the above pass flag was not set
  +unless_flag :my_pass_flag do
  +  test :test3
  +end
  +~~~
  +
  +Note that flag names will usually be forced to uppercase, this is to institute a convention that
  +flags/flow variables are always uppercased in order to avoid any test program bugs from
  +incorrectly referencing a given flag due to case sensitivity.
  +
  +However, if you need to reference a flag from a 3rd party test module that does not follow this
  +convention, then a literal flag can be supplied by prefixing it with `$` as shown below:
  +
  +~~~ruby
  +test :test1, on_fail: { set_flag: :$My_Mixed_Flag }, continue: true
  +test :test2, if_flag: "$My_Mixed_Flag"
  +unless_flag "$My_Mixed_Flag" do
  +  test :test3
  +end
  +
  +test :extra_test, if_enable: :$MCEn_extras
  +unless_enable "$MCEn_test" do
  +  test :test1
  +  test :test2
  +end
  +~~~
  +
  +In all cases the `$` will be removed from the final flag name that appears in the test program.
  +
   
   % end
  
positive.code: para :vreg_meas, softbin: 105, lo: 1.12, hi: 1.34V, if_job: "FC"
  ~~~
  
  For an IG-XL based tester this would generate code like this:
  
  ~~~text
  # Label           Job        Enable         Test
                               vreg_cz        Characterize    vreg_meas char    107
                               skip_hvst      goto            VREG_LABEL_1
                                              Test            vreg_hvst_max     101
  VREG_LABEL_1                                nop                      
                    FC                        Test            vreg_meas         105
  ~~~
  
  The unless "skip_hvst" is enabled is a good example of where Origen patches around
  weaknesses in the underlying vendor API - IG-XL doesn't provide a native !enabled
  control, however you can write your flow as if it does and Origen will generate
  the equivalent logic.
  
  #### Execution Based on a Previous Test
  
  The following methods are available to describe these cases:
  
  * **if_ran / unless_ran** - Run only if a previous test did or did not run
  * **if_failed (unless_passed)** - Run only if a previous test failed (site specific)
  * **if_passed (unless_failed)** - Run only if a previous test passed (site specific)
  
  All of these methods require you to provide the ID of the previous test on which
  the conditional execution will depend.
  This ID must be assigned by you in the flow line of the previous test by adding
  and <code>id</code> key like this:
  
  ~~~ruby
  para :vreg_meas, softbin: 105, lo: 1.12, hi: 1.34, id: :vreg_meas_1
  
negative.code: func :pgm_vreg_hvst_passcode, softbin: 51, vdd: :nom, unless_passed: :vreg_hvst_done
  ~~~
  
  Origen automatically takes care of setting up all of the tests in the relationship:
  
  * The parent tests in the relationship are automatically set to continue on fail
  * Flag(s) will be set to indicate whether the parent test passed or failed
  * Conditional execution flags are set on all dependent tests
  
  AND and OR conditions can be created by using `if_any/all_failed/passed`
  variations as follows:
  
  ~~~ruby
  func :test1, id: :t1
  func :test2, id: :t2
  
  # OR logic - This test will run if either of the referenced tests fail
  func :test3, if_any_failed: [:t1, :t2]
  
  # AND logic - This test will only run if both of the referenced tests fail
  func :test4, if_all_passed: [:t1, :t2]
  
  # Block forms are available as with all condition APIs
  if_any_passed [:t1, :t2] do
    #...
  end
  ~~~
  
  #### References to External Tests
  
  It is possible to generate conditional relationships between tests that span across
  different flow modules, in that case the test ID must be appended with `:extern_`.
  This will indicate to Origen that the reference is external and
  will prevent an error being raised for the ID not being found within the current flow.
  
  Here is an example:
  
  ~~~ruby
  # program/flow_1.rb
  Flow.create do
    # This ID can only be referenced within this flow
    func :test1, id: :t1
    # This ID can be referenced outside of this flow
    func :test2 id: :extern_t2
  end
  
  # program/flow_2.rb
  Flow.create do
    # This will generate an undefined ID error
    func :test3, if_failed: :t1
    # But this will work, since the ID's name indicates that it is an intentional external reference
    func :test4, if_failed: :extern_t2
  end
  ~~~
  
  #### Applying Conditions to Sub-Flows
  
  All of the flow control methods have a block form which will apply the
  condition to all tests within the block.
  
  A very useful pattern is to split your code into small re-usable snippets
  and then wrap the import with these flow control methods to apply conditional
  execution.
  For example, here the 'FH' job requirement will be applied to all tests
  imported from the vreg component:
  
  ~~~ruby
  