%%  Updated 7 May 2014
%%
%% This is file `ametsoc_2014.bst',
%% generated with the docstrip utility.
%%
%% The original source files were:
%%
%% merlin.mbs  (with options: `ay,nat,nm-rev1,jnrlst,nmlm,x8,m1,keyxyr,dt-beg,yr-com,yrp-col,note-yr,thtit-a,vol-2bf,vnum-sp,volp-com,pgsep-s,num-xser,numser,ser-vol,bkpg-x,pg-bk,pre-edn,agu-doi,doi,edparc,bkedcap,edby,edbyy,blk-tit,in-x,pp,ed,abr,ednx,ord,jabr,eprint,url,url-nt,em-it,nfss,')
%% ----------------------------------------
%% *** Bibliography style for all AMS Journals and BAMS ***
%%
%% Copyright 1994-2005 Patrick W Daly
%% Updated 2014 Nicole Rietmann
% ===============================================================
% IMPORTANT NOTICE:
% This bibliographic style (bst) file has been generated from one or
% more master bibliographic style (mbs) files, listed above.
%
% This generated file can be redistributed and/or modified under the terms
% of the LaTeX Project Public License Distributed from CTAN
% archives in directory macros/latex/base/lppl.txt; either
% version 1 of the License, or any later version.
% ===============================================================
% Name and version information of the main mbs file:
% \ProvidesFile{merlin.mbs}[2005/10/17 4.14 (PWD, AO, DPC)]
%   For use with BibTeX version 0.99a or later
%-------------------------------------------------------------------
% This bibliography style file is intended for texts in ENGLISH
% This is an author-year citation style bibliography. As such, it is
% non-standard LaTeX, and requires a special package file to function properly.
% Such a package is    natbib.sty   by Patrick W. Daly
% The form of the \bibitem entries is
%   \bibitem[Jones et al.(1990)]{key}...
%   \bibitem[Jones et al.(1990)Jones, Baker, and Smith]{key}...
% The essential feature is that the label (the part in brackets) consists
% of the author names, as they should appear in the citation, with the year
% in parentheses following. There must be no space before the opening
% parenthesis!
% With natbib v5.3, a full list of authors may also follow the year.
% In natbib.sty, it is possible to define the type of enclosures that is
% really wanted (brackets or parentheses), but in either case, there must
% be parentheses in the label.
% The \cite command functions as follows:
%   \citet{key} ==>>                Jones et al. (1990)
%   \citet*{key} ==>>               Jones, Baker, and Smith (1990)
%   \citep{key} ==>>                (Jones et al. 1990)
%   \citep*{key} ==>>               (Jones, Baker, and Smith, 1990)
%   \citep[chap. 2]{key} ==>>       (Jones et al. 1990, chap. 2)
%   \citep[e.g.,][]{key} ==>>        (e.g., Jones et al. 1990)
%   \citep[e.g.,][p. 32]{key} ==>>   (e.g., Jones et al., p. 32)
%   \citeauthor{key} ==>>           Jones et al.
%   \citeauthor*{key} ==>>          Jones, Baker, and Smith
%   \citeyear{key} ==>>             1990
%---------------------------------------------------------------------

ENTRY
 { address
   archive
   author
   booktitle
   chapter
   doi
   edition
   editor
   eid
   eprint
   howpublished
   department
   institution
   journal
   key
   month
   note
   number
   organization
   pages
   publisher
   school
   series
   title
   type
   url
   volume
   year
 }
 {}
 { label extra.label sort.label short.list }
INTEGERS { output.state before.all mid.sentence after.sentence after.block }
FUNCTION {init.state.consts}
{ #0 'before.all :=
 #1 'mid.sentence :=
 #2 'after.sentence :=
 #3 'after.block :=
}
STRINGS { s t}
FUNCTION {output.nonnull}
{ 's :=
 output.state mid.sentence =
   { ", " * write$ }
   { output.state after.block =
       { add.period$ write$
         newline$
         "\newblock " write$
       }
       { output.state before.all =
           'write$
           { add.period$ " " * write$ }
         if$
       }
     if$
     mid.sentence 'output.state :=
   }
 if$
 s
}
FUNCTION {output}
{ duplicate$ empty$
   'pop$
   'output.nonnull
 if$
}
FUNCTION {output.check}
{ 't :=
 duplicate$ empty$
   { pop$ "empty " t * " in " * cite$ * warning$ }
   'output.nonnull
 if$
}
FUNCTION {fin.entry}
{ add.period$
 write$
 newline$
}

