Fundamentals of Sequence Analysis, 1998-1999

Lecture 9. RNA folding

In this lecture we'll cover the tools that are available for predicting RNA folds. We'll begin with the simplest tool, which finds potential stem-loop regions, then look at finding slightly more complex patterns with RNABOB, then discuss the Zuker programs, which find folded RNA structures, and finish with a brief mention of the new program Pseudoknot.


Finding Stem-Loop structures

The GCG program Stemloop searches for stem-loop structures using purely geometrical constraints. The following example, from the GCG manual, finds all stem/loops with a stem of at least 10 bases per side, having at least 21 hydrogen bonds, with no less than 3 and no more than 100 bases in the loop. The first menu qualifier directs the output to a file, the second forces the results to be sorted by quality. Only the best two loops from the output file are shown here.

$ stemloop/infile=gb_vi:mcvsatrn5/stem=10/bonds=21/maxloop=100/minloop=3 -
   /menu1=3/menu2=2/default
$ search/window=(0,10) MCVSATRN5.STEM "average"
 Average Match: 1.80  Average Mismatch: 0.00  Nibbling Threshold:  0.50

                           March 11, 1999 09:09  ..

     49 TCTGTCACTCGGC  GGTGTGGGTTACCT    13, 26.0
        | |||||||||||
    102 ACGCAGTGAGTTG  GGCGGCATCGTCCC    28

    106 CGGACTGGGGAC  CGCTGGCTTGCGAGCTATGTCCGCT    12, 24.0
        | || ||||| |                           A
    180 GACTCGCCCCCG  AGTTTACTCGCGCATCACGACTCTC    51

The second loop starts at 106, ends at 180, has a stem of size 12, has 24.0 hydrogen bonds in the stem, and has a loop of 51 nucleotides. Quality is defined as the number of hydrogen bonds, so it too is 24.0. Note that in RNA folding the base pair G-T is allowed. The number of bonds in each possible combination of nucleotides is retrieved from a file.

$ search/remain genrundata:stemloop.cmp  ".."
  A    C    G    T    U   ..
 0.0  0.0  0.0  2.0  2.0  A
      0.0  3.0  0.0  0.0  C
           0.0  1.0  1.0  G
                0.0  0.0  T
                     0.0  U

To change these values, for instance, to penalize some of the more unlikely pairs by making their values negative, make a copy of this file and edit it. Have the program use your modified copy by adding the command line qualifier /DATA=my_stemploop.cmp (or whatever the file is named).


Finding Pseudoknots

Pseudoknots are relatively common in RNA, yet are difficult to detect with the usual pattern search tools. In the following figure, the PDB entry 1KAJ (H Kang , JV Hines , I Tinoco "Conformation of a non-frameshifting RNA pseudoknot from mouse mammary tumor virus." J Mol Biol, 259 (1), 1996, 135-147) has been formatted using the Swiss PDB Viewer program to illustrate a pseudoknot. The two helical regions are colored purple and red, hydrogen bonds are dotted green lines, and the control panel pane shows the order in which the halves of each helix appear in the sequence.

Since the sequence in the paired region is essentially arbitrary, the FindPatterns program may not be used. Instead, use Sean Eddy's RNABOB program, and specify the pattern with a description file. Just be careful not to over interpret the results, as small patterns such as that for the pseudoknot tend to show up fairly frequently. The pseudoknot description file matched 33 sites in 10000bp of randomly shuffled sequence. The description file for the pseudoknot pattern contains these lines:


# pseudoknot description file for RNABOB
h1 s1 h2 s2 h1' s3 h2'
h1 0:0 NNNNN:NNNNN
h2 0:0 NNNN*:*NNNN
s1 0   N[2]
s2 0   N[2]
s3 0   NNN[5]

The first line is a comment. The second line specifies the pattern of core regions which are either h (helix=paired) or s (single stranded). h1 is a paired region, h1' is its complement. The next series of lines specify the allowed pattern for each h or s region. The syntax for these declarations is:


h1 mismatches_on_h1:mismatches_on_h1' pattern_h1:pattern_h1'
s1 mismatches  pattern_h1

