SCRIPT  /home/jason/.vim/bundle/vimagit/common/magit_common.vim
Sourced 3 times
Total time:   0.001263
 Self time:   0.001263

count  total (s)   self (s)
                            " Section names
                            " These are used to beautify the magit buffer and to help for some block
                            " selection
    3              0.000203 let g:magit_sections = {
                             \ 'info':           'Info',
                             \ 'staged':         'Staged changes',
                             \ 'unstaged':       'Unstaged changes',
                             \ 'commit_start':   'Commit message',
                             \ 'commit_end':     'Commit message end',
                             \ 'stash':          'Stash list'
                             \ }
                            
    3              0.000295 let g:magit_git_status_code = {
                             \ 'M': 'modified', 
                             \ 'A': 'added',
                             \ 'D': 'deleted',
                             \ 'R': 'renamed',
                             \ 'C': 'copied',
                             \ 'U': 'updated but unmerged',
                             \ '?': 'untracked',
                             \ '!': 'ignored',
                             \ 'E': 'empty',
                             \ 'L': 'symlink',
                             \ 'N': 'new dir',
                             \ 'S': 'submodule',
                             \ }
                            
                            " Regular expressions used to select blocks
    3              0.000014 let g:magit_file_re  = '^\('
   39              0.000131 for status_code in values(g:magit_git_status_code)
   36              0.000133 	let g:magit_file_re .= status_code . '\|'
   36              0.000042 endfor
    3              0.000014 let g:magit_file_re .= 'unknown status\): \(.\{-\}\)\%( -> .*\)\?$'
                            
    3              0.000009 let g:magit_section_re  = '^\('
   21              0.000044 for section_name in values(g:magit_sections)
   18              0.000063 	let g:magit_section_re .= section_name . '\|'
   18              0.000018 endfor
    3              0.000012 let g:magit_section_re .= 'unknown section\)$'
                            
    3              0.000007 let g:magit_diff_re  = '^diff --git'
    3              0.000007 let g:magit_end_diff_re  = '^$'
    3              0.000007 let g:magit_stash_re = '^stash@{\d\+}:'
    3              0.000010 let g:magit_hunk_re  = '^@@ -\(\d\+\),\?\(\d*\) +\(\d\+\),\?\(\d*\) @@'
    3              0.000007 let g:magit_bin_re   = '^Binary files '
    3              0.000007 let g:magit_eof_re   = '\%$'
                            
                            

SCRIPT  /home/jason/.vim/bundle/vimagit/syntax/magit.vim
Sourced 3 times
Total time:   0.040787
 Self time:   0.026364

count  total (s)   self (s)
                            if exists("b:current_syntax")
                              finish
                            endif
                            
    3              0.001224 execute 'source ' . resolve(expand('<sfile>:p:h')) . '/../common/magit_common.vim'
                            
    3              0.000022 syn case match
    3              0.000043 syn sync minlines=50
                            
    3              0.010500 syn include @diff syntax/diff.vim
                            
    3              0.000117 execute 'syn match titleEntry "' . g:magit_section_re . '" contains=titleSign'
    3              0.000025 if has("conceal")
    3              0.000024 	syn match titleSign contained "\%(&@\|@&\)" conceal
    3              0.000004 else
                            	syn match titleSign contained "\%(&@\|@&\)"
                            endif
    3              0.000010 hi def link titleEntry String
    3              0.000008 hi def link titleSign  Ignore
                            
    3              0.000037 execute 'syn match stashEntry "' . g:magit_stash_re . '"'
    3              0.000010 hi def link stashEntry String
                            
    3              0.000120 execute 'syn match fileEntry "' . g:magit_file_re . '"'
    3              0.000010 hi def link fileEntry String
                            
    3              0.000208 execute 'syn region gitTitle start=/^$\n' . g:magit_section_re . '/ end=/^$/ contains=titleEntry'
                            
    3              0.000253 execute 'syn region gitStash start=/' . g:magit_stash_re . '/ end=/\%(' .
                             \ g:magit_stash_re . '\)\@=/ contains=stashEntry fold'
                            
    3              0.000152 execute 'syn region gitFile start=/' . g:magit_file_re . '/ end=/\%(' .
                            			\ g:magit_end_diff_re . '\)\@=/ contains=gitHunk,fileEntry fold'
                            
    3              0.000114 execute 'syn region gitHunk start=/' .
                             \ g:magit_hunk_re . '/ end=/\%(' . g:magit_end_diff_re . '\|' . g:magit_hunk_re 
                             \ '\)\@=/ contains=@diff fold'
                            
    3              0.000028 let b:current_syntax = "magit"