FUNCTION {new.block}
{ output.state before.all =
   'skip$
   { after.block 'output.state := }
 if$
}
FUNCTION {new.sentence}
{ output.state after.block =
   'skip$
   { output.state before.all =
       'skip$
       { after.sentence 'output.state := }
     if$
   }
 if$
}
FUNCTION {add.blank}
{  " " * before.all 'output.state :=
}

FUNCTION {date.block}
{
 ":" *
 add.blank
}

FUNCTION {not}
{   { #0 }
   { #1 }
 if$
}
FUNCTION {and}
{   'skip$
   { pop$ #0 }
 if$
}
FUNCTION {or}
{   { pop$ #1 }
   'skip$
 if$
}
FUNCTION {new.block.checkb}
{ empty$
 swap$ empty$
 and
   'skip$
   'new.block
 if$
}
FUNCTION {field.or.null}
{ duplicate$ empty$
   { pop$ "" }
   'skip$
 if$
}
FUNCTION {emphasize}
{ duplicate$ empty$
   { pop$ "" }
   { "\textit{" swap$ * "}" * }
 if$
}
FUNCTION {bolden}
{ duplicate$ empty$
   { pop$ "" }
   { "\textbf{" swap$ * "}" * }
 if$
}
FUNCTION {tie.or.space.prefix}
{ duplicate$ text.length$ #3 <
   { "~" }
   { " " }
 if$
 swap$
}

FUNCTION {capitalize}
{ "u" change.case$ "t" change.case$ }

FUNCTION {space.word}
{ " " swap$ * " " * }
% Here are the language-specific definitions for explicit words.
% Each function has a name bbl.xxx where xxx is the English word.
% The language selected here is ENGLISH
FUNCTION {bbl.and}
{ "and"}

FUNCTION {bbl.cand}
{ ", and"}

FUNCTION {bbl.etal}
{ "et~al." }

FUNCTION {bbl.editors}
{ "Eds." }

FUNCTION {bbl.editor}
{ "Ed." }

FUNCTION {bbl.edby}
{ "edited by" }

FUNCTION {bbl.edition}
{ "ed." }

FUNCTION {bbl.volume}
{ "Vol." }

FUNCTION {bbl.of}
{ "of" }

FUNCTION {bbl.number}
{ "No." }

FUNCTION {bbl.nr}
{ "No." }

FUNCTION {bbl.in}
{ "in" }

FUNCTION {bbl.pages}
{ "pp." }

FUNCTION {bbl.page}
{ "p." }

FUNCTION {bbl.chapter}
{ "chap." }

FUNCTION {bbl.techrep}
{ "Tech. Rep." }

FUNCTION {bbl.mthesis}
{ "M.S. thesis" }

FUNCTION {bbl.phdthesis}
{ "Ph.D. thesis" }

FUNCTION {bbl.first}
{ "1st" }

FUNCTION {bbl.second}
{ "2nd" }

FUNCTION {bbl.third}
{ "3rd" }

FUNCTION {bbl.fourth}
{ "4th" }

FUNCTION {bbl.fifth}
{ "5th" }

FUNCTION {bbl.st}
{ "st" }

FUNCTION {bbl.nd}
{ "nd" }

FUNCTION {bbl.rd}
{ "rd" }

FUNCTION {bbl.th}
{ "th" }

MACRO {jan} {"Jan."}

MACRO {feb} {"Feb."}

MACRO {mar} {"Mar."}

MACRO {apr} {"Apr."}

MACRO {may} {"May"}

MACRO {jun} {"Jun."}

MACRO {jul} {"Jul."}

MACRO {aug} {"Aug."}

MACRO {sep} {"Sep."}

MACRO {oct} {"Oct."}

MACRO {nov} {"Nov."}

MACRO {dec} {"Dec."}

FUNCTION {eng.ord}
{ duplicate$ "1" swap$ *
 #-2 #1 substring$ "1" =
    { bbl.th * }
    { duplicate$ #-1 #1 substring$
      duplicate$ "1" =
        { pop$ bbl.st * }
        { duplicate$ "2" =
            { pop$ bbl.nd * }
            { "3" =
                { bbl.rd * }
                { bbl.th * }
              if$
            }
          if$
         }
      if$
    }
  if$
}

MACRO {acmcs} {"ACM Comput. Surv."}

MACRO {acta} {"Acta Inf."}

MACRO {cacm} {"Commun. ACM"}

MACRO {ibmjrd} {"IBM J. Res. Dev."}

MACRO {ibmsj} {"IBM Syst.~J."}

MACRO {ieeese} {"IEEE Trans. Software Eng."}

MACRO {ieeetc} {"IEEE Trans. Comput."}

MACRO {ieeetcad}
{"IEEE Trans. Comput. Aid. Des."}

MACRO {ipl} {"Inf. Process. Lett."}

MACRO {jacm} {"J.~ACM"}

MACRO {jcss} {"J.~Comput. Syst. Sci."}

MACRO {scp} {"Sci. Comput. Program."}

MACRO {sicomp} {"SIAM J. Comput."}

MACRO {tocs} {"ACM Trans. Comput. Syst."}

MACRO {tods} {"ACM Trans. Database Syst."}

MACRO {tog} {"ACM Trans. Graphic."}

MACRO {toms} {"ACM Trans. Math. Software"}

MACRO {toois} {"ACM Trans. Office Inf. Syst."}

MACRO {toplas} {"ACM Trans. Progr. Lang. Syst."}

MACRO {tcs} {"Theor. Comput. Sci."}

FUNCTION {bibinfo.check}
{ swap$
 duplicate$ missing$
   {
     pop$ pop$
     ""
   }
   { duplicate$ empty$
       {
         swap$ pop$
       }
       { swap$
         pop$
       }
     if$
   }
 if$
}
FUNCTION {bibinfo.warn}
{ swap$
 duplicate$ missing$
   {
     swap$ "missing " swap$ * " in " * cite$ * warning$ pop$
     ""
   }
   { duplicate$ empty$
       {
         swap$ "empty " swap$ * " in " * cite$ * warning$
       }
       { swap$
         pop$
       }
     if$
   }
 if$
}
FUNCTION {format.eprint}
{ eprint duplicate$ empty$
   'skip$
   { "\eprint"
     archive empty$
       'skip$
       { "[" * archive * "]" * }
     if$
     "{" * swap$ * "}" *
   }
 if$
}
STRINGS  { bibinfo}
INTEGERS { nameptr namesleft numnames }

FUNCTION {format.names}
{ 'bibinfo :=
 duplicate$ empty$ 'skip$ {
 's :=
 "" 't :=
 #1 'nameptr :=
 s num.names$ 'numnames :=
 numnames 'namesleft :=
   { namesleft #0 > }
   { s nameptr
     duplicate$ #1 >
       { "{f.~}{vv~}{ll}{, jj}" }
       { "{vv~}{ll}{, f.}{, jj}" }
     if$
     format.name$
     bibinfo bibinfo.check
     't :=
     nameptr #1 >
       {
         nameptr #1
         #1 + =
         numnames #8
         > and
           { "others" 't :=
             #1 'namesleft := }
           'skip$
         if$
         namesleft #1 >
           { ", " * t * }
    { t "others" =
 { ", and Coauthors" * }
 { ", and " * t * }
             if$
           }
         if$
       }
       't
     if$
     nameptr #1 + 'nameptr :=
     namesleft #1 - 'namesleft :=
   }
 while$
 } if$
}
FUNCTION {format.names.ed}
{
 'bibinfo :=
 duplicate$ empty$ 'skip$ {
 's :=
 "" 't :=
 #1 'nameptr :=
 s num.names$ 'numnames :=
 numnames 'namesleft :=
   { namesleft #0 > }
   { s nameptr
     "{f.~}{vv~}{ll}{, jj}"
     format.name$
     bibinfo bibinfo.check
     't :=
     nameptr #1 >
       {
         namesleft #1 >
         { ", " * t * }
    { t "others" =
 { " et~al." * }
 { ", and " * t * }
             if$
           }
         if$
       }
       't
     if$
     nameptr #1 + 'nameptr :=
     namesleft #1 - 'namesleft :=
   }
 while$
 } if$
}
FUNCTION {format.key}
{ empty$
   { key field.or.null }
   { "" }
 if$
}

FUNCTION {format.authors}
{ author "author" format.names
}
FUNCTION {get.bbl.editor}
{ editor num.names$ #1 > 'bbl.editors 'bbl.editor if$ }

FUNCTION {format.editors}
{ editor "editor" format.names duplicate$ empty$ 'skip$
   {
     "," *
     " " *
     get.bbl.editor
     capitalize
 % " " swap$ * "," *
     *
   }
 if$
}
FUNCTION {format.conf.pages}
{ pages "pages" bibinfo.check}

FUNCTION {format.book.pages}
{ pages "pages" bibinfo.check
 duplicate$ empty$ 'skip$
   { " " * bbl.pages * }
 if$
}
FUNCTION {format.doi}
{ doi "doi" bibinfo.check
 duplicate$ empty$ 'skip$
   {
     "\doi{" swap$ * "}" *
   }
 if$
}
FUNCTION {format.note}
{
 url empty$
   'skip$
   { "\urlprefix\url{" url * "}" * output }
 if$
note empty$
   { "" }
   { note #1 #1 substring$
     duplicate$ "{" =
       'skip$
       { output.state mid.sentence =
         { "l" }
         { "u" }
       if$
       change.case$
       }
     if$
     note #2 global.max$ substring$ * "note" bibinfo.check
   }
 if$
}

FUNCTION {format.title}
{ title
 duplicate$ empty$ 'skip$
   { "t" change.case$ }
 if$
 "title" bibinfo.check
}
FUNCTION {format.full.names}
{'s :=
"" 't :=
 #1 'nameptr :=
 s num.names$ 'numnames :=
 numnames 'namesleft :=
   { namesleft #0 > }
   { s nameptr
     "{vv~}{ll}" format.name$
     't :=
     nameptr #1 >
       {
         nameptr #1
         #1 + =
         numnames #8
         > and
           { "others" 't :=
             #1 'namesleft := }
           'skip$
         if$
         namesleft #1 >
           { ", " * t * }
           {
             s nameptr "{ll}" format.name$ duplicate$ "others" =
               { 't := }
               { pop$ }
             if$
             t "others" =
               {
                 " " * bbl.etal *
               }
               {
                 numnames #2 >
                   { "," * }
                   'skip$
                 if$
                 ", and "
                  * t *
               }
             if$
           }
         if$
       }
       't
     if$
     nameptr #1 + 'nameptr :=
     namesleft #1 - 'namesleft :=
   }
 while$
}

FUNCTION {author.editor.key.full}
{ author empty$
   { editor empty$
       { key empty$
           { cite$ #1 #3 substring$ }
           'key
         if$
       }
       { editor format.full.names }
     if$
   }
   { author format.full.names }
 if$
}

FUNCTION {author.key.full}
{ author empty$
   { key empty$
        { cite$ #1 #3 substring$ }
         'key
     if$
   }
   { author format.full.names }
 if$
}

FUNCTION {editor.key.full}
{ editor empty$
   { key empty$
        { cite$ #1 #3 substring$ }
         'key
     if$
   }
   { editor format.full.names }
 if$
}

FUNCTION {make.full.names}
{ type$ "book" =
 type$ "inbook" =
 or
   'author.editor.key.full
   { type$ "proceedings" =
       'editor.key.full
       'author.key.full
     if$
   }
 if$
}

FUNCTION {output.bibitem}
{ newline$
 "\bibitem[{" write$
 label write$
 ")" make.full.names duplicate$ short.list =
    { pop$ }
    { * }
  if$
 "}]{" * write$
 cite$ write$
 "}" write$
 newline$
 ""
 before.all 'output.state :=
}

FUNCTION {if.digit}
{ duplicate$ "0" =
 swap$ duplicate$ "1" =
 swap$ duplicate$ "2" =
 swap$ duplicate$ "3" =
 swap$ duplicate$ "4" =
 swap$ duplicate$ "5" =
 swap$ duplicate$ "6" =
 swap$ duplicate$ "7" =
 swap$ duplicate$ "8" =
 swap$ "9" = or or or or or or or or or
}
FUNCTION {n.separate}
{ 't :=
 ""
 #0 'numnames :=
 { t empty$ not }
 { t #-1 #1 substring$ if.digit
     { numnames #1 + 'numnames := }
     { #0 'numnames := }
   if$
   t #-1 #1 substring$ swap$ *
   t #-2 global.max$ substring$ 't :=
   numnames #5 =
     { duplicate$ #1 #2 substring$ swap$
       #3 global.max$ substring$
       "\," swap$ * *
     }
     'skip$
   if$
 }
 while$
}
FUNCTION {n.dashify}
{
 n.separate
 't :=
 ""
   { t empty$ not }
   { t #1 #1 substring$ "-" =
       { t #1 #2 substring$ "--" = not
           { "--" *
             t #2 global.max$ substring$ 't :=
           }
           {   { t #1 #1 substring$ "-" = }
               { "-" *
                 t #2 global.max$ substring$ 't :=
               }
             while$
           }
         if$
       }
       { t #1 #1 substring$ *
         t #2 global.max$ substring$ 't :=
       }
     if$
   }
 while$
}

FUNCTION {word.in}
{ "" }

FUNCTION {format.date}
{ year "year" bibinfo.check duplicate$ empty$
   {
     "empty year in " cite$ * "; set to ????" * warning$
      pop$ "????"
   }
   'skip$
 if$
 extra.label *
 before.all 'output.state :=
 ", " swap$ *
}
FUNCTION {format.btitle}
{ title "title" bibinfo.check
 duplicate$ empty$ 'skip$
   {
     emphasize
   }
 if$
}
FUNCTION {either.or.check}
{ empty$
   'pop$
   { "can't use both " swap$ * " fields in " * cite$ * warning$ }
 if$
}
FUNCTION {format.bvolume}
{ volume empty$
   { "" }
   { bbl.volume volume tie.or.space.prefix
     "volume" bibinfo.check * *
     series "series" bibinfo.check
     duplicate$ empty$ 'pop$
%%% NO ITALIC SERIES        { emphasize ", " * swap$ * }
     {", " * swap$ * }
     if$
     "volume and number" number either.or.check
   }
 if$
}
FUNCTION {format.number.series}
{ volume empty$
   { number empty$
       { series field.or.null }
       { series empty$
           { number "number" bibinfo.check }
           { output.state mid.sentence =
               { bbl.number }
               { bbl.number capitalize }
             if$
             number tie.or.space.prefix "number" bibinfo.check * *
             "," * " " *
             series "series" bibinfo.check *
           }
         if$
       }
     if$
   }
   { "" }
 if$
}
FUNCTION {is.num}
{ chr.to.int$
 duplicate$ "0" chr.to.int$ < not
 swap$ "9" chr.to.int$ > not and
}

FUNCTION {extract.num}
{ duplicate$ 't :=
 "" 's :=
 { t empty$ not }
 { t #1 #1 substring$
   t #2 global.max$ substring$ 't :=
   duplicate$ is.num
     { s swap$ * 's := }
     { pop$ "" 't := }
   if$
 }
 while$
 s empty$
   'skip$
   { pop$ s }
 if$
}

FUNCTION {convert.edition}
{ extract.num "l" change.case$ 's :=
 s "first" = s "1" = or
   { bbl.first 't := }
   { s "second" = s "2" = or
       { bbl.second 't := }
       { s "third" = s "3" = or
           { bbl.third 't := }
           { s "fourth" = s "4" = or
               { bbl.fourth 't := }
               { s "fifth" = s "5" = or
                   { bbl.fifth 't := }
                   { s #1 #1 substring$ is.num
                       { s eng.ord 't := }
                       { edition 't := }
                     if$
                   }
                 if$
               }
             if$
           }
         if$
       }
     if$
   }
 if$
 t
}

FUNCTION {format.edition}
{ edition duplicate$ empty$ 'skip$
   {
     convert.edition
     output.state mid.sentence =
       { "l" }
       { "t" }
     if$ change.case$
     "edition" bibinfo.check
     " " * bbl.edition *
   }
 if$
}
INTEGERS { multiresult }
FUNCTION {multi.page.check}
{ 't :=
 #0 'multiresult :=
   { multiresult not
     t empty$ not
     and
   }
   { t #1 #1 substring$
     duplicate$ "-" =
     swap$ duplicate$ "," =
     swap$ "+" =
     or or
       { #1 'multiresult := }
       { t #2 global.max$ substring$ 't := }
     if$
   }
 while$
 multiresult
}
FUNCTION {format.pages}
{ pages duplicate$ empty$ 'skip$
   { duplicate$ multi.page.check
       {
         n.dashify
       }
       {
       }
     if$
     "pages" bibinfo.check
   }
 if$
}
FUNCTION {format.journal.pages}
{ pages duplicate$ empty$ 'pop$
   { swap$ duplicate$ empty$
       { pop$ pop$ format.pages }
       {
         ", " *
         swap$
         n.dashify
         "pages" bibinfo.check
         *
       }
     if$
   }
 if$
}
FUNCTION {format.journal.eid}
{ eid "eid" bibinfo.check
 duplicate$ empty$ 'pop$
   { swap$ duplicate$ empty$ 'skip$
     {
         ", " *
     }
     if$
     swap$ *
   }
 if$
}
FUNCTION {format.vol.num.pages}
{ volume field.or.null
 duplicate$ empty$ 'skip$
   {
     "volume" bibinfo.check
   }
 if$
 number "number" bibinfo.check duplicate$ empty$ 'skip$
   {
     swap$ duplicate$ empty$
       { "there's a number but no volume in " cite$ * warning$ }
       'skip$
     if$
     swap$
     "~(" swap$ * ")" *
   }
 if$ *
 bolden
 eid empty$
   { format.journal.pages }
   { format.journal.eid }
 if$
}

FUNCTION {format.chapter.pages}
{ chapter empty$
   'format.pages
   { type empty$
       { bbl.chapter }
       { type "l" change.case$
         "type" bibinfo.check
       }
     if$
     chapter tie.or.space.prefix
     "chapter" bibinfo.check
     * *
     pages empty$
       'skip$
       { ", " * format.pages * }
     if$
   }
 if$
}

FUNCTION {format.booktitle}
{
 booktitle "booktitle" bibinfo.check
 emphasize
}
FUNCTION {format.bktitle}
{
 booktitle "booktitle" bibinfo.check
}
FUNCTION {format.in.ed.booktitle}
{ format.booktitle duplicate$ empty$ 'skip$
   {
     editor "editor" format.names.ed duplicate$ empty$ 'pop$
       {
         get.bbl.editor
         swap$ "," *
         " " * swap$ *
         swap$
         "," *
         " " * swap$
         * }
     if$
     word.in swap$ *
   }
 if$
}
FUNCTION {format.thesis.type}
{ type duplicate$ empty$
   'pop$
   { swap$ pop$
     "t" change.case$ "type" bibinfo.check
   }
 if$
}
FUNCTION {format.tr.number}
{ number "number" bibinfo.check
 type duplicate$ empty$
   { pop$ bbl.techrep }
   'skip$
 if$
 "type" bibinfo.check
 swap$ duplicate$ empty$
   { pop$ "t" change.case$ }
   { tie.or.space.prefix * * }
 if$
}
FUNCTION {format.article.crossref}
{
 word.in
 " \cite{" * crossref * "}" *
}
FUNCTION {format.book.crossref}
{ volume duplicate$ empty$
   { "empty volume in " cite$ * "'s crossref of " * crossref * warning$
     pop$ word.in
   }
   { bbl.volume
     capitalize
     swap$ tie.or.space.prefix "volume" bibinfo.check * * bbl.of space.word *
   }
 if$
 " \cite{" * crossref * "}" *
}
FUNCTION {format.incoll.inproc.crossref}
{
 word.in
 " \cite{" * crossref * "}" *
}
FUNCTION {format.org.or.pub}
{ 't :=
 ""
 address empty$ t empty$ and
   'skip$
   {
     t empty$
       { address "address" bibinfo.check *
       }
       { t *
         address empty$
           'skip$
           { ", " * address "address" bibinfo.check * }
         if$
       }
     if$
   }
 if$
}
FUNCTION {format.publisher.address}
{ publisher "publisher" bibinfo.warn format.org.or.pub
}

FUNCTION {format.organization.address}
{ format.org.or.pub organization "organization" bibinfo.check
}

FUNCTION {article}
{ output.bibitem
 format.authors "author" output.check
 author format.key output
 format.date "year" output.check
 date.block
 format.title "title" output.check
 new.sentence
 crossref missing$
   {
     journal
     "journal" bibinfo.check
     emphasize
     "journal" output.check
     format.vol.num.pages output
       format.doi output
   }
   { format.article.crossref output.nonnull
     format.pages output
   }
 if$
 format.note output
 format.eprint output
 fin.entry
}
FUNCTION {book}
{ output.bibitem
 author empty$
   { format.editors "author and editor" output.check
     editor format.key output
     %add.blank
   }
   { format.authors output.nonnull
     crossref missing$
       { "author and editor" editor either.or.check }
       'skip$
     if$
   }
 if$
 format.date "year" output.check
 date.block
 format.btitle "title" output.check
 crossref missing$
   { format.bvolume output
 new.sentence
     format.edition output
     format.number.series output
     format.publisher.address output
   }
   {
 new.sentence
     format.book.crossref output.nonnull
   }
 if$
 format.book.pages output
 format.doi output
 format.note output
 format.eprint output
 fin.entry
}

FUNCTION {booklet}
{ output.bibitem
 format.authors output
 author format.key output
 format.date "year" output.check
 date.block
 format.title "title" output.check
 new.sentence
 howpublished "howpublished" bibinfo.check output
 address "address" bibinfo.check output
 format.book.pages output
 format.doi output
 format.note output
 format.eprint output
 fin.entry
}

FUNCTION {inbook}
{ output.bibitem
 author empty$
   { format.editors "author and editor" output.check
     editor format.key output
   }
   { format.authors output.nonnull
     crossref missing$
       { "author and editor" editor either.or.check }
       'skip$
     if$
   }
 if$
 format.date "year" output.check
 date.block
 format.btitle "title" output.check
 crossref missing$
   {
     format.bvolume output
     format.chapter.pages "chapter and pages" output.check
 new.sentence
     format.edition output
     format.number.series output
     format.publisher.address output
   }
   {
     format.chapter.pages "chapter and pages" output.check
 new.sentence
     format.book.crossref output.nonnull
   }
 if$
 format.doi output
 format.note output
 format.eprint output
 fin.entry
}

FUNCTION {incollection}
{ output.bibitem
 format.authors "author" output.check
 author format.key output
 format.date "year" output.check
 date.block
 format.title "title" output.check
 new.sentence
 crossref missing$
   { format.in.ed.booktitle "booktitle" output.check
      format.bvolume output
      format.number.series output
     format.edition output
     format.publisher.address output
     format.chapter.pages output
   }
   { format.incoll.inproc.crossref output.nonnull
     format.chapter.pages output
   }
 if$
 format.doi output
 format.note output
 format.eprint output
 fin.entry
}
FUNCTION {inproceedings}
{ output.bibitem
 format.authors "author" output.check
 author format.key output
 format.date "year" output.check
 date.block
 format.title "title" output.check
 new.sentence
 crossref missing$
   { format.in.ed.booktitle "booktitle" output.check

     publisher empty$
       { format.organization.address output }
       { format.publisher.address output
         organization "organization" bibinfo.check output

       }
     if$
     format.bvolume output
     howpublished "howpublished" bibinfo.check output
     format.pages output
     format.number.series output
   }
   { format.incoll.inproc.crossref output.nonnull
     format.pages output
   }
 if$
 format.doi output
 format.note output
 format.eprint output
 fin.entry
}
FUNCTION {conference}
{ output.bibitem
 format.authors "author" output.check
 author format.key output
 format.date "year" output.check
 date.block
 format.title "title" output.check
 new.sentence
 crossref missing$
   { format.in.ed.booktitle "booktitle" output.check

     publisher empty$
       { format.organization.address output }
       { format.publisher.address output
         organization "organization" bibinfo.check output
                 }
     if$
     format.bvolume output
     howpublished "howpublished" bibinfo.check output
     format.conf.pages output
     format.number.series output
   }
   { format.incoll.inproc.crossref output.nonnull
     format.conf.pages output
   }
 if$
 format.doi output
 format.note output
 format.eprint output
 fin.entry
}
FUNCTION {manual}
{ output.bibitem
 format.authors output
 author format.key output
 format.date "year" output.check
 date.block
 format.btitle "title" output.check
 new.sentence
 address "address" bibinfo.check output
 organization "organization" bibinfo.check output
 format.edition output
 format.doi output
 format.note output
 format.eprint output
 fin.entry
}

FUNCTION {mastersthesis}
{ output.bibitem
 format.authors "author" output.check
 author format.key output
 format.date "year" output.check
 date.block
 format.title
 "title" output.check
 new.sentence
 bbl.mthesis format.thesis.type output.nonnull
 department "department" bibinfo.warn output
 school "school" bibinfo.warn output
 format.book.pages output
 address "address" bibinfo.check output
 format.doi output
 format.note output
 format.eprint output
 fin.entry
}

FUNCTION {misc}
{ output.bibitem
 format.authors output
 author format.key output
 format.date "year" output.check
 date.block
 format.number.series output
 new.sentence
 format.title output
 new.sentence
 format.publisher.address output
 format.note output
 format.book.pages output
 howpublished "howpublished" bibinfo.check output
 format.doi output
 format.eprint output
 fin.entry
}

FUNCTION {atlas}
{ output.bibitem
 format.authors output "author" output.check
 author format.key output
 format.date "year" output.check
 date.block
 format.number.series output
 new.sentence
 format.btitle "title" output.check
 format.publisher.address output
 format.note output
%  format.book.pages output
 fin.entry
}

FUNCTION {phdthesis}
{ output.bibitem
 format.authors "author" output.check
 author format.key output
 format.date "year" output.check
 date.block
 format.title
 "title" output.check
 new.sentence
 bbl.phdthesis format.thesis.type output.nonnull
 school "school" bibinfo.warn output
 format.book.pages output
 address "address" bibinfo.check output
 format.doi output
 format.note output
 format.eprint output
 fin.entry
}

FUNCTION {proceedings}
{ output.bibitem
 format.editors output
 editor format.key output
 format.date "year" output.check
 date.block
 format.btitle "title" output.check
 format.bvolume output
 format.number.series output
 publisher empty$
   { format.organization.address output }
   { organization "organization" bibinfo.check output
     format.publisher.address output
   }
 if$
 format.doi output
 format.note output
 format.eprint output
 fin.entry
}

FUNCTION {techreport}
{ output.bibitem
 format.authors "author" output.check
 author format.key output
 format.date "year" output.check
 date.block
 format.title
 "title" output.check
 new.sentence
 format.tr.number output.nonnull
 howpublished "howpublished" bibinfo.check output
 institution "institution" bibinfo.warn output
address "address" bibinfo.check output
 format.book.pages output
 new.sentence
 format.doi output
 format.note output
 format.eprint output
 fin.entry
}

FUNCTION {unpublished}
{ output.bibitem
 format.authors "author" output.check
 author format.key output
 format.date "year" output.check
 date.block
 format.title "title" output.check
 format.doi output
 format.note "note" output.check
 format.eprint output
 fin.entry
}

FUNCTION {default.type} { misc }
READ
FUNCTION {sortify}
{ purify$
 "l" change.case$
}
INTEGERS { len }
FUNCTION {chop.word}
{ 's :=
 'len :=
 s #1 len substring$ =
   { s len #1 + global.max$ substring$ }
   's
 if$
}
FUNCTION {format.lab.names}
{ 's :=
 "" 't :=
 s #1 "{vv~}{ll}" format.name$
 s num.names$ duplicate$
 #2 >
   { pop$
     " " * bbl.etal *
   }
   { #2 <
       'skip$
       { s #2 "{ff }{vv }{ll}{ jj}" format.name$ "others" =
           {
             " " * bbl.etal *
           }
           { bbl.and space.word * s #2 "{vv~}{ll}" format.name$
             * }
         if$
       }
     if$
   }
 if$
}

FUNCTION {author.key.label}
{ author empty$
   { key empty$
       { cite$ #1 #3 substring$ }
       'key
     if$
   }
   { author format.lab.names }
 if$
}

FUNCTION {author.editor.key.label}
{ author empty$
   { editor empty$
       { key empty$
           { cite$ #1 #3 substring$ }
           'key
         if$
       }
       { editor format.lab.names }
     if$
   }
   { author format.lab.names }
 if$
}

FUNCTION {editor.key.label}
{ editor empty$
   { key empty$
       { cite$ #1 #3 substring$ }
       'key
     if$
   }
   { editor format.lab.names }
 if$
}

FUNCTION {calc.short.authors}
{ type$ "book" =
 type$ "inbook" =
 or
   'author.editor.key.label
   { type$ "proceedings" =
       'editor.key.label
       'author.key.label
     if$
   }
 if$
 'short.list :=
}

FUNCTION {calc.label}
{ calc.short.authors
 short.list
 "("
 *
 year duplicate$ empty$
 short.list key field.or.null = or
    { pop$ "" }
    'skip$
 if$
 *
 'label :=
}

FUNCTION {sort.format.names}
{ 's :=
 #1 'nameptr :=
 ""
 s num.names$ 'numnames :=
 numnames 'namesleft :=
   { namesleft #0 > }
   { s nameptr
     "{vv{ } }{ll{ }}{  f{ }}{  jj{ }}"
     format.name$ 't :=
     nameptr #1 >
       {
         nameptr #1
         #1 + =
         numnames #8
         > and
           { "others" 't :=
             #1 'namesleft := }
           'skip$
         if$
         "   "  *
         namesleft #1 = t "others" = and
           { "zzzzz" * }
           { t sortify * }
         if$
       }
       { t sortify * }
     if$
     nameptr #1 + 'nameptr :=
     namesleft #1 - 'namesleft :=
   }
 while$
}

FUNCTION {sort.format.title}
{ 't :=
 "A " #2
   "An " #3
     "The " #4 t chop.word
   chop.word
 chop.word
 sortify
 #1 global.max$ substring$
}
FUNCTION {author.sort}
{ author empty$
   { key empty$
       { "to sort, need author or key in " cite$ * warning$
         ""
       }
       { key sortify }
     if$
   }
   { author sort.format.names }
 if$
}
FUNCTION {author.editor.sort}
{ author empty$
   { editor empty$
       { key empty$
           { "to sort, need author, editor, or key in " cite$ * warning$
             ""
           }
           { key sortify }
         if$
       }
       { editor sort.format.names }
     if$
   }
   { author sort.format.names }
 if$
}
FUNCTION {editor.sort}
{ editor empty$
   { key empty$
       { "to sort, need editor or key in " cite$ * warning$
         ""
       }
       { key sortify }
     if$
   }
   { editor sort.format.names }
 if$
}
FUNCTION {presort}
{ calc.label
 label sortify
 "    "
 *
 type$ "book" =
 type$ "inbook" =
 or
   'author.editor.sort
   { type$ "proceedings" =
       'editor.sort
       'author.sort
     if$
   }
 if$
 #1 entry.max$ substring$
 'sort.label :=
 sort.label
 *
 "    "
 *
 title field.or.null
 sort.format.title
 *
 #1 entry.max$ substring$
 'sort.key$ :=
}

ITERATE {presort}
SORT
STRINGS { last.label next.extra }
INTEGERS { last.extra.num number.label }
FUNCTION {initialize.extra.label.stuff}
{ #0 int.to.chr$ 'last.label :=
 "" 'next.extra :=
 #0 'last.extra.num :=
 #0 'number.label :=
}
FUNCTION {forward.pass}
{ last.label label =
   { last.extra.num #1 + 'last.extra.num :=
     last.extra.num int.to.chr$ 'extra.label :=
   }
   { "a" chr.to.int$ 'last.extra.num :=
     "" 'extra.label :=
     label 'last.label :=
   }
 if$
 number.label #1 + 'number.label :=
}
FUNCTION {reverse.pass}
{ next.extra "b" =
   { "a" 'extra.label := }
   'skip$
 if$
 extra.label 'next.extra :=
 extra.label
 duplicate$ empty$
   'skip$
   { "{\natexlab{" swap$ * "}}" * }
 if$
 'extra.label :=
 label extra.label * 'label :=
}
EXECUTE {initialize.extra.label.stuff}
ITERATE {forward.pass}
REVERSE {reverse.pass}
FUNCTION {bib.sort.order}
{ sort.label
 "    "
 *
 year field.or.null sortify
 *
 "    "
 *
 title field.or.null
 sort.format.title
 *
 #1 entry.max$ substring$
 'sort.key$ :=
}
ITERATE {bib.sort.order}
SORT
FUNCTION {begin.bib}
{ preamble$ empty$
   'skip$
   { preamble$ write$ newline$ }
 if$
 "\begin{thebibliography}{" number.label int.to.str$ * "}" *
 write$ newline$
 "\providecommand{\natexlab}[1]{#1}"
 write$ newline$
 "\providecommand{\url}[1]{\texttt{#1}}"
 write$ newline$
"\renewcommand{\UrlFont}{\rmfamily}"
 write$ newline$
 "\providecommand{\urlprefix}{URL }"
 write$ newline$
 "\expandafter\ifx\csname urlstyle\endcsname\relax"
 write$ newline$
 "  \providecommand{\doi}[1]{doi:\discretionary{}{}{}#1}\else"
 write$ newline$
 "  \providecommand{\doi}{doi:\discretionary{}{}{}\begingroup \urlstyle{rm}\Url}\fi"
 write$ newline$
 "\providecommand{\eprint}[2][]{\url{#2}}"
 write$ newline$
}
EXECUTE {begin.bib}
EXECUTE {init.state.consts}
ITERATE {call.type$}
FUNCTION {end.bib}
{ newline$
 "\end{thebibliography}" write$ newline$
}
EXECUTE {end.bib}
%% End of customized bst file
%%
%% End of file `ametsoc_V2.bst'.

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.