Lets take Beal's $1,000,000 Beal's Conjecture has a million dollar prize if you prove/disprove it.

It states that if  where A, B, C, x, y, and z are positive integers with x, y, z > 2, then A, B, and C have a common prime factor.

The challenge is to write a program that searches for a counter example to disprove this! 

Rules


Write a program searching for a counter example of Beal's Conjecture
You can perform an exhaustive search (i.e., all possible combinations of numbers that fit this form) or use some optimizations (e.g., A and B are symmetrical).
You must use arbitrary-precision integers.


Notes


This is a popularity contest, be creative!
Speed isn't necessary, but makes it more interesting. Optimize!
I am also interested in seeing the shortest code too. You will get a +1 from me!
I'll run the winning program on a supercomputer that I have access to!
This conjecture is considered to be true, but that doesn't mean we can't try!
Peter Norvig of Google  has attempted this problem too. You may use his page as guidance. He has a short Python program you can use as an example.
Some other guy (who also happens to work at Google) has greatly improved on Norvig's approach, his page (with source code) can be found here. 
My SO question related to this from two years ago may also be helpful: Fin all A^x in a given range.
I'm being pathetically lazy (pun intended), but why not... seems to fulfill the rules.

Haskell, 204

import Control.Monad
import Control.Monad.Omega
main=print.filter(\[(a,x),(b,y),(c,z)] 
 -&gt;and$(a^x+b^y==c^z):zipWith(((&gt;1).).gcd)[a,b,c][b,c,a])
 .runOmega$mapM(\_-&gt;liftM2(,)(each[1..])$each[3..])"123"


This prints1 all combinations which fulfill the counterexample property. I used the control-monad-omega package for diagonalising ℕ6... might be considered library-cheating. But seeing as someone will later post an APL answer where all this stuff is built into the language (or isn't it?), I don't give too much about it...

Of course, the program is way too slow (naïve exhaustion, and linked-lists as data structure) to be expectable of actually yielding a counterexample, but Haskell itself can actually achieve decent performance.



1Since it prints the tuples in list format, i.e. in one line, you need to switch your terminal's buffering off or you won't see when a result comes in. Alternatively, you can replace print with mapM_ print so you get a newline after each result, flushing a line-buffered terminal.

To test the program, change each[3..] to each[2..], then you'll simply get all non-coprime pythagorean tuples as result.