SCRIPT  /home/jason/.vim/bundle/vimagit/autoload/magit/sign.vim
Sourced 1 time
Total time:   0.000355
 Self time:   0.000355

count  total (s)   self (s)
                            " Got lot of stuf from vim-gitgutter
                            " https://github.com/airblade/vim-gitgutter
                            
                            " Vim doesn't namespace sign ids so every plugin shares the same
                            " namespace.  Sign ids are simply integers so to avoid clashes with other
                            " signs we guess at a clear run.
                            "
                            " Note also we currently never reset s:next_sign_id.
    1              0.000013 let s:first_sign_id = 42000
    1              0.000004 let s:next_sign_id  = s:first_sign_id
    1              0.000009 let s:dummy_sign_id = s:first_sign_id - 1
                            " Remove-all-signs optimisation requires Vim 7.3.596+.
    1              0.000007 let s:supports_star = v:version > 703 || (v:version == 703 && has("patch596"))
                            
    1              0.000016 let s:bufnr = bufnr(g:magit_buffer_name)
                            
    1              0.000007 function! magit#sign#remove_all(...)
                            	if ( a:0 == 1 )
                            		let pattern = a:1
                            	else
                            		let pattern = '^Magit.*'
                            	endif
                            	let signs = magit#sign#find_signs(pattern, 1, line('$'))
                            	call magit#sign#remove_signs(signs)
                            endfunction
                            
                            " magit#sign#remove_signs: unplace a list of signs
                            " param[in] sign_ids: list of signs dict
    1              0.000005 function! magit#sign#remove_signs(sign_ids)
                                let bufnr = magit#utils#bufnr()
                                for sign in values(a:sign_ids)
                                    execute "sign unplace" sign.id
                                endfor
                            endfunction
                            
    1              0.000005 function! magit#sign#add_sign(line, type, bufnr)
                            	let id = <SID>get_next_sign_id()
                            	execute ":sign place " . id .
                            		\ " line=" . a:line . " name=" . s:magit_mark_signs[a:type] .
                            		\ " buffer=" . a:bufnr
                            	return id
                            endfunction
                            
    1              0.000005 function! magit#sign#remove_sign(id)
                            	execute ":sign unplace " . a:id
                            endfunction
                            
                            " s:get_next_sign_id: helper function to increment sign ids
    1              0.000003 function! s:get_next_sign_id()
                            	let next_id = s:next_sign_id
                            	let s:next_sign_id += 1
                            	return next_id
                            endfunction
                            
                            " magit#sign#find_signs: this function returns signs matching a pattern in a
                            " range of lines
                            " param[in] pattern: regex pattern to match
                            " param[in] startline,endline: range of lines
                            " FIXME: find since which version "sign place" is sorted
    1              0.000005 function! magit#sign#find_signs(pattern, startline, endline)
                            	let bufnr = magit#utils#bufnr()
                            	" <line_number (string)>: {'id': <id (number)>, 'name': <name (string)>}
                            	let found_signs = {}
                            
                            	redir => signs
                            	silent execute "sign place buffer=" . bufnr
                            	redir END
                            
                            	for sign_line in filter(split(signs, '\n'), 'v:val =~# "="')
                            		" Typical sign line:  line=88 id=1234 name=GitGutterLineAdded
                            		" We assume splitting is faster than a regexp.
                            		let components  = split(sign_line)
                            		let name        = split(components[2], '=')[1]
                            		let line_number = str2nr(split(components[0], '=')[1])
                            		if ( name =~# a:pattern &&
                            			\ line_number >= a:startline &&
                            			\ line_number <= a:endline )
                            			let id = str2nr(split(components[1], '=')[1])
                            			let found_signs[line_number] = {'id': id, 'name': name}
                            		endif
                            	endfor
                            	return found_signs
                            endfunction
                            
                            " magit#sign#find_stage_signs: helper function to get marked lines for stage
                            " param[in] startline,endline: range of lines
                            " return Dict of marked lines
    1              0.000004 function! magit#sign#find_stage_signs(startline, endline)
                            	return magit#sign#find_signs(s:magit_mark_signs.M, a:startline, a:endline)
                            endfunction
                            
                            " s:magit_mark_sign: string of the sign for lines to be staged
    1              0.000033 let s:magit_mark_signs = {'M': 'MagitTBS', 'S': 'MagitBS', 'E': 'MagitBE'}
                            
                            " magit#sign#init: initializer function for signs
    1              0.000004 function! magit#sign#init()
                            	execute "sign define " . s:magit_mark_signs.M . " text=S> linehl=Visual"
                            	execute "sign define " . s:magit_mark_signs.S
                            	execute "sign define " . s:magit_mark_signs.E
                            endfunction
                            
                            " magit#sign#toggle_signs: toggle marks for range of lines
                            " marked lines are unmarked, non marked are marked
                            " param[in] type; type of sign to toggle (see s:magit_mark_signs)
                            " param[in] startline,endline: range of lines
    1              0.000005 function! magit#sign#toggle_signs(type, startline, endline)
                            	let bufnr = magit#utils#bufnr()
                            	let current_signs = magit#sign#find_signs(s:magit_mark_signs[a:type], a:startline, a:endline)
                            	let line = a:startline
                            	while ( line <= a:endline )
                            		if ( has_key(current_signs, line) == 0 )
                            			call magit#sign#add_sign(line, a:type, bufnr)
                            		else
                            			call magit#sign#remove_sign(current_signs[line].id)
                            		endif
                            		let line += 1
                            	endwhile
                            endfunction

