%%% Modification of BibTeX style file /usr/local/texlive/2009/texmf-dist/bibtex/bst/base/unsrt.bst
 %%% ... by urlbst, version 0.7 (marked with "% urlbst")
 %%% See <http://purl.org/nxg/dist/urlbst>
 %%% Added webpage entry type, and url and lastchecked fields.
 %%% Added eprint support.
 %%% Added DOI support.
 %%% Added PUBMED support.
 %%% Added hyperref support.
 %%% Original headers follow...
 
 % BibTeX standard bibliography style `unsrt'
 	% version 0.99a for BibTeX versions 0.99a or later, LaTeX version 2.09.
 	% Copyright (C) 1985, all rights reserved.
 	% Copying of this file is authorized only if either
 	% (1) you make absolutely no changes to your copy, including name, or
 	% (2) if you do make changes, you name it something other than
 	% btxbst.doc, plain.bst, unsrt.bst, alpha.bst, and abbrv.bst.
 	% This restriction helps ensure that all standard styles are identical.
 	% The file btxbst.doc has the documentation for this style.
 
 ENTRY
   { address
     author
     booktitle
     chapter
     edition
     editor
     howpublished
     institution
     journal
     key
     month
     note
     number
     organization
     pages
     publisher
     school
     series
     title
     type
     volume
     year
     eprint % urlbst
     doi % urlbst
     pubmed % urlbst
     url % urlbst
     lastchecked % urlbst
   }
   {}
   { label }
 
 INTEGERS { output.state before.all mid.sentence after.sentence after.block }
 
 % urlbst...
 % urlbst constants and state variables
 STRINGS { urlintro
   eprinturl eprintprefix doiprefix doiurl pubmedprefix pubmedurl
   citedstring onlinestring linktextstring
   openinlinelink closeinlinelink }
 INTEGERS { hrefform inlinelinks makeinlinelink
   addeprints adddoiresolver addpubmedresolver }
 FUNCTION {init.urlbst.variables}
 {
   % The following constants may be adjusted by hand, if desired
 
   % The first set allow you to enable or disable certain functionality.
   #1 'addeprints :=         % 0=no eprints; 1=include eprints
   #1 'adddoiresolver :=     % 0=no DOI resolver; 1=include it
   #1 'addpubmedresolver :=     % 0=no PUBMED resolver; 1=include it
   #2 'hrefform :=           % 0=no crossrefs; 1=hypertex xrefs; 2=hyperref refs
   #0 'inlinelinks :=        % 0=URLs explicit; 1=URLs attached to titles
 
   % String constants, which you _might_ want to tweak.
   "URL: " 'urlintro := % prefix before URL; typically "Available from:" or "URL":
   "online" 'onlinestring := % indication that resource is online; typically "online"
   "cited " 'citedstring := % indicator of citation date; typically "cited "
   "[link]" 'linktextstring := % dummy link text; typically "[link]"
   "http://arxiv.org/abs/" 'eprinturl := % prefix to make URL from eprint ref
   "arXiv:" 'eprintprefix := % text prefix printed before eprint ref; typically "arXiv:"
   "http://dx.doi.org/" 'doiurl := % prefix to make URL from DOI
   "doi:" 'doiprefix :=      % text prefix printed before DOI ref; typically "doi:"
   "http://www.ncbi.nlm.nih.gov/pubmed/" 'pubmedurl := % prefix to make URL from PUBMED
   "PMID:" 'pubmedprefix :=      % text prefix printed before PUBMED ref; typically "PMID:"
 
   % The following are internal state variables, not configuration constants,
   % so they shouldn't be fiddled with.
   #0 'makeinlinelink :=     % state variable managed by possibly.setup.inlinelink
   "" 'openinlinelink :=     % ditto
   "" 'closeinlinelink :=    % ditto
 }
 INTEGERS { 
   bracket.state
   outside.brackets
   open.brackets
   within.brackets
   close.brackets
 }
 % ...urlbst to here
 FUNCTION {init.state.consts}
 { #0 'outside.brackets := % urlbst...
   #1 'open.brackets :=
   #2 'within.brackets :=
   #3 'close.brackets := % ...urlbst to here
 
   #0 'before.all :=
   #1 'mid.sentence :=
   #2 'after.sentence :=
   #3 'after.block :=
 }
 
 STRINGS { s t }
 
 % urlbst
 FUNCTION {output.nonnull.original}
 { '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
 }
 
 % urlbst...
 % The following three functions are for handling inlinelink.  They wrap
 % a block of text which is potentially output with write$ by multiple
 % other functions, so we don't know the content a priori.
 % They communicate between each other using the variables makeinlinelink
 % (which is true if a link should be made), and closeinlinelink (which holds
 % the string which should close any current link.  They can be called
 % at any time, but start.inlinelink will be a no-op unless something has
 % previously set makeinlinelink true, and the two ...end.inlinelink functions
 % will only do their stuff if start.inlinelink has previously set
 % closeinlinelink to be non-empty.
 % (thanks to 'ijvm' for suggested code here)
 FUNCTION {uand}
 { 'skip$ { pop$ #0 } if$ } % 'and' (which isn't defined at this point in the file)
 FUNCTION {possibly.setup.inlinelink}
 { makeinlinelink hrefform #0 > uand
     { doi empty$ adddoiresolver uand
         { pubmed empty$ addpubmedresolver uand
             { eprint empty$ addeprints uand
                 { url empty$
                     { "" }
                     { url }
                   if$ }
                 { eprinturl eprint * }
               if$ }
             { pubmedurl pubmed * }
           if$ }
         { doiurl doi * }
       if$
       % an appropriately-formatted URL is now on the stack
       hrefform #1 = % hypertex
         { "\special {html:<a href=" quote$ * swap$ * quote$ * "> }{" * 'openinlinelink :=
           "\special {html:</a>}" 'closeinlinelink := }
         { "\href {" swap$ * "} {" * 'openinlinelink := % hrefform=#2 -- hyperref
           % the space between "} {" matters: a URL of just the right length can cause "\% newline em"
           "}" 'closeinlinelink := }
       if$
       #0 'makeinlinelink :=
       }
     'skip$
   if$ % makeinlinelink
 }
 FUNCTION {add.inlinelink}
 { openinlinelink empty$
     'skip$
     { openinlinelink swap$ * closeinlinelink *
       "" 'openinlinelink :=
       }
   if$
 }
 FUNCTION {output.nonnull}
 { % Save the thing we've been asked to output
   's :=
   % If the bracket-state is close.brackets, then add a close-bracket to
   % what is currently at the top of the stack, and set bracket.state
   % to outside.brackets
   bracket.state close.brackets =
     { "]" *
       outside.brackets 'bracket.state :=
     }
     'skip$
   if$
   bracket.state outside.brackets =
     { % We're outside all brackets -- this is the normal situation.
       % Write out what's currently at the top of the stack, using the
       % original output.nonnull function.
       s
       add.inlinelink
       output.nonnull.original % invoke the original output.nonnull
     }
     { % Still in brackets.  Add open-bracket or (continuation) comma, add the
       % new text (in s) to the top of the stack, and move to the close-brackets
       % state, ready for next time (unless inbrackets resets it).  If we come
       % into this branch, then output.state is carefully undisturbed.
       bracket.state open.brackets =
         { " [" * }
         { ", " * } % bracket.state will be within.brackets
       if$ 
       s * 
       close.brackets 'bracket.state :=
     }
   if$
 }
 
 % Call this function just before adding something which should be presented in 
 % brackets.  bracket.state is handled specially within output.nonnull.
 FUNCTION {inbrackets}
 { bracket.state close.brackets =
     { within.brackets 'bracket.state := } % reset the state: not open nor closed
     { open.brackets 'bracket.state := }
   if$
 }
 
 FUNCTION {format.lastchecked}
 { lastchecked empty$
     { "" }
     { inbrackets citedstring lastchecked * }
   if$
 }
 % ...urlbst to here
 
 FUNCTION {output}
 { duplicate$ empty$
     'pop$
     'output.nonnull
   if$
 }
 
 FUNCTION {output.check}
 { 't :=
   duplicate$ empty$
     { pop$ "empty " t * " in " * cite$ * warning$ }
     'output.nonnull
   if$
 }
 
 FUNCTION {output.bibitem.original} % urlbst (renamed from output.bibitem, so it can be wrapped below)
 { newline$
   "\bibitem{" write$
   cite$ write$
   "}" write$
   newline$
   ""
   before.all 'output.state :=
 }
 
 FUNCTION {fin.entry.original} % urlbst (renamed from fin.entry, so it can be wrapped below)
 { 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 {not}
 {   { #0 }
     { #1 }
   if$
 }
 
 FUNCTION {and}
 {   'skip$
     { pop$ #0 }
   if$
 }
 
 FUNCTION {or}
 {   { pop$ #1 }
     'skip$
   if$
 }
 
 FUNCTION {new.block.checka}
 { empty$
     'skip$
     'new.block
   if$
 }
 
 FUNCTION {new.block.checkb}
 { empty$
   swap$ empty$
   and
     'skip$
     'new.block
   if$
 }
 
 FUNCTION {new.sentence.checka}
 { empty$
     'skip$
     'new.sentence
   if$
 }
 
 FUNCTION {new.sentence.checkb}
 { empty$
   swap$ empty$
   and
     'skip$
     'new.sentence
   if$
 }
 
 FUNCTION {field.or.null}
 { duplicate$ empty$
     { pop$ "" }
     'skip$
   if$
 }
 
 FUNCTION {emphasize}
 { duplicate$ empty$
     { pop$ "" }
     { "{\em " swap$ * "}" * }
   if$
 }
 
 INTEGERS { nameptr namesleft numnames }
 
 FUNCTION {format.names}
 { 's :=
   #1 'nameptr :=
   s num.names$ 'numnames :=
   numnames 'namesleft :=
     { namesleft #0 > }
     { s nameptr "{ff~}{vv~}{ll}{, jj}" format.name$ 't :=
       nameptr #1 >
 	{ namesleft #1 >
 	    { ", " * t * }
 	    { numnames #2 >
 		{ "," * }
 		'skip$
 	      if$
 	      t "others" =
 		{ " et~al." * }
 		{ " and " * t * }
 	      if$
 	    }
 	  if$
 	}
 	't
       if$
       nameptr #1 + 'nameptr :=
       namesleft #1 - 'namesleft :=
     }
   while$
 }
 
 FUNCTION {format.authors}
 { author empty$
     { "" }
     { author format.names }
   if$
 }
 
 FUNCTION {format.editors}
 { editor empty$
     { "" }
     { editor format.names
       editor num.names$ #1 >
 	{ ", editors" * }
 	{ ", editor" * }
       if$
     }
   if$
 }
 
 FUNCTION {format.title}
 { title empty$
     { "" }
     { title "t" change.case$ }
   if$
 }
 
 FUNCTION {n.dashify}
 { '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 {format.date}
 { year empty$
     { month empty$
 	{ "" }
 	{ "there's a month but no year in " cite$ * warning$
 	  month
 	}
       if$
     }
     { month empty$
 	'year
 	{ month " " * year * }
       if$
     }
   if$
 }
 
 FUNCTION {format.btitle}
 { title emphasize
 }
 
 FUNCTION {tie.or.space.connect}
 { duplicate$ text.length$ #3 <
     { "~" }
     { " " }
   if$
   swap$ * *
 }
 
 FUNCTION {either.or.check}
 { empty$
     'pop$
     { "can't use both " swap$ * " fields in " * cite$ * warning$ }
   if$
 }
 
 FUNCTION {format.bvolume}
 { volume empty$
     { "" }
     { "volume" volume tie.or.space.connect
       series empty$
 	'skip$
 	{ " of " * series emphasize * }
       if$
       "volume and number" number either.or.check
     }
   if$
 }
 
 FUNCTION {format.number.series}
 { volume empty$
     { number empty$
 	{ series field.or.null }
 	{ output.state mid.sentence =
 	    { "number" }
 	    { "Number" }
 	  if$
 	  number tie.or.space.connect
 	  series empty$
 	    { "there's a number but no series in " cite$ * warning$ }
 	    { " in " * series * }
 	  if$
 	}
       if$
     }
     { "" }
   if$
 }
 
 FUNCTION {format.edition}
 { edition empty$
     { "" }
     { output.state mid.sentence =
 	{ edition "l" change.case$ " edition" * }
 	{ edition "t" change.case$ " edition" * }
       if$
     }
   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 empty$
     { "" }
     { pages multi.page.check
 	{ "pages" pages n.dashify tie.or.space.connect }
 	{ "page" pages tie.or.space.connect }
       if$
     }
   if$
 }
 
 FUNCTION {format.vol.num.pages}
 { volume field.or.null
   number empty$
     'skip$
     { "(" number * ")" * *
       volume empty$
 	{ "there's a number but no volume in " cite$ * warning$ }
 	'skip$
       if$
     }
   if$
   pages empty$
     'skip$
     { duplicate$ empty$
 	{ pop$ format.pages }
 	{ ":" * pages n.dashify * }
       if$
     }
   if$
 }
 
 FUNCTION {format.chapter.pages}
 { chapter empty$
     'format.pages
     { type empty$
 	{ "chapter" }
 	{ type "l" change.case$ }
       if$
       chapter tie.or.space.connect
       pages empty$
 	'skip$
 	{ ", " * format.pages * }
       if$
     }
   if$
 }
 
 FUNCTION {format.in.ed.booktitle}
 { booktitle empty$
     { "" }
     { editor empty$
 	{ "In " booktitle emphasize * }
 	{ "In " format.editors * ", " * booktitle emphasize * }
       if$
     }
   if$
 }
 
 FUNCTION {empty.misc.check}
 { author empty$ title empty$ howpublished empty$
   month empty$ year empty$ note empty$
   and and and and and
     { "all relevant fields are empty in " cite$ * warning$ }
     'skip$
   if$
 }
 
 FUNCTION {format.thesis.type}
 { type empty$
     'skip$
     { pop$
       type "t" change.case$
     }
   if$
 }
 
 FUNCTION {format.tr.number}
 { type empty$
     { "Technical Report" }
     'type
   if$
   number empty$
     { "t" change.case$ }
     { number tie.or.space.connect }
   if$
 }
 
 FUNCTION {format.article.crossref}
 { key empty$
     { journal empty$
 	{ "need key or journal for " cite$ * " to crossref " * crossref *
 	  warning$
 	  ""
 	}
 	{ "In {\em " journal * "\/}" * }
       if$
     }
     { "In " key * }
   if$
   " \cite{" * crossref * "}" *
 }
 
 FUNCTION {format.crossref.editor}
 { editor #1 "{vv~}{ll}" format.name$
   editor num.names$ duplicate$
   #2 >
     { pop$ " et~al." * }
     { #2 <
 	'skip$
 	{ editor #2 "{ff }{vv }{ll}{ jj}" format.name$ "others" =
 	    { " et~al." * }
 	    { " and " * editor #2 "{vv~}{ll}" format.name$ * }
 	  if$
 	}
       if$
     }
   if$
 }
 
 FUNCTION {format.book.crossref}
 { volume empty$
     { "empty volume in " cite$ * "'s crossref of " * crossref * warning$
       "In "
     }
     { "Volume" volume tie.or.space.connect
       " of " *
     }
   if$
   editor empty$
   editor field.or.null author field.or.null =
   or
     { key empty$
 	{ series empty$
 	    { "need editor, key, or series for " cite$ * " to crossref " *
 	      crossref * warning$
 	      "" *
 	    }
 	    { "{\em " * series * "\/}" * }
 	  if$
 	}
 	{ key * }
       if$
     }
     { format.crossref.editor * }
   if$
   " \cite{" * crossref * "}" *
 }
 
 FUNCTION {format.incoll.inproc.crossref}
 { editor empty$
   editor field.or.null author field.or.null =
   or
     { key empty$
 	{ booktitle empty$
 	    { "need editor, key, or booktitle for " cite$ * " to crossref " *
 	      crossref * warning$
 	      ""
 	    }
 	    { "In {\em " booktitle * "\/}" * }
 	  if$
 	}
 	{ "In " key * }
       if$
     }
     { "In " format.crossref.editor * }
   if$
   " \cite{" * crossref * "}" *
 }
 
 % urlbst...
 % Functions for making hypertext links.
 % In all cases, the stack has (link-text href-url)
 %
 % make 'null' specials
 FUNCTION {make.href.null}
 {
   pop$
 }
 % make hypertex specials
 FUNCTION {make.href.hypertex}
 { 
   "\special {html:<a href=" quote$ *
   swap$ * quote$ * "> }" * swap$ *
   "\special {html:</a>}" *
 }
 % make hyperref specials
 FUNCTION {make.href.hyperref}
 { 
   "\href {" swap$ * "} {\path{" * swap$ * "}}" *
 }
 FUNCTION {make.href}
 { hrefform #2 =
     'make.href.hyperref      % hrefform = 2
     { hrefform #1 =
         'make.href.hypertex  % hrefform = 1
         'make.href.null      % hrefform = 0 (or anything else)
       if$
     }
   if$
 }
 
 % If inlinelinks is true, then format.url should be a no-op, since it's
 % (a) redundant, and (b) could end up as a link-within-a-link.
 FUNCTION {format.url}
 { inlinelinks #1 = url empty$ or
    { "" }
    { hrefform #1 =
        { % special case -- add HyperTeX specials
          urlintro "\url{" url * "}" * url make.href.hypertex * }
        { urlintro "\url{" * url * "}" * }
      if$
    }
   if$
 }
 
 FUNCTION {format.eprint}
 { eprint empty$
     { "" }
     { eprintprefix eprint * eprinturl eprint * make.href }
   if$
 }
 
 FUNCTION {format.doi}
 { doi empty$
     { "" }
     { doiprefix doi * doiurl doi * make.href }
   if$
 }
 
 FUNCTION {format.pubmed}
 { pubmed empty$
     { "" }
     { pubmedprefix pubmed * pubmedurl pubmed * make.href }
   if$
 }
 
 % Output a URL.  We can't use the more normal idiom (something like
 % `format.url output'), because the `inbrackets' within
 % format.lastchecked applies to everything between calls to `output',
 % so that `format.url format.lastchecked * output' ends up with both
 % the URL and the lastchecked in brackets.
 FUNCTION {output.url}
 { url empty$
     'skip$ 
     { new.block 
       format.url output
       format.lastchecked output 
     }
   if$
 }
 
 FUNCTION {output.web.refs}
 {
   new.block
   inlinelinks
     'skip$ % links were inline -- don't repeat them
     {
       output.url
       addeprints eprint empty$ not and
         { format.eprint output.nonnull }
         'skip$
       if$
       adddoiresolver doi empty$ not and
         { format.doi output.nonnull }
         'skip$
       if$
       addpubmedresolver pubmed empty$ not and
         { format.pubmed output.nonnull }
         'skip$
       if$
     }
   if$
 }
 
 % Wrapper for output.bibitem.original.
 % If the URL field is not empty, set makeinlinelink to be true,
 % so that an inline link will be started at the next opportunity
 FUNCTION {output.bibitem}
 { outside.brackets 'bracket.state :=
   output.bibitem.original
   inlinelinks url empty$ not doi empty$ not or pubmed empty$ not or eprint empty$ not or and
     { #1 'makeinlinelink := }
     { #0 'makeinlinelink := }
   if$
 }
 
 % Wrapper for fin.entry.original
 FUNCTION {fin.entry}
 { output.web.refs  % urlbst
   makeinlinelink       % ooops, it appears we didn't have a title for inlinelink
     { possibly.setup.inlinelink % add some artificial link text here, as a fallback
       linktextstring output.nonnull }
     'skip$
   if$
   bracket.state close.brackets = % urlbst
     { "]" * }
     'skip$
   if$
   fin.entry.original
 }
 
 % Webpage entry type.
 % Title and url fields required;
 % author, note, year, month, and lastchecked fields optional
 % See references 
 %   ISO 690-2 http://www.nlc-bnc.ca/iso/tc46sc9/standard/690-2e.htm
 %   http://www.classroom.net/classroom/CitingNetResources.html
 %   http://neal.ctstateu.edu/history/cite.html
 %   http://www.cas.usf.edu/english/walker/mla.html
 % for citation formats for web pages.
 FUNCTION {webpage}
 { output.bibitem
   author empty$
     { editor empty$
         'skip$  % author and editor both optional
         { format.editors output.nonnull }
       if$
     }
     { editor empty$
         { format.authors output.nonnull }
         { "can't use both author and editor fields in " cite$ * warning$ }
       if$
     }
   if$
   new.block
   title empty$ 'skip$ 'possibly.setup.inlinelink if$
   format.title "title" output.check
   inbrackets onlinestring output
   new.block
   year empty$
     'skip$
     { format.date "year" output.check }
   if$
   % We don't need to output the URL details ('lastchecked' and 'url'),
   % because fin.entry does that for us, using output.web.refs.  The only
   % reason we would want to put them here is if we were to decide that
   % they should go in front of the rather miscellaneous information in 'note'.
   new.block
   note output
   fin.entry
 }
 % ...urlbst to here
 
 
 FUNCTION {article}
 { output.bibitem
   format.authors "author" output.check
   new.block
   title empty$ 'skip$ 'possibly.setup.inlinelink if$ % urlbst
   format.title "title" output.check
   new.block
   crossref missing$
     { journal emphasize "journal" output.check
       possibly.setup.inlinelink format.vol.num.pages output% urlbst
       format.date "year" output.check
     }
     { format.article.crossref output.nonnull
       format.pages output
     }
   if$
   new.block
   note output
   fin.entry
 }
 
 FUNCTION {book}
 { output.bibitem
   author empty$
     { format.editors "author and editor" output.check }
     { format.authors output.nonnull
       crossref missing$
 	{ "author and editor" editor either.or.check }
 	'skip$
       if$
     }
   if$
   new.block
   title empty$ 'skip$ 'possibly.setup.inlinelink if$ % urlbst
   format.btitle "title" output.check
   crossref missing$
     { format.bvolume output
       new.block
       format.number.series output
       new.sentence
       publisher "publisher" output.check
       address output
     }
     { new.block
       format.book.crossref output.nonnull
     }
   if$
   format.edition output
   format.date "year" output.check
   new.block
   note output
   fin.entry
 }
 
 FUNCTION {booklet}
 { output.bibitem
   format.authors output
   new.block
   title empty$ 'skip$ 'possibly.setup.inlinelink if$ % urlbst
   format.title "title" output.check
   howpublished address new.block.checkb
   howpublished output
   address output
   format.date output
   new.block
   note output
   fin.entry
 }
 
 FUNCTION {inbook}
 { output.bibitem
   author empty$
     { format.editors "author and editor" output.check }
     { format.authors output.nonnull
       crossref missing$
 	{ "author and editor" editor either.or.check }
 	'skip$
       if$
     }
   if$
   new.block
   title empty$ 'skip$ 'possibly.setup.inlinelink if$ % urlbst
   format.btitle "title" output.check
   crossref missing$
     { format.bvolume output
       format.chapter.pages "chapter and pages" output.check
       new.block
       format.number.series output
       new.sentence
       publisher "publisher" output.check
       address output
     }
     { format.chapter.pages "chapter and pages" output.check
       new.block
       format.book.crossref output.nonnull
     }
   if$
   format.edition output
   format.date "year" output.check
   new.block
   note output
   fin.entry
 }
 
 FUNCTION {incollection}
 { output.bibitem
   format.authors "author" output.check
   new.block
   title empty$ 'skip$ 'possibly.setup.inlinelink if$ % urlbst
   format.title "title" output.check
   new.block
   crossref missing$
     { format.in.ed.booktitle "booktitle" output.check
       format.bvolume output
       format.number.series output
       format.chapter.pages output
       new.sentence
       publisher "publisher" output.check
       address output
       format.edition output
       format.date "year" output.check
     }
     { format.incoll.inproc.crossref output.nonnull
       format.chapter.pages output
     }
   if$
   new.block
   note output
   fin.entry
 }
 
 FUNCTION {inproceedings}
 { output.bibitem
   format.authors "author" output.check
   new.block
   title empty$ 'skip$ 'possibly.setup.inlinelink if$ % urlbst
   format.title "title" output.check
   new.block
   crossref missing$
     { format.in.ed.booktitle "booktitle" output.check
       format.bvolume output
       format.number.series output
       format.pages output
       address empty$
 	{ organization publisher new.sentence.checkb
 	  organization output
 	  publisher output
 	  format.date "year" output.check
 	}
 	{ address output.nonnull
 	  format.date "year" output.check
 	  new.sentence
 	  organization output
 	  publisher output
 	}
       if$
     }
     { format.incoll.inproc.crossref output.nonnull
       format.pages output
     }
   if$
   new.block
   note output
   fin.entry
 }
 
 FUNCTION {conference} { inproceedings }
 
 FUNCTION {manual}
 { output.bibitem
   author empty$
     { organization empty$
 	'skip$
 	{ organization output.nonnull
 	  address output
 	}
       if$
     }
     { format.authors output.nonnull }
   if$
   new.block
   title empty$ 'skip$ 'possibly.setup.inlinelink if$ % urlbst
   format.btitle "title" output.check
   author empty$
     { organization empty$
 	{ address new.block.checka
 	  address output
 	}
 	'skip$
       if$
     }
     { organization address new.block.checkb
       organization output
       address output
     }
   if$
   format.edition output
   format.date output
   new.block
   note output
   fin.entry
 }
 
 FUNCTION {mastersthesis}
 { output.bibitem
   format.authors "author" output.check
   new.block
   title empty$ 'skip$ 'possibly.setup.inlinelink if$ % urlbst
   format.title "title" output.check
   new.block
   "Master's thesis" format.thesis.type output.nonnull
   school "school" output.check
   address output
   format.date "year" output.check
   new.block
   note output
   fin.entry
 }
 
 FUNCTION {misc}
 { output.bibitem
   format.authors output
   title howpublished new.block.checkb
   title empty$ 'skip$ 'possibly.setup.inlinelink if$ % urlbst
   format.title output
   howpublished new.block.checka
   howpublished output
   format.date output
   new.block
   note output
   fin.entry
   empty.misc.check
 }
 
 FUNCTION {phdthesis}
 { output.bibitem
   format.authors "author" output.check
   new.block
   title empty$ 'skip$ 'possibly.setup.inlinelink if$ % urlbst
   format.btitle "title" output.check
   new.block
   "PhD thesis" format.thesis.type output.nonnull
   school "school" output.check
   address output
   format.date "year" output.check
   new.block
   note output
   fin.entry
 }
 
 FUNCTION {proceedings}
 { output.bibitem
   editor empty$
     { organization output }
     { format.editors output.nonnull }
   if$
   new.block
   title empty$ 'skip$ 'possibly.setup.inlinelink if$ % urlbst
   format.btitle "title" output.check
   format.bvolume output
   format.number.series output
   address empty$
     { editor empty$
 	{ publisher new.sentence.checka }
 	{ organization publisher new.sentence.checkb
 	  organization output
 	}
       if$
       publisher output
       format.date "year" output.check
     }
     { address output.nonnull
       format.date "year" output.check
       new.sentence
       editor empty$
 	'skip$
 	{ organization output }
       if$
       publisher output
     }
   if$
   new.block
   note output
   fin.entry
 }
 
 FUNCTION {techreport}
 { output.bibitem
   format.authors "author" output.check
   new.block
   title empty$ 'skip$ 'possibly.setup.inlinelink if$ % urlbst
   format.title "title" output.check
   new.block
   format.tr.number output.nonnull
   institution "institution" output.check
   address output
   format.date "year" output.check
   new.block
   note output
   fin.entry
 }
 
 FUNCTION {unpublished}
 { output.bibitem
   format.authors "author" output.check
   new.block
   title empty$ 'skip$ 'possibly.setup.inlinelink if$ % urlbst
   format.title "title" output.check
   new.block
   note "note" output.check
   format.date output
   fin.entry
 }
 
 FUNCTION {default.type} { misc }
 
 MACRO {jan} {"January"}
 
 MACRO {feb} {"February"}
 
 MACRO {mar} {"March"}
 
 MACRO {apr} {"April"}
 
 MACRO {may} {"May"}
 
 MACRO {jun} {"June"}
 
 MACRO {jul} {"July"}
 
 MACRO {aug} {"August"}
 
 MACRO {sep} {"September"}
 
 MACRO {oct} {"October"}
 
 MACRO {nov} {"November"}
 
 MACRO {dec} {"December"}
 
 MACRO {acmcs} {"ACM Computing Surveys"}
 
 MACRO {acta} {"Acta Informatica"}
 
 MACRO {cacm} {"Communications of the ACM"}
 
 MACRO {ibmjrd} {"IBM Journal of Research and Development"}
 
 MACRO {ibmsj} {"IBM Systems Journal"}
 
 MACRO {ieeese} {"IEEE Transactions on Software Engineering"}
 
 MACRO {ieeetc} {"IEEE Transactions on Computers"}
 
 MACRO {ieeetcad}
  {"IEEE Transactions on Computer-Aided Design of Integrated Circuits"}
 
 MACRO {ipl} {"Information Processing Letters"}
 
 MACRO {jacm} {"Journal of the ACM"}
 
 MACRO {jcss} {"Journal of Computer and System Sciences"}
 
 MACRO {scp} {"Science of Computer Programming"}
 
 MACRO {sicomp} {"SIAM Journal on Computing"}
 
 MACRO {tocs} {"ACM Transactions on Computer Systems"}
 
 MACRO {tods} {"ACM Transactions on Database Systems"}
 
 MACRO {tog} {"ACM Transactions on Graphics"}
 
 MACRO {toms} {"ACM Transactions on Mathematical Software"}
 
 MACRO {toois} {"ACM Transactions on Office Information Systems"}
 
 MACRO {toplas} {"ACM Transactions on Programming Languages and Systems"}
 
 MACRO {tcs} {"Theoretical Computer Science"}
 
 READ
 
 STRINGS { longest.label }
 
 INTEGERS { number.label longest.label.width }
 
 FUNCTION {initialize.longest.label}
 { "" 'longest.label :=
   #1 'number.label :=
   #0 'longest.label.width :=
 }
 
 FUNCTION {longest.label.pass}
 { number.label int.to.str$ 'label :=
   number.label #1 + 'number.label :=
   label width$ longest.label.width >
     { label 'longest.label :=
       label width$ 'longest.label.width :=
     }
     'skip$
   if$
 }
 
 EXECUTE {initialize.longest.label}
 
 ITERATE {longest.label.pass}
 
 FUNCTION {begin.bib}
 { preamble$ empty$
     'skip$
     { preamble$ write$ newline$ }
   if$
   "\begin{thebibliography}{"  longest.label  * "}" * write$ newline$
 }
 
 EXECUTE {begin.bib}
 
 EXECUTE {init.urlbst.variables} % urlbst
 EXECUTE {init.state.consts}
 
 ITERATE {call.type$}
 
 FUNCTION {end.bib}
 { newline$
   "\end{thebibliography}" write$ newline$
 }
 
 EXECUTE {end.bib}