If no mismatches are allowed, set those fields to zero. When specifying patterns, A,C,G,T match only themselves, Y,R match pyrimidines or purines, N matches anything, and * matches 0 or 1 N's. NNNN will match any four characters, **** will match zero to four characters. For long gaps, use [15], which is the equivalent of 15 * characters. # at the beginning of a line is a comment.

Here is an example where we use the pseudoknot pattern described above to detect the 1KAJ pseudoknot in a small test file, where it is embedded in random sequence. RNABOB will process both Fasta and GCG formatted sequence files, but it will not read entries from a GCG database. By default the output of the program goes to the screen, here it is redirected with the PIPE command to a file, and then displayed later with the TYPE command.

$  rnabob -h
rnabob - fast RNA pattern searching
    version 2.1 (March 1996), using squid 1.5g (March 1996)
Usage: rnabob [-options]  

  Available options:
     -c:    search both strands of database
     -h:    print short help and usage info
     -q:    quiet: suppress verbose banner and headers
     -s:    skip mode: disallow overlapping matches
     -F:    fancy: show full alignments to pattern
$ type rnabob:testcase.seq
uppercase region is the pseudoknot from the 1KAJ PDB entry

 Testcase.  Length: 78  March 12, 1999 11:39  Type: N  Check: 1927  ..

       1  actgctagct ggcgatcgat cgatcgaGGC GCAGUGGGCU AGCGCCACUC

      51  AAAAGCCCGt agctagtcga tcgatcga
$ pipe -
  rnabob "-qsF" rnabob:pseudoknot.des -
    rnabob:testcase.seq > results.txt
$ type results.txt
          28     59 testcase.Seq
      |GGCGC|AG|TGGGC|TA|GCGCC|ACTCAAAA|GCCCG|

Folding programs

The other programs in the GCG package that predict RNA structures are based on the work of Michael Zuker. These programs attempt to figure out which bases pair with which other bases by finding structures (essentially, lists of paired bases) that minimize the free energy of the system. The programs allow for a considerable amount of preexisting information to be applied as constraints, restricting the folding to only certain conformations. For instance, genetic or chemical modification experiments may show that for a particular RNA sequence, bases 10-20 are single stranded, bases 21 through 30 are paired (but the identity of the region each is paired with is not revealed), and base 31 is paired with base 50. All of these contraints may be applied, so that all folding models produced conform to these known features.

The mechanisms used by the Zuker programs to find the free-energies of RNA loops will not be discussed here. However, it is worth mentioning that the method employed specifically excludes from consideration both base triples and pseudoknots in the region to be folded. There isn't much that can be done to control for base triples, but it is a good idea to run RNABOB over any region that will be folded with the Zuker programs. If possible pseudoknot forming regions are discovered, then it is a good idea to rerun the Zuker programs with those regions forced into a pseudoknot configuration. This reanalysis is not shown here for the test sequence used in this lecture, but is covered in the homework.

$ rnabob "-sqF" rnabob:pseudoknot.des gendocdata:ALUCONS.SEQ
    64     93  Alucons.Seq
|CTTGA|GC|CCAGG|AGT|TCGAG|ACCAG|CCTGG|
   167    191  Alucons.Seq
|CAGCT|A|CTCG|GGA|GGCTG|AGG|CGGG|
   249    278  Alucons.Seq
|CTCCG|GCC|TGGG|CGA|CGGAG|CGAGAC|CCCG|

The GCG package has two RNA folding programs that are derivatives of M. Zuker's programs. The older one is FoldRNA, which finds a single best structure. M. Zuker and P. Stiegler (1981) Nucleics Acid Research 9:133-148, M. Zuker (1989) Methods in Enzymology, 180:262-288. The output of that program is a connect file, which is a text representation of which bases are connected (paired) with which other bases. To plot a connect file, it must be processed by one of the graphics programs Squiggles, Circles, Domes, and Mountains. This set of programs has been, for most uses, replaced by the newer programs MFold and PlotFold, M. Zuker (1989)Science 244:48-52. Only these last two programs will be discussed further.