SCRIPT  /home/jason/.vim/bundle/vimagit/autoload/magit/git.vim
Sourced 1 time
Total time:   0.000299
 Self time:   0.000299

count  total (s)   self (s)
                            let s:git_cmd="GIT_CONFIG=/dev/null GIT_CONFIG_NOSYSTEM=1 XDG_CONFIG_HOME=/ git"
                            
                            " magit#git#get_status: this function returns the git status output formated
                            " into a List of Dict as
                            " [ {staged', 'unstaged', 'filename'}, ... ]
    1              0.000006 function! magit#git#get_status()
                            	let file_list = []
                            
                            	" systemlist v7.4.248 problem again
                            	" we can't use git status -z here, because system doesn't make the
                            	" difference between NUL and NL. -status z terminate entries with NUL,
                            	" instead of NF
                            	let status_list=magit#utils#systemlist(s:git_cmd . " status --porcelain")
                            	for file_status_line in status_list
                            		let line_match = matchlist(file_status_line, '\(.\)\(.\) \%(.\{-\} -> \)\?"\?\(.\{-\}\)"\?$')
                            		let filename = line_match[3]
                            		call add(file_list, { 'staged': line_match[1], 'unstaged': line_match[2], 'filename': filename })
                            	endfor
                            	return file_list
                            endfunction
                            
                            " s:magit_top_dir: top directory of git tree
                            " it is evaluated only once
                            " FIXME: it won't work when playing with multiple git directories wihtin one
                            " vim session
    1              0.000003 let s:magit_top_dir=''
                            " magit#git#top_dir: return the absolute path of current git worktree
                            " return top directory
    1              0.000003 function! magit#git#top_dir()
                            	if ( s:magit_top_dir == '' )
                            		let s:magit_top_dir=magit#utils#strip(
                            			\ system(s:git_cmd . " rev-parse --show-toplevel")) . "/"
                            		if ( v:shell_error != 0 )
                            			echoerr "Git error: " . s:magit_top_dir
                            		endif
                            	endif
                            	return s:magit_top_dir
                            endfunction
                            
                            " s:magit_git_dir: git directory
                            " it is evaluated only once
                            " FIXME: it won't work when playing with multiple git directories wihtin one
                            " vim session
    1              0.000003 let s:magit_git_dir=''
                            " magit#git#git_dir: return the absolute path of current git worktree
                            " return git directory
    1              0.000003 function! magit#git#git_dir()
                            	if ( s:magit_git_dir == '' )
                            		let s:magit_git_dir=magit#utils#strip(system(s:git_cmd . " rev-parse --git-dir")) . "/"
                            		if ( v:shell_error != 0 )
                            			echoerr "Git error: " . s:magit_git_dir
                            		endif
                            	endif
                            	return s:magit_git_dir
                            endfunction
                            
                            " magit#git#git_diff: helper function to get diff of a file
                            " nota: when git fail (due to misformated patch for example), an error
                            " message is raised.
                            " param[in] filemane: it must be quoted if it contains spaces
                            " param[in] status: status of the file (see g:magit_git_status_code)
                            " param[in] mode: can be staged or unstaged
    1              0.000005 function! magit#git#git_diff(filename, status, mode)
                            	let dev_null = ( a:status == '?' ) ? " /dev/null " : " "
                            	let staged_flag = ( a:mode == 'staged' ) ? " --staged " : " "
                            	let git_cmd="git diff --no-ext-diff " . staged_flag .
                            				\ "--no-color --patch -- " . dev_null . " "
                            				\ .a:filename
                            	silent let diff_list=magit#utils#systemlist(git_cmd)
                            	if ( empty(diff_list) )
                            		echohl WarningMsg
                            		echom "diff command \"" . diff_cmd . "\" returned nothing"
                            		echohl None
                            		throw 'diff error'
                            	endif
                            	return diff_list
                            endfunction
                            
                            " magit#git#git_sub_summary: helper function to get diff of a submodule
                            " nota: when git fail (due to misformated patch for example), an error
                            " message is raised.
                            " param[in] filemane: it must be quoted if it contains spaces
                            " param[in] mode: can be staged or unstaged
    1              0.000004 function! magit#git#git_sub_summary(filename, mode)
                            	let staged_flag = ( a:mode == 'staged' ) ? " --cached " : " --files "
                            	let git_cmd="git submodule summary " . staged_flag . " HEAD "
                            				\ .a:filename
                            	silent let diff_list=magit#utils#systemlist(git_cmd)
                            	if ( empty(diff_list) )
                            		echohl WarningMsg
                            		echom "diff command \"" . diff_cmd . "\" returned nothing"
                            		echohl None
                            		throw 'diff error'
                            	endif
                            	return diff_list
                            endfunction
                            
                            " magit#git#git_add: helper function to add a whole file
                            " nota: when git fail (due to misformated patch for example), an error
                            " message is raised.
                            " param[in] filemane: it must be quoted if it contains spaces
    1              0.000004 function! magit#git#git_add(filename)
                            	let git_cmd=s:git_cmd . " add --no-ignore-removal -- " . a:filename
                            	silent let git_result=magit#utils#system(git_cmd)
                            	if ( v:shell_error != 0 )
                            		echoerr "Git error: " . git_result
                            		echoerr "Git cmd: " . git_cmd
                            	endif
                            endfunction
                            
                            " magit#git#git_checkout: helper function to add a whole file
                            " nota: when git fail (due to misformated patch for example), an error
                            " message is raised.
                            " param[in] filemane: it must be quoted if it contains spaces
    1              0.000004 function! magit#git#git_checkout(filename)
                            	let git_cmd=s:git_cmd . " checkout -- " . a:filename
                            	silent let git_result=magit#utils#system(git_cmd)
                            	if ( v:shell_error != 0 )
                            		echoerr "Git error: " . git_result
                            		echoerr "Git cmd: " . git_cmd
                            	endif
                            endfunction
                            
                            " magit#git#git_reset: helper function to add a whole file
                            " nota: when git fail (due to misformated patch for example), an error
                            " message is raised.
                            " param[in] filemane: it must be quoted if it contains spaces
    1              0.000003 function! magit#git#git_reset(filename)
                            	let git_cmd=s:git_cmd . " reset HEAD -- " . a:filename
                            	silent let git_result=magit#utils#system(git_cmd)
                            	if ( v:shell_error != 0 )
                            		echoerr "Git error: " . git_result
                            		echoerr "Git cmd: " . git_cmd
                            	endif
                            endfunction
                            
                            " magit#git#git_apply: helper function to stage a selection
                            " nota: when git fail (due to misformated patch for example), an error
                            " message is raised.
                            " param[in] selection: the text to stage. It must be a patch, i.e. a diff 
                            " header plus one or more hunks
                            " return: no
    1              0.000004 function! magit#git#git_apply(header, selection)
                            	let selection = magit#utils#flatten(a:header + a:selection)
                            	if ( selection[-1] !~ '^$' )
                            		let selection += [ '' ]
                            	endif
                            	let git_cmd=s:git_cmd . " apply --recount --no-index --cached -"
                            	silent let git_result=magit#utils#system(git_cmd, selection)
                            	if ( v:shell_error != 0 )
                            		echoerr "Git error: " . git_result
                            		echoerr "Git cmd: " . git_cmd
                            		echoerr "Tried to aply this"
                            		echoerr string(selection)
                            	endif
                            endfunction
                            
                            " magit#git#git_unapply: helper function to unstage a selection
                            " nota: when git fail (due to misformated patch for example), an error
                            " message is raised.
                            " param[in] selection: the text to stage. It must be a patch, i.e. a diff 
                            " header plus one or more hunks
                            " return: no
    1              0.000003 function! magit#git#git_unapply(header, selection, mode)
                            	let cached_flag=''
                            	if ( a:mode == 'staged' )
                            		let cached_flag=' --cached '
                            	endif
                            	let selection = magit#utils#flatten(a:header + a:selection)
                            	if ( selection[-1] !~ '^$' )
                            		let selection += [ '' ]
                            	endif
                            	silent let git_result=magit#utils#system(
                            		\ s:git_cmd . " apply --recount --no-index " . cached_flag . " --reverse - ",
                            		\ selection)
                            	if ( v:shell_error != 0 )
                            		echoerr "Git error: " . git_result
                            		echoerr "Tried to unaply this"
                            		echoerr string(selection)
                            	endif
                            endfunction
                            
    1              0.000004 function! magit#git#submodule_status()
                            	return system(s:git_cmd . " submodule status")
                            endfunction

