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: # Automatically characterize the vreg if the measurement fails
  para :vreg_meas, softbin: 107, cz: true, if_failed: :vreg_meas_1
  # Then bin out
  bin_out softbin: 105, if_failed: :vreg_meas_1
  # Check if the HVST has already been run on this device
  func :rd_vreg_hvst_passcode, softbin: 50, vdd: :nom, id: :vreg_hvst_done
  # If not run it
  
negative.code: para :vreg_meas, softbin: 105, lo: 1.12, hi: 1.34V, if_job: "FC"
  ~~~
  
  The use of `if/unless_enable` will make use of flow enable words on Teradyne platforms and user
  flow variables on Advantest.
  The `if/unless_job` control will make use of the job column on Teradyne platforms and a user
  flow variable named `@JOB` on Advantest.
  
  Both of these controls support a block form, which allows it to be applied to a group of test
  and, in the case of enable words, it also provides a way to implement AND and OR logic:
  
  ~~~ruby
  # OR - Run these tests if either word is set
  if_enable [:word1, :word2] do
    func: :test1
    func: :test2
  end
  
  # AND - Run these tests if both words are set
  if_enable :word1 do
    if_enable :word2 do
      func: :test1
      func: :test2
    end
  end
  ~~~
  
  #### 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
  * **if_passed (unless_failed)** - Run only if a previous test passed
  
  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
  an `:id` key, like this:
  
  ~~~ruby
  para :vreg_meas, softbin: 105, lo: 1.12, hi: 1.34, id: :vreg_meas_1
  