The parameters are not used yet.
 type ('term, 'lazy_term, 'reduction, 'ident) tactic =
   | Absurd of loc * 'term
   | Apply of loc * 'term
-  | ApplyS of loc * 'term
+  | ApplyS of loc * 'term * (string * string) list
   | Assumption of loc
   | Auto of loc * (string * string) list
   | Change of loc * ('term, 'lazy_term, 'ident) pattern * 'lazy_term
 
   function
   | Absurd (_, term) -> "absurd" ^ term_pp term
   | Apply (_, term) -> "apply " ^ term_pp term
-  | ApplyS (_, term) -> "applyS " ^ term_pp term
+  | ApplyS (_, term, params) ->
+     "applyS " ^ term_pp term ^
+      String.concat " " 
+        (List.map (fun (k,v) -> if v <> "" then k ^ "=" ^ v else k) params)
   | Auto (_,params) -> "auto " ^ 
       String.concat " " 
         (List.map (fun (k,v) -> if v <> "" then k ^ "=" ^ v else k) params)
 
   match ast with
   | GrafiteAst.Absurd (_, term) -> Tactics.absurd term
   | GrafiteAst.Apply (_, term) -> Tactics.apply term
-  | GrafiteAst.ApplyS (_, term) ->
-     Tactics.applyS ~term ~dbd:(LibraryDb.instance ())
+  | GrafiteAst.ApplyS (_, term, params) ->
+     Tactics.applyS ~term ~params ~dbd:(LibraryDb.instance ())
   | GrafiteAst.Assumption _ -> Tactics.assumption
   | GrafiteAst.Auto (_,params) ->
       AutoTactic.auto_tac ~params ~dbd:(LibraryDb.instance ()) 
 
     | GrafiteAst.Apply (loc, term) ->
         let metasenv,cic = disambiguate_term context metasenv term in
         metasenv,GrafiteAst.Apply (loc, cic)
-    | GrafiteAst.ApplyS (loc, term) ->
+    | GrafiteAst.ApplyS (loc, term, params) ->
         let metasenv,cic = disambiguate_term context metasenv term in
-        metasenv,GrafiteAst.ApplyS (loc, cic)
+        metasenv,GrafiteAst.ApplyS (loc, cic, params)
     | GrafiteAst.Assumption loc ->
         metasenv,GrafiteAst.Assumption loc
     | GrafiteAst.Auto (loc,params) ->
 
         GrafiteAst.Absurd (loc, t)
     | IDENT "apply"; t = tactic_term ->
         GrafiteAst.Apply (loc, t)
-    | IDENT "applyS"; t = tactic_term ->
-        GrafiteAst.ApplyS (loc, t)
+    | IDENT "applyS"; t = tactic_term ; params = 
+        LIST0 [ i = IDENT -> i,"" | i = IDENT ; SYMBOL "="; v = [ v = int ->
+          string_of_int v | v = IDENT -> v ] -> i,v ] ->
+        GrafiteAst.ApplyS (loc, t, params)
     | IDENT "assumption" ->
         GrafiteAst.Assumption loc
     | IDENT "auto"; params = 
 
   | Fail s,tables,cache,maxm -> None,cache
 ;;
 
-let applyS_tac ~dbd ~term =
+let applyS_tac ~dbd ~term ~params =
  ProofEngineTypes.mk_tactic
   (fun status ->
     try 
 
   AutoTypes.flags ->
     (Cic.substitution * Cic.metasenv) list * AutoCache.cache
 
-val applyS_tac: dbd:HMysql.dbd -> term: Cic.term -> ProofEngineTypes.tactic
-
+val applyS_tac:
+ dbd:HMysql.dbd -> term: Cic.term -> params:(string * string) list ->
+  ProofEngineTypes.tactic
 
 (* GENERATED FILE, DO NOT EDIT. STAMP:Thu Sep 28 10:29:58 CEST 2006 *)
 val absurd : term:Cic.term -> ProofEngineTypes.tactic
 val apply : term:Cic.term -> ProofEngineTypes.tactic
-val applyS : dbd:HMysql.dbd -> term:Cic.term -> ProofEngineTypes.tactic
+val applyS :
+  dbd:HMysql.dbd -> term:Cic.term -> params:(string * string) list -> ProofEngineTypes.tactic
 val assumption : ProofEngineTypes.tactic
 val auto :
   params:(string * string) list -> dbd:HMysql.dbd -> ProofEngineTypes.tactic
 
   <!ENTITY LCFtactical "<emphasis><link linkend='grammar.LCFtactical'>LCF-tactical</link></emphasis>">
   <!ENTITY qstring "<emphasis><link linkend='grammar.qstring'>qstring</link></emphasis>">
   <!ENTITY interpretation "<emphasis><link linkend='grammar.interpretation'>interpretation</link></emphasis>">
+  <!ENTITY autoparams "<emphasis><link linkend='grammar.autoparams'>auto_params</link></emphasis>">
 ]>
 
 <?yelp:chunk-depth 3?>
 
   <sect1 id="tac_applyS">
     <title>applyS</title>
     <titleabbrev>applyS</titleabbrev>
-    <para><userinput>applyS t</userinput></para>
+    <para><userinput>applyS t auto_params</userinput></para>
     <para>
       <variablelist>
         <varlistentry role="tactic.synopsis">
           <term>Synopsis:</term>
           <listitem>
-            <para><emphasis role="bold">applyS</emphasis> &sterm;</para>
+            <para><emphasis role="bold">applyS</emphasis> &sterm; &autoparams;</para>
           </listitem>
         </varlistentry>
         <varlistentry>
              Then it closes the current sequent by applying
              <command>t</command> to <command>n</command>
              implicit arguments (that become new sequents).
+             The <command>auto_params</command> parameters are passed
+             directly to <command>auto paramodulation</command>.
             </para>
           </listitem>
         </varlistentry>
   <sect1 id="tac_auto">
     <title>auto</title>
     <titleabbrev>auto</titleabbrev>
-    <para><userinput>auto depth=d width=w paramodulation full</userinput></para>
+    <para><userinput>auto params</userinput></para>
     <para>
       <variablelist>
         <varlistentry role="tactic.synopsis">
           <term>Synopsis:</term>
           <listitem>
-            <para><emphasis role="bold">auto</emphasis> [<emphasis role="bold">depth=</emphasis>&nat;] [<emphasis role="bold">width=</emphasis>&nat;] [<emphasis role="bold">paramodulation</emphasis>] [<emphasis role="bold">full</emphasis>]</para>
+            <para><emphasis role="bold">auto</emphasis> &autoparams;</para>
           </listitem>
         </varlistentry>
         <varlistentry>
           <listitem>
             <para>None, but the tactic may fail finding a proof if every
              proof is in the search space that is pruned away. Pruning is
-             controlled by <command>d</command> and <command>w</command>.
+             controlled by the optional <command>params</command>.
              Moreover, only lemmas whose type signature is a subset of the
              signature of the current sequent are considered. The signature of
-             a sequent is ...TODO</para>
+             a sequent is ...&TODO;</para>
           </listitem>
         </varlistentry>
         <varlistentry>
 
      </tgroup>
     </table>
     </sect2>
+
+    <sect2 id="auto-params">
+    <title>auto-params</title>
+    <para>&TODO;</para>
+    <table frame="topbot" rowsep="0" colsep="0" role="grammar">
+      <title>reduction-kind</title>
+      <tgroup cols="4">
+      <tbody>
+       <row>
+       <entry id="grammar.autoparams">&autoparams;</entry>
+       <entry>::=</entry>
+        <entry><emphasis role="bold">depth=&nat;</emphasis></entry>
+        <entry>&TODO;</entry>
+       </row>
+       <row>
+        <entry/>
+        <entry>|</entry>
+        <entry><emphasis role="bold">width=&nat;</emphasis></entry>
+        <entry>&TODO;</entry>
+       </row>
+       <row>
+        <entry/>
+        <entry>|</entry>
+        <entry><emphasis role="bold">&TODO;</emphasis></entry>
+        <entry>&TODO;</entry>
+       </row>
+      </tbody>
+     </tgroup>
+    </table>
+    </sect2>
   </sect1>
 
 </chapter>