FUNCTION  magit#sign#remove_sign()
Called 0 times
Total time:   0.000000
 Self time:   0.000000

count  total (s)   self (s)
                            	execute ":sign unplace " . a:id

FUNCTION  magit#git#git_sub_summary()
Called 0 times
Total time:   0.000000
 Self time:   0.000000

count  total (s)   self (s)
                            	let staged_flag = ( a:mode == 'staged' ) ? " --cached " : " --files "
                            	let git_cmd="git submodule summary " . staged_flag . " HEAD " .a:filename
                            	silent let diff_list=magit#utils#systemlist(git_cmd)
                            	if ( empty(diff_list) )
                            		echohl WarningMsg
                            		echom "diff command \"" . diff_cmd . "\" returned nothing"
                            		echohl None
                            		throw 'diff error'
                            	endif
                            	return diff_list

FUNCTION  magit#git#get_status()
Called 4 times
Total time:   0.343238
 Self time:   0.002135

count  total (s)   self (s)
    4              0.000015 	let file_list = []
                            
                            	" systemlist v7.4.248 problem again
                            	" we can't use git status -z here, because system doesn't make the
                            	" difference between NUL and NL. -status z terminate entries with NUL,
                            	" instead of NF
    4   0.341767   0.000664 	let status_list=magit#utils#systemlist(s:git_cmd . " status --porcelain")
    8              0.000027 	for file_status_line in status_list
    4              0.000844 		let line_match = matchlist(file_status_line, '\(.\)\(.\) \%(.\{-\} -> \)\?"\?\(.\{-\}\)"\?$')
    4              0.000069 		let filename = line_match[3]
    4              0.000325 		call add(file_list, { 'staged': line_match[1], 'unstaged': line_match[2], 'filename': filename })
    4              0.000008 	endfor
    4              0.000102 	return file_list

