1. Accept that you are trapped in a mindfuck cycle. This is a bit similar to accepting that you are on a passenger train that is about to careen into a wall of solid rock.
3. When you are no longer hyperventilating, stand up and walk towards the back of the train. You will find that you have a much larger perspective from this vantage point.
4. Watch the other passengers scream and carry on in a ridiculous manner. Remember, these people are not you. You are merely travelling together. While they may resent you for being so calm, they cannot hurt you. (These people comprise everything you hate about yourself). Stare straight at them. Single them out, one by one. Eventually, they will exhaust themselves by shaking their fists and yelling obscenities.
5. One of them will walk over to you, curious at your strange behaviour.
6. Then, in typical herd fashion, the rest should follow.
7. Sit them down in a circle around you and tell them a story about trains. Make them laugh and clap their hands.
8. Now, turn your head to the side, and look out the window.
9. Suddenly you will realize that you are outside the train, standing in the green grass.
10. You will have a terrific view of the imminent carnage.

In my experience, the way to resolve such mental dependency cycles is by atomic transaction. The procedure is approximately as follows:

1. Trace all the components of the cycle. Starting with a statement known to be in the cycle in question, repeatedly follow whichever link it is that is causing the cyclic dependency until you hit the original statement again.
2. Determine a combination of truth values for the statements through which you passed in step 1 that will break the cycle as desired, without having other undesired side effects.
3. Issue a begin transaction command. Make sure it succeeds. If it does not, you may need to repair your transactions module, which is outside the scope of this node.
4. Issue alter truth value commands for each statement in the cycle, using the vector determined in step 2 for the values. If this does not succeed, there is most likely a dependency you missed; abort the transaction, go back to step 1, and trace more thoroughly this time.
5. Commit the transaction. This is theoretically the simplest part, but it is often the most involved. This is not a digital system. You may have to carefully fine-tune some of the pushing-parameters, particularly the individual strengths of the alteration commands, in order to cause all of the changed statements to switch over at more or less the same time. If you make a mistake, the statements may all fall back into the original cycle, in which case you must go back to step 3 and try again. Alternatively, some statements may switch over while others stubbornly remain locked into their original positions; this will tend to draw a lot of current, because the links between the switched statements and the non-switched statements have to go through the cycle's potential barrier. However, assuming it succeeds, and the transaction is committed...
6. You're free. You may desire to make one final pass to ensure that there's no remaining garbage, though this is not strictly necessary since if there are no other links to the statements in question, the GC should clean everything up by itself anyway. Now hack in a check to make sure it doesn't happen again.