Step one: finding the energy matrices

MFold reads in an RNA sequence, and calculates from it a series of energy matrices. From these matrices the program PlotFold deduces and displays folded RNA structures. There are invariably many such structures, which differ slightly from each other in conformation, and hence energy. MFold/PlotFold may be used to show as many of these as is desired, starting from the fold with the lowest energy, and working up through folds with higher energies. These other N folds often have energies which are very close to optimal, and these may in fact be closer to the actual fold, then the "best" fold. The older FoldRNA program only finds a single fold. Here is the example for MFold in the GCG manual:

$ mfold/infile=gendocdata:ALUCONS.SEQ/default

The method MFold uses to fold RNA takes on the order of length3 time to complete. This test sequence is 290 bases long, and completes in 52 seconds on our system. MFold will not fold a sequence longer than 1400 bases, which should take around 5834 seconds, or 97 minutes. If an RNA longer than this must be analyzed, break it up into pieces of 1000 bases, with at least a 300 base overlap between successive pieces, and examine each fragment separately. The overlap is required so that the analysis does not miss a stem/loop structure simply because the fragmentation process randomly cut it in half.

The MFold program is CPU intensive, and as just shown, can run for a significant length of time. Therefore, the MFold program should be run as a batch job, by appending the /BATCH qualifier to the command, for any but the shortest of RNA sequences. Note also that the output file it produces (here ALUCONS.MFOLD) can be quite large. You should make a point of deleting these or they will use up your disk quota in short order. The file which MFold produces is unusual for a GCG program in that it contains binary data. This file may be viewed only through the PlotFold program - TYPE or similar commands will not display its contents in a meaningful way.

Some of the more important MFold qualifiers are:

/circular      for a circular molecule
/temp          change the folding temperature, default is 37
/force         force base pairing on start1, end2, size:
               10,49,10    10=>19 pairs with 49=>40
               10,0,10     10=>19 pairs (program decides with what)
/prevent       Opposite of /force, preclude pairing between the ranges
               10,49,10    10=>19 may not pair with 49=>40
               10,0,10     10=>19 may not pair

Step two: viewing the energies and connection statistics

Plotfold is a standard GCG graphics program that accepts as input the output file from MFold. It will display secondary structure predictions in circles, domes, mountains, squiggles, text and connect file formats. Before doing so, it is usually best to use one of the other two graphics modes which display the energy/connection information. Like many of the programs we have covered, the structure output options for MFold/Plotfold will always give a result, but it is only the energy/connection information which may be easily interpreted to show which regions of these predicted structures are likely to be real.

$ tektronix versaterm tt
$ plotfold/infile=ALUCONS.mfold/menu=a/levels=1/default

This creates a dotplot which appears to be similar to that produced by the Dotplot program. However, the interpretation is different. In the conventional dotplot each point indicates a region of similarity, whereas in this dotplot, each point indicates two paired bases. Diagonals perpendicular to the main diagonal indicate possible stem/loop structures, with the center of the loop at the point of intersections. Since in the loop region bases are not paired, these diagonals never extend all the way to the main diagonal.

Examine the row and column that intersect at (70,70), on the diagonal. There is only a single base (dot) above background, at position 94. This means that base 70 only pairs with base 94 in the predicted structures (either optimal or within 5.7 kcal/mole of optimal). Expand or decrease this energy range using the /INCrement command line option (/increment=5.7 is the default.) For instance, here is the graph for an increment twice as large.

$ tektronix versaterm tt
$ plotfold/infile=ALUCONS.mfold/menu=a/levels=1 -
  /increment=11.4/default

It is, however, somewhat painful to do this graphically for all bases. So a second option is provided, called a P-Num plot, which is essentially the above analysis done for each base for you. That is, for each base (drawn horizontally) is plotted the number of different bases that were observed to pair with it in the optimal and near optimal structures. The closer this number is to one (or zero, which is never paired) the smaller is the variation in the structure for that region. Bases with a value of one may have paired in only one structure, or to the same base in all structures.

$ plotfold/infile=ALUCONS.mfold/menu=B/default


Step three: viewing the predicted folds