FUNCTION  magit#sign#init()
Called 1 time
Total time:   0.000094
 Self time:   0.000094

count  total (s)   self (s)
    1              0.000080 	execute "sign define " . s:magit_mark_signs.M . " text=S> linehl=Visual"
    1              0.000007 	execute "sign define " . s:magit_mark_signs.S
    1              0.000005 	execute "sign define " . s:magit_mark_signs.E

FUNCTION  magit#git#git_diff()
Called 2 times
Total time:   0.214972
 Self time:   0.000421

count  total (s)   self (s)
    2              0.000012 	let dev_null = ( a:status == '?' ) ? " /dev/null " : " "
    2              0.000146 	let staged_flag = ( a:mode == 'staged' ) ? " --staged " : " "
    2              0.000014 	let git_cmd="git diff --no-ext-diff " . staged_flag . "--no-color --patch -- " . dev_null . " " .a:filename
    2   0.214732   0.000181 	silent let diff_list=magit#utils#systemlist(git_cmd)
    2              0.000028 	if ( empty(diff_list) )
                            		echohl WarningMsg
                            		echom "diff command \"" . diff_cmd . "\" returned nothing"
                            		echohl None
                            		throw 'diff error'
                            	endif
    2              0.000020 	return diff_list

FUNCTION  magit#sign#add_sign()
Called 0 times
Total time:   0.000000
 Self time:   0.000000

