Begone t1737...

44 files changed, 3772 insertions, 0 deletions

diff --git a/test/pending/shootout/fasta.check b/test/pending/shootout/fasta.check
new file mode 100644
index 0000000000..f1caba0d62
--- /dev/null
+++ b/test/pending/shootout/fasta.check
@@ -0,0 +1,171 @@
+>ONE Homo sapiens alu
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCG
+>TWO IUB ambiguity codes
+cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg
+tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa
+NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt
+cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga
+gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa
+HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca
+tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt
+tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt
+acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct
+tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt
+gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa
+accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt
+RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt
+tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag
+cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg
+ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat
+actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg
+YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa
+KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata
+aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa
+aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg
+gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc
+tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK
+tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt
+ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg
+ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa
+BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt
+aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc
+tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc
+cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac
+aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga
+tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga
+aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD
+gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg
+ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV
+taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa
+ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat
+gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg
+gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa
+tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt
+tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt
+taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca
+cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag
+aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt
+cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt
+ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW
+attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag
+ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa
+attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc
+tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta
+>THREE Homo sapiens frequency
+aacacttcaccaggtatcgtgaaggctcaagattacccagagaacctttgcaatataaga
+atatgtatgcagcattaccctaagtaattatattctttttctgactcaaagtgacaagcc
+ctagtgtatattaaatcggtatatttgggaaattcctcaaactatcctaatcaggtagcc
+atgaaagtgatcaaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaa
+tagattgcgcaaaattcgtaccttaagtctctcgccaagatattaggatcctattactca
+tatcgtgtttttctttattgccgccatccccggagtatctcacccatccttctcttaaag
+gcctaatattacctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgat
+tcttatgtgtaccatatgtatagtaatcacgcgactatatagtgctttagtatcgcccgt
+gggtgagtgaatattctgggctagcgtgagatagtttcttgtcctaatatttttcagatc
+gaatagcttctatttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtc
+atgaccagatccacgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtc
+taacttatatcccgtcgcttactttctaacaccccttatgtatttttaaaattacgttta
+ttcgaacgtacttggcggaagcgttattttttgaagtaagttacattgggcagactcttg
+acattttcgatacgactttctttcatccatcacaggactcgttcgtattgatatcagaag
+ctcgtgatgattagttgtcttctttaccaatactttgaggcctattctgcgaaatttttg
+ttgccctgcgaacttcacataccaaggaacacctcgcaacatgccttcatatccatcgtt
+cattgtaattcttacacaatgaatcctaagtaattacatccctgcgtaaaagatggtagg
+ggcactgaggatatattaccaagcatttagttatgagtaatcagcaatgtttcttgtatt
+aagttctctaaaatagttacatcgtaatgttatctcgggttccgcgaataaacgagatag
+attcattatatatggccctaagcaaaaacctcctcgtattctgttggtaattagaatcac
+acaatacgggttgagatattaattatttgtagtacgaagagatataaaaagatgaacaat
+tactcaagtcaagatgtatacgggatttataataaaaatcgggtagagatctgctttgca
+attcagacgtgccactaaatcgtaatatgtcgcgttacatcagaaagggtaactattatt
+aattaataaagggcttaatcactacatattagatcttatccgatagtcttatctattcgt
+tgtatttttaagcggttctaattcagtcattatatcagtgctccgagttctttattattg
+ttttaaggatgacaaaatgcctcttgttataacgctgggagaagcagactaagagtcgga
+gcagttggtagaatgaggctgcaaaagacggtctcgacgaatggacagactttactaaac
+caatgaaagacagaagtagagcaaagtctgaagtggtatcagcttaattatgacaaccct
+taatacttccctttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttaga
+ggcatctctcgctcataaataggtagactactcgcaatccaatgtgactatgtaatactg
+ggaacatcagtccgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacat
+gagaccacccccgtggggattattagtccgcagtaatcgactcttgacaatccttttcga
+ttatgtcatagcaatttacgacagttcagcgaagtgactactcggcgaaatggtattact
+aaagcattcgaacccacatgaatgtgattcttggcaatttctaatccactaaagcttttc
+cgttgaatctggttgtagatatttatataagttcactaattaagatcacggtagtatatt
+gatagtgatgtctttgcaagaggttggccgaggaatttacggattctctattgatacaat
+ttgtctggcttataactcttaaggctgaaccaggcgtttttagacgacttgatcagctgt
+tagaatggtttggactccctctttcatgtcagtaacatttcagccgttattgttacgata
+tgcttgaacaatattgatctaccacacacccatagtatattttataggtcatgctgttac
+ctacgagcatggtattccacttcccattcaatgagtattcaacatcactagcctcagaga
+tgatgacccacctctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagac
+gatatcaagcgctttaaattgcatataacatttgagggtaaagctaagcggatgctttat
+ataatcaatactcaataataagatttgattgcattttagagttatgacacgacatagttc
+actaacgagttactattcccagatctagactgaagtactgatcgagacgatccttacgtc
+gatgatcgttagttatcgacttaggtcgggtctctagcggtattggtacttaaccggaca
+ctatactaataacccatgatcaaagcataacagaatacagacgataatttcgccaacata
+tatgtacagaccccaagcatgagaagctcattgaaagctatcattgaagtcccgctcaca
+atgtgtcttttccagacggtttaactggttcccgggagtcctggagtttcgacttacata
+aatggaaacaatgtattttgctaatttatctatagcgtcatttggaccaatacagaatat
+tatgttgcctagtaatccactataacccgcaagtgctgatagaaaatttttagacgattt
+ataaatgccccaagtatccctcccgtgaatcctccgttatactaattagtattcgttcat
+acgtataccgcgcatatatgaacatttggcgataaggcgcgtgaattgttacgtgacaga
+gatagcagtttcttgtgatatggttaacagacgtacatgaagggaaactttatatctata
+gtgatgcttccgtagaaataccgccactggtctgccaatgatgaagtatgtagctttagg
+tttgtactatgaggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgac
+gaatttatactaatacgctttcactattggctacaaaatagggaagagtttcaatcatga
+gagggagtatatggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcat
+tcttgaaagatacataagcgataagttacgacaattataagcaacatccctaccttcgta
+acgatttcactgttactgcgcttgaaatacactatggggctattggcggagagaagcaga
+tcgcgccgagcatatacgagacctataatgttgatgatagagaaggcgtctgaattgata
+catcgaagtacactttctttcgtagtatctctcgtcctctttctatctccggacacaaga
+attaagttatatatatagagtcttaccaatcatgttgaatcctgattctcagagttcttt
+ggcgggccttgtgatgactgagaaacaatgcaatattgctccaaatttcctaagcaaatt
+ctcggttatgttatgttatcagcaaagcgttacgttatgttatttaaatctggaatgacg
+gagcgaagttcttatgtcggtgtgggaataattcttttgaagacagcactccttaaataa
+tatcgctccgtgtttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtgg
+tgtatatatcggataacaattaatacgatgttcatagtgacagtatactgatcgagtcct
+ctaaagtcaattacctcacttaacaatctcattgatgttgtgtcattcccggtatcgccc
+gtagtatgtgctctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgtta
+ggtaagatctctctgaattccttcgtgccaacttaaaacattatcaaaatttcttctact
+tggattaactacttttacgagcatggcaaattcccctgtggaagacggttcattattatc
+ggaaaccttatagaaattgcgtgttgactgaaattagatttttattgtaagagttgcatc
+tttgcgattcctctggtctagcttccaatgaacagtcctcccttctattcgacatcgggt
+ccttcgtacatgtctttgcgatgtaataattaggttcggagtgtggccttaatgggtgca
+actaggaatacaacgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaac
+gtgctccttgcttagcttgtgaatgagactcagtagttaaataaatccatatctgcaatc
+gattccacaggtattgtccactatctttgaactactctaagagatacaagcttagctgag
+accgaggtgtatatgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcga
+gaagctaataccggctgtttccagctttataagattaaaatttggctgtcctggcggcct
+cagaattgttctatcgtaatcagttggttcattaattagctaagtacgaggtacaactta
+tctgtcccagaacagctccacaagtttttttacagccgaaacccctgtgtgaatcttaat
+atccaagcgcgttatctgattagagtttacaactcagtattttatcagtacgttttgttt
+ccaacattacccggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgta
+ggaagtgaaaagataaatat
diff --git a/test/pending/shootout/fasta.scala b/test/pending/shootout/fasta.scala
new file mode 100644
index 0000000000..8b711083a5
--- /dev/null
+++ b/test/pending/shootout/fasta.scala
@@ -0,0 +1,162 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy
+*/
+
+import java.io._
+
+object fasta { 
+   def main(args: Array[String]) = {
+
+      val ALU =
+         "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG" +
+         "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA" +
+         "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT" +
+         "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA" +
+         "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG" +
+         "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC" +
+         "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"
+
+      val _IUB = Array(
+         Pair('a', 0.27), 
+         Pair('c', 0.12), 
+         Pair('g', 0.12), 
+         Pair('t', 0.27), 
+
+         Pair('B', 0.02), 
+         Pair('D', 0.02),
+         Pair('H', 0.02), 
+         Pair('K', 0.02), 
+         Pair('M', 0.02),
+         Pair('N', 0.02), 
+         Pair('R', 0.02), 
+         Pair('S', 0.02),
+         Pair('V', 0.02), 
+         Pair('W', 0.02), 
+         Pair('Y', 0.02)
+      )
+
+      val IUB = makeCumulative(_IUB)
+
+      val _HomoSapiens = Array(
+         Pair('a', 0.3029549426680), 
+         Pair('c', 0.1979883004921),
+         Pair('g', 0.1975473066391), 
+         Pair('t', 0.3015094502008)
+      )
+
+      val HomoSapiens = makeCumulative(_HomoSapiens)
+
+
+      val n = Integer parseInt(args(0))
+      val s = new FastaOutputStream(System.out)
+
+      s.writeDescription("ONE Homo sapiens alu")
+      s.writeRepeatingSequence(ALU,n*2)
+
+      s.writeDescription("TWO IUB ambiguity codes")
+      s.writeRandomSequence(IUB,n*3)
+
+      s.writeDescription("THREE Homo sapiens frequency")
+      s.writeRandomSequence(HomoSapiens,n*5)
+
+      s.close
+   } 
+
+   def makeCumulative(a: Array[Pair[Char,Double]]) = {
+      var cp = 0.0
+      a map (frequency =>
+         frequency match { 
+            case Pair(code,percent) => 
+               cp = cp + percent; new Frequency(code.toByte,cp) 
+         } 
+      )
+   }
+
+}
+
+
+// We could use instances of Pair or Tuple2 but specific labels
+// make the code more readable than index numbers
+
+class Frequency(_code: Byte, _percent: Double){ 
+   var code = _code; var percent = _percent;
+}
+
+
+// extend the Java BufferedOutputStream class
+
+class FastaOutputStream(out: OutputStream) extends BufferedOutputStream(out) {
+
+   private val LineLength = 60
+   private val nl = '\n'.toByte
+
+   def writeDescription(desc: String) = { write( (">" + desc + "\n").getBytes ) }
+
+   def writeRepeatingSequence(_alu: String, length: Int) = {
+      val alu = _alu.getBytes
+      var n = length; var k = 0; val kn = alu.length;
+
+      while (n > 0) {
+         val m = if (n < LineLength) n else LineLength
+
+         var i = 0
+         while (i < m){ 
+            if (k == kn) k = 0
+            val b = alu(k)
+            if (count < buf.length){ buf(count) = b; count = count + 1 }
+            else { write(b) } // flush buffer
+            k = k+1
+            i = i+1 
+         }
+
+         write(nl)
+         n = n - LineLength
+      }
+
+   }
+
+   def writeRandomSequence(distribution: Array[Frequency], length: Int) = {
+      var n = length
+      while (n > 0) {
+         val m = if (n < LineLength) n else LineLength
+
+         var i = 0
+         while (i < m){ 
+            val b = selectRandom(distribution)
+            if (count < buf.length){ buf(count) = b; count = count + 1 }
+            else { write(b) } // flush buffer
+            i = i+1 
+         }
+
+         if (count < buf.length){ buf(count) = nl; count = count + 1 }
+         else { write(nl) } // flush buffer
+         n = n - LineLength
+      }
+   }
+
+   private def selectRandom(distribution: Array[Frequency]): Byte = {
+      val n = distribution.length
+      val r = RandomNumber scaledTo(1.0)
+
+      var i = 0
+      while (i < n) {
+         if (r < distribution(i).percent) return distribution(i).code
+         i = i+1
+      }
+      return distribution(n-1).code
+   }
+}
+
+
+object RandomNumber {
+   private val IM = 139968
+   private val IA = 3877
+   private val IC = 29573
+   private var seed = 42
+
+   def scaledTo(max: Double) = {
+      seed = (seed * IA + IC) % IM
+      max * seed / IM
+   }
+}
diff --git a/test/pending/shootout/fasta.scala.runner b/test/pending/shootout/fasta.scala.runner
new file mode 100644
index 0000000000..e95a749cf2
--- /dev/null
+++ b/test/pending/shootout/fasta.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(25000,250000,2500000)) fasta.main(Array(n.toString)) 
+}
diff --git a/test/pending/shootout/harmonic.scala-2.scala b/test/pending/shootout/harmonic.scala-2.scala
new file mode 100644
index 0000000000..a55e164e50
--- /dev/null
+++ b/test/pending/shootout/harmonic.scala-2.scala
@@ -0,0 +1,14 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy (Scala novice)
+*/
+
+object harmonic {
+   def main(args: Array[String]) = {
+      val n = Integer.parseInt(args(0));
+      var partialSum = 0.0;
+
+      for (i <- Iterator.range(1,n+1)) partialSum = partialSum + 1.0/i;
+      Console.printf("{0,number,#.000000000}\n")(partialSum);
+   }
+}
diff --git a/test/pending/shootout/harmonic.scala-2.scala.runner b/test/pending/shootout/harmonic.scala-2.scala.runner
new file mode 100644
index 0000000000..d0ea85742a
--- /dev/null
+++ b/test/pending/shootout/harmonic.scala-2.scala.runner
@@ -0,0 +1,16 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy (Scala novice)
+*/
+object Test extends Application {
+  for(n <- List(6000000,8000000,10000000)) harmonic.main(Array(n.toString)) 
+} 
+object harmonic {
+   def main(args: Array[String]) = {
+      val n = Integer.parseInt(args(0));
+      var partialSum = 0.0;
+
+      for (i <- Iterator.range(1,n+1)) partialSum = partialSum + 1.0/i;
+      Console.printf("{0,number,#.000000000}\n")(partialSum);
+   }
+}
diff --git a/test/pending/shootout/harmonic.scala-3.scala b/test/pending/shootout/harmonic.scala-3.scala
new file mode 100644
index 0000000000..dc631fcf12
--- /dev/null
+++ b/test/pending/shootout/harmonic.scala-3.scala
@@ -0,0 +1,15 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy (Scala novice)
+*/
+
+object harmonic {
+   def main(args: Array[String]) = {
+      val n = Integer.parseInt(args(0));
+      var partialSum = 0.0;
+      var i = 1;
+
+      while (i < n){ partialSum = partialSum + 1.0/i; i = i + 1; }
+      Console.printf("{0,number,#.000000000}\n", partialSum);
+   }
+}
diff --git a/test/pending/shootout/harmonic.scala-3.scala.runner b/test/pending/shootout/harmonic.scala-3.scala.runner
new file mode 100644
index 0000000000..b5eda3f034
--- /dev/null
+++ b/test/pending/shootout/harmonic.scala-3.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(6000000,8000000,10000000)) harmonic.main(Array(n.toString)) 
+}
diff --git a/test/pending/shootout/heapsort.scala b/test/pending/shootout/heapsort.scala
new file mode 100644
index 0000000000..59b1fe27cb
--- /dev/null
+++ b/test/pending/shootout/heapsort.scala
@@ -0,0 +1,72 @@
+/* The Computer Language Shootout 
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy (Scala novice)
+*/
+
+object heapsort {
+   def main(args: Array[String]) = {
+      val n = toPositiveInt(args);
+
+      val numbers = new Array[Double](n+1);
+      for (i <- Iterator.range(1,n+1)) 
+         numbers(i) = generate(100.0);
+
+      heapsort(n, numbers);
+
+      Console.printf("{0,number,#.000000000}\n", numbers(n));
+   }
+
+
+   def heapsort(n: Int, ra: Array[Double]): Unit = {
+      var l = 0; var j = 0; var ir = 0; var i = 0; 
+      var rra = 0.0d;
+
+      if (n < 2) return;
+      l = (n >> 1) + 1;
+      ir = n;
+      while (true) {
+         if (l > 1) { l = l-1; rra = ra(l); }
+         else {
+            rra = ra(ir);
+            ra(ir) = ra(1);
+            ir = ir-1;
+            if (ir == 1) {
+               ra(1) = rra;
+               return;
+            }
+         }
+         i = l;
+         j = l << 1;
+         while (j <= ir) {
+            if (j < ir && ra(j) < ra(j+1)) { j = j+1; }
+            if (rra < ra(j)) {
+               ra(i) = ra(j);
+               i = j;
+               j = j + i;
+            } 
+            else j = ir + 1;
+         }
+         ra(i) = rra;
+      }
+   }
+
+
+   private val IM = 139968;
+   private val IA = 3877;
+   private val IC = 29573;
+   private var seed = 42;
+
+   private def generate(max: Double) = {
+      seed = (seed * IA + IC) % IM;
+      max * seed / IM;
+   }
+
+
+   private def toPositiveInt(s: Array[String]) = {
+      val i = 
+         try { Integer.parseInt(s(0)); } 
+         catch { case _ => 1 }
+      if (i>0) i; else 1;
+   }
+
+}
diff --git a/test/pending/shootout/heapsort.scala.runner b/test/pending/shootout/heapsort.scala.runner
new file mode 100644
index 0000000000..07e4ec7fbd
--- /dev/null
+++ b/test/pending/shootout/heapsort.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(20000,40000,60000,80000,100000)) heapsort.main(Array(n.toString)) 
+}
diff --git a/test/pending/shootout/mandelbrot.scala-2.check b/test/pending/shootout/mandelbrot.scala-2.check
new file mode 100644
index 0000000000..2f7bbbc6b0
--- /dev/null
+++ b/test/pending/shootout/mandelbrot.scala-2.check
diff --git a/test/pending/shootout/mandelbrot.scala-2.scala b/test/pending/shootout/mandelbrot.scala-2.scala
new file mode 100644
index 0000000000..dffdc354a0
--- /dev/null
+++ b/test/pending/shootout/mandelbrot.scala-2.scala
@@ -0,0 +1,79 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy
+*/
+
+// This test is in pending because it fails on windows only,
+// but partest's output and the fact that this test outputs in
+// binary makes it a challenge to debug remotely.  However,
+// it's easy to guess that it has to do with the BufferedOutputStream
+// and some kind of windows-specific damage that requires an extra
+// flush, or different line-ending characters, or any of the various
+// write-once-know-quirks-everywhere aspects of java i/o.
+//
+//   [partest] testing: [...]\files\shootout\mandelbrot.scala-2.scala                [FAILED]
+//   [partest] P4
+//   [partest] 200 200
+//   [partest] 
+// ^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^B^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@
+// ^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@
+// [etc]
+
+import java.io.BufferedOutputStream
+
+object mandelbrot { 
+   def main(args: Array[String]) = {
+      val side = Integer.parseInt(args(0))
+      val limitSquared = 4.0
+      val max = 50
+      var bits = 0
+      var bitnum = 0
+      val w = new BufferedOutputStream(System.out)
+
+      Console.println("P4\n" + side + " " + side)
+
+      var y = 0
+      while (y < side){
+
+         var x = 0
+         while (x < side){
+
+            val cr = 2.0 * x / side - 1.5
+            val ci = 2.0 * y / side - 1.0
+
+            var zr = 0.0; var zi = 0.0
+            var tr = 0.0; var ti = 0.0
+
+            var j = max
+            do {
+               zi = 2.0 * zr * zi + ci
+               zr = tr - ti + cr
+               ti = zi*zi
+               tr = zr*zr
+
+               j = j - 1
+            } while (!(tr + ti > limitSquared) && j > 0)
+
+
+            bits = bits << 1
+            if (!(tr + ti > limitSquared)) bits = bits + 1
+            bitnum = bitnum + 1
+
+            if (x == side - 1){
+               bits = bits << (8 - bitnum)
+               bitnum = 8
+            }
+
+            if (bitnum == 8){
+               w.write(bits.toByte)
+               bits = 0
+               bitnum = 0
+            }
+
+            x = x + 1
+         }
+         y = y + 1
+      }
+      w.close
+   } 
+}
diff --git a/test/pending/shootout/mandelbrot.scala-2.scala.runner b/test/pending/shootout/mandelbrot.scala-2.scala.runner
new file mode 100644
index 0000000000..27f69f6aec
--- /dev/null
+++ b/test/pending/shootout/mandelbrot.scala-2.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(200,400,600)) mandelbrot.main(Array(n.toString)) 
+}
diff --git a/test/pending/shootout/message.check b/test/pending/shootout/message.check
new file mode 100644
index 0000000000..354b2529b2
--- /dev/null
+++ b/test/pending/shootout/message.check
@@ -0,0 +1 @@
+500000
diff --git a/test/pending/shootout/message.javaopts b/test/pending/shootout/message.javaopts
new file mode 100644
index 0000000000..1879c77427
--- /dev/null
+++ b/test/pending/shootout/message.javaopts
@@ -0,0 +1 @@
+-Xss128k
diff --git a/test/pending/shootout/message.scala b/test/pending/shootout/message.scala
new file mode 100644
index 0000000000..a7a1dacc9d
--- /dev/null
+++ b/test/pending/shootout/message.scala
@@ -0,0 +1,47 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy
+*/
+
+
+import scala.concurrent._ 
+
+object message {
+   def main(args: Array[String]) = {
+      val n = Integer.parseInt(args(0))
+      val nActors = 500
+      val finalSum = n * nActors
+
+      case class Message(value: Int)
+
+      class Incrementor(next: Pid) extends Actor {
+         var sum = 0
+
+         override def run() = {
+            while (true) {
+               receive { 
+                  case Message(value) => 
+                     val j = value + 1 
+                     if (null != next){ 
+                        next ! Message(j) 
+                     } else { 
+                        sum = sum + j
+                        if (sum >= finalSum){ 
+                           Console.println(sum); 
+                           System.exit(0) // exit without cleaning up
+                        }
+                     } 
+               }
+            }
+         }
+
+         def pid() = { this.start; this.self }
+      }
+
+      def actorChain(i: Int, a: Pid): Pid = 
+         if (i > 0) actorChain(i-1, new Incrementor(a).pid ) else a
+
+      val firstActor = actorChain(nActors, null)
+      var i = n; while (i > 0){ firstActor ! Message(0); i = i-1 }
+   }
+}
diff --git a/test/pending/shootout/message.scala.runner b/test/pending/shootout/message.scala.runner
new file mode 100644
index 0000000000..ffbee1640b
--- /dev/null
+++ b/test/pending/shootout/message.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(1000,2000,3000)) message.main(Array(n.toString)) 
+}
diff --git a/test/pending/shootout/meteor.scala b/test/pending/shootout/meteor.scala
new file mode 100644
index 0000000000..2fd702753a
--- /dev/null
+++ b/test/pending/shootout/meteor.scala
@@ -0,0 +1,496 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy
+*/
+
+// This is an un-optimised example implementation
+
+
+import scala.collection.mutable._
+
+object meteor {
+   def main(args: Array[String]) = {
+      val solver = new Solver( Integer.parseInt(args(0)) )
+      solver.findSolutions
+      solver.printSolutions
+   }
+}
+
+
+
+
+// Solver.scala 
+// import scala.collection.mutable._
+
+final class Solver (n: Int) {
+   private var countdown = n
+   private var first: String = _
+   private var last: String = _
+
+   private val board = new Board()
+
+   val pieces = Array( 
+      new Piece(0), new Piece(1), new Piece(2), new Piece(3), new Piece(4), 
+      new Piece(5), new Piece(6), new Piece(7), new Piece(8), new Piece(9) )
+
+   val unplaced = new BitSet(pieces.length)
+
+   { unplaced ++= (0 until pieces.length) }
+
+
+   def findSolutions(): Unit = {
+      if (countdown == 0) return
+
+      if (unplaced.size > 0){
+         val emptyCellIndex = board.firstEmptyCellIndex
+
+         for (k <- Iterator.range(0,pieces.length)){
+            if (unplaced.contains(k)){
+               unplaced -= k
+
+               for (i <- Iterator.range(0,Piece.orientations)){
+                  val piece = pieces(k).nextOrientation
+
+                  for (j <- Iterator.range(0,Piece.size)){
+                     if (board.add(j,emptyCellIndex,piece)) {
+
+                        if (!shouldPrune) findSolutions
+
+                        board.remove(piece)
+                     }
+                  }
+               }
+               unplaced += k
+            }
+         }
+      }
+      else {
+         puzzleSolved
+      }
+   }
+
+   private def puzzleSolved() = {
+      val b = board.asString
+      if (first == null){ 
+         first = b; last = b 
+      } else {
+         if (b < first){ first = b } else { if (b > last){ last = b } }
+      }
+      countdown = countdown - 1
+   }
+
+   private def shouldPrune() = {
+      board.unmark
+      !board.cells.forall(c => c.contiguousEmptyCells % Piece.size == 0) 
+   }
+
+
+   def printSolutions() = {
+
+      def printBoard(s: String) = {
+         var indent = false
+         var i = 0
+         while (i < s.length){
+            if (indent) Console.print(' ')
+            for (j <- Iterator.range(0,Board.cols)){
+               Console.print(s.charAt(i)); Console.print(' ')
+               i = i + 1
+            }
+            Console.print('\n')
+            indent = !indent
+         }
+         Console.print('\n')
+      }
+
+      Console.print(n + " solutions found\n\n")
+      printBoard(first)
+      printBoard(last)
+   }
+
+/*
+   def printPieces() = 
+      for (i <- Iterator.range(0,Board.pieces)) pieces(i).print 
+*/
+
+}
+
+
+
+
+// Board.scala
+// import scala.collection.mutable._
+
+object Board {
+   val cols = 5
+   val rows = 10
+   val size = rows * cols
+}
+
+final class Board { 
+   val cells = boardCells()
+
+   val cellsPieceWillFill = new Array[BoardCell](Piece.size)
+   var cellCount = 0
+
+   def unmark() = for (c <- cells) c.unmark
+
+   def asString() = 
+      new String( cells map( 
+         c => if (c.piece == null) '-'.toByte 
+              else (c.piece.number + 48).toByte ))
+
+   def firstEmptyCellIndex() = cells.findIndexOf(c => c.isEmpty)
+
+   def add(pieceIndex: Int, boardIndex: Int, p: Piece) = {
+      cellCount = 0
+      p.unmark
+    
+      find( p.cells(pieceIndex), cells(boardIndex))
+
+      val boardHasSpace = cellCount == Piece.size && 
+         cellsPieceWillFill.forall(c => c.isEmpty)  
+
+      if (boardHasSpace) cellsPieceWillFill.foreach(c => c.piece = p) 
+
+      boardHasSpace
+   }
+
+   def remove(piece: Piece) = for (c <- cells; if c.piece == piece) c.empty
+
+
+   private def find(p: PieceCell, b: BoardCell): Unit = {
+      if (p != null && !p.marked && b != null){
+         cellsPieceWillFill(cellCount) = b
+         cellCount = cellCount + 1
+         p.mark
+         for (i <- Iterator.range(0,Cell.sides)) find(p.next(i), b.next(i))
+      }
+   }
+
+
+   private def boardCells() = {
+      val a = for (i <- Array.range(0,Board.size)) yield new BoardCell(i)
+      val m = (Board.size / Board.cols) - 1
+
+      for (i <- Iterator.range(0,a.length)){
+         val row = i / Board.cols
+         val isFirst = i % Board.cols == 0
+         val isLast = (i+1) % Board.cols == 0
+         val c = a(i)
+
+         if (row % 2 == 1) {
+            if (!isLast) c.next(Cell.NE) = a(i-(Board.cols-1))
+            c.next(Cell.NW) = a(i-Board.cols) 
+            if (row != m) {
+               if (!isLast) c.next(Cell.SE) = a(i+(Board.cols+1))
+               c.next(Cell.SW) = a(i+Board.cols) 
+            }
+         } else {
+            if (row != 0) {
+               if (!isFirst) c.next(Cell.NW) = a(i-(Board.cols+1))
+               c.next(Cell.NE) = a(i-Board.cols)
+            }
+            if (row != m) {
+               if (!isFirst) c.next(Cell.SW) = a(i+(Board.cols-1))
+               c.next(Cell.SE) = a(i+Board.cols)
+            }
+         }
+         if (!isFirst) c.next(Cell.W) = a(i-1)
+         if (!isLast) c.next(Cell.E) = a(i+1)
+      }
+      a
+   }
+
+
+/*
+// Printing all the board cells and their neighbours
+// helps check that they are connected properly
+
+   def printBoardCellsAndNeighbours() = {
+      Console.println("cell\tNW NE W  E  SW SE")
+      for (i <- Iterator.range(0,Board.size)){
+         Console.print(i + "\t")
+         for (j <- Iterator.range(0,Cell.sides)){
+            val c = cells(i).next(j)
+            if (c == null) 
+               Console.print("-- ") 
+            else 
+               Console.printf("{0,number,00} ")(c.number)
+         }
+         Console.println("")
+      }
+      Console.println("")
+   }
+*/
+
+}
+
+
+
+
+// Piece.scala
+
+object Piece {
+   val size = 5
+   val rotations = Cell.sides
+   val flips = 2
+   val orientations = rotations * flips
+}
+
+final class Piece(_number: Int) {
+   val number = _number
+   val cells = for (i <- Array.range(0,Piece.size)) yield new PieceCell()
+
+   { 
+      number match {
+         case 0 => make0
+         case 1 => make1
+         case 2 => make2
+         case 3 => make3
+         case 4 => make4
+         case 5 => make5
+         case 6 => make6
+         case 7 => make7
+         case 8 => make8
+         case 9 => make9     
+      }
+   }
+
+   def flip() = for (c <- cells) c.flip
+   def rotate() = for (c <- cells) c.rotate
+   def unmark() = for (c <- cells) c.unmark
+
+
+   private var orientation = 0
+
+   def nextOrientation() = {
+      if (orientation == Piece.orientations) orientation = 0
+      if (orientation % Piece.rotations == 0) flip else rotate
+      orientation = orientation + 1
+      this
+   }
+
+
+   private def make0() = {
+      cells(0).next(Cell.E) = cells(1)
+      cells(1).next(Cell.W) = cells(0)
+      cells(1).next(Cell.E) = cells(2)
+      cells(2).next(Cell.W) = cells(1)
+      cells(2).next(Cell.E) = cells(3)
+      cells(3).next(Cell.W) = cells(2)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make1() = {
+      cells(0).next(Cell.SE) = cells(1)
+      cells(1).next(Cell.NW) = cells(0)
+      cells(1).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.NE) = cells(1)
+      cells(2).next(Cell.W) = cells(3)
+      cells(3).next(Cell.E) = cells(2)
+      cells(3).next(Cell.SW) = cells(4)
+      cells(4).next(Cell.NE) = cells(3)
+   }
+
+   private def make2() = {
+      cells(0).next(Cell.W) = cells(1)
+      cells(1).next(Cell.E) = cells(0)
+      cells(1).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.NE) = cells(1)
+      cells(2).next(Cell.SE) = cells(3)
+      cells(3).next(Cell.NW) = cells(2)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make3() = {
+      cells(0).next(Cell.SW) = cells(1)
+      cells(1).next(Cell.NE) = cells(0)
+      cells(1).next(Cell.W) = cells(2)
+      cells(2).next(Cell.E) = cells(1)
+      cells(1).next(Cell.SW) = cells(3)
+      cells(3).next(Cell.NE) = cells(1)
+      cells(2).next(Cell.SE) = cells(3)
+      cells(3).next(Cell.NW) = cells(2)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make4() = {
+      cells(0).next(Cell.SE) = cells(1)
+      cells(1).next(Cell.NW) = cells(0)
+      cells(1).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.NE) = cells(1)
+      cells(1).next(Cell.E) = cells(3)
+      cells(3).next(Cell.W) = cells(1)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make5() = {
+      cells(0).next(Cell.SW) = cells(1)
+      cells(1).next(Cell.NE) = cells(0)
+      cells(0).next(Cell.SE) = cells(2)
+      cells(2).next(Cell.NW) = cells(0)
+      cells(1).next(Cell.SE) = cells(3)
+      cells(3).next(Cell.NW) = cells(1)
+      cells(2).next(Cell.SW) = cells(3)
+      cells(3).next(Cell.NE) = cells(2)
+      cells(3).next(Cell.SW) = cells(4)
+      cells(4).next(Cell.NE) = cells(3)
+   }
+
+   private def make6() = {
+      cells(0).next(Cell.SW) = cells(1)
+      cells(1).next(Cell.NE) = cells(0)
+      cells(2).next(Cell.SE) = cells(1)
+      cells(1).next(Cell.NW) = cells(2)
+      cells(1).next(Cell.SE) = cells(3)
+      cells(3).next(Cell.NW) = cells(1)
+      cells(3).next(Cell.SW) = cells(4)
+      cells(4).next(Cell.NE) = cells(3)
+   }
+
+   private def make7() = {
+      cells(0).next(Cell.SE) = cells(1)
+      cells(1).next(Cell.NW) = cells(0)
+      cells(0).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.NE) = cells(0)
+      cells(2).next(Cell.SW) = cells(3)
+      cells(3).next(Cell.NE) = cells(2)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make8() = {
+      cells(0).next(Cell.E) = cells(1)
+      cells(1).next(Cell.W) = cells(0)
+      cells(1).next(Cell.E) = cells(2)
+      cells(2).next(Cell.W) = cells(1)
+      cells(2).next(Cell.NE) = cells(3)
+      cells(3).next(Cell.SW) = cells(2)
+      cells(3).next(Cell.E) = cells(4)
+      cells(4).next(Cell.W) = cells(3)
+   }
+
+   private def make9() = {
+      cells(0).next(Cell.E) = cells(1)
+      cells(1).next(Cell.W) = cells(0)
+      cells(1).next(Cell.E) = cells(2)
+      cells(2).next(Cell.W) = cells(1)
+      cells(2).next(Cell.NE) = cells(3)
+      cells(3).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.E) = cells(4)
+      cells(4).next(Cell.W) = cells(2)
+      cells(4).next(Cell.NW) = cells(3)
+      cells(3).next(Cell.SE) = cells(4)
+   }
+
+/*
+   def print() = {
+      Console.println("Piece # " + number)
+      Console.println("cell\tNW NE W  E  SW SE")
+      for (i <- Iterator.range(0,Piece.size)){
+         Console.print(i + "\t")
+         for (j <- Iterator.range(0,Cell.sides)){
+            val c = cells(i).next(j)
+            if (c == null) 
+               Console.print("-- ") 
+            else 
+               for (k <- Iterator.range(0,Piece.size)){
+                  if (cells(k) == c) Console.printf(" {0,number,0} ")(k)
+               }       
+         }
+         Console.println("")
+      }
+      Console.println("")
+   }
+*/
+
+}
+
+
+
+
+// Cell.scala
+
+object Cell {
+   val NW = 0; val NE = 1
+   val W  = 2; val E  = 3
+   val SW = 4; val SE = 5   
+
+   val sides = 6
+}
+
+abstract class Cell {
+  implicit def m: Manifest[T]
+  type T
+  val next = new Array[T](Cell.sides)
+  var marked = false
+
+  def mark() = marked = true
+  def unmark() = marked = false
+}
+
+// BoardCell.scala
+
+final class BoardCell(_number: Int) extends {
+   type T = BoardCell
+   implicit val m = manifest[BoardCell]
+} with Cell {
+   val number = _number
+   var piece: Piece = _
+
+   def isEmpty() = piece == null
+   def empty() = piece = null
+
+   def contiguousEmptyCells(): Int = {
+      if (!marked && isEmpty){
+         mark
+         var count = 1 
+
+         for (neighbour <- next)
+            if (neighbour != null && neighbour.isEmpty) 
+               count = count + neighbour.contiguousEmptyCells
+
+         count } else { 0 }
+   }
+}
+
+
+
+
+// PieceCell.scala
+
+final class PieceCell extends Cell {
+   type T = PieceCell
+
+   def flip = {
+      var swap = next(Cell.NE)
+      next(Cell.NE) = next(Cell.NW)
+      next(Cell.NW) = swap
+
+      swap = next(Cell.E)
+      next(Cell.E) = next(Cell.W)
+      next(Cell.W) = swap
+
+      swap = next(Cell.SE)
+      next(Cell.SE) = next(Cell.SW)
+      next(Cell.SW) = swap
+   }
+
+   def rotate = {
+      var swap = next(Cell.E)
+      next(Cell.E) = next(Cell.NE)
+      next(Cell.NE) = next(Cell.NW)
+      next(Cell.NW) = next(Cell.W)
+      next(Cell.W) = next(Cell.SW)
+      next(Cell.SW) = next(Cell.SE)
+      next(Cell.SE) = swap
+   }
+}
+
+
+
+
diff --git a/test/pending/shootout/meteor.scala-2.scala b/test/pending/shootout/meteor.scala-2.scala
new file mode 100644
index 0000000000..2b42c19260
--- /dev/null
+++ b/test/pending/shootout/meteor.scala-2.scala
@@ -0,0 +1,496 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy
+*/
+
+// This is an un-optimised example implementation
+// classes BoardCell and PieceCell have Array 
+
+
+import scala.collection.mutable._
+
+object meteor {
+   def main(args: Array[String]) = {
+      val solver = new Solver( Integer.parseInt(args(0)) )
+      solver.findSolutions
+      solver.printSolutions
+   }
+}
+
+
+
+
+// Solver.scala 
+// import scala.collection.mutable._
+
+final class Solver (n: Int) {
+   private var countdown = n
+   private var first: String = _
+   private var last: String = _
+
+   private val board = new Board()
+
+   val pieces = Array( 
+      new Piece(0), new Piece(1), new Piece(2), new Piece(3), new Piece(4), 
+      new Piece(5), new Piece(6), new Piece(7), new Piece(8), new Piece(9) )
+
+   val unplaced = new BitSet(pieces.length)
+
+   { unplaced ++= (0 until pieces.length) }
+
+
+   def findSolutions(): Unit = {
+      if (countdown == 0) return
+
+      if (unplaced.size > 0){
+         val emptyCellIndex = board.firstEmptyCellIndex
+
+         for (k <- Iterator.range(0,pieces.length)){
+            if (unplaced.contains(k)){
+               unplaced -= k
+
+               for (i <- Iterator.range(0,Piece.orientations)){
+                  val piece = pieces(k).nextOrientation
+
+                  for (j <- Iterator.range(0,Piece.size)){
+                     if (board.add(j,emptyCellIndex,piece)) {
+
+                        if (!shouldPrune) findSolutions
+
+                        board.remove(piece)
+                     }
+                  }
+               }
+               unplaced += k
+            }
+         }
+      }
+      else {
+         puzzleSolved
+      }
+   }
+
+   private def puzzleSolved() = {
+      val b = board.asString
+      if (first == null){ 
+         first = b; last = b 
+      } else {
+         if (b < first){ first = b } else { if (b > last){ last = b } }
+      }
+      countdown = countdown - 1
+   }
+
+   private def shouldPrune() = {
+      board.unmark
+      !board.cells.forall(c => c.contiguousEmptyCells % Piece.size == 0) 
+   }
+
+
+   def printSolutions() = {
+
+      def printBoard(s: String) = {
+         var indent = false
+         var i = 0
+         while (i < s.length){
+            if (indent) Console.print(' ')
+            for (j <- Iterator.range(0,Board.cols)){
+               Console.print(s.charAt(i)); Console.print(' ')
+               i = i + 1
+            }
+            Console.print('\n')
+            indent = !indent
+         }
+         Console.print('\n')
+      }
+
+      Console.print(n + " solutions found\n\n")
+      printBoard(first)
+      printBoard(last)
+   }
+
+/*
+   def printPieces() = 
+      for (i <- Iterator.range(0,Board.pieces)) pieces(i).print 
+*/
+
+}
+
+
+
+
+// Board.scala
+// import scala.collection.mutable._
+
+object Board {
+   val cols = 5
+   val rows = 10
+   val size = rows * cols
+}
+
+final class Board { 
+   val cells = boardCells()
+
+   val cellsPieceWillFill = new Array[BoardCell](Piece.size)
+   var cellCount = 0
+
+   def unmark() = for (c <- cells) c.unmark
+
+   def asString() = 
+      new String( cells map( 
+         c => if (c.piece == null) '-'.toByte 
+              else (c.piece.number + 48).toByte ))
+
+   def firstEmptyCellIndex() = cells.findIndexOf(c => c.isEmpty)
+
+
+   def add(pieceIndex: Int, boardIndex: Int, p: Piece) = {
+      cellCount = 0
+      p.unmark
+    
+      find( p.cells(pieceIndex), cells(boardIndex))
+
+      val boardHasSpace = cellCount == Piece.size && 
+         cellsPieceWillFill.forall(c => c.isEmpty)  
+
+      if (boardHasSpace) cellsPieceWillFill.foreach(c => c.piece = p) 
+
+      boardHasSpace
+   }
+
+   def remove(piece: Piece) = for (c <- cells; if c.piece == piece) c.empty
+
+
+   private def find(p: PieceCell, b: BoardCell): Unit = {
+      if (p != null && !p.marked && b != null){
+         cellsPieceWillFill(cellCount) = b
+         cellCount = cellCount + 1
+         p.mark
+         for (i <- Iterator.range(0,Cell.sides)) find(p.next(i), b.next(i))
+      }
+   }
+
+
+   private def boardCells() = {
+      val a = for (i <- Array.range(0,Board.size)) yield new BoardCell(i)
+      val m = (Board.size / Board.cols) - 1
+
+      for (i <- Iterator.range(0,a.length)){
+         val row = i / Board.cols
+         val isFirst = i % Board.cols == 0
+         val isLast = (i+1) % Board.cols == 0
+         val c = a(i)
+
+         if (row % 2 == 1) {
+            if (!isLast) c.next(Cell.NE) = a(i-(Board.cols-1))
+            c.next(Cell.NW) = a(i-Board.cols) 
+            if (row != m) {
+               if (!isLast) c.next(Cell.SE) = a(i+(Board.cols+1))
+               c.next(Cell.SW) = a(i+Board.cols) 
+            }
+         } else {
+            if (row != 0) {
+               if (!isFirst) c.next(Cell.NW) = a(i-(Board.cols+1))
+               c.next(Cell.NE) = a(i-Board.cols)
+            }
+            if (row != m) {
+               if (!isFirst) c.next(Cell.SW) = a(i+(Board.cols-1))
+               c.next(Cell.SE) = a(i+Board.cols)
+            }
+         }
+         if (!isFirst) c.next(Cell.W) = a(i-1)
+         if (!isLast) c.next(Cell.E) = a(i+1)
+      }
+      a
+   }
+
+
+/*
+// Printing all the board cells and their neighbours
+// helps check that they are connected properly
+
+   def printBoardCellsAndNeighbours() = {
+      Console.println("cell\tNW NE W  E  SW SE")
+      for (i <- Iterator.range(0,Board.size)){
+         Console.print(i + "\t")
+         for (j <- Iterator.range(0,Cell.sides)){
+            val c = cells(i).next(j)
+            if (c == null) 
+               Console.print("-- ") 
+            else 
+               Console.printf("{0,number,00} ")(c.number)
+         }
+         Console.println("")
+      }
+      Console.println("")
+   }
+*/
+
+}
+
+
+
+
+// Piece.scala
+
+object Piece {
+   val size = 5
+   val rotations = Cell.sides
+   val flips = 2
+   val orientations = rotations * flips
+}
+
+final class Piece(_number: Int) {
+   val number = _number
+   val cells = for (i <- Array.range(0,Piece.size)) yield new PieceCell()
+
+   { 
+      number match {
+         case 0 => make0
+         case 1 => make1
+         case 2 => make2
+         case 3 => make3
+         case 4 => make4
+         case 5 => make5
+         case 6 => make6
+         case 7 => make7
+         case 8 => make8
+         case 9 => make9     
+      }
+   }
+
+   def flip() = for (c <- cells) c.flip
+   def rotate() = for (c <- cells) c.rotate
+   def unmark() = for (c <- cells) c.unmark
+
+
+   private var orientation = 0
+
+   def nextOrientation() = {
+      if (orientation == Piece.orientations) orientation = 0
+      if (orientation % Piece.rotations == 0) flip else rotate
+      orientation = orientation + 1
+      this
+   }
+
+
+   private def make0() = {
+      cells(0).next(Cell.E) = cells(1)
+      cells(1).next(Cell.W) = cells(0)
+      cells(1).next(Cell.E) = cells(2)
+      cells(2).next(Cell.W) = cells(1)
+      cells(2).next(Cell.E) = cells(3)
+      cells(3).next(Cell.W) = cells(2)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make1() = {
+      cells(0).next(Cell.SE) = cells(1)
+      cells(1).next(Cell.NW) = cells(0)
+      cells(1).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.NE) = cells(1)
+      cells(2).next(Cell.W) = cells(3)
+      cells(3).next(Cell.E) = cells(2)
+      cells(3).next(Cell.SW) = cells(4)
+      cells(4).next(Cell.NE) = cells(3)
+   }
+
+   private def make2() = {
+      cells(0).next(Cell.W) = cells(1)
+      cells(1).next(Cell.E) = cells(0)
+      cells(1).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.NE) = cells(1)
+      cells(2).next(Cell.SE) = cells(3)
+      cells(3).next(Cell.NW) = cells(2)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make3() = {
+      cells(0).next(Cell.SW) = cells(1)
+      cells(1).next(Cell.NE) = cells(0)
+      cells(1).next(Cell.W) = cells(2)
+      cells(2).next(Cell.E) = cells(1)
+      cells(1).next(Cell.SW) = cells(3)
+      cells(3).next(Cell.NE) = cells(1)
+      cells(2).next(Cell.SE) = cells(3)
+      cells(3).next(Cell.NW) = cells(2)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make4() = {
+      cells(0).next(Cell.SE) = cells(1)
+      cells(1).next(Cell.NW) = cells(0)
+      cells(1).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.NE) = cells(1)
+      cells(1).next(Cell.E) = cells(3)
+      cells(3).next(Cell.W) = cells(1)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make5() = {
+      cells(0).next(Cell.SW) = cells(1)
+      cells(1).next(Cell.NE) = cells(0)
+      cells(0).next(Cell.SE) = cells(2)
+      cells(2).next(Cell.NW) = cells(0)
+      cells(1).next(Cell.SE) = cells(3)
+      cells(3).next(Cell.NW) = cells(1)
+      cells(2).next(Cell.SW) = cells(3)
+      cells(3).next(Cell.NE) = cells(2)
+      cells(3).next(Cell.SW) = cells(4)
+      cells(4).next(Cell.NE) = cells(3)
+   }
+
+   private def make6() = {
+      cells(0).next(Cell.SW) = cells(1)
+      cells(1).next(Cell.NE) = cells(0)
+      cells(2).next(Cell.SE) = cells(1)
+      cells(1).next(Cell.NW) = cells(2)
+      cells(1).next(Cell.SE) = cells(3)
+      cells(3).next(Cell.NW) = cells(1)
+      cells(3).next(Cell.SW) = cells(4)
+      cells(4).next(Cell.NE) = cells(3)
+   }
+
+   private def make7() = {
+      cells(0).next(Cell.SE) = cells(1)
+      cells(1).next(Cell.NW) = cells(0)
+      cells(0).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.NE) = cells(0)
+      cells(2).next(Cell.SW) = cells(3)
+      cells(3).next(Cell.NE) = cells(2)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make8() = {
+      cells(0).next(Cell.E) = cells(1)
+      cells(1).next(Cell.W) = cells(0)
+      cells(1).next(Cell.E) = cells(2)
+      cells(2).next(Cell.W) = cells(1)
+      cells(2).next(Cell.NE) = cells(3)
+      cells(3).next(Cell.SW) = cells(2)
+      cells(3).next(Cell.E) = cells(4)
+      cells(4).next(Cell.W) = cells(3)
+   }
+
+   private def make9() = {
+      cells(0).next(Cell.E) = cells(1)
+      cells(1).next(Cell.W) = cells(0)
+      cells(1).next(Cell.E) = cells(2)
+      cells(2).next(Cell.W) = cells(1)
+      cells(2).next(Cell.NE) = cells(3)
+      cells(3).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.E) = cells(4)
+      cells(4).next(Cell.W) = cells(2)
+      cells(4).next(Cell.NW) = cells(3)
+      cells(3).next(Cell.SE) = cells(4)
+   }
+
+/*
+   def print() = {
+      Console.println("Piece # " + number)
+      Console.println("cell\tNW NE W  E  SW SE")
+      for (i <- Iterator.range(0,Piece.size)){
+         Console.print(i + "\t")
+         for (j <- Iterator.range(0,Cell.sides)){
+            val c = cells(i).next(j)
+            if (c == null) 
+               Console.print("-- ") 
+            else 
+               for (k <- Iterator.range(0,Piece.size)){
+                  if (cells(k) == c) Console.printf(" {0,number,0} ")(k)
+               }       
+         }
+         Console.println("")
+      }
+      Console.println("")
+   }
+*/
+
+}
+
+
+
+
+// Cell.scala
+
+object Cell {
+   val NW = 0; val NE = 1
+   val W  = 2; val E  = 3
+   val SW = 4; val SE = 5   
+
+   val sides = 6
+}
+
+abstract class Cell {
+   var marked = false
+
+   def mark() = marked = true
+   def unmark() = marked = false
+}
+
+
+
+
+// BoardCell.scala
+
+final class BoardCell(_number: Int) extends Cell {
+   val next = new Array[BoardCell](Cell.sides)
+   val number = _number
+   var piece: Piece = _
+
+   def isEmpty() = piece == null
+   def empty() = piece = null
+
+   def contiguousEmptyCells(): Int = {
+      if (!marked && isEmpty){
+         mark
+         var count = 1 
+
+         for (neighbour <- next)
+            if (neighbour != null && neighbour.isEmpty) 
+               count = count + neighbour.contiguousEmptyCells
+
+         count } else { 0 }
+   }
+}
+
+
+
+
+// PieceCell.scala
+
+final class PieceCell extends Cell {
+   val next = new Array[PieceCell](Cell.sides)
+
+   def flip = {
+      var swap = next(Cell.NE)
+      next(Cell.NE) = next(Cell.NW)
+      next(Cell.NW) = swap
+
+      swap = next(Cell.E)
+      next(Cell.E) = next(Cell.W)
+      next(Cell.W) = swap
+
+      swap = next(Cell.SE)
+      next(Cell.SE) = next(Cell.SW)
+      next(Cell.SW) = swap
+   }
+
+   def rotate = {
+      var swap = next(Cell.E)
+      next(Cell.E) = next(Cell.NE)
+      next(Cell.NE) = next(Cell.NW)
+      next(Cell.NW) = next(Cell.W)
+      next(Cell.W) = next(Cell.SW)
+      next(Cell.SW) = next(Cell.SE)
+      next(Cell.SE) = swap
+   }
+}
+
+
+
+
diff --git a/test/pending/shootout/meteor.scala-2.scala.runner b/test/pending/shootout/meteor.scala-2.scala.runner
new file mode 100644
index 0000000000..dae384311f
--- /dev/null
+++ b/test/pending/shootout/meteor.scala-2.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(0)) meteor.main(Array(n.toString)) 
+}
diff --git a/test/pending/shootout/meteor.scala-3.scala b/test/pending/shootout/meteor.scala-3.scala
new file mode 100644
index 0000000000..01dacf90c6
--- /dev/null
+++ b/test/pending/shootout/meteor.scala-3.scala
@@ -0,0 +1,557 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy
+*/
+
+// Most for-comprehension replaced by while loops
+
+
+
+import scala.collection.mutable._
+
+object meteor {
+   def main(args: Array[String]) = {
+      val solver = new Solver( Integer.parseInt(args(0)) )
+      solver.findSolutions
+      solver.printSolutions
+   }
+}
+
+
+
+
+// Solver.scala 
+// import scala.collection.mutable._
+
+final class Solver (n: Int) {
+   private var countdown = n
+   private var first: String = _
+   private var last: String = _
+
+   private val board = new Board()
+
+   val pieces = Array( 
+      new Piece(0), new Piece(1), new Piece(2), new Piece(3), new Piece(4), 
+      new Piece(5), new Piece(6), new Piece(7), new Piece(8), new Piece(9) )
+
+   val unplaced = new BitSet(pieces.length)
+
+   { unplaced ++= (0 until pieces.length) }
+
+
+   def findSolutions(): Unit = {
+      if (countdown == 0) return
+
+      if (unplaced.size > 0){
+         val emptyCellIndex = board.firstEmptyCellIndex
+
+         var k = 0
+         while (k < pieces.length){
+            if (unplaced.contains(k)){
+               unplaced -= k
+
+               var i = 0
+               while (i < Piece.orientations){
+                  val piece = pieces(k).nextOrientation
+
+                  var j = 0
+                  while (j < Piece.size){
+                     if (board.add(j,emptyCellIndex,piece)) {
+
+                        if (!shouldPrune) findSolutions
+
+                        board.remove(piece)
+                     }
+                     j = j + 1
+                  }
+                  i = i + 1
+               }
+               unplaced += k
+            }
+            k = k + 1
+         }
+      }
+      else {
+         puzzleSolved
+      }
+   }
+
+   private def puzzleSolved() = {
+      val b = board.asString
+      if (first == null){ 
+         first = b; last = b 
+      } else {
+         if (b < first){ first = b } else { if (b > last){ last = b } }
+      }
+      countdown = countdown - 1
+   }
+
+   private def shouldPrune(): Boolean = {
+      board.unmark
+      var i = 0
+      while (i < board.cells.length){    
+         if (board.cells(i).contiguousEmptyCells % Piece.size != 0) return true 
+         i = i + 1
+      }
+      false
+   }
+
+
+   def printSolutions() = {
+
+      def printBoard(s: String) = {
+         var indent = false
+         var i = 0
+         while (i < s.length){
+            if (indent) Console.print(' ')
+            var j = 0
+            while (j < Board.cols){
+               Console.print(s.charAt(i)); Console.print(' ')
+               j = j + 1
+               i = i + 1
+            }
+            Console.print('\n')
+            indent = !indent
+         }
+         Console.print('\n')
+      }
+
+      Console.print(n + " solutions found\n\n")
+      printBoard(first)
+      printBoard(last)
+   }
+
+/*
+   def printPieces() = 
+      for (i <- Iterator.range(0,Board.pieces)) pieces(i).print 
+*/
+
+}
+
+
+
+
+
+// Board.scala
+// import scala.collection.mutable._
+
+object Board {
+   val cols = 5
+   val rows = 10
+   val size = rows * cols
+}
+
+final class Board { 
+   val cells = boardCells()
+
+   val cellsPieceWillFill = new Array[BoardCell](Piece.size)
+   var cellCount = 0
+
+   def unmark() = {
+      var i = 0
+      while (i < cells.length){    
+         cells(i).unmark
+         i = i + 1
+      }
+   }
+
+   def asString() = 
+      new String( cells map( 
+         c => if (c.piece == null) '-'.toByte 
+              else (c.piece.number + 48).toByte ))
+
+   def firstEmptyCellIndex() = cells.findIndexOf(c => c.isEmpty)
+
+
+   def add(pieceIndex: Int, boardIndex: Int, p: Piece): Boolean = {
+      cellCount = 0
+      p.unmark
+    
+      find(p.cells(pieceIndex), cells(boardIndex))
+
+      if (cellCount != Piece.size) return false
+
+      var i = 0
+      while (i < cellCount){
+         if (!cellsPieceWillFill(i).isEmpty) return false
+         i = i + 1
+      }
+
+      i = 0
+      while (i < cellCount){    
+         cellsPieceWillFill(i).piece  = p
+         i = i + 1
+      }
+
+      true
+   }
+
+   def remove(piece: Piece) = {
+      var i = 0
+      while (i < cells.length){  
+         if (cells(i).piece == piece) cells(i).empty 
+         i = i + 1
+      }
+   }
+
+   private def find(p: PieceCell, b: BoardCell): Unit = {
+      if (p != null && !p.marked && b != null){
+         cellsPieceWillFill(cellCount) = b
+         cellCount = cellCount + 1
+         p.mark
+
+         var i = 0
+         while (i < Cell.sides){    
+            find(p.next(i), b.next(i))
+            i = i + 1
+         }
+      }
+   }
+
+
+   private def boardCells() = {
+      val a = for (i <- Array.range(0,Board.size)) yield new BoardCell(i)
+      val m = (Board.size / Board.cols) - 1
+
+      for (i <- Iterator.range(0,a.length)){
+         val row = i / Board.cols
+         val isFirst = i % Board.cols == 0
+         val isLast = (i+1) % Board.cols == 0
+         val c = a(i)
+
+         if (row % 2 == 1) {
+            if (!isLast) c.next(Cell.NE) = a(i-(Board.cols-1))
+            c.next(Cell.NW) = a(i-Board.cols) 
+            if (row != m) {
+               if (!isLast) c.next(Cell.SE) = a(i+(Board.cols+1))
+               c.next(Cell.SW) = a(i+Board.cols) 
+            }
+         } else {
+            if (row != 0) {
+               if (!isFirst) c.next(Cell.NW) = a(i-(Board.cols+1))
+               c.next(Cell.NE) = a(i-Board.cols)
+            }
+            if (row != m) {
+               if (!isFirst) c.next(Cell.SW) = a(i+(Board.cols-1))
+               c.next(Cell.SE) = a(i+Board.cols)
+            }
+         }
+         if (!isFirst) c.next(Cell.W) = a(i-1)
+         if (!isLast) c.next(Cell.E) = a(i+1)
+      }
+      a
+   }
+
+/*
+// Printing all the board cells and their neighbours
+// helps check that they are connected properly
+
+   def printBoardCellsAndNeighbours() = {
+      Console.println("cell\tNW NE W  E  SW SE")
+      for (i <- Iterator.range(0,Board.size)){
+         Console.print(i + "\t")
+         for (j <- Iterator.range(0,Cell.sides)){
+            val c = cells(i).next(j)
+            if (c == null) 
+               Console.print("-- ") 
+            else 
+               Console.printf("{0,number,00} ")(c.number)
+         }
+         Console.println("")
+      }
+      Console.println("")
+   }
+*/
+
+}
+
+
+
+
+// Piece.scala
+
+object Piece {
+   val size = 5
+   val rotations = Cell.sides
+   val flips = 2
+   val orientations = rotations * flips
+}
+
+final class Piece(_number: Int) {
+   val number = _number
+   val cells = for (i <- Array.range(0,Piece.size)) yield new PieceCell()
+
+   { 
+      number match {
+         case 0 => make0
+         case 1 => make1
+         case 2 => make2
+         case 3 => make3
+         case 4 => make4
+         case 5 => make5
+         case 6 => make6
+         case 7 => make7
+         case 8 => make8
+         case 9 => make9     
+      }
+   }
+
+   def flip() = {
+      var i = 0
+      while (i < cells.length){    
+         cells(i).flip
+         i = i + 1
+      }
+   }
+
+   def rotate() = {
+      var i = 0
+      while (i < cells.length){    
+         cells(i).rotate
+         i = i + 1
+      }
+   }
+
+   def unmark() = {
+      var i = 0
+      while (i < cells.length){    
+         cells(i).unmark
+         i = i + 1
+      }
+   }
+
+
+   private var orientation = 0
+
+   def nextOrientation() = {
+      if (orientation == Piece.orientations) orientation = 0
+      if (orientation % Piece.rotations == 0) flip else rotate
+      orientation = orientation + 1
+      this
+   }
+
+
+   private def make0() = {
+      cells(0).next(Cell.E) = cells(1)
+      cells(1).next(Cell.W) = cells(0)
+      cells(1).next(Cell.E) = cells(2)
+      cells(2).next(Cell.W) = cells(1)
+      cells(2).next(Cell.E) = cells(3)
+      cells(3).next(Cell.W) = cells(2)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make1() = {
+      cells(0).next(Cell.SE) = cells(1)
+      cells(1).next(Cell.NW) = cells(0)
+      cells(1).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.NE) = cells(1)
+      cells(2).next(Cell.W) = cells(3)
+      cells(3).next(Cell.E) = cells(2)
+      cells(3).next(Cell.SW) = cells(4)
+      cells(4).next(Cell.NE) = cells(3)
+   }
+
+   private def make2() = {
+      cells(0).next(Cell.W) = cells(1)
+      cells(1).next(Cell.E) = cells(0)
+      cells(1).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.NE) = cells(1)
+      cells(2).next(Cell.SE) = cells(3)
+      cells(3).next(Cell.NW) = cells(2)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make3() = {
+      cells(0).next(Cell.SW) = cells(1)
+      cells(1).next(Cell.NE) = cells(0)
+      cells(1).next(Cell.W) = cells(2)
+      cells(2).next(Cell.E) = cells(1)
+      cells(1).next(Cell.SW) = cells(3)
+      cells(3).next(Cell.NE) = cells(1)
+      cells(2).next(Cell.SE) = cells(3)
+      cells(3).next(Cell.NW) = cells(2)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make4() = {
+      cells(0).next(Cell.SE) = cells(1)
+      cells(1).next(Cell.NW) = cells(0)
+      cells(1).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.NE) = cells(1)
+      cells(1).next(Cell.E) = cells(3)
+      cells(3).next(Cell.W) = cells(1)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make5() = {
+      cells(0).next(Cell.SW) = cells(1)
+      cells(1).next(Cell.NE) = cells(0)
+      cells(0).next(Cell.SE) = cells(2)
+      cells(2).next(Cell.NW) = cells(0)
+      cells(1).next(Cell.SE) = cells(3)
+      cells(3).next(Cell.NW) = cells(1)
+      cells(2).next(Cell.SW) = cells(3)
+      cells(3).next(Cell.NE) = cells(2)
+      cells(3).next(Cell.SW) = cells(4)
+      cells(4).next(Cell.NE) = cells(3)
+   }
+
+   private def make6() = {
+      cells(0).next(Cell.SW) = cells(1)
+      cells(1).next(Cell.NE) = cells(0)
+      cells(2).next(Cell.SE) = cells(1)
+      cells(1).next(Cell.NW) = cells(2)
+      cells(1).next(Cell.SE) = cells(3)
+      cells(3).next(Cell.NW) = cells(1)
+      cells(3).next(Cell.SW) = cells(4)
+      cells(4).next(Cell.NE) = cells(3)
+   }
+
+   private def make7() = {
+      cells(0).next(Cell.SE) = cells(1)
+      cells(1).next(Cell.NW) = cells(0)
+      cells(0).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.NE) = cells(0)
+      cells(2).next(Cell.SW) = cells(3)
+      cells(3).next(Cell.NE) = cells(2)
+      cells(3).next(Cell.SE) = cells(4)
+      cells(4).next(Cell.NW) = cells(3)
+   }
+
+   private def make8() = {
+      cells(0).next(Cell.E) = cells(1)
+      cells(1).next(Cell.W) = cells(0)
+      cells(1).next(Cell.E) = cells(2)
+      cells(2).next(Cell.W) = cells(1)
+      cells(2).next(Cell.NE) = cells(3)
+      cells(3).next(Cell.SW) = cells(2)
+      cells(3).next(Cell.E) = cells(4)
+      cells(4).next(Cell.W) = cells(3)
+   }
+
+   private def make9() = {
+      cells(0).next(Cell.E) = cells(1)
+      cells(1).next(Cell.W) = cells(0)
+      cells(1).next(Cell.E) = cells(2)
+      cells(2).next(Cell.W) = cells(1)
+      cells(2).next(Cell.NE) = cells(3)
+      cells(3).next(Cell.SW) = cells(2)
+      cells(2).next(Cell.E) = cells(4)
+      cells(4).next(Cell.W) = cells(2)
+      cells(4).next(Cell.NW) = cells(3)
+      cells(3).next(Cell.SE) = cells(4)
+   }
+
+/*
+   def print() = {
+      Console.println("Piece # " + number)
+      Console.println("cell\tNW NE W  E  SW SE")
+      for (i <- Iterator.range(0,Piece.size)){
+         Console.print(i + "\t")
+         for (j <- Iterator.range(0,Cell.sides)){
+            val c = cells(i).next(j)
+            if (c == null) 
+               Console.print("-- ") 
+            else 
+               for (k <- Iterator.range(0,Piece.size)){
+                  if (cells(k) == c) Console.printf(" {0,number,0} ")(k)
+               }       
+         }
+         Console.println("")
+      }
+      Console.println("")
+   }
+*/
+
+}
+
+
+
+
+// Cell.scala
+
+object Cell {
+   val NW = 0; val NE = 1
+   val W  = 2; val E  = 3
+   val SW = 4; val SE = 5   
+
+   val sides = 6
+}
+
+abstract class Cell {
+   var marked = false
+
+   def mark() = marked = true
+   def unmark() = marked = false
+}
+
+
+
+
+// BoardCell.scala
+
+final class BoardCell(_number: Int) extends Cell {
+   val next = new Array[BoardCell](Cell.sides)
+   val number = _number
+   var piece: Piece = _
+
+   def isEmpty() = piece == null
+   def empty() = piece = null
+
+   def contiguousEmptyCells(): Int = {
+      if (!marked && isEmpty){
+         mark
+         var count = 1 
+
+         var i = 0
+         while (i < next.length){      
+            if (next(i) != null && next(i).isEmpty) 
+               count = count + next(i).contiguousEmptyCells
+            i = i + 1
+         }
+
+         count } else { 0 }
+   }
+}
+
+
+
+
+// PieceCell.scala
+
+final class PieceCell extends Cell {
+   val next = new Array[PieceCell](Cell.sides)
+
+   def flip = {
+      var swap = next(Cell.NE)
+      next(Cell.NE) = next(Cell.NW)
+      next(Cell.NW) = swap
+
+      swap = next(Cell.E)
+      next(Cell.E) = next(Cell.W)
+      next(Cell.W) = swap
+
+      swap = next(Cell.SE)
+      next(Cell.SE) = next(Cell.SW)
+      next(Cell.SW) = swap
+   }
+
+   def rotate = {
+      var swap = next(Cell.E)
+      next(Cell.E) = next(Cell.NE)
+      next(Cell.NE) = next(Cell.NW)
+      next(Cell.NW) = next(Cell.W)
+      next(Cell.W) = next(Cell.SW)
+      next(Cell.SW) = next(Cell.SE)
+      next(Cell.SE) = swap
+   }
+}
+
+
+
+
diff --git a/test/pending/shootout/meteor.scala-3.scala.runner b/test/pending/shootout/meteor.scala-3.scala.runner
new file mode 100644
index 0000000000..dae384311f
--- /dev/null
+++ b/test/pending/shootout/meteor.scala-3.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(0)) meteor.main(Array(n.toString)) 
+}
diff --git a/test/pending/shootout/meteor.scala-4.scala b/test/pending/shootout/meteor.scala-4.scala
new file mode 100644
index 0000000000..ee036f7fab
--- /dev/null
+++ b/test/pending/shootout/meteor.scala-4.scala
@@ -0,0 +1,587 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy
+*/
+
+// Most for-comprehension replaced by while loops
+// BoardCells occupied by each Piece orientation are cached
+// Piece orientations are cached
+
+import scala.collection.mutable._
+
+object meteor {
+   def main(args: Array[String]) = {
+      val solver = new Solver( Integer.parseInt(args(0)) )
+      solver.findSolutions
+      solver.printSolutions 
+   }
+}
+
+
+
+
+// Solver.scala 
+// import scala.collection.mutable._
+
+final class Solver (n: Int) {
+   private var countdown = n
+   private var first: String = _
+   private var last: String = _
+
+   private val board = new Board()
+
+   val pieces = Array( 
+      new Piece(0), new Piece(1), new Piece(2), new Piece(3), new Piece(4), 
+      new Piece(5), new Piece(6), new Piece(7), new Piece(8), new Piece(9) )
+
+   val unplaced = new BitSet(pieces.length)
+
+   { unplaced ++= (0 until pieces.length) }
+
+
+   def findSolutions(): Unit = {
+      if (countdown == 0) return
+
+      if (unplaced.size > 0){
+         val emptyCellIndex = board.firstEmptyCellIndex
+
+         var k = 0
+         while (k < pieces.length){
+            if (unplaced.contains(k)){
+               unplaced -= k
+
+               var i = 0
+               while (i < Piece.orientations){
+                  val piece = pieces(k).nextOrientation
+
+                  var j = 0
+                  while (j < Piece.size){
+                     if (board.add(j,emptyCellIndex,piece)) {
+
+                        if (!shouldPrune) findSolutions
+
+                        board.remove(piece)
+                     }
+                     j = j + 1
+                  }
+                  i = i + 1
+               }
+               unplaced += k
+            }
+            k = k + 1
+         }
+      }
+      else {
+         puzzleSolved
+      }
+   }
+
+   private def puzzleSolved() = {
+      val b = board.asString
+      if (first == null){ 
+         first = b; last = b 
+      } else {
+         if (b < first){ first = b } else { if (b > last){ last = b } }
+      }
+      countdown = countdown - 1
+   }
+
+   private def shouldPrune(): Boolean = {
+      board.unmark
+      var i = 0
+      while (i < board.cells.length){    
+         if (board.cells(i).contiguousEmptyCells % Piece.size != 0) return true 
+         i = i + 1
+      }
+      false
+   }
+
+
+   def printSolutions() = {
+
+      def printBoard(s: String) = {
+         var indent = false
+         var i = 0
+         while (i < s.length){
+            if (indent) Console.print(' ')
+            var j = 0
+            while (j < Board.cols){
+               Console.print(s.charAt(i)); Console.print(' ')
+               j = j + 1
+               i = i + 1
+            }
+            Console.print('\n')
+            indent = !indent
+         }
+         Console.print('\n')
+      }
+
+      Console.print(n + " solutions found\n\n")
+      printBoard(first)
+      printBoard(last)
+   }
+
+/*
+   def printPieces() = 
+      for (i <- Iterator.range(0,Board.pieces)) pieces(i).print 
+*/
+
+}
+
+
+
+// Board.scala
+// import scala.collection.mutable._
+
+object Board {
+   val cols = 5
+   val rows = 10
+   val size = rows * cols
+   val pieces = 10
+   val noFit = new Array[BoardCell](0)
+}
+
+final class Board { 
+   val cells = boardCells()
+
+   val cellsPieceWillFill = new Array[BoardCell](Piece.size)
+   var cellCount = 0
+
+   def unmark() = {
+      var i = 0
+      while (i < cells.length){    
+         cells(i).unmark
+         i = i + 1
+      }
+   }
+
+   def asString() = 
+      new String( cells map( 
+         c => if (c.piece == null) '-'.toByte 
+              else (c.piece.number + 48).toByte ))
+
+   def firstEmptyCellIndex() = cells.findIndexOf(c => c.isEmpty)
+
+
+   private val cache: Array[Array[Array[Array[ Array[BoardCell] ]]]] = 
+      for (i <- Array.range(0,Board.pieces)) 
+         yield 
+            for (j <- Array.range(0,Piece.orientations)) 
+               yield 
+                  for (k <- Array.range(0,Piece.size)) // piece cell index
+                     yield 
+                        for (m <- Array.range(0,Board.size)) // board cell index
+                           yield (null: BoardCell)
+
+
+   def add(pieceIndex: Int, boardIndex: Int, p: Piece): Boolean = {
+      var a = cache(p.number)(p.orientation)(pieceIndex)(boardIndex)
+
+      cellCount = 0
+      p.unmark
+
+      if (a == null){
+         find(p.cells(pieceIndex), cells(boardIndex))
+
+         if (cellCount != Piece.size){ 
+            cache(p.number)(p.orientation)(pieceIndex)(boardIndex) = Board.noFit
+            return false
+         }
+
+         a = cellsPieceWillFill .filter(c => true)
+         cache(p.number)(p.orientation)(pieceIndex)(boardIndex) = a
+      } 
+      else {
+         if (a == Board.noFit) return false
+      }
+
+      var i = 0
+      while (i < a.length){
+         if (!a(i).isEmpty) return false
+         i = i + 1
+      }
+
+      i = 0
+      while (i < a.length){    
+         a(i).piece = p
+         i = i + 1
+      }
+
+      true
+   }
+
+
+   def remove(piece: Piece) = {
+      var i = 0
+      while (i < cells.length){  
+         if (cells(i).piece == piece) cells(i).empty 
+         i = i + 1
+      }
+   }
+
+
+   private def find(p: PieceCell, b: BoardCell): Unit = {
+      if (p != null && !p.marked && b != null){
+         cellsPieceWillFill(cellCount) = b
+         cellCount = cellCount + 1
+         p.mark
+
+         var i = 0
+         while (i < Cell.sides){    
+            find(p.next(i), b.next(i))
+            i = i + 1
+         }
+      }
+   }
+
+
+   private def boardCells() = {
+      val a = for (i <- Array.range(0,Board.size)) yield new BoardCell(i)
+      val m = (Board.size / Board.cols) - 1
+
+      for (i <- Iterator.range(0,a.length)){
+         val row = i / Board.cols
+         val isFirst = i % Board.cols == 0
+         val isLast = (i+1) % Board.cols == 0
+         val c = a(i)
+
+         if (row % 2 == 1) {
+            if (!isLast) c.next(Cell.NE) = a(i-(Board.cols-1))
+            c.next(Cell.NW) = a(i-Board.cols) 
+            if (row != m) {
+               if (!isLast) c.next(Cell.SE) = a(i+(Board.cols+1))
+               c.next(Cell.SW) = a(i+Board.cols) 
+            }
+         } else {
+            if (row != 0) {
+               if (!isFirst) c.next(Cell.NW) = a(i-(Board.cols+1))
+               c.next(Cell.NE) = a(i-Board.cols)
+            }
+            if (row != m) {
+               if (!isFirst) c.next(Cell.SW) = a(i+(Board.cols-1))
+               c.next(Cell.SE) = a(i+Board.cols)
+            }
+         }
+         if (!isFirst) c.next(Cell.W) = a(i-1)
+         if (!isLast) c.next(Cell.E) = a(i+1)
+      }
+      a
+   }
+
+
+/*
+// Printing all the board cells and their neighbours
+// helps check that they are connected properly
+
+   def printBoardCellsAndNeighbours() = {
+      Console.println("cell\tNW NE W  E  SW SE")
+      for (i <- Iterator.range(0,Board.size)){
+         Console.print(i + "\t")
+         for (j <- Iterator.range(0,Cell.sides)){
+            val c = cells(i).next(j)
+            if (c == null) 
+               Console.print("-- ") 
+            else 
+               Console.printf("{0,number,00} ")(c.number)
+         }
+         Console.println("")
+      }
+      Console.println("")
+   }
+*/
+
+}
+
+
+
+
+// Piece.scala
+
+object Piece {
+   val size = 5
+   val rotations = Cell.sides
+   val flips = 2
+   val orientations = rotations * flips
+}
+
+final class Piece(_number: Int) {
+   val number = _number
+
+   def unmark() = {
+      val c = cache(orientation)
+      var i = 0
+      while (i < c.length){    
+         c(i).unmark
+         i = i + 1
+      }
+   }
+
+   def cells = cache(orientation)
+
+   private val cache = 
+      for (i <- Array.range(0,Piece.orientations)) 
+         yield pieceOrientation(i)
+
+   var orientation = 0
+
+   def nextOrientation() = {    
+      orientation = (orientation + 1) % Piece.orientations
+      this
+   }
+
+
+   private def pieceOrientation(k: Int) = {
+      val cells = for (i <- Array.range(0,Piece.size)) yield new PieceCell()
+      makePiece(number,cells)
+
+      var i = 0
+      while (i < k){  
+         if (i % Piece.rotations == 0) 
+            for (c <- cells) c.flip
+         else
+            for (c <- cells) c.rotate
+
+         i = i + 1
+      }
+      cells
+   }
+
+   private def makePiece(number: Int, cells: Array[PieceCell]) = {
+      number match {
+         case 0 => make0(cells)
+         case 1 => make1(cells)
+         case 2 => make2(cells)
+         case 3 => make3(cells)
+         case 4 => make4(cells)
+         case 5 => make5(cells)
+         case 6 => make6(cells)
+         case 7 => make7(cells)
+         case 8 => make8(cells)
+         case 9 => make9(cells)
+      }
+   }
+
+   private def make0(a: Array[PieceCell]) = {
+      a(0).next(Cell.E) = a(1)
+      a(1).next(Cell.W) = a(0)
+      a(1).next(Cell.E) = a(2)
+      a(2).next(Cell.W) = a(1)
+      a(2).next(Cell.E) = a(3)
+      a(3).next(Cell.W) = a(2)
+      a(3).next(Cell.SE) = a(4)
+      a(4).next(Cell.NW) = a(3)
+   }
+
+   private def make1(a: Array[PieceCell]) = {
+      a(0).next(Cell.SE) = a(1)
+      a(1).next(Cell.NW) = a(0)
+      a(1).next(Cell.SW) = a(2)
+      a(2).next(Cell.NE) = a(1)
+      a(2).next(Cell.W) = a(3)
+      a(3).next(Cell.E) = a(2)
+      a(3).next(Cell.SW) = a(4)
+      a(4).next(Cell.NE) = a(3)
+   }
+
+   private def make2(a: Array[PieceCell]) = {
+      a(0).next(Cell.W) = a(1)
+      a(1).next(Cell.E) = a(0)
+      a(1).next(Cell.SW) = a(2)
+      a(2).next(Cell.NE) = a(1)
+      a(2).next(Cell.SE) = a(3)
+      a(3).next(Cell.NW) = a(2)
+      a(3).next(Cell.SE) = a(4)
+      a(4).next(Cell.NW) = a(3)
+   }
+
+   private def make3(a: Array[PieceCell]) = {
+      a(0).next(Cell.SW) = a(1)
+      a(1).next(Cell.NE) = a(0)
+      a(1).next(Cell.W) = a(2)
+      a(2).next(Cell.E) = a(1)
+      a(1).next(Cell.SW) = a(3)
+      a(3).next(Cell.NE) = a(1)
+      a(2).next(Cell.SE) = a(3)
+      a(3).next(Cell.NW) = a(2)
+      a(3).next(Cell.SE) = a(4)
+      a(4).next(Cell.NW) = a(3)
+   }
+
+   private def make4(a: Array[PieceCell]) = {
+      a(0).next(Cell.SE) = a(1)
+      a(1).next(Cell.NW) = a(0)
+      a(1).next(Cell.SW) = a(2)
+      a(2).next(Cell.NE) = a(1)
+      a(1).next(Cell.E) = a(3)
+      a(3).next(Cell.W) = a(1)
+      a(3).next(Cell.SE) = a(4)
+      a(4).next(Cell.NW) = a(3)
+   }
+
+   private def make5(a: Array[PieceCell]) = {
+      a(0).next(Cell.SW) = a(1)
+      a(1).next(Cell.NE) = a(0)
+      a(0).next(Cell.SE) = a(2)
+      a(2).next(Cell.NW) = a(0)
+      a(1).next(Cell.SE) = a(3)
+      a(3).next(Cell.NW) = a(1)
+      a(2).next(Cell.SW) = a(3)
+      a(3).next(Cell.NE) = a(2)
+      a(3).next(Cell.SW) = a(4)
+      a(4).next(Cell.NE) = a(3)
+   }
+
+   private def make6(a: Array[PieceCell]) = {
+      a(0).next(Cell.SW) = a(1)
+      a(1).next(Cell.NE) = a(0)
+      a(2).next(Cell.SE) = a(1)
+      a(1).next(Cell.NW) = a(2)
+      a(1).next(Cell.SE) = a(3)
+      a(3).next(Cell.NW) = a(1)
+      a(3).next(Cell.SW) = a(4)
+      a(4).next(Cell.NE) = a(3)
+   }
+
+   private def make7(a: Array[PieceCell]) = {
+      a(0).next(Cell.SE) = a(1)
+      a(1).next(Cell.NW) = a(0)
+      a(0).next(Cell.SW) = a(2)
+      a(2).next(Cell.NE) = a(0)
+      a(2).next(Cell.SW) = a(3)
+      a(3).next(Cell.NE) = a(2)
+      a(3).next(Cell.SE) = a(4)
+      a(4).next(Cell.NW) = a(3)
+   }
+
+   private def make8(a: Array[PieceCell]) = {
+      a(0).next(Cell.E) = a(1)
+      a(1).next(Cell.W) = a(0)
+      a(1).next(Cell.E) = a(2)
+      a(2).next(Cell.W) = a(1)
+      a(2).next(Cell.NE) = a(3)
+      a(3).next(Cell.SW) = a(2)
+      a(3).next(Cell.E) = a(4)
+      a(4).next(Cell.W) = a(3)
+   }
+
+   private def make9(a: Array[PieceCell]) = {
+      a(0).next(Cell.E) = a(1)
+      a(1).next(Cell.W) = a(0)
+      a(1).next(Cell.E) = a(2)
+      a(2).next(Cell.W) = a(1)
+      a(2).next(Cell.NE) = a(3)
+      a(3).next(Cell.SW) = a(2)
+      a(2).next(Cell.E) = a(4)
+      a(4).next(Cell.W) = a(2)
+      a(4).next(Cell.NW) = a(3)
+      a(3).next(Cell.SE) = a(4)
+   }
+
+/*
+   def print() = {
+      Console.println("Piece # " + number)
+      Console.println("cell\tNW NE W  E  SW SE")
+      for (i <- Iterator.range(0,Piece.size)){
+         Console.print(i + "\t")
+         for (j <- Iterator.range(0,Cell.sides)){
+            val c = cells(i).next(j)
+            if (c == null) 
+               Console.print("-- ") 
+            else 
+               for (k <- Iterator.range(0,Piece.size)){
+                  if (cells(k) == c) Console.printf(" {0,number,0} ")(k)
+               }       
+         }
+         Console.println("")
+      }
+      Console.println("")
+   }
+*/
+}
+
+
+
+
+
+// Cell.scala
+
+object Cell {
+   val NW = 0; val NE = 1
+   val W  = 2; val E  = 3
+   val SW = 4; val SE = 5   
+
+   val sides = 6
+}
+
+abstract class Cell {
+   var marked = false
+
+   def mark() = marked = true
+   def unmark() = marked = false
+}
+
+
+
+
+// BoardCell.scala
+
+final class BoardCell(_number: Int) extends Cell {
+   val next = new Array[BoardCell](Cell.sides)
+   val number = _number
+   var piece: Piece = _
+
+   def isEmpty() = piece == null
+   def empty() = piece = null
+
+   def contiguousEmptyCells(): Int = {
+      if (!marked && isEmpty){
+         mark
+         var count = 1 
+
+         var i = 0
+         while (i < next.length){      
+            if (next(i) != null && next(i).isEmpty) 
+               count = count + next(i).contiguousEmptyCells
+            i = i + 1
+         }
+
+         count } else { 0 }
+   }
+}
+
+
+
+
+// PieceCell.scala
+
+final class PieceCell extends Cell {
+   val next = new Array[PieceCell](Cell.sides)
+
+   def flip = {
+      var swap = next(Cell.NE)
+      next(Cell.NE) = next(Cell.NW)
+      next(Cell.NW) = swap
+
+      swap = next(Cell.E)
+      next(Cell.E) = next(Cell.W)
+      next(Cell.W) = swap
+
+      swap = next(Cell.SE)
+      next(Cell.SE) = next(Cell.SW)
+      next(Cell.SW) = swap
+   }
+
+   def rotate = {
+      var swap = next(Cell.E)
+      next(Cell.E) = next(Cell.NE)
+      next(Cell.NE) = next(Cell.NW)
+      next(Cell.NW) = next(Cell.W)
+      next(Cell.W) = next(Cell.SW)
+      next(Cell.SW) = next(Cell.SE)
+      next(Cell.SE) = swap
+   }
+}
+
+
+
+
diff --git a/test/pending/shootout/meteor.scala-4.scala.runner b/test/pending/shootout/meteor.scala-4.scala.runner
new file mode 100644
index 0000000000..dae384311f
--- /dev/null
+++ b/test/pending/shootout/meteor.scala-4.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(0)) meteor.main(Array(n.toString)) 
+}
diff --git a/test/pending/shootout/meteor.scala.runner b/test/pending/shootout/meteor.scala.runner
new file mode 100644
index 0000000000..dae384311f
--- /dev/null
+++ b/test/pending/shootout/meteor.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(0)) meteor.main(Array(n.toString)) 
+}
diff --git a/test/pending/shootout/methcall.scala b/test/pending/shootout/methcall.scala
new file mode 100644
index 0000000000..9f7234c72d
--- /dev/null
+++ b/test/pending/shootout/methcall.scala
@@ -0,0 +1,58 @@
+/* The Computer Language Shootout 
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy (Scala novice)
+*/
+
+object methcall {
+   def main(args: Array[String]) = {
+      var n = toPositiveInt(args);
+      var v: Boolean = false
+
+      val toggle = new Toggle(true);
+      for (i <- Iterator.range(1,n)) v = toggle.activate.value;         
+
+      Console println( toggle.activate.value );
+
+      val ntoggle = new NToggle(true,3);
+      for (i <- Iterator.range(1,n)) v = ntoggle.activate.value;    
+     
+      Console println( ntoggle.activate.value );
+   }
+
+
+   private def toPositiveInt(s: Array[String]) = {
+      val i = 
+         try { Integer.parseInt(s(0)); } 
+         catch { case _ => 1 }
+      if (i>0) i; else 1;
+   }
+}
+
+
+private class Toggle(b: Boolean) {
+   var state = b;
+
+   def value = state;
+
+   def activate = {
+      state = !state;
+      this 
+   }
+}
+
+
+private class NToggle(b: Boolean, trigger: Int) 
+extends Toggle(b) {
+
+   val toggleTrigger = trigger;
+   var count = 0;
+
+   override def activate = {
+      count = count + 1;
+      if (count >= toggleTrigger) {
+         state = !state;
+         count = 0;
+      }
+      this
+   }
+}
diff --git a/test/pending/shootout/methcall.scala.runner b/test/pending/shootout/methcall.scala.runner
new file mode 100644
index 0000000000..555413cc6c
--- /dev/null
+++ b/test/pending/shootout/methcall.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(100000,400000,700000,1000000)) methcall.main(Array(n.toString)) 
+}
diff --git a/test/pending/shootout/nsieve.scala-4.check b/test/pending/shootout/nsieve.scala-4.check
new file mode 100644
index 0000000000..5ae0440a5a
--- /dev/null
+++ b/test/pending/shootout/nsieve.scala-4.check
@@ -0,0 +1,9 @@
+Primes up to  1280000    98610
+Primes up to   640000    52074
+Primes up to   320000    27608
+Primes up to  2560000   187134
+Primes up to  1280000    98610
+Primes up to   640000    52074
+Primes up to  5120000   356244
+Primes up to  2560000   187134
+Primes up to  1280000    98610
diff --git a/test/pending/shootout/nsieve.scala-4.scala b/test/pending/shootout/nsieve.scala-4.scala
new file mode 100644
index 0000000000..741eb80398
--- /dev/null
+++ b/test/pending/shootout/nsieve.scala-4.scala
@@ -0,0 +1,45 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy
+*/
+
+
+object nsieve { 
+
+   def nsieve(m: Int, isPrime: Array[Boolean]) = {
+      for (i <- List.range(2, m)) isPrime(i) = true
+      var count = 0
+
+      for (i <- List.range(2, m)){
+         if (isPrime(i)){
+            var k = i+i
+            while (k < m){ isPrime(k) = false; k = k+i }
+            count = count + 1
+         }
+      }
+      count
+   }
+
+
+   def main(args: Array[String]) = {
+      val n = Integer.parseInt(args(0))
+      val m = (1<<n)*10000
+      val flags = new Array[Boolean](m+1)
+
+      def printPrimes(m: Int) = {
+
+         def pad(i: Int, width: Int) = {
+            val s = i.toString
+            List.range(0, width - s.length)
+               .map((i) => " ") .foldLeft("")((a,b) => a+b) + s 
+         }
+
+         Console.println("Primes up to " +  pad(m,8) + pad(nsieve(m,flags),9))
+      }
+
+
+      printPrimes(m)
+      printPrimes( (1<<n-1)*10000 )
+      printPrimes( (1<<n-2)*10000 )
+   } 
+}
diff --git a/test/pending/shootout/nsieve.scala-4.scala.runner b/test/pending/shootout/nsieve.scala-4.scala.runner
new file mode 100644
index 0000000000..67be6d5844
--- /dev/null
+++ b/test/pending/shootout/nsieve.scala-4.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(7,8,9)) nsieve.main(Array(n.toString)) 
+}
diff --git a/test/pending/shootout/pidigits.check b/test/pending/shootout/pidigits.check
new file mode 100644
index 0000000000..ad4dc9962b
--- /dev/null
+++ b/test/pending/shootout/pidigits.check
@@ -0,0 +1,100 @@
+3141592653	:10
+5897932384	:20
+6264338327	:30
+9502884197	:40
+1693993751	:50
+0582097494	:60
+4592307816	:70
+4062862089	:80
+9862803482	:90
+5342117067	:100
+9821480865	:110
+1328230664	:120
+7093844609	:130
+5505822317	:140
+2535940812	:150
+8481117450	:160
+2841027019	:170
+3852110555	:180
+9644622948	:190
+9549303819	:200
+6442881097	:210
+5665933446	:220
+1284756482	:230
+3378678316	:240
+5271201909	:250
+1456485669	:260
+2346034861	:270
+0454326648	:280
+2133936072	:290
+6024914127	:300
+3724587006	:310
+6063155881	:320
+7488152092	:330
+0962829254	:340
+0917153643	:350
+6789259036	:360
+0011330530	:370
+5488204665	:380
+2138414695	:390
+1941511609	:400
+4330572703	:410
+6575959195	:420
+3092186117	:430
+3819326117	:440
+9310511854	:450
+8074462379	:460
+9627495673	:470
+5188575272	:480
+4891227938	:490
+1830119491	:500
+2983367336	:510
+2440656643	:520
+0860213949	:530
+4639522473	:540
+7190702179	:550
+8609437027	:560
+7053921717	:570
+6293176752	:580
+3846748184	:590
+6766940513	:600
+2000568127	:610
+1452635608	:620
+2778577134	:630
+2757789609	:640
+1736371787	:650
+2146844090	:660
+1224953430	:670
+1465495853	:680
+7105079227	:690
+9689258923	:700
+5420199561	:710
+1212902196	:720
+0864034418	:730
+1598136297	:740
+7477130996	:750
+0518707211	:760
+3499999983	:770
+7297804995	:780
+1059731732	:790
+8160963185	:800
+9502445945	:810
+5346908302	:820
+6425223082	:830
+5334468503	:840
+5261931188	:850
+1710100031	:860
+3783875288	:870
+6587533208	:880
+3814206171	:890
+7766914730	:900
+3598253490	:910
+4287554687	:920
+3115956286	:930
+3882353787	:940
+5937519577	:950
+8185778053	:960
+2171226806	:970
+6130019278	:980
+7661119590	:990
+9216420198	:1000
diff --git a/test/pending/shootout/pidigits.scala b/test/pending/shootout/pidigits.scala
new file mode 100644
index 0000000000..b0becafda8
--- /dev/null
+++ b/test/pending/shootout/pidigits.scala
@@ -0,0 +1,69 @@
+/* ------------------------------------------------------------------ */
+/* The Computer Language Shootout                               */
+/* http://shootout.alioth.debian.org/                                 */
+/*                                                                    */
+/* Contributed by Anthony Borla                                       */
+/* ------------------------------------------------------------------ */
+
+object pidigits
+{
+  def main(args: Array[String]): Unit =
+  {
+    val N: Int = Integer.parseInt(args(0)); var i: Int = 10
+
+    while (i <= N)
+    {
+      System.out.println(pi_digits(10) + "\t:" + i)
+      i = i + 10
+    }
+
+    i = i - 10
+
+    if (i < N)
+    {
+      System.out.println(pi_digits(N - i) + "\t:" + N)
+    }
+  }
+
+  def compose(a: Array[BigInt], b: Array[BigInt]): Array[BigInt] =
+  {
+    return Array(a(0) * b(0),
+                 a(0) * b(1) + a(1) * b(3),
+                 a(2) * b(0) + a(3) * b(2),
+                 a(2) * b(1) + a(3) * b(3))
+  }
+
+  def extract(a: Array[BigInt], j: Int): BigInt =
+  {
+    return (a(0) * j + a(1)) / (a(2) * j + a(3))
+  }
+
+  def pi_digits(c: Int): String =
+  {
+    val r: StringBuffer = new StringBuffer(); var i: Int = 0
+
+    while (i < c)
+    {
+      var y: BigInt = extract(Z, 3)
+
+      while (y != extract(Z, 4))
+      {
+        K = K + 1; Z = compose(Z, Array(K, 4 * K + 2, 0, 2 * K + 1))
+        y = extract(Z, 3)
+      }
+
+//      Z = compose(Array(10, (-y) * 10, 0, 1), Z)
+
+      Z = compose(Array(10, y * (-10), 0, 1), Z)
+
+      r.append(y); i = i + 1; 
+    }
+
+    return r.toString()
+  }
+
+  var K: Int = 0
+
+  var Z: Array[BigInt] = Array(1, 0, 0, 1)
+}
+
diff --git a/test/pending/shootout/pidigits.scala.runner b/test/pending/shootout/pidigits.scala.runner
new file mode 100644
index 0000000000..4bf5a8bde9
--- /dev/null
+++ b/test/pending/shootout/pidigits.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(600,800,1000)) pidigits.main(Array(n.toString)) 
+}
diff --git a/test/pending/shootout/prodcons.scala b/test/pending/shootout/prodcons.scala
new file mode 100644
index 0000000000..d48d3e94d8
--- /dev/null
+++ b/test/pending/shootout/prodcons.scala
@@ -0,0 +1,64 @@
+/* The Computer Language Shootout 
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy (Scala novice)
+*/
+
+import concurrent.SyncVar;
+import concurrent.ops._;
+
+object prodcons {
+   def main(args: Array[String]) = {
+      val n = toPositiveInt(args);
+      val buffer = new SharedBuffer();
+      var p = 0;
+      var c = 0;
+      val cDone = new SyncVar[Boolean];
+
+      spawn { 
+         while(p<n) { p=p+1; buffer put(p); }
+      }
+
+      spawn { 
+         var v: Int = _;
+         while(c<n) { c=c+1; v = buffer.get; }
+         cDone set true;
+      }
+
+      cDone.get;
+      Console println(p + " " + c); 
+   }
+
+
+   private def toPositiveInt(s: Array[String]) = {
+      val i = 
+         try { Integer.parseInt(s(0)); } 
+         catch { case _ => 1 }
+      if (i>0) i; else 1;
+   }
+}
+
+
+private class SharedBuffer() {
+   var contents: Int = _;
+   var available = false;
+
+   def get = synchronized {
+      while (available == false) wait();
+      available = false;
+         // Console println("\t" + "get " + contents);
+      notifyAll();
+      contents
+   }
+
+   def put(value: Int) = synchronized {
+      while (available == true) wait();
+      contents = value;
+      available = true;
+         // Console println("put " + value);
+      notifyAll();
+   }
+}
+
+
+
+
diff --git a/test/pending/shootout/prodcons.scala.runner b/test/pending/shootout/prodcons.scala.runner
new file mode 100644
index 0000000000..75faf8ca6e
--- /dev/null
+++ b/test/pending/shootout/prodcons.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(30000,70000,100000,150000)) prodcons.main(Array(n.toString)) 
+}
diff --git a/test/pending/shootout/random.scala b/test/pending/shootout/random.scala
new file mode 100644
index 0000000000..0a86a35637
--- /dev/null
+++ b/test/pending/shootout/random.scala
@@ -0,0 +1,32 @@
+/* The Computer Language Shootout 
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy (Scala novice)
+*/
+
+object random {
+   def main(args: Array[String]) = {
+      var n = toPositiveInt(args);
+      var result: Double = 0
+
+      while (n>0) { result=generate(100.0); n=n-1; }
+
+      Console.printf("{0,number,#.000000000}\n", result)
+   }
+
+   private val IM = 139968;
+   private val IA = 3877;
+   private val IC = 29573;
+   private var seed = 42;
+
+   def generate(max: Double) = {
+      seed = (seed * IA + IC) % IM;
+      max * seed / IM;
+   }
+
+   private def toPositiveInt(s: Array[String]) = {
+      val i = 
+         try { Integer.parseInt(s(0)); } 
+         catch { case _ => 1 }
+      if (i>0) i; else 1;
+   }
+}
diff --git a/test/pending/shootout/random.scala.runner b/test/pending/shootout/random.scala.runner
new file mode 100644
index 0000000000..11cbeef0f6
--- /dev/null
+++ b/test/pending/shootout/random.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(9000,300000,600000,900000)) random.main(Array(n.toString)) 
+}
diff --git a/test/pending/shootout/revcomp.scala-2.check b/test/pending/shootout/revcomp.scala-2.check
new file mode 100644
index 0000000000..14d792ade8
--- /dev/null
+++ b/test/pending/shootout/revcomp.scala-2.check
@@ -0,0 +1,171 @@
+>ONE Homo sapiens alu
+CGGAGTCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAAC
+CTCCGCCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACA
+GGCGCGCGCCACCACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCAT
+GTTGGCCAGGCTGGTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAA
+AGTGCTGGGATTACAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTC
+TGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCGCCTCCCGG
+GTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGCGCGCCACC
+ACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGGCCAGGCTG
+GTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTA
+CAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTCTGTCGCCCAGGCT
+GGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCGCCTCCCGGGTTCAAGCGATTC
+TCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGCGCGCCACCACGCCCGGCTAAT
+TTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGGCCAGGCTGGTCTCGAACTCCT
+GACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCA
+CCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGC
+GCGATCTCGGCTCACTGCAACCTCCGCCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCC
+TCCCGAGTAGCTGGGATTACAGGCGCGCGCCACCACGCCCGGCTAATTTTTGTATTTTTA
+GTAGAGACGGGGTTTCACCATGTTGGCCAGGCTGGTCTCGAACTCCTGACCTCAGGTGAT
+CCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACCGCGCCCGGCCT
+TTTTGAGACGGAGTCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTC
+ACTGCAACCTCCGCCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTG
+GGATTACAGGCGCGCGCCACCACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGT
+TTCACCATGTTGGCCAGGCTGGTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGG
+CCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAG
+TCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCG
+CCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGC
+GCGCCACCACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGG
+CCAGGCTGGTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGC
+TGGGATTACAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTCTGTCG
+CCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCGCCTCCCGGGTTCA
+AGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGCGCGCCACCACGCC
+CGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGGCCAGGCTGGTCTC
+GAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGC
+GTGAGCCACCGCGCCCGGCC
+>TWO IUB ambiguity codes
+TAGGDHACHATCRGTRGVTGAGWTATGYTGCTGTCABACDWVTRTAAGAVVAGATTTNDA
+GASMTCTGCATBYTTCAAKTTACMTATTACTTCATARGGYACMRTGTTTTYTATACVAAT
+TTCTAKGDACKADACTATATNTANTCGTTCACGBCGYSCBHTANGGTGATCGTAAAGTAA
+CTATBAAAAGATSTGWATBCSGAKHTTABBAACGTSYCATGCAAVATKTSKTASCGGAAT
+WVATTTNTCCTTCTTCTTDDAGTGGTTGGATACVGTTAYMTMTBTACTTTHAGCTAGBAA
+AAGAGKAAGTTRATWATCAGATTMDDTTTAAAVAAATATTKTCYTAAATTVCNKTTRACG
+ADTATATTTATGATSADSCAATAWAGCGRTAGTGTAAGTGACVGRADYGTGCTACHVSDT
+CTVCARCSYTTAATATARAAAATTTAATTTACDAATTGBACAGTAYAABATBTGCAGBVG
+TGATGGDCAAAATBNMSTTABKATTGGSTCCTAGBTTACTTGTTTAGTTTATHCGATSTA
+AAGTCGAKAAASTGTTTTAWAKCAGATATACTTTTMTTTTGBATAGAGGAGCMATGATRA
+AAGGNCAYDCCDDGAAAGTHGBTAATCKYTBTACBGTBCTTTTTGDTAASSWTAAWAARA
+TTGGCTAAGWGRADTYACATAGCTCBTAGATAWAGCAATNGTATMATGTTKMMAGTAWTC
+CCNTSGAAWATWCAAAAMACTGAADNTYGATNAATCCGAYWNCTAACGTTAGAGDTTTTC
+ATCTGGKRTAVGAABVCTGWGBTCTDVGKATTBTCTAAGGVADAAAVWTCTAGGGGAGGG
+TTAGAACAATTAAHTAATNAAATGCATKATCTAAYRTDTCAGSAYTTYHGATRTTWAVTA
+BGNTCDACAGBCCRCAGWCRTCABTGMMAWGMCTCAACCGATRTGBCAVAATCGTDWDAA
+CAYAWAATWCTGGTAHCCCTAAGATAACSCTTAGTGSAACAWTBGTCDTTDGACWDBAAC
+HTTTNGSKTYYAAYGGATNTGATTTAARTTAMBAATCTAAGTBTCATYTAACTTADTGTT
+TCGATACGAAHGGCYATATACCWDTKYATDCSHTDTCAAAATGTGBACTGSCCVGATGTA
+TCMMAGCCTTDAAABAATGAAGAGTAACTHATMGVTTAATAACCCGGTTVSANTGCAATT
+GTGAGATTTAMGTTTAMAAYGCTGACAYAAAAAGGCACAMYTAAGVGGCTGGAABVTACG
+GATTSTYGTBVAKTATWACCGTGTKAGTDTGTATGTTTAAAGGAAAAAGTAACATARAAA
+GGTYCAMNYAAABTATAGNTSATANAGTCATCCTATWADKAACTRGTMSACDGTATSAYT
+AAHSHGTAABYGACTYTATADTGSTATAGAGAAATCGNTAAAGGAAATCAGTTGTNCYMV
+TNACDRTATBNATATASTAGAAMSCGGGANRCKKMCAAACATTNAGTCTRMAATBMTACC
+CGTACTTCTBGDSYAATWGAAAATGACADDCHAKAAAYATATTKTTTTCACANACWAGAA
+AKATCCTTATTAYKHKCTAAACARTATTTTDATBTVWCYGCAATACTAGGKAAASTTDGA
+MGGCHTTHAATVCAHDRYAGGRCTATACGTCMAGAGAGCTBTHGNACARTCCBDCTAAGA
+GCGGCTTTARTAAAGAATCCNAGTAWBTGACTTGAATTACWTVACAGAAABCAATNAAAC
+CGTNTRANTTGAYCMAWBADTANABRGGTKTHTWTAGTTVCTMBKTAGMTVKCCAGCANT
+TVAGSWTTAGCCGCRHTTTCCTTHNTATTAAGAAGAATAGGMTRAARTCTABGTACDTTT
+TATAAVDHAHTATAGATCCTAGTAAGYTWATDWCATGAGGGATAGTAAMDMNGBASTWAM
+TSTATRBAYDABATGTATATYCGCACTGTTTTAACMCWBTATAWAGTATBTSTATVTTAR
+CCTMTTAAKADATCAACTAATYTSVTAKGDATTATGCKTCAYCAKAATACTTKAANGAGT
+ATTSDAGATCGGAAATACTTAAYAAVGTATMCGCTTGTGTDCTAATYTATTTTATTTWAA
+CAGWRCTATGTAGMTGTTTGTTYKTNGTTKTCAGAACNTRACCTACKTGSRATGTGGGGG
+CTGTCATTAAGTAAATNGSTTABCCCCTCGCAGCTCWHTCGCGAAGCAVATGCKACGHCA
+ACAKTTAATAACASAAADATTWNYTGTAATTGTTCGTMHACHTWATGTGCWTTTTGAAHY
+ACTTTGTAYAMSAAACTTAADAAATATAGTABMATATYAATGSGGTAGTTTGTGTBYGGT
+TWSGSVGWMATTDMTCCWWCABTCSVACAGBAATGTTKATBGTCAATAATCTTCTTAAAC
+ARVAATHAGYBWCTRWCABGTWWAATCTAAGTCASTAAAKTAAGVKBAATTBGABACGTA
+AGGTTAAATAAAAACTRMDTWBCTTTTTAATAAAAGATMGCCTACKAKNTBAGYRASTGT
+ASSTCGTHCGAAKTTATTATATTYTTTGTAGAACATGTCAAAACTWTWTHGKTCCYAATA
+AAGTGGAYTMCYTAARCSTAAATWAKTGAATTTRAGTCTSSATACGACWAKAASATDAAA
+TGYYACTSAACAAHAKTSHYARGASTATTATTHAGGYGGASTTTBGAKGATSANAACACD
+TRGSTTRAAAAAAAACAAGARTCVTAGTAAGATAWATGVHAAKATWGAAAAGTYAHVTAC
+TCTGRTGTCAWGATRVAAKTCGCAAVCGASWGGTTRTCSAMCCTAACASGWKKAWDAATG
+ACRCBACTATGTGTCTTCAAAHGSCTATATTTCGTVWAGAAGTAYCKGARAKSGKAGTAN
+TTTCYACATWATGTCTAAAADMDTWCAATSTKDACAMAADADBSAAATAGGCTHAHAGTA
+CGACVGAATTATAAAGAHCCVAYHGHTTTACATSTTTATGNCCMTAGCATATGATAVAAG
+>THREE Homo sapiens frequency
+ATATTTATCTTTTCACTTCCTACATTGGTCAGACCATTATTCGACACGTGGCGTCATTTT
+GTCATACCGGGTAATGTTGGAAACAAAACGTACTGATAAAATACTGAGTTGTAAACTCTA
+ATCAGATAACGCGCTTGGATATTAAGATTCACACAGGGGTTTCGGCTGTAAAAAAACTTG
+TGGAGCTGTTCTGGGACAGATAAGTTGTACCTCGTACTTAGCTAATTAATGAACCAACTG
+ATTACGATAGAACAATTCTGAGGCCGCCAGGACAGCCAAATTTTAATCTTATAAAGCTGG
+AAACAGCCGGTATTAGCTTCTCGCATACTTTGCCTGCATTGGTACCTTACAGATATCAGC
+GTAGTCATATACACCTCGGTCTCAGCTAAGCTTGTATCTCTTAGAGTAGTTCAAAGATAG
+TGGACAATACCTGTGGAATCGATTGCAGATATGGATTTATTTAACTACTGAGTCTCATTC
+ACAAGCTAAGCAAGGAGCACGTTTTGGTGCCGGCATACCGATTTGCTATCATGTCAGCAA
+ATTTGCGTTGTATTCCTAGTTGCACCCATTAAGGCCACACTCCGAACCTAATTATTACAT
+CGCAAAGACATGTACGAAGGACCCGATGTCGAATAGAAGGGAGGACTGTTCATTGGAAGC
+TAGACCAGAGGAATCGCAAAGATGCAACTCTTACAATAAAAATCTAATTTCAGTCAACAC
+GCAATTTCTATAAGGTTTCCGATAATAATGAACCGTCTTCCACAGGGGAATTTGCCATGC
+TCGTAAAAGTAGTTAATCCAAGTAGAAGAAATTTTGATAATGTTTTAAGTTGGCACGAAG
+GAATTCAGAGAGATCTTACCTAACAAAGGCATTAGTAGATGTTCCTTGGTTCACACTCGG
+TCAATCAGAGCACATACTACGGGCGATACCGGGAATGACACAACATCAATGAGATTGTTA
+AGTGAGGTAATTGACTTTAGAGGACTCGATCAGTATACTGTCACTATGAACATCGTATTA
+ATTGTTATCCGATATATACACCACCGATTTGCTTGTGCAAGGTTACAGACCCATTCGATA
+AATACAAACACGGAGCGATATTATTTAAGGAGTGCTGTCTTCAAAAGAATTATTCCCACA
+CCGACATAAGAACTTCGCTCCGTCATTCCAGATTTAAATAACATAACGTAACGCTTTGCT
+GATAACATAACATAACCGAGAATTTGCTTAGGAAATTTGGAGCAATATTGCATTGTTTCT
+CAGTCATCACAAGGCCCGCCAAAGAACTCTGAGAATCAGGATTCAACATGATTGGTAAGA
+CTCTATATATATAACTTAATTCTTGTGTCCGGAGATAGAAAGAGGACGAGAGATACTACG
+AAAGAAAGTGTACTTCGATGTATCAATTCAGACGCCTTCTCTATCATCAACATTATAGGT
+CTCGTATATGCTCGGCGCGATCTGCTTCTCTCCGCCAATAGCCCCATAGTGTATTTCAAG
+CGCAGTAACAGTGAAATCGTTACGAAGGTAGGGATGTTGCTTATAATTGTCGTAACTTAT
+CGCTTATGTATCTTTCAAGAATGAACGGCAGCATATACATACGTTCTACCTTTAGCTACA
+AAGCATCCATATACTCCCTCTCATGATTGAAACTCTTCCCTATTTTGTAGCCAATAGTGA
+AAGCGTATTAGTATAAATTCGTCGGTTTTTCACTCGCAACTGTTATACTCTGCAAACAAA
+CGAAAGCCTCATAGTACAAACCTAAAGCTACATACTTCATCATTGGCAGACCAGTGGCGG
+TATTTCTACGGAAGCATCACTATAGATATAAAGTTTCCCTTCATGTACGTCTGTTAACCA
+TATCACAAGAAACTGCTATCTCTGTCACGTAACAATTCACGCGCCTTATCGCCAAATGTT
+CATATATGCGCGGTATACGTATGAACGAATACTAATTAGTATAACGGAGGATTCACGGGA
+GGGATACTTGGGGCATTTATAAATCGTCTAAAAATTTTCTATCAGCACTTGCGGGTTATA
+GTGGATTACTAGGCAACATAATATTCTGTATTGGTCCAAATGACGCTATAGATAAATTAG
+CAAAATACATTGTTTCCATTTATGTAAGTCGAAACTCCAGGACTCCCGGGAACCAGTTAA
+ACCGTCTGGAAAAGACACATTGTGAGCGGGACTTCAATGATAGCTTTCAATGAGCTTCTC
+ATGCTTGGGGTCTGTACATATATGTTGGCGAAATTATCGTCTGTATTCTGTTATGCTTTG
+ATCATGGGTTATTAGTATAGTGTCCGGTTAAGTACCAATACCGCTAGAGACCCGACCTAA
+GTCGATAACTAACGATCATCGACGTAAGGATCGTCTCGATCAGTACTTCAGTCTAGATCT
+GGGAATAGTAACTCGTTAGTGAACTATGTCGTGTCATAACTCTAAAATGCAATCAAATCT
+TATTATTGAGTATTGATTATATAAAGCATCCGCTTAGCTTTACCCTCAAATGTTATATGC
+AATTTAAAGCGCTTGATATCGTCTACTCAAGTTCAGGTTTCACATGGCCGCAACGTGACG
+TTATTAGAGGTGGGTCATCATCTCTGAGGCTAGTGATGTTGAATACTCATTGAATGGGAA
+GTGGAATACCATGCTCGTAGGTAACAGCATGACCTATAAAATATACTATGGGTGTGTGGT
+AGATCAATATTGTTCAAGCATATCGTAACAATAACGGCTGAAATGTTACTGACATGAAAG
+AGGGAGTCCAAACCATTCTAACAGCTGATCAAGTCGTCTAAAAACGCCTGGTTCAGCCTT
+AAGAGTTATAAGCCAGACAAATTGTATCAATAGAGAATCCGTAAATTCCTCGGCCAACCT
+CTTGCAAAGACATCACTATCAATATACTACCGTGATCTTAATTAGTGAACTTATATAAAT
+ATCTACAACCAGATTCAACGGAAAAGCTTTAGTGGATTAGAAATTGCCAAGAATCACATT
+CATGTGGGTTCGAATGCTTTAGTAATACCATTTCGCCGAGTAGTCACTTCGCTGAACTGT
+CGTAAATTGCTATGACATAATCGAAAAGGATTGTCAAGAGTCGATTACTGCGGACTAATA
+ATCCCCACGGGGGTGGTCTCATGTCTCCCCAGGCGAGTGGGGACGGTTGATAAACACGCT
+GCATCGCGGACTGATGTTCCCAGTATTACATAGTCACATTGGATTGCGAGTAGTCTACCT
+ATTTATGAGCGAGAGATGCCTCTAACTACTTCGACTTTTAAAACCTTTCCACGCCAGTAT
+TCGGCGAAAGGGAAGTATTAAGGGTTGTCATAATTAAGCTGATACCACTTCAGACTTTGC
+TCTACTTCTGTCTTTCATTGGTTTAGTAAAGTCTGTCCATTCGTCGAGACCGTCTTTTGC
+AGCCTCATTCTACCAACTGCTCCGACTCTTAGTCTGCTTCTCCCAGCGTTATAACAAGAG
+GCATTTTGTCATCCTTAAAACAATAATAAAGAACTCGGAGCACTGATATAATGACTGAAT
+TAGAACCGCTTAAAAATACAACGAATAGATAAGACTATCGGATAAGATCTAATATGTAGT
+GATTAAGCCCTTTATTAATTAATAATAGTTACCCTTTCTGATGTAACGCGACATATTACG
+ATTTAGTGGCACGTCTGAATTGCAAAGCAGATCTCTACCCGATTTTTATTATAAATCCCG
+TATACATCTTGACTTGAGTAATTGTTCATCTTTTTATATCTCTTCGTACTACAAATAATT
+AATATCTCAACCCGTATTGTGTGATTCTAATTACCAACAGAATACGAGGAGGTTTTTGCT
+TAGGGCCATATATAATGAATCTATCTCGTTTATTCGCGGAACCCGAGATAACATTACGAT
+GTAACTATTTTAGAGAACTTAATACAAGAAACATTGCTGATTACTCATAACTAAATGCTT
+GGTAATATATCCTCAGTGCCCCTACCATCTTTTACGCAGGGATGTAATTACTTAGGATTC
+ATTGTGTAAGAATTACAATGAACGATGGATATGAAGGCATGTTGCGAGGTGTTCCTTGGT
+ATGTGAAGTTCGCAGGGCAACAAAAATTTCGCAGAATAGGCCTCAAAGTATTGGTAAAGA
+AGACAACTAATCATCACGAGCTTCTGATATCAATACGAACGAGTCCTGTGATGGATGAAA
+GAAAGTCGTATCGAAAATGTCAAGAGTCTGCCCAATGTAACTTACTTCAAAAAATAACGC
+TTCCGCCAAGTACGTTCGAATAAACGTAATTTTAAAAATACATAAGGGGTGTTAGAAAGT
+AAGCGACGGGATATAAGTTAGACTCAAGATTCCGCCGTAAAACGAGACTGATTCCGAAGA
+TTGTTCGTGGATCTGGTCATGACTTTCACTGAGTAAGGAGTTTCGACATATGTCAATAAA
+CACAAAAATAGAAGCTATTCGATCTGAAAAATATTAGGACAAGAAACTATCTCACGCTAG
+CCCAGAATATTCACTCACCCACGGGCGATACTAAAGCACTATATAGTCGCGTGATTACTA
+TACATATGGTACACATAAGAATCACGATCAGGTTCTCAATTTTCAACAATATATGTTTAT
+TTGCATAGGTAATATTAGGCCTTTAAGAGAAGGATGGGTGAGATACTCCGGGGATGGCGG
+CAATAAAGAAAAACACGATATGAGTAATAGGATCCTAATATCTTGGCGAGAGACTTAAGG
+TACGAATTTTGCGCAATCTATTTTTTACTTGGCCAGAATTCATGTATGGTATAAGTACGA
+ACTTTTTTGATCACTTTCATGGCTACCTGATTAGGATAGTTTGAGGAATTTCCCAAATAT
+ACCGATTTAATATACACTAGGGCTTGTCACTTTGAGTCAGAAAAAGAATATAATTACTTA
+GGGTAATGCTGCATACATATTCTTATATTGCAAAGGTTCTCTGGGTAATCTTGAGCCTTC
+ACGATACCTGGTGAAGTGTT
diff --git a/test/pending/shootout/revcomp.scala-2.scala b/test/pending/shootout/revcomp.scala-2.scala
new file mode 100644
index 0000000000..92260ad021
--- /dev/null
+++ b/test/pending/shootout/revcomp.scala-2.scala
@@ -0,0 +1,92 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy
+*/
+
+import java.io._
+import scala.collection.mutable.Stack
+
+object revcomp { 
+
+   val IUB = IUBCodeComplements
+
+   def IUBCodeComplements() = {
+      val code = "ABCDGHKMNRSTVWYabcdghkmnrstvwy".getBytes
+      val comp = "TVGHCDMKNYSABWRTVGHCDMKNYSABWR".getBytes
+      val a: Array[Byte] = new Array( 'z'.toByte )
+
+      for (indexValue <- code zip comp)
+         indexValue match { case Pair(i,v) => a(i) = v }
+
+      a
+   }
+
+
+   type LineStack = Stack[Array[Byte]]
+
+   def main(args: Array[String]) = {
+      val r = new BufferedReader(new InputStreamReader(System.in))
+      val w = new BufferedOutputStream(System.out)
+
+      var lines: LineStack = new Stack
+      var desc = ""
+
+      var line = r.readLine
+      while (line != null) {
+         val c = line.charAt(0)
+         if (c == '>'){
+            if (desc.length > 0){
+               complementReverseWrite(desc, lines, w)
+               lines = new Stack
+            }
+            desc = line
+         } else {
+            if (c != ';') lines += line.getBytes
+         }
+         line = r.readLine
+      }
+      r.close
+
+      if (desc.length > 0) complementReverseWrite(desc, lines, w)
+      w.close
+   } 
+
+
+   def complementReverseWrite(desc: String, lines: LineStack, 
+         w: BufferedOutputStream) = {
+
+      def inplaceComplementReverse(b: Array[Byte]) = {
+         var i = 0 
+         var j = b.length - 1
+         while (i < j){
+            val swap = b(i) 
+            b(i) = IUB( b(j) ) 
+            b(j) = IUB( swap )
+            i = i + 1
+            j = j - 1
+         }
+         if (i == j) b(i) = IUB( b(i) )
+      }
+
+      val nl = '\n'.toByte
+      w.write(desc.getBytes); w.write(nl)
+
+      val n = 60
+      val k = if (lines.isEmpty) 0 else lines.top.length
+      val isSplitLine = k < n
+      var isFirstLine = true
+
+      while (!lines.isEmpty) {
+        val line = lines.pop
+        inplaceComplementReverse(line)
+        
+        if (isSplitLine){
+           if (isFirstLine){ w.write(line); isFirstLine = false }
+           else { w.write(line,0,n-k); w.write(nl); w.write(line,n-k,k) }
+        } 
+        else { w.write(line); w.write(nl) }
+      }
+      if (isSplitLine && !isFirstLine) w.write(nl)
+   }
+
+}
diff --git a/test/pending/shootout/revcomp.scala-2.scala.runner b/test/pending/shootout/revcomp.scala-2.scala.runner
new file mode 100644
index 0000000000..f51d6170c8
--- /dev/null
+++ b/test/pending/shootout/revcomp.scala-2.scala.runner
@@ -0,0 +1,6 @@
+object Test extends Application {
+  for(n <- List(25000,250000,2500000)) {
+    System.setIn(new java.io.FileInputStream(System.getProperty("partest.cwd")+"/revcomp-input"+n+".txt"))
+    revcomp.main(Array(n.toString)) 
+  }
+}
diff --git a/test/pending/shootout/revcomp.scala-3.check b/test/pending/shootout/revcomp.scala-3.check
new file mode 100644
index 0000000000..14d792ade8
--- /dev/null
+++ b/test/pending/shootout/revcomp.scala-3.check
@@ -0,0 +1,171 @@
+>ONE Homo sapiens alu
+CGGAGTCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAAC
+CTCCGCCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACA
+GGCGCGCGCCACCACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCAT
+GTTGGCCAGGCTGGTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAA
+AGTGCTGGGATTACAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTC
+TGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCGCCTCCCGG
+GTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGCGCGCCACC
+ACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGGCCAGGCTG
+GTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTA
+CAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTCTGTCGCCCAGGCT
+GGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCGCCTCCCGGGTTCAAGCGATTC
+TCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGCGCGCCACCACGCCCGGCTAAT
+TTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGGCCAGGCTGGTCTCGAACTCCT
+GACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCA
+CCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGC
+GCGATCTCGGCTCACTGCAACCTCCGCCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCC
+TCCCGAGTAGCTGGGATTACAGGCGCGCGCCACCACGCCCGGCTAATTTTTGTATTTTTA
+GTAGAGACGGGGTTTCACCATGTTGGCCAGGCTGGTCTCGAACTCCTGACCTCAGGTGAT
+CCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACCGCGCCCGGCCT
+TTTTGAGACGGAGTCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTC
+ACTGCAACCTCCGCCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTG
+GGATTACAGGCGCGCGCCACCACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGT
+TTCACCATGTTGGCCAGGCTGGTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGG
+CCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAG
+TCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCG
+CCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGC
+GCGCCACCACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGG
+CCAGGCTGGTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGC
+TGGGATTACAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTCTGTCG
+CCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCGCCTCCCGGGTTCA
+AGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGCGCGCCACCACGCC
+CGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGGCCAGGCTGGTCTC
+GAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGC
+GTGAGCCACCGCGCCCGGCC
+>TWO IUB ambiguity codes
+TAGGDHACHATCRGTRGVTGAGWTATGYTGCTGTCABACDWVTRTAAGAVVAGATTTNDA
+GASMTCTGCATBYTTCAAKTTACMTATTACTTCATARGGYACMRTGTTTTYTATACVAAT
+TTCTAKGDACKADACTATATNTANTCGTTCACGBCGYSCBHTANGGTGATCGTAAAGTAA
+CTATBAAAAGATSTGWATBCSGAKHTTABBAACGTSYCATGCAAVATKTSKTASCGGAAT
+WVATTTNTCCTTCTTCTTDDAGTGGTTGGATACVGTTAYMTMTBTACTTTHAGCTAGBAA
+AAGAGKAAGTTRATWATCAGATTMDDTTTAAAVAAATATTKTCYTAAATTVCNKTTRACG
+ADTATATTTATGATSADSCAATAWAGCGRTAGTGTAAGTGACVGRADYGTGCTACHVSDT
+CTVCARCSYTTAATATARAAAATTTAATTTACDAATTGBACAGTAYAABATBTGCAGBVG
+TGATGGDCAAAATBNMSTTABKATTGGSTCCTAGBTTACTTGTTTAGTTTATHCGATSTA
+AAGTCGAKAAASTGTTTTAWAKCAGATATACTTTTMTTTTGBATAGAGGAGCMATGATRA
+AAGGNCAYDCCDDGAAAGTHGBTAATCKYTBTACBGTBCTTTTTGDTAASSWTAAWAARA
+TTGGCTAAGWGRADTYACATAGCTCBTAGATAWAGCAATNGTATMATGTTKMMAGTAWTC
+CCNTSGAAWATWCAAAAMACTGAADNTYGATNAATCCGAYWNCTAACGTTAGAGDTTTTC
+ATCTGGKRTAVGAABVCTGWGBTCTDVGKATTBTCTAAGGVADAAAVWTCTAGGGGAGGG
+TTAGAACAATTAAHTAATNAAATGCATKATCTAAYRTDTCAGSAYTTYHGATRTTWAVTA
+BGNTCDACAGBCCRCAGWCRTCABTGMMAWGMCTCAACCGATRTGBCAVAATCGTDWDAA
+CAYAWAATWCTGGTAHCCCTAAGATAACSCTTAGTGSAACAWTBGTCDTTDGACWDBAAC
+HTTTNGSKTYYAAYGGATNTGATTTAARTTAMBAATCTAAGTBTCATYTAACTTADTGTT
+TCGATACGAAHGGCYATATACCWDTKYATDCSHTDTCAAAATGTGBACTGSCCVGATGTA
+TCMMAGCCTTDAAABAATGAAGAGTAACTHATMGVTTAATAACCCGGTTVSANTGCAATT
+GTGAGATTTAMGTTTAMAAYGCTGACAYAAAAAGGCACAMYTAAGVGGCTGGAABVTACG
+GATTSTYGTBVAKTATWACCGTGTKAGTDTGTATGTTTAAAGGAAAAAGTAACATARAAA
+GGTYCAMNYAAABTATAGNTSATANAGTCATCCTATWADKAACTRGTMSACDGTATSAYT
+AAHSHGTAABYGACTYTATADTGSTATAGAGAAATCGNTAAAGGAAATCAGTTGTNCYMV
+TNACDRTATBNATATASTAGAAMSCGGGANRCKKMCAAACATTNAGTCTRMAATBMTACC
+CGTACTTCTBGDSYAATWGAAAATGACADDCHAKAAAYATATTKTTTTCACANACWAGAA
+AKATCCTTATTAYKHKCTAAACARTATTTTDATBTVWCYGCAATACTAGGKAAASTTDGA
+MGGCHTTHAATVCAHDRYAGGRCTATACGTCMAGAGAGCTBTHGNACARTCCBDCTAAGA
+GCGGCTTTARTAAAGAATCCNAGTAWBTGACTTGAATTACWTVACAGAAABCAATNAAAC
+CGTNTRANTTGAYCMAWBADTANABRGGTKTHTWTAGTTVCTMBKTAGMTVKCCAGCANT
+TVAGSWTTAGCCGCRHTTTCCTTHNTATTAAGAAGAATAGGMTRAARTCTABGTACDTTT
+TATAAVDHAHTATAGATCCTAGTAAGYTWATDWCATGAGGGATAGTAAMDMNGBASTWAM
+TSTATRBAYDABATGTATATYCGCACTGTTTTAACMCWBTATAWAGTATBTSTATVTTAR
+CCTMTTAAKADATCAACTAATYTSVTAKGDATTATGCKTCAYCAKAATACTTKAANGAGT
+ATTSDAGATCGGAAATACTTAAYAAVGTATMCGCTTGTGTDCTAATYTATTTTATTTWAA
+CAGWRCTATGTAGMTGTTTGTTYKTNGTTKTCAGAACNTRACCTACKTGSRATGTGGGGG
+CTGTCATTAAGTAAATNGSTTABCCCCTCGCAGCTCWHTCGCGAAGCAVATGCKACGHCA
+ACAKTTAATAACASAAADATTWNYTGTAATTGTTCGTMHACHTWATGTGCWTTTTGAAHY
+ACTTTGTAYAMSAAACTTAADAAATATAGTABMATATYAATGSGGTAGTTTGTGTBYGGT
+TWSGSVGWMATTDMTCCWWCABTCSVACAGBAATGTTKATBGTCAATAATCTTCTTAAAC
+ARVAATHAGYBWCTRWCABGTWWAATCTAAGTCASTAAAKTAAGVKBAATTBGABACGTA
+AGGTTAAATAAAAACTRMDTWBCTTTTTAATAAAAGATMGCCTACKAKNTBAGYRASTGT
+ASSTCGTHCGAAKTTATTATATTYTTTGTAGAACATGTCAAAACTWTWTHGKTCCYAATA
+AAGTGGAYTMCYTAARCSTAAATWAKTGAATTTRAGTCTSSATACGACWAKAASATDAAA
+TGYYACTSAACAAHAKTSHYARGASTATTATTHAGGYGGASTTTBGAKGATSANAACACD
+TRGSTTRAAAAAAAACAAGARTCVTAGTAAGATAWATGVHAAKATWGAAAAGTYAHVTAC
+TCTGRTGTCAWGATRVAAKTCGCAAVCGASWGGTTRTCSAMCCTAACASGWKKAWDAATG
+ACRCBACTATGTGTCTTCAAAHGSCTATATTTCGTVWAGAAGTAYCKGARAKSGKAGTAN
+TTTCYACATWATGTCTAAAADMDTWCAATSTKDACAMAADADBSAAATAGGCTHAHAGTA
+CGACVGAATTATAAAGAHCCVAYHGHTTTACATSTTTATGNCCMTAGCATATGATAVAAG
+>THREE Homo sapiens frequency
+ATATTTATCTTTTCACTTCCTACATTGGTCAGACCATTATTCGACACGTGGCGTCATTTT
+GTCATACCGGGTAATGTTGGAAACAAAACGTACTGATAAAATACTGAGTTGTAAACTCTA
+ATCAGATAACGCGCTTGGATATTAAGATTCACACAGGGGTTTCGGCTGTAAAAAAACTTG
+TGGAGCTGTTCTGGGACAGATAAGTTGTACCTCGTACTTAGCTAATTAATGAACCAACTG
+ATTACGATAGAACAATTCTGAGGCCGCCAGGACAGCCAAATTTTAATCTTATAAAGCTGG
+AAACAGCCGGTATTAGCTTCTCGCATACTTTGCCTGCATTGGTACCTTACAGATATCAGC
+GTAGTCATATACACCTCGGTCTCAGCTAAGCTTGTATCTCTTAGAGTAGTTCAAAGATAG
+TGGACAATACCTGTGGAATCGATTGCAGATATGGATTTATTTAACTACTGAGTCTCATTC
+ACAAGCTAAGCAAGGAGCACGTTTTGGTGCCGGCATACCGATTTGCTATCATGTCAGCAA
+ATTTGCGTTGTATTCCTAGTTGCACCCATTAAGGCCACACTCCGAACCTAATTATTACAT
+CGCAAAGACATGTACGAAGGACCCGATGTCGAATAGAAGGGAGGACTGTTCATTGGAAGC
+TAGACCAGAGGAATCGCAAAGATGCAACTCTTACAATAAAAATCTAATTTCAGTCAACAC
+GCAATTTCTATAAGGTTTCCGATAATAATGAACCGTCTTCCACAGGGGAATTTGCCATGC
+TCGTAAAAGTAGTTAATCCAAGTAGAAGAAATTTTGATAATGTTTTAAGTTGGCACGAAG
+GAATTCAGAGAGATCTTACCTAACAAAGGCATTAGTAGATGTTCCTTGGTTCACACTCGG
+TCAATCAGAGCACATACTACGGGCGATACCGGGAATGACACAACATCAATGAGATTGTTA
+AGTGAGGTAATTGACTTTAGAGGACTCGATCAGTATACTGTCACTATGAACATCGTATTA
+ATTGTTATCCGATATATACACCACCGATTTGCTTGTGCAAGGTTACAGACCCATTCGATA
+AATACAAACACGGAGCGATATTATTTAAGGAGTGCTGTCTTCAAAAGAATTATTCCCACA
+CCGACATAAGAACTTCGCTCCGTCATTCCAGATTTAAATAACATAACGTAACGCTTTGCT
+GATAACATAACATAACCGAGAATTTGCTTAGGAAATTTGGAGCAATATTGCATTGTTTCT
+CAGTCATCACAAGGCCCGCCAAAGAACTCTGAGAATCAGGATTCAACATGATTGGTAAGA
+CTCTATATATATAACTTAATTCTTGTGTCCGGAGATAGAAAGAGGACGAGAGATACTACG
+AAAGAAAGTGTACTTCGATGTATCAATTCAGACGCCTTCTCTATCATCAACATTATAGGT
+CTCGTATATGCTCGGCGCGATCTGCTTCTCTCCGCCAATAGCCCCATAGTGTATTTCAAG
+CGCAGTAACAGTGAAATCGTTACGAAGGTAGGGATGTTGCTTATAATTGTCGTAACTTAT
+CGCTTATGTATCTTTCAAGAATGAACGGCAGCATATACATACGTTCTACCTTTAGCTACA
+AAGCATCCATATACTCCCTCTCATGATTGAAACTCTTCCCTATTTTGTAGCCAATAGTGA
+AAGCGTATTAGTATAAATTCGTCGGTTTTTCACTCGCAACTGTTATACTCTGCAAACAAA
+CGAAAGCCTCATAGTACAAACCTAAAGCTACATACTTCATCATTGGCAGACCAGTGGCGG
+TATTTCTACGGAAGCATCACTATAGATATAAAGTTTCCCTTCATGTACGTCTGTTAACCA
+TATCACAAGAAACTGCTATCTCTGTCACGTAACAATTCACGCGCCTTATCGCCAAATGTT
+CATATATGCGCGGTATACGTATGAACGAATACTAATTAGTATAACGGAGGATTCACGGGA
+GGGATACTTGGGGCATTTATAAATCGTCTAAAAATTTTCTATCAGCACTTGCGGGTTATA
+GTGGATTACTAGGCAACATAATATTCTGTATTGGTCCAAATGACGCTATAGATAAATTAG
+CAAAATACATTGTTTCCATTTATGTAAGTCGAAACTCCAGGACTCCCGGGAACCAGTTAA
+ACCGTCTGGAAAAGACACATTGTGAGCGGGACTTCAATGATAGCTTTCAATGAGCTTCTC
+ATGCTTGGGGTCTGTACATATATGTTGGCGAAATTATCGTCTGTATTCTGTTATGCTTTG
+ATCATGGGTTATTAGTATAGTGTCCGGTTAAGTACCAATACCGCTAGAGACCCGACCTAA
+GTCGATAACTAACGATCATCGACGTAAGGATCGTCTCGATCAGTACTTCAGTCTAGATCT
+GGGAATAGTAACTCGTTAGTGAACTATGTCGTGTCATAACTCTAAAATGCAATCAAATCT
+TATTATTGAGTATTGATTATATAAAGCATCCGCTTAGCTTTACCCTCAAATGTTATATGC
+AATTTAAAGCGCTTGATATCGTCTACTCAAGTTCAGGTTTCACATGGCCGCAACGTGACG
+TTATTAGAGGTGGGTCATCATCTCTGAGGCTAGTGATGTTGAATACTCATTGAATGGGAA
+GTGGAATACCATGCTCGTAGGTAACAGCATGACCTATAAAATATACTATGGGTGTGTGGT
+AGATCAATATTGTTCAAGCATATCGTAACAATAACGGCTGAAATGTTACTGACATGAAAG
+AGGGAGTCCAAACCATTCTAACAGCTGATCAAGTCGTCTAAAAACGCCTGGTTCAGCCTT
+AAGAGTTATAAGCCAGACAAATTGTATCAATAGAGAATCCGTAAATTCCTCGGCCAACCT
+CTTGCAAAGACATCACTATCAATATACTACCGTGATCTTAATTAGTGAACTTATATAAAT
+ATCTACAACCAGATTCAACGGAAAAGCTTTAGTGGATTAGAAATTGCCAAGAATCACATT
+CATGTGGGTTCGAATGCTTTAGTAATACCATTTCGCCGAGTAGTCACTTCGCTGAACTGT
+CGTAAATTGCTATGACATAATCGAAAAGGATTGTCAAGAGTCGATTACTGCGGACTAATA
+ATCCCCACGGGGGTGGTCTCATGTCTCCCCAGGCGAGTGGGGACGGTTGATAAACACGCT
+GCATCGCGGACTGATGTTCCCAGTATTACATAGTCACATTGGATTGCGAGTAGTCTACCT
+ATTTATGAGCGAGAGATGCCTCTAACTACTTCGACTTTTAAAACCTTTCCACGCCAGTAT
+TCGGCGAAAGGGAAGTATTAAGGGTTGTCATAATTAAGCTGATACCACTTCAGACTTTGC
+TCTACTTCTGTCTTTCATTGGTTTAGTAAAGTCTGTCCATTCGTCGAGACCGTCTTTTGC
+AGCCTCATTCTACCAACTGCTCCGACTCTTAGTCTGCTTCTCCCAGCGTTATAACAAGAG
+GCATTTTGTCATCCTTAAAACAATAATAAAGAACTCGGAGCACTGATATAATGACTGAAT
+TAGAACCGCTTAAAAATACAACGAATAGATAAGACTATCGGATAAGATCTAATATGTAGT
+GATTAAGCCCTTTATTAATTAATAATAGTTACCCTTTCTGATGTAACGCGACATATTACG
+ATTTAGTGGCACGTCTGAATTGCAAAGCAGATCTCTACCCGATTTTTATTATAAATCCCG
+TATACATCTTGACTTGAGTAATTGTTCATCTTTTTATATCTCTTCGTACTACAAATAATT
+AATATCTCAACCCGTATTGTGTGATTCTAATTACCAACAGAATACGAGGAGGTTTTTGCT
+TAGGGCCATATATAATGAATCTATCTCGTTTATTCGCGGAACCCGAGATAACATTACGAT
+GTAACTATTTTAGAGAACTTAATACAAGAAACATTGCTGATTACTCATAACTAAATGCTT
+GGTAATATATCCTCAGTGCCCCTACCATCTTTTACGCAGGGATGTAATTACTTAGGATTC
+ATTGTGTAAGAATTACAATGAACGATGGATATGAAGGCATGTTGCGAGGTGTTCCTTGGT
+ATGTGAAGTTCGCAGGGCAACAAAAATTTCGCAGAATAGGCCTCAAAGTATTGGTAAAGA
+AGACAACTAATCATCACGAGCTTCTGATATCAATACGAACGAGTCCTGTGATGGATGAAA
+GAAAGTCGTATCGAAAATGTCAAGAGTCTGCCCAATGTAACTTACTTCAAAAAATAACGC
+TTCCGCCAAGTACGTTCGAATAAACGTAATTTTAAAAATACATAAGGGGTGTTAGAAAGT
+AAGCGACGGGATATAAGTTAGACTCAAGATTCCGCCGTAAAACGAGACTGATTCCGAAGA
+TTGTTCGTGGATCTGGTCATGACTTTCACTGAGTAAGGAGTTTCGACATATGTCAATAAA
+CACAAAAATAGAAGCTATTCGATCTGAAAAATATTAGGACAAGAAACTATCTCACGCTAG
+CCCAGAATATTCACTCACCCACGGGCGATACTAAAGCACTATATAGTCGCGTGATTACTA
+TACATATGGTACACATAAGAATCACGATCAGGTTCTCAATTTTCAACAATATATGTTTAT
+TTGCATAGGTAATATTAGGCCTTTAAGAGAAGGATGGGTGAGATACTCCGGGGATGGCGG
+CAATAAAGAAAAACACGATATGAGTAATAGGATCCTAATATCTTGGCGAGAGACTTAAGG
+TACGAATTTTGCGCAATCTATTTTTTACTTGGCCAGAATTCATGTATGGTATAAGTACGA
+ACTTTTTTGATCACTTTCATGGCTACCTGATTAGGATAGTTTGAGGAATTTCCCAAATAT
+ACCGATTTAATATACACTAGGGCTTGTCACTTTGAGTCAGAAAAAGAATATAATTACTTA
+GGGTAATGCTGCATACATATTCTTATATTGCAAAGGTTCTCTGGGTAATCTTGAGCCTTC
+ACGATACCTGGTGAAGTGTT
diff --git a/test/pending/shootout/revcomp.scala-3.scala b/test/pending/shootout/revcomp.scala-3.scala
new file mode 100644
index 0000000000..ae12f0499b
--- /dev/null
+++ b/test/pending/shootout/revcomp.scala-3.scala
@@ -0,0 +1,147 @@
+/* The Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy
+*/
+
+import java.io._
+import scala.collection.mutable.Stack
+
+object revcomp { 
+   def main(args: Array[String]) = {
+      val out = new FastaOutputStream(System.out)
+      val in = new FastaInputStream(System.in)
+
+      out.writeReverseComplement( in.readSequenceStack )
+      out.writeReverseComplement( in.readSequenceStack )
+      out.writeReverseComplement( in.readSequenceStack )
+
+      in.close
+      out.close
+   } 
+}
+
+
+trait FastaByteStream {
+   val nl = '\n'.toByte  
+
+   type Line = Array[Byte]
+   type LineStack = Stack[Line]
+}
+
+
+// extend the Java BufferedInputStream class
+
+final class FastaInputStream(in: InputStream) 
+      extends BufferedInputStream(in) with FastaByteStream {
+
+   val gt = '>'.toByte
+   val sc = ';'.toByte
+
+   def readSequenceStack(): Pair[Line,LineStack] = {
+      var header: Line = null
+      val lines: LineStack = new Stack
+
+      var line = readLine()
+      while (line != null) {
+         val c = line(0)
+         if (c == gt){                       // '>'
+            if (header == null){
+               header = line
+            } else {
+               pos = pos - line.length - 1   // reposition to start of line
+               return Pair(header,lines)
+            }
+         } else {
+            if (c != sc) lines push line       // ';'
+         }
+         line = readLine()
+      }
+      return Pair(header,lines)
+   }
+
+   def readLine() = {
+      var bytes: Line = null
+      if (in == null) bytes
+      else {
+         mark(128)                      // mark the start of the line
+         if (count == 0) read()         // fill buffer
+        
+         var i = markpos
+         while (i < count && buf(i) != nl) i = i + 1
+
+         if (i >= count){               // line extends past end of buffer
+            pos = i; read(); i = pos;   // fill buffer again
+            while (i < count && buf(i) != nl) i = i + 1
+         }
+
+         if (i < count){     
+            bytes = new Array(i - markpos)
+            System.arraycopy(buf, markpos, bytes, 0, i - markpos);
+            pos = i+1
+         }          
+      }
+      bytes
+   }
+}
+
+
+// extend the Java BufferedOutputStream class
+
+final class FastaOutputStream(in: OutputStream) 
+      extends BufferedOutputStream(in) with FastaByteStream {
+
+   private val IUB = IUBCodeComplements
+
+   private def IUBCodeComplements() = {
+      val code = "ABCDGHKMNRSTVWYabcdghkmnrstvwy".getBytes
+      val comp = "TVGHCDMKNYSABWRTVGHCDMKNYSABWR".getBytes
+      val iub: Array[Byte] = new Array( 'z'.toByte )
+
+      for (indexValue <- code zip comp)
+         indexValue match { case Pair(i,v) => iub(i) = v }
+
+      iub
+   }
+
+   def writeReverseComplement(sequence: Pair[Line,LineStack]) = {
+
+      def inplaceComplementReverse(b: Array[Byte]) = {
+         var i = 0 
+         var j = b.length - 1
+         while (i < j){
+            val swap = b(i) 
+            b(i) = IUB( b(j) ) 
+            b(j) = IUB( swap )
+            i = i + 1
+            j = j - 1
+         }
+         if (i == j) b(i) = IUB( b(i) )
+      }
+
+      sequence match {
+         case Pair(header,lines) => {
+
+            write(header); write(nl)
+
+            val k = if (lines.isEmpty) 0 else lines.top.length
+            val LineLength = 60
+            val isSplitLine = k < LineLength
+            var isFirstLine = true
+
+            while (!lines.isEmpty) {
+               val line = lines.pop
+               inplaceComplementReverse(line)
+        
+               if (isSplitLine){
+                  if (isFirstLine){ write(line); isFirstLine = false } 
+                  else { write(line,0,LineLength-k); write(nl); write(line,LineLength-k,k) }
+               } 
+               else { write(line); write(nl) }
+            }
+
+            if (isSplitLine && !isFirstLine) write(nl)
+         }
+      }
+   }
+
+}
diff --git a/test/pending/shootout/revcomp.scala-3.scala.runner b/test/pending/shootout/revcomp.scala-3.scala.runner
new file mode 100644
index 0000000000..f51d6170c8
--- /dev/null
+++ b/test/pending/shootout/revcomp.scala-3.scala.runner
@@ -0,0 +1,6 @@
+object Test extends Application {
+  for(n <- List(25000,250000,2500000)) {
+    System.setIn(new java.io.FileInputStream(System.getProperty("partest.cwd")+"/revcomp-input"+n+".txt"))
+    revcomp.main(Array(n.toString)) 
+  }
+}
diff --git a/test/pending/shootout/sieve.scala b/test/pending/shootout/sieve.scala
new file mode 100644
index 0000000000..b494980ee4
--- /dev/null
+++ b/test/pending/shootout/sieve.scala
@@ -0,0 +1,43 @@
+/* The Computer Language Shootout 
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy (Scala novice)
+*/
+
+object sieve {
+   def main(args: Array[String]) = {
+      var n = toPositiveInt(args);
+      val start = 2;
+      val stop = 8192;
+      val isPrime = new Array[Boolean](stop+1);
+      var count: Int = 0;
+
+      while (n>0) { 
+         count = 0;
+
+         for (i <- Iterator.range(start,stop+1)) 
+            isPrime(i)=true;
+
+         for (i <- Iterator.range(start,stop+1)) {
+            if( isPrime(i) ) {
+               var k = i+i;
+               while (k<=stop) { isPrime(k)=false; k=k+i; }
+               count = count+1;
+            }
+         }
+         n=n-1; 
+      }
+
+      Console.println("Count: " + count);
+   }
+
+
+   private def toPositiveInt(s: Array[String]) = {
+      val i = 
+         try { Integer.parseInt(s(0)); } 
+         catch { case _ => 1 }
+      if (i>0) i; else 1;
+   }
+}
+
+
+
diff --git a/test/pending/shootout/sieve.scala.runner b/test/pending/shootout/sieve.scala.runner
new file mode 100644
index 0000000000..893c3abe90
--- /dev/null
+++ b/test/pending/shootout/sieve.scala.runner
@@ -0,0 +1,3 @@
+object Test extends Application {
+  for(n <- List(300,600,900,1200)) sieve.main(Array(n.toString)) 
+}