When PlotFold is run in the other graphics modes it sequentially outputs the optimal and suboptimal structures. The number of structures which will be shown is determined by the /LISTsize qualifier. Be sure to refer to the P-Num plot, produced above, to help determine which regions in any given fold are likely to have the structure shown. To see why this is important, the two best folds are shown for the Squiggles format. Each of the following structure display types has one or more special command line options which you can use to modify the resulting plot, see the online help or manual for more information.


Connect format

All of the other graphic formats start from the connection information, which may be output to a file. The older Domes, Circles, Mountains, and Squiggles programs, as well as some nonGCG programs can read this file format to produce graphics.

$ plotfold/infile=ALUCONS.mfold/menu=H/listsize=1/default
$ extract/head=14 alucons.connect
MFOLD of: Alucons.Seq  Check: 1861 from: 1 to: 290  March 11, 1999 13:05 ..

 Length: 290  Energy: -114.5

    1 G       0    2    0    1
    2 G       1    3    0    2
    3 C       2    4    0    3
    4 C       3    5  160    4
    5 G       4    6  159    5
    6 G       5    7  158    6
    7 G       6    8  157    7
    8 C       7    9  156    8
    9 G       8   10  155    9
   10 C       9   11  154   10

The meaning of the six columns are:

  1. Sequence position for this base.
  2. Name of base.
  3. Sequence position 5' to this base.
  4. Sequence position 3' to this base.
  5. Sequence position paired with this base.
  6. Sequence position for this base. (usually)
A column containing a zero indicates no connection at that position.


Mountains format

In Mountains format horizontal lines connect paired bases, sorted so that those closest to each other are drawn nearest the top of the graph, and those furthest from each other nearest the bottom of the graph. A peak on such a graph represents the base of a loop region (or the top of the stem) and the base of each peak represents the base of a stem region.

$ plotfold/infile=ALUCONS.mfold/menu=E/default


Domes format

In Domes format all bases lie along the horizontal axis of the plot and are connected by half circles. These half circles are layered so that nearest connecting bases are at the inside of the "onion" structure that results.

$ plotfold/infile=ALUCONS.mfold/menu=D/default


Circles format

In Circles format all bases are arrayed around the outside of a circle and then connected with semicircular arcs. It is very similar to Domes format.

$ plotfold/infile=ALUCONS.mfold/menu=C/default


Squiggles format

In Squiggles fromat extended stemloop structures are drawn so that the paried and unpaired bases are clearly indicated. In this mode folds often result in regions overlaying each other. The plot may be rearranged somehat to reduce this effect by using the /pivot qualifier. For instance, /pivot=10,20,40 rotates the structure from bases 10 to 20 by 40 degrees. Up to 10 pivot points may be be specified using /pivot2 /pivot3 and so forth. The sequence may optionally be drawn around the figure, but is not here as the resulting plot is only legible when sent to a very high resolution device, such as a laser printer. In this example the two folds with the lowest energies are drawn, so that you may compare their structures.

$ plotfold/infile=ALUCONS.mfold/menu=F/listsize=2 -
  /seqheight=1.5/default

Like the preceding graphic plots, the squiggles plot is constructed directly from the connection information. The squiggles implementation is a bit complicated, but the basic ideas are straightforward, and since they are not obvious, we should go over them. The program looks at the connect information and uses it to construct polygons. It then looks at each polygon and and sees how many neighboring polygons it has. The program then arranges the neighbors around the center polygon by dividing 360 degrees by the number of neighbors. In an ungapped stem, for instance, each polygon has four sides and two neighbors. So there is a 180 degree rotation around the central polygon from one neighbor to the next. Where three stems come together they are arranged 360 degrees divided by three, which is 120 degrees, apart, for 5 stems there are 72 degrees between neighbors, and so forth. If a polygon has only one neighbor then it is a loop, and is drawn as a regular polygon (although later rotations may distort it a bit.) Lastly, the series of polygon edges connecting two neighboring polygons are drawn as half an ellipse. Take a moment to examine the squiggles plots and you will see all of the properties which were just described.