count  total (s)   self (s)
                            	let id = <SID>get_next_sign_id()
                            	execute ":sign place " . id . " line=" . a:line . " name=" . s:magit_mark_signs[a:type] . " buffer=" . a:bufnr
                            	return id

FUNCTION  <SNR>71_get_next_sign_id()
Called 0 times
Total time:   0.000000
 Self time:   0.000000

count  total (s)   self (s)
                            	let next_id = s:next_sign_id
                            	let s:next_sign_id += 1
                            	return next_id

FUNCTION  magit#sign#remove_all()
Called 2 times
Total time:   0.000455
 Self time:   0.000060

count  total (s)   self (s)
    2              0.000007 	if ( a:0 == 1 )
                            		let pattern = a:1
                            	else
    2              0.000005 		let pattern = '^Magit.*'
    2              0.000001 	endif
    2   0.000384   0.000023 	let signs = magit#sign#find_signs(pattern, 1, line('$'))
    2   0.000048   0.000014 	call magit#sign#remove_signs(signs)

FUNCTION  magit#git#git_apply()
Called 0 times
Total time:   0.000000
 Self time:   0.000000

count  total (s)   self (s)
                            	let selection = magit#utils#flatten(a:header + a:selection)
                            	if ( selection[-1] !~ '^$' )
                            		let selection += [ '' ]
                            	endif
                            	let git_cmd=s:git_cmd . " apply --recount --no-index --cached -"
                            	silent let git_result=magit#utils#system(git_cmd, selection)
                            	if ( v:shell_error != 0 )
                            		echoerr "Git error: " . git_result
                            		echoerr "Git cmd: " . git_cmd
                            		echoerr "Tried to aply this"
                            		echoerr string(selection)
                            	endif

