header:
  - name: ['Name', ['rowname']]
  - Inp: ['Input ranges<a href="#fn-stagger" class="fn-ref">*</a>', ['Inp']]
  - Acc: ['Accumu&shy;lator', ['Acc']]
  - Ret: ['Returns<a href="#fn-position" class="fn-ref">&target;</a>', ['Ret']]
  - Ops: ['Operations<a href="#fn-opabbrs" class="fn-ref">&dagger;</a>', ['Ops']]
  - Def: ['Default operations', ['Def']]
  - Cpx: ['Compl&shy;exity', ['Cpx']]
  - Dir: ['Order<a href="#fn-order" class="fn-ref">&ddagger;</a>', ['Dir']]
  - Cmp: ['Compare to', ['Cmp']]
  - Family: ['Family', ['Family', 'hidden']]

data:
  - name: '{std:inner_@product}'
    id: 'std:inner_product'
    Inp: '2{^&darr;I|FN:raccess}'
    Acc: 'Arg'
    Ret: 'Value'
    Ops: 'A, bT'
    Def: '{std:plus}, {std:multiplies}'
    Cpx: 'Unspc.'
    Dir: 'Fwd.'
    Cmp: '{#std:transform_@reduce}'
    Family: '10'
  - name: '{CH:adjacent_@reduce}{&rtrif;|YT:sEvYmb3eKsw?t=}'
    id: 'CH:adjacent_reduce'
    Inp: '1s{^&darr;F|FN:raccess}'
    Acc: 'Arg'
    Ret: 'Value'
    Ops: 'A, bT'
    Def: ''
    Cpx: 'Unspc.'
    Dir: 'Fwd.'
    Cmp: '{#std:inner_@product}'
    Family: '10'

  - name: '{std:transform_@reduce}'
    id: 'std:transform_reduce'
    Inp: '1{^&darr;I,&par;F|FN:raccess} / 2{^&darr;I,&par;F|FN:raccess}'
    Acc: 'Arg'
    Ret: 'Value'
    Ops: 'acR, uT / bT'
    Def: '{std:plus}, {std:multiplies}'
    Cpx: 'O(N)'
    Dir: '{&par;|FN:par}'
    Cmp: ''
    Family: '20'

  - name: '{std:find}'
    id: 'std:find'
    Inp: '1{^&darr;I,&par;F|FN:raccess}+Value'
    Acc: ''
    Ret: 'Position'
    Ops: ''
    Def: '{std:equal_to}'
    Cpx: 'O(N)'
    Dir: 'S/C, {&par;|FN:par}'
    Cmp: ''
    Family: '70'
  - name: '{std:find_if}, {std:find_@if_not}'
    id: 'std:find_if'
    Inp: '1{^&darr;I,&par;F|FN:raccess}'
    Acc: ''
    Ret: 'Position'
    Ops: 'uP'
    Def: ''
    Cpx: 'O(N)'
    Dir: 'S/C, {&par;|FN:par}'
    Cmp: ''
    Family: '70'
  - name: '{std:find_@first_of}'
    id: 'std:find_first_of'
    Inp: '1{^&darr;I,&par;F|FN:raccess} + 1{^&darr;F|FN:raccess}'
    Acc: ''
    Ret: 'Position'
    Ops: 'bP'
    Def: '{std:equal_to}'
    Cpx: 'O(S×N)'
    Dir: 'S/C, {&par;|FN:par}'
    Cmp: '{#std:find_if}'
    Family: '70'

  - name: '{std:min_@element}, {std:max_@element}'
    id: 'std:min_element'
    Inp: '1{^&darr;F|FN:raccess}'
    Acc: 'First'
    Ret: 'Position'
    Ops: 'bP'
    Def: '{std:less}'
    Cpx: 'O(N), =(max(N-1, 0))'
    Dir: 'Fwd., {&par;|FN:par}'
    Cmp: ''
    Family: '72'
  - name: '{std:minmax_@element}'
    id: 'std:minmax_element'
    Inp: '1{^&darr;F|FN:raccess}'
    Acc: 'First'
    Ret: '2 Positions{^&target;|FN:position}'
    Ops: 'bP'
    Def: '{std:less}'
    Cpx: 'O(N), &leq;(max(floor((3/2)*(N−1)), 0))'
    Dir: 'Fwd., {&par;|FN:par}'
    Cmp: ''
    Family: '72'

  - name: '{std:lower_@bound}, {std:upper_@bound}'
    id: 'std:lower_bound'
    Inp: '1{^&darr;F|FN:raccess}+Value'
    Acc: ''
    Ret: 'Position'
    Ops: 'bP'
    Def: '{std:less}'
    Cpx: 'O(log N) + O(1){^&darr;R|FN:raccess}; O(N)'
    Dir: 'B/S'
    Cmp: ''
    Family: '75'
  - name: '{std:equal_@range}'
    id: 'std:equal_range'
    Inp: '1{^&darr;F|FN:raccess}+Value'
    Acc: ''
    Ret: 'Range{^&target;|FN:position}'
    Ops: 'bP'
    Def: '{std:less}'
    Cpx: 'O(log N) + O(1){^&darr;R|FN:raccess}; O(N)'
    Dir: 'B/S'
    Cmp: ''
    Family: '75'

  - name: '{std:search}'
    id: 'std:search'
    Inp: '2{^&darr;F|FN:raccess}'
    Acc: ''
    Ret: 'Position'
    Ops: 'bP'
    Def: '{std:equal_to}'
    Cpx: '&leq;(S×N)'
    Dir: '{&par;|FN:par}'
    Cmp: ''
    Family: '80'
  - name: '{std:find_end}'
    id: 'std:find_end'
    Inp: '2{^&darr;F|FN:raccess}'
    Acc: ''
    Ret: 'Position'
    Ops: 'bP'
    Def: '{std:equal_to}'
    Cpx: '&leq;(S×(N-S+1))'
    Dir: '{&par;|FN:par}'
    Cmp: '{#std:search}'
    Family: '80'
  - name: '{kblib:starts_@with}'
    id: 'kblib:starts_with'
    Inp: '2{^&darr;F|FN:raccess}'
    Acc: ''
    Ret: '{:bool}'
    Ops: 'bP'
    Def: '{std:equal_to}'
    Cpx: 'N &gt; S ? O(S) : O(1){^&darr;R|FN:raccess}; O(min(S, N)){^&darr;F|FN:raccess}'
    Dir: 'Fwd.'
    Cmp: ''
    Family: '80'
  - name: '{kblib:ends_@with}'
    id: 'kblib:ends_with'
    Inp: '2{^&darr;B|FN:raccess}'
    Acc: ''
    Ret: '{:bool}'
    Ops: 'bP'
    Def: '{std:equal_to}'
    Cpx: 'N &gt; S ? O(S) : O(1){^&darr;R|FN:raccess}; O(min(S, N)){^&darr;B|FN:raccess}'
    Dir: ''
    Cmp: ''
    Family: '80'
  - name: '{std:ranges::starts_@with}'
    id: 'std:ranges::starts_with'
    Inp: '2{^&darr;I|FN:raccess}'
    Acc: ''
    Ret: '{:bool}'
    Ops: 'bP, uT, uT{^&Delta;|FN:3way}'
    Def: '{std:equal_to}, {std:identity}, {std:identity}'
    Cpx: '&leq;(min(S, N))'
    Dir: ''
    Cmp: ''
    Family: '80'
  - name: '{std:ranges::ends_@with}'
    id: 'std:ranges::ends_with'
    Inp: '2{^&darr;F|FN:raccess}'
    Acc: ''
    Ret: '{:bool}'
    Ops: 'bP, uT, uT{^&Delta;|FN:3way}'
    Def: '{std:equal_to}, {std:identity}, {std:identity}'
    Cpx: '&leq;(min(S, N))'
    Dir: ''
    Cmp: ''
    Family: '80'

  - name: '{%search (C++17)|std:search}'
    id: 'std:search.17'
    Inp: '1{^&darr;F|FN:raccess}'
    Acc: ''
    Ret: 'Position'
    Ops: 'Searcher'
    Def: ''
    Cpx: 'Depends on Searcher'
    Dir: ''
    Cmp: ''
    Family: '85'

  - name: '{kblib:find_@match}'
    id: 'kblib:find_match'
    Inp: '2{^&darr;I|FN:raccess}'
    Acc: ''
    Ret: 'Position{^&target;|FN:position}'
    Ops: 'bP'
    Def: '{std:equal_to}'
    Cpx: 'O(N), O(min(N, M))'
    Dir: 'S/C'
    Cmp: ''
    Family: '90'
  - name: '{std:mismatch}'
    id: 'std:mismatch'
    Inp: '2{^&darr;I,&par;F|FN:raccess}'
    Acc: ''
    Ret: 'Position{^&target;|FN:position}'
    Ops: 'bP'
    Def: '{std:equal_to}'
    Cpx: 'O(N), O(min(N, M))'
    Dir: 'S/C, {&par;|FN:par}'
    Cmp: '{#kblib:find_match}'
    Family: '90'
  - name: '{std:adjacent_@find}'
    id: 'std:adjacent_find'
    Inp: '1s{^&darr;F|FN:raccess}'
    Acc: ''
    Ret: 'Position'
    Ops: 'bP'
    Def: '{std:equal_to}'
    Cpx: '=(min((result-first)+1, (last-first)-1)); O(N){^&darr;&par;|FN:raccess}'
    Dir: 'S/C, {&par;|FN:par}'
    Cmp: '{#kblib:find_match}'
    Family: '90'
  - name: '{std:is_sorted_@until}'
    id: 'std:is_sorted_until'
    Inp: '1s{^&darr;F|FN:raccess}'
    Acc: ''
    Ret: 'Position'
    Ops: 'bP'
    Def: '{std:less}'
    Cpx: 'O(N)'
    Dir: 'S/C, {&par;|FN:par}'
    Cmp: '{#kblib:find_match}'
    Family: '90'

  - name: '{std:search_n}'
    id: 'std:search_n'
    Inp: '1{^&darr;F|FN:raccess} + Count + Value'
    Acc: ''
    Ret: 'Position'
    Ops: 'bP'
    Def: '{std:equal_to}'
    Cpx: '&leq;(N)'
    Dir: '{&par;|FN:par}'
    Cmp: '{#std:adjacent_@find}'
    Family: '95'

  - name: '{std:accumulate}'
    id: 'std:accumulate'
    Inp: '1{^&darr;I|FN:raccess}'
    Acc: 'Arg'
    Ret: 'Value'
    Ops: 'A'
    Def: '{std:plus}'
    Cpx: 'Unspc.; <span class="kblib">O(N)</span>'
    Dir: 'Fwd.'
    Cmp: ''
    Family: '110'
  - name: '{kblib:sum}'
    id: 'kblib:sum'
    Inp: '1{^&darr;I|FN:raccess}'
    Acc: 'First'
    Ret: 'Value'
    Ops: 'R'
    Def: '{std:plus}'
    Cpx: 'O(N)'
    Dir: 'Fwd.'
    Cmp: '{#std:accumulate}'
    Family: '110'
  - name: '{std:reduce}'
    id: 'std:reduce'
    Inp: '1{^&darr;I,&par;F|FN:raccess}'
    Acc: 'Arg'
    Ret: 'Value'
    Ops: 'acR'
    Def: '{std:plus}'
    Cpx: 'O(N)'
    Dir: '{&par;|FN:par}'
    Cmp: ''
    Family: '110'
  - name: '{std:count}'
    id: 'std:count'
    Inp: '1{^&darr;I,&par;F|FN:raccess}+Value'
    Acc: '{:0}'
    Ret: '{std:size_t}'
    Ops: ''
    Def: '{std:equal_to}'
    Cpx: '=(N)'
    Dir: 'Fwd., {&par;|FN:par}'
    Cmp: '{#std:accumulate}'
    Family: '110'
  - name: '{std:count_if}'
    id: 'std:count_if'
    Inp: '1{^&darr;I,&par;F|FN:raccess}'
    Acc: '{:0}'
    Ret: '{std:size_t}'
    Ops: 'uP'
    Def: ''
    Cpx: '=(N)'
    Dir: 'Fwd., {&par;|FN:par}'
    Cmp: '{#std:accumulate}'
    Family: '110'
  - name: '{std:binary_@search}'
    id: 'std:binary_search'
    Inp: '1{^&darr;F|FN:raccess}+Value'
    Acc: ''
    Ret: '{:bool}'
    Ops: 'bP'
    Def: '{std:less}'
    Cpx: 'O(log N) + O(1){^&darr;R|FN:raccess}; O(N)'
    Dir: 'B/S'
    Cmp: ''
    Family: '110'

  - name: '{std:is_partitioned}'
    id: 'std:is_partitioned'
    Inp: '1{^&darr;I,&par;F|FN:raccess}'
    Acc: ''
    Ret: '{:bool}'
    Ops: 'uP'
    Def: ''
    Cpx: 'O(N)'
    Dir: 'Fwd., {&par;|FN:par}'
    Cmp: ''
    Family: '120'
  - name: '{std:is_sorted}'
    id: 'std:is_sorted'
    Inp: '1{^&darr;F|FN:raccess}'
    Acc: ''
    Ret: '{:bool}'
    Ops: 'bP'
    Def: '{std:less}'
    Cpx: 'O(N)'
    Dir: 'Fwd., {&par;|FN:par}'
    Cmp: ''
    Family: '120'
  - name: '{std:is_heap}'
    id: 'std:is_heap'
    Inp: '1{^&darr;R|FN:raccess}'
    Acc: ''
    Ret: '{:bool}'
    Ops: 'bP'
    Def: '{std:less}'
    Cpx: 'O(N)'
    Dir: '{&par;|FN:par}'
    Cmp: ''
    Family: '120'
  - name: '{std:is_permutation}'
    id: 'std:is_permutation'
    Inp: '2{^&darr;F|FN:raccess}'
    Acc: ''
    Ret: '{:bool}'
    Ops: 'bP'
    Def: '{std:equal_to}'
    Cpx: 'N==M ? O(N<sup>2</sup>) : O(1){^&darr;R|FN:raccess}; O(N<sup>2</sup>)'
    Dir: ''
    Cmp: ''
    Family: '120'
  - name: '{std:includes}'
    id: 'std:includes'
    Inp: '2{^&darr;I,&par;F|FN:raccess}'
    Acc: ''
    Ret: '{:bool}'
    Ops: 'bP'
    Def: '{std:less}'
    Cpx: 'O(N+M), &leq;(2×(N+M-1))'
    Dir: 'Fwd., {&par;|FN:par}'
    Cmp: ''
    Family: '120'

  - name: '{kblib:first_result}'
    id: 'kblib:first_result'
    Inp: '1{^&darr;I|FN:raccess}+Value / 2{^&darr;I|FN:raccess}+Value'
    Acc: 'Arg'
    Ret: 'Value'
    Ops: 'uT / bT'
    Def: ''
    Cpx: 'O(N)'
    Dir: 'S/C'
    Cmp: ''
    Family: '125'
  - name: '{kblib:first_@result_if}'
    id: 'kblib:first_result_if'
    Inp: '1{^&darr;I|FN:raccess} / 2{^&darr;I|FN:raccess}'
    Acc: ''
    Ret: 'Value'
    Ops: 'uT / bT, uP / bP'
    Def: ''
    Cpx: 'O(N)'
    Dir: 'S/C'
    Cmp: ''
    Family: '125'
  - name: '{std:all_of}, {std:none_of}'
    id: 'std:all_of'
    Inp: '1{^&darr;I,&par;F|FN:raccess}'
    Acc: '{:true}'
    Ret: '{:bool}'
    Ops: 'uP'
    Def: ''
    Cpx: 'O(N)'
    Dir: 'S/C, {&par;|FN:par}'
    Cmp: '{#kblib:first_result}'
    Family: '125'
  - name: '{std:any_of}'
    id: 'std:any_of'
    Inp: '1{^&darr;I,&par;F|FN:raccess}'
    Acc: '{:false}'
    Ret: '{:bool}'
    Ops: 'uP'
    Def: ''
    Cpx: 'O(N)'
    Dir: 'S/C, {&par;|FN:par}'
    Cmp: '{#kblib:first_result}'
    Family: '125'
  - name: '{kblib:contains}'
    id: 'kblib:contains'
    Inp: '1{^&darr;I|FN:raccess}+Value'
    Acc: '{:false}'
    Ret: '{:bool}'
    Ops: ''
    Def: '{std:equal_to}'
    Cpx: 'O(N)'
    Dir: 'S/C'
    Cmp: '{#kblib:first_result}'
    Family: '125'
  - name: '{kblib:contains_@any}'
    id: 'kblib:contains_any'
    Inp: '2{^&darr;I|FN:raccess}'
    Acc: '{:false}'
    Ret: '{:bool}'
    Ops: ''
    Def: '{kblib:contains}'
    Cpx: 'O(S×N)'
    Dir: 'S/C'
    Cmp: '{#kblib:first_result}'
    Family: '125'
  - name: '{std:equal}'
    id: 'std:equal'
    Inp: '2{^&darr;I,&par;F|FN:raccess}'
    Acc: ''
    Ret: '{:bool}'
    Ops: 'bP'
    Def: '{std:equal_to}'
    Cpx: 'N==M ? &leq;(N) : O(1){^&darr;R|FN:raccess}; &leq;(N); O(N){^&darr;&par;|FN:raccess}'
    Dir: 'Fwd., {&par;|FN:par}'
    Cmp: '{#kblib:first_result}'
    Family: '125'
  - name: '{std:lexicographical_@compare}'
    id: 'std:lexicographical_compare'
    Inp: '2{^&darr;I,&par;F|FN:raccess}'
    Acc: ''
    Ret: '{:bool}'
    Ops: 'bP'
    Def: '{std:less}'
    Cpx: '&leq;(2×min(N, M))'
    Dir: 'Fwd., {&par;|FN:par}'
    Cmp: '{#kblib:first_result}'
    Family: '125'
  - name: '{std:lexicographical_@compare_@three_way}'
    id: 'std:lexicographical_compare_three_way'
    Inp: '2{^&darr;I|FN:raccess}'
    Acc: ''
    Ret: 'ordering'
    Ops: 'Compare{^&Delta;|FN:3way}'
    Def: '{std:compare_@three_way}'
    Cpx: '&lt;(min(N, M))'
    Dir: 'Fwd.'
    Cmp: '{#kblib:first_result}'
    Family: '125'

  - name: '{std:partition_@point}'
    id: 'std:partition_point'
    Inp: '1{^&darr;F|FN:raccess}'
    Acc: ''
    Ret: 'Position'
    Ops: 'uP'
    Def: ''
    Cpx: 'O(log N){^&darr;R|FN:raccess}; O(N)'
    Dir: 'B/S'
    Cmp: ''
    Family: '130'
  - name: '{std:is_heap_@until}'
    id: 'std:is_heap_until'
    Inp: '1{^&darr;R|FN:raccess}'
    Acc: ''
    Ret: 'Position'
    Ops: 'bP'
    Def: '{std:less}'
    Cpx: 'O(N)'
    Dir: '{&par;|FN:par}'
    Cmp: ''
    Family: '130'