MFold will not produce a connect file which contains pseudoknots, but you may edit the connect file to represent this configuration. Unfortunately, the graphics method as implemented in Squiggles does not handle pseudoknots correctly. To see what happens, do the homework problems.


Text format

Text format is a lot like Squiggles, but is drawn with bits of text rather than with graphics. Text format is most often used as the starting point for a figure for a paper. It is imported into a wordprocessor or graphics program and then tweaked to achieve the desired final appearance.

$ plotfold/infile=ALUCONS.mfold/menu=G/default
$ type alucons.fold

 FOLDING BASES    1 TO  290 OF Alucons.Seq
 TEMPERATURE  =  37.0  ENERGY  =    -114.5
 
              10         20          30      
----GGC  |       -  G  T       GTAA      AGC 
         CGGGCGCG GC GC CACGCCT      TCCC   A
         GTCCGCGC CG TG GTGCGGG      AGGG   C
AAAAAAA  ^       G  G  -       ----      CTT 
.      160       150        140         40   
 
                                                            50        60        
                                        -------------------C        A GA     -  
                                     GGC                    GAGGCGGG G  TTGCT TG
                                     CCG                    CTCTGCCC C  AGCGA AC
                                        ATTAAAAACATAAAAAACAT        - AG     T  
                                            130       120       110        100  
 
            70        80  
     .....-A       AGTTCG 
            GCCCAGG       
            CGGGTCC      A
     .....AG       GACCAG 
                90        
 
                  170 
         TAA      AGC 
              TCCC   T
              AGGG   A
         ---      CTC 
                      
 
            180       190       200         210       220       230     
              GGC         A GA      --GA       AGG     GC       A  -  T 
                 TGAGGCGGG G  TCGCTT    GCCCGGG   CGGAG  TGCAGTG GC CG G
                 ACTCTGCCC C  AGCGAG    CGGGTCC   GCCTC  ACGTCAC CG GC A
              ---         - AG      GCAG       --G     --       -  C  T 
                  280        270       260         250          240     


The Pseudoknot program

E. Rivas and S. Eddy published a very interesting paper last month which describes a folding program which can correctly deduce the structure of RNAs with very complicated folds, such as pseudoknots.E. Rivas and S. Eddy (1999) J. Mol. Biol 285:2053-2068. The catch is that in order to find pseudoknots the program takes O(n6) time to process, and also requires a lot of memory. In the paper they cite a four hour run time to fold a 100 base RNA on an SGI R10K Origin200. It would probably take at least twice that on our machine. So if you want to run it in that mode, please let me know, and I'll help you set up a batch job to do it. Here is an example where the program runs in a mode similar to that of the Zuker programs, except that it finds only the single best structure. Run times are similar to those for MFold.

$ pseudo -h
knotf2: optimal minimum-energy RNA folding with pseudoknots and coaxial 
energies
         KNOT 1.0 (FEB 1999) using squid 1.5m (Sept 1997)
Usage: knotf2 [-options] 
where options are:
   -h            : print short help and usage info
   -c            : add V6 the time consuming (N^5) coaxials
   -k            : allow pseudoknots
   -o   : direct structure-annotated sequence to 
   -s            : shuffle the sequences
   -t            : print traceback
   -v            : verbose debugging output
$ pseudo -o results.txt  gendocdata:alucons.seq
knotf2: optimal minimum-energy RNA folding with pseudoknots and coaxial energies
        RNAfold_knots 1.0 (FEB 1999) using squid 1.5m (Sept 1997)