FUNCTION  magit#sign#toggle_signs()
Called 0 times
Total time:   0.000000
 Self time:   0.000000

count  total (s)   self (s)
                            	let bufnr = magit#utils#bufnr()
                            	let current_signs = magit#sign#find_signs(s:magit_mark_signs[a:type], a:startline, a:endline)
                            	let line = a:startline
                            	while ( line <= a:endline )
                            		if ( has_key(current_signs, line) == 0 )
                            			call magit#sign#add_sign(line, a:type, bufnr)
                            		else
                            			call magit#sign#remove_sign(current_signs[line].id)
                            		endif
                            		let line += 1
                            	endwhile

FUNCTION  magit#git#git_unapply()
Called 0 times
Total time:   0.000000
 Self time:   0.000000

count  total (s)   self (s)
                            	let cached_flag=''
                            	if ( a:mode == 'staged' )
                            		let cached_flag=' --cached '
                            	endif
                            	let selection = magit#utils#flatten(a:header + a:selection)
                            	if ( selection[-1] !~ '^$' )
                            		let selection += [ '' ]
                            	endif
                            	silent let git_result=magit#utils#system( s:git_cmd . " apply --recount --no-index " . cached_flag . " --reverse - ", selection)
                            	if ( v:shell_error != 0 )
                            		echoerr "Git error: " . git_result
                            		echoerr "Tried to unaply this"
                            		echoerr string(selection)
                            	endif

FUNCTION  magit#git#git_add()
Called 0 times
Total time:   0.000000
 Self time:   0.000000

count  total (s)   self (s)
                            	let git_cmd=s:git_cmd . " add --no-ignore-removal -- " . a:filename
                            	silent let git_result=magit#utils#system(git_cmd)
                            	if ( v:shell_error != 0 )
                            		echoerr "Git error: " . git_result
                            		echoerr "Git cmd: " . git_cmd
                            	endif

FUNCTION  magit#git#git_dir()
Called 0 times
Total time:   0.000000
 Self time:   0.000000

count  total (s)   self (s)
                            	if ( s:magit_git_dir == '' )
                            		let s:magit_git_dir=magit#utils#strip(system(s:git_cmd . " rev-parse --git-dir")) . "/"
                            		if ( v:shell_error != 0 )
                            			echoerr "Git error: " . s:magit_git_dir
                            		endif
                            	endif
                            	return s:magit_git_dir

FUNCTION  magit#sign#find_stage_signs()
Called 0 times
Total time:   0.000000
 Self time:   0.000000

count  total (s)   self (s)
                            	return magit#sign#find_signs(s:magit_mark_signs.M, a:startline, a:endline)

FUNCTION  magit#git#git_checkout()
Called 0 times
Total time:   0.000000
 Self time:   0.000000

count  total (s)   self (s)
                            	let git_cmd=s:git_cmd . " checkout -- " . a:filename
                            	silent let git_result=magit#utils#system(git_cmd)
                            	if ( v:shell_error != 0 )
                            		echoerr "Git error: " . git_result
                            		echoerr "Git cmd: " . git_cmd
                            	endif

FUNCTION  magit#sign#find_signs()
Called 2 times
Total time:   0.000361
 Self time:   0.000353

count  total (s)   self (s)
    2   0.000056   0.000048 	let bufnr = magit#utils#bufnr()
                            	" <line_number (string)>: {'id': <id (number)>, 'name': <name (string)>}
    2              0.000005 	let found_signs = {}
                            
    2              0.000009 	redir => signs
    2              0.000083 	silent execute "sign place buffer=" . bufnr
    2              0.000009 	redir END
                            
    2              0.000140 	for sign_line in filter(split(signs, '\n'), 'v:val =~# "="')
                            		" Typical sign line:  line=88 id=1234 name=GitGutterLineAdded
                            		" We assume splitting is faster than a regexp.
                            		let components  = split(sign_line)
                            		let name        = split(components[2], '=')[1]
                            		let line_number = str2nr(split(components[0], '=')[1])
                            		if ( name =~# a:pattern && line_number >= a:startline && line_number <= a:endline )
                            			let id = str2nr(split(components[1], '=')[1])
                            			let found_signs[line_number] = {'id': id, 'name': name}
                            		endif
                            	endfor
    2              0.000004 	return found_signs

FUNCTION  magit#git#top_dir()
Called 12 times
Total time:   0.048557
 Self time:   0.001127

count  total (s)   self (s)
   12              0.000110 	if ( s:magit_top_dir == '' )
    1   0.047972   0.000542 		let s:magit_top_dir=magit#utils#strip( system(s:git_cmd . " rev-parse --show-toplevel")) . "/"
    1              0.000005 		if ( v:shell_error != 0 )
                            			echoerr "Git error: " . s:magit_top_dir
                            		endif
    1              0.000001 	endif
   12              0.000040 	return s:magit_top_dir

FUNCTION  magit#sign#remove_signs()
Called 2 times
Total time:   0.000034
 Self time:   0.000030

count  total (s)   self (s)
    2   0.000016   0.000012     let bufnr = magit#utils#bufnr()
    2              0.000008     for sign in values(a:sign_ids)
                                    execute "sign unplace" sign.id
                                endfor

FUNCTION  magit#git#submodule_status()
Called 2 times
Total time:   0.599567
 Self time:   0.001131

count  total (s)   self (s)
    2   0.599520   0.001084 	return system(s:git_cmd . " submodule status")

FUNCTION  magit#git#git_reset()
Called 0 times
Total time:   0.000000
 Self time:   0.000000

count  total (s)   self (s)
                            	let git_cmd=s:git_cmd . " reset HEAD -- " . a:filename
                            	silent let git_result=magit#utils#system(git_cmd)
                            	if ( v:shell_error != 0 )
                            		echoerr "Git error: " . git_result
                            		echoerr "Git cmd: " . git_cmd
                            	endif

FUNCTIONS SORTED ON TOTAL TIME
count  total (s)   self (s)  function
    2   0.599567   0.001131  magit#git#submodule_status()
    4   0.343238   0.002135  magit#git#get_status()
    2   0.214972   0.000421  magit#git#git_diff()
   12   0.048557   0.001127  magit#git#top_dir()
    2   0.000455   0.000060  magit#sign#remove_all()
    2   0.000361   0.000353  magit#sign#find_signs()
    1   0.000094             magit#sign#init()
    2   0.000034   0.000030  magit#sign#remove_signs()
                             magit#sign#remove_sign()
                             magit#git#git_sub_summary()
                             magit#sign#add_sign()
                             <SNR>71_get_next_sign_id()
                             magit#git#git_apply()
                             magit#sign#toggle_signs()
                             magit#git#git_unapply()
                             magit#git#git_add()
                             magit#git#git_dir()
                             magit#sign#find_stage_signs()
                             magit#git#git_checkout()
                             magit#git#git_reset()

FUNCTIONS SORTED ON SELF TIME
count  total (s)   self (s)  function
    4   0.343238   0.002135  magit#git#get_status()
    2   0.599567   0.001131  magit#git#submodule_status()
   12   0.048557   0.001127  magit#git#top_dir()
    2   0.214972   0.000421  magit#git#git_diff()
    2   0.000361   0.000353  magit#sign#find_signs()
    1              0.000094  magit#sign#init()
    2   0.000455   0.000060  magit#sign#remove_all()
    2   0.000034   0.000030  magit#sign#remove_signs()
                             magit#sign#remove_sign()
                             magit#git#git_sub_summary()
                             magit#sign#add_sign()
                             <SNR>71_get_next_sign_id()
                             magit#git#git_apply()
                             magit#sign#toggle_signs()
                             magit#git#git_unapply()
                             magit#git#git_add()
                             magit#git#git_dir()
                             magit#sign#find_stage_signs()
                             magit#git#git_checkout()
                             magit#git#git_reset()