---------------------------------------------------
Folding sequences from:  gendocdata:alucons.seq 
---------------------------------------------------
$ type results.txt
NAM  Alucons.Seq
SEQ  +SS
  1 G   G   C   C   G   G   G   C   G   C   G   G   C   G   G   C   U   C   A   C
    0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  
    182 181 180 179 158 157 156 155 154 153 152 150 149 .   147 146 .   145 144 143 

 21 G   C   C   U   G   U   A   A   U   C   C   C   A   G   C   A   C   U   U   C
    20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39  
    142 141 140 139 138 .   .   .   43  42  41  40  .   .   .   .   .   .   .   .   

 41 G   G   G   A   G   G   C   C   G   A   G   G   C   G   G   G   A   G   G   A
    40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57  58  59  
    31  30  29  28  .   137 136 .   115 114 113 112 111 110 109 108 .   107 .   .   

 61 U   U   G   C   U   U   G   A   G   C   C   C   A   G   G   A   G   U   U   C
    60  61  62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  
    104 103 102 101 100 .   .   .   94  93  92  91  90  89  88  .   84  83  .   .   

 81 G   A   G   A   C   C   A   G   C   C   U   G   G   G   C   G   A   C   A   U
    80  81  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96  97  98  99  
    .   .   .   77  76  .   .   .   74  73  72  71  70  69  68  .   .   .   .   .   

101 A   G   C   G   A   G   A   C   C   C   C   G   U   C   U   C   U   A   C   A
    100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 
    64  63  62  61  60  .   .   57  55  54  53  52  51  50  49  48  .   .   .   .   

121 A   A   A   A   A   U   A   C   A   A   A   A   A   U   U   A   G   C   C   G
    120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 
    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   46  45  24  23  

141 G   G   C   G   U   G   G   U   G   G   C   G   C   G   C   G   C   C   U   G
    140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 
    22  21  20  19  18  17  15  14  .   12  11  .   10  9   8   7   6   5   4   .   

161 U   A   A   U   C   C   C   A   G   C   U   A   C   U   C   G   G   G   A   G
    160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 
    .   .   .   178 177 176 175 .   .   .   .   .   .   .   .   166 165 164 163 3   

181 G   C   U   G   A   G   G   C   G   G   G   A   G   G   A   U   C   G   C   U
    180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 
    2   1   0   281 280 279 278 277 276 275 274 .   273 .   .   270 269 268 267 266 

201 U   G   A   G   C   C   C   G   G   G   A   G   G   C   G   G   A   G   G   C
    200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 
    265 .   .   260 259 258 257 256 255 254 .   .   .   252 251 250 249 248 .   .   

221 U   G   C   A   G   U   G   A   G   C   C   G   U   G   A   U   C   G   C   G
    220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 
    .   246 245 244 243 242 241 .   240 239 237 236 .   .   .   .   231 230 .   229 

241 C   C   A   C   U   G   C   A   C   U   C   C   G   G   C   C   U   G   G   G
    240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 
    228 226 225 224 223 222 221 .   217 216 215 214 213 .   209 208 207 206 205 204 

261 C   G   A   C   G   G   A   G   C   G   A   G   A   C   C   C   C   G   U   C
    260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 
    203 .   .   .   .   200 199 198 197 196 195 .   .   192 190 189 188 187 186 185 

281 U   C   A   A   A   A   A   A   A   A
    280 281 282 283 284 285 286 287 288 289 
    184 183 .   .   .   .   .   .   .   .   

----------------------------------------------------------------------
   Log odds score:      139100 
energy (kcal/mol):     -139.10 
  number of pairs:       93.00 
----------------------------------------------------------------------
Allow pseudoknots? NO
----------------------------------------------------------------------
Parameters (energy  units, kcal/mol)
 P1   parameter:          0.00 
 P2   parameter:          0.00 
 P3   parameter:          0.00 
 P4   parameter:          0.00 
 P5   parameter:          4.60 
 P6   parameter:          0.40 
 P10  parameter:          0.10 

To view the output with Squiggles convert this file to connect format. Squiggles demands a certain input format, so the title isn't quite right. If you need to publish it, save the output to a Figure file and edit it. Note that the energy of this optimal model is a lot lower than that from MFold, yet the structure is nearly identical. Presumably this is because the two programs use slightly different energy tables.

A Pseudoknot analysis, allowing pseudoknots of the whole alucons sequence is not shown since it has not been calculated. That's because the expected run time is 2 (we have a slower machine) * 4 hours * 2906/1006 = 4760 hours, or 198 days!

$ selex2connect results.txt results.connect 290 "139.1"
$ squiggles/infile=results.connect"


Next week we'll survey interesting web sites.