cannam@128: ;uInt longest_match_x64( cannam@128: ; deflate_state *s, cannam@128: ; IPos cur_match); /* current match */ cannam@128: cannam@128: ; gvmat64.asm -- Asm portion of the optimized longest_match for 32 bits x86_64 cannam@128: ; (AMD64 on Athlon 64, Opteron, Phenom cannam@128: ; and Intel EM64T on Pentium 4 with EM64T, Pentium D, Core 2 Duo, Core I5/I7) cannam@128: ; Copyright (C) 1995-2010 Jean-loup Gailly, Brian Raiter and Gilles Vollant. cannam@128: ; cannam@128: ; File written by Gilles Vollant, by converting to assembly the longest_match cannam@128: ; from Jean-loup Gailly in deflate.c of zLib and infoZip zip. cannam@128: ; cannam@128: ; and by taking inspiration on asm686 with masm, optimised assembly code cannam@128: ; from Brian Raiter, written 1998 cannam@128: ; cannam@128: ; This software is provided 'as-is', without any express or implied cannam@128: ; warranty. In no event will the authors be held liable for any damages cannam@128: ; arising from the use of this software. cannam@128: ; cannam@128: ; Permission is granted to anyone to use this software for any purpose, cannam@128: ; including commercial applications, and to alter it and redistribute it cannam@128: ; freely, subject to the following restrictions: cannam@128: ; cannam@128: ; 1. The origin of this software must not be misrepresented; you must not cannam@128: ; claim that you wrote the original software. If you use this software cannam@128: ; in a product, an acknowledgment in the product documentation would be cannam@128: ; appreciated but is not required. cannam@128: ; 2. Altered source versions must be plainly marked as such, and must not be cannam@128: ; misrepresented as being the original software cannam@128: ; 3. This notice may not be removed or altered from any source distribution. cannam@128: ; cannam@128: ; cannam@128: ; cannam@128: ; http://www.zlib.net cannam@128: ; http://www.winimage.com/zLibDll cannam@128: ; http://www.muppetlabs.com/~breadbox/software/assembly.html cannam@128: ; cannam@128: ; to compile this file for infozip Zip, I use option: cannam@128: ; ml64.exe /Flgvmat64 /c /Zi /DINFOZIP gvmat64.asm cannam@128: ; cannam@128: ; to compile this file for zLib, I use option: cannam@128: ; ml64.exe /Flgvmat64 /c /Zi gvmat64.asm cannam@128: ; Be carrefull to adapt zlib1222add below to your version of zLib cannam@128: ; (if you use a version of zLib before 1.0.4 or after 1.2.2.2, change cannam@128: ; value of zlib1222add later) cannam@128: ; cannam@128: ; This file compile with Microsoft Macro Assembler (x64) for AMD64 cannam@128: ; cannam@128: ; ml64.exe is given with Visual Studio 2005/2008/2010 and Windows WDK cannam@128: ; cannam@128: ; (you can get Windows WDK with ml64 for AMD64 from cannam@128: ; http://www.microsoft.com/whdc/Devtools/wdk/default.mspx for low price) cannam@128: ; cannam@128: cannam@128: cannam@128: ;uInt longest_match(s, cur_match) cannam@128: ; deflate_state *s; cannam@128: ; IPos cur_match; /* current match */ cannam@128: .code cannam@128: longest_match PROC cannam@128: cannam@128: cannam@128: ;LocalVarsSize equ 88 cannam@128: LocalVarsSize equ 72 cannam@128: cannam@128: ; register used : rax,rbx,rcx,rdx,rsi,rdi,r8,r9,r10,r11,r12 cannam@128: ; free register : r14,r15 cannam@128: ; register can be saved : rsp cannam@128: cannam@128: chainlenwmask equ rsp + 8 - LocalVarsSize ; high word: current chain len cannam@128: ; low word: s->wmask cannam@128: ;window equ rsp + xx - LocalVarsSize ; local copy of s->window ; stored in r10 cannam@128: ;windowbestlen equ rsp + xx - LocalVarsSize ; s->window + bestlen , use r10+r11 cannam@128: ;scanstart equ rsp + xx - LocalVarsSize ; first two bytes of string ; stored in r12w cannam@128: ;scanend equ rsp + xx - LocalVarsSize ; last two bytes of string use ebx cannam@128: ;scanalign equ rsp + xx - LocalVarsSize ; dword-misalignment of string r13 cannam@128: ;bestlen equ rsp + xx - LocalVarsSize ; size of best match so far -> r11d cannam@128: ;scan equ rsp + xx - LocalVarsSize ; ptr to string wanting match -> r9 cannam@128: IFDEF INFOZIP cannam@128: ELSE cannam@128: nicematch equ (rsp + 16 - LocalVarsSize) ; a good enough match size cannam@128: ENDIF cannam@128: cannam@128: save_rdi equ rsp + 24 - LocalVarsSize cannam@128: save_rsi equ rsp + 32 - LocalVarsSize cannam@128: save_rbx equ rsp + 40 - LocalVarsSize cannam@128: save_rbp equ rsp + 48 - LocalVarsSize cannam@128: save_r12 equ rsp + 56 - LocalVarsSize cannam@128: save_r13 equ rsp + 64 - LocalVarsSize cannam@128: ;save_r14 equ rsp + 72 - LocalVarsSize cannam@128: ;save_r15 equ rsp + 80 - LocalVarsSize cannam@128: cannam@128: cannam@128: ; summary of register usage cannam@128: ; scanend ebx cannam@128: ; scanendw bx cannam@128: ; chainlenwmask edx cannam@128: ; curmatch rsi cannam@128: ; curmatchd esi cannam@128: ; windowbestlen r8 cannam@128: ; scanalign r9 cannam@128: ; scanalignd r9d cannam@128: ; window r10 cannam@128: ; bestlen r11 cannam@128: ; bestlend r11d cannam@128: ; scanstart r12d cannam@128: ; scanstartw r12w cannam@128: ; scan r13 cannam@128: ; nicematch r14d cannam@128: ; limit r15 cannam@128: ; limitd r15d cannam@128: ; prev rcx cannam@128: cannam@128: ; all the +4 offsets are due to the addition of pending_buf_size (in zlib cannam@128: ; in the deflate_state structure since the asm code was first written cannam@128: ; (if you compile with zlib 1.0.4 or older, remove the +4). cannam@128: ; Note : these value are good with a 8 bytes boundary pack structure cannam@128: cannam@128: cannam@128: MAX_MATCH equ 258 cannam@128: MIN_MATCH equ 3 cannam@128: MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1) cannam@128: cannam@128: cannam@128: ;;; Offsets for fields in the deflate_state structure. These numbers cannam@128: ;;; are calculated from the definition of deflate_state, with the cannam@128: ;;; assumption that the compiler will dword-align the fields. (Thus, cannam@128: ;;; changing the definition of deflate_state could easily cause this cannam@128: ;;; program to crash horribly, without so much as a warning at cannam@128: ;;; compile time. Sigh.) cannam@128: cannam@128: ; all the +zlib1222add offsets are due to the addition of fields cannam@128: ; in zlib in the deflate_state structure since the asm code was first written cannam@128: ; (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)"). cannam@128: ; (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0"). cannam@128: ; if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8"). cannam@128: cannam@128: cannam@128: IFDEF INFOZIP cannam@128: cannam@128: _DATA SEGMENT cannam@128: COMM window_size:DWORD cannam@128: ; WMask ; 7fff cannam@128: COMM window:BYTE:010040H cannam@128: COMM prev:WORD:08000H cannam@128: ; MatchLen : unused cannam@128: ; PrevMatch : unused cannam@128: COMM strstart:DWORD cannam@128: COMM match_start:DWORD cannam@128: ; Lookahead : ignore cannam@128: COMM prev_length:DWORD ; PrevLen cannam@128: COMM max_chain_length:DWORD cannam@128: COMM good_match:DWORD cannam@128: COMM nice_match:DWORD cannam@128: prev_ad equ OFFSET prev cannam@128: window_ad equ OFFSET window cannam@128: nicematch equ nice_match cannam@128: _DATA ENDS cannam@128: WMask equ 07fffh cannam@128: cannam@128: ELSE cannam@128: cannam@128: IFNDEF zlib1222add cannam@128: zlib1222add equ 8 cannam@128: ENDIF cannam@128: dsWSize equ 56+zlib1222add+(zlib1222add/2) cannam@128: dsWMask equ 64+zlib1222add+(zlib1222add/2) cannam@128: dsWindow equ 72+zlib1222add cannam@128: dsPrev equ 88+zlib1222add cannam@128: dsMatchLen equ 128+zlib1222add cannam@128: dsPrevMatch equ 132+zlib1222add cannam@128: dsStrStart equ 140+zlib1222add cannam@128: dsMatchStart equ 144+zlib1222add cannam@128: dsLookahead equ 148+zlib1222add cannam@128: dsPrevLen equ 152+zlib1222add cannam@128: dsMaxChainLen equ 156+zlib1222add cannam@128: dsGoodMatch equ 172+zlib1222add cannam@128: dsNiceMatch equ 176+zlib1222add cannam@128: cannam@128: window_size equ [ rcx + dsWSize] cannam@128: WMask equ [ rcx + dsWMask] cannam@128: window_ad equ [ rcx + dsWindow] cannam@128: prev_ad equ [ rcx + dsPrev] cannam@128: strstart equ [ rcx + dsStrStart] cannam@128: match_start equ [ rcx + dsMatchStart] cannam@128: Lookahead equ [ rcx + dsLookahead] ; 0ffffffffh on infozip cannam@128: prev_length equ [ rcx + dsPrevLen] cannam@128: max_chain_length equ [ rcx + dsMaxChainLen] cannam@128: good_match equ [ rcx + dsGoodMatch] cannam@128: nice_match equ [ rcx + dsNiceMatch] cannam@128: ENDIF cannam@128: cannam@128: ; parameter 1 in r8(deflate state s), param 2 in rdx (cur match) cannam@128: cannam@128: ; see http://weblogs.asp.net/oldnewthing/archive/2004/01/14/58579.aspx and cannam@128: ; http://msdn.microsoft.com/library/en-us/kmarch/hh/kmarch/64bitAMD_8e951dd2-ee77-4728-8702-55ce4b5dd24a.xml.asp cannam@128: ; cannam@128: ; All registers must be preserved across the call, except for cannam@128: ; rax, rcx, rdx, r8, r9, r10, and r11, which are scratch. cannam@128: cannam@128: cannam@128: cannam@128: ;;; Save registers that the compiler may be using, and adjust esp to cannam@128: ;;; make room for our stack frame. cannam@128: cannam@128: cannam@128: ;;; Retrieve the function arguments. r8d will hold cur_match cannam@128: ;;; throughout the entire function. edx will hold the pointer to the cannam@128: ;;; deflate_state structure during the function's setup (before cannam@128: ;;; entering the main loop. cannam@128: cannam@128: ; parameter 1 in rcx (deflate_state* s), param 2 in edx -> r8 (cur match) cannam@128: cannam@128: ; this clear high 32 bits of r8, which can be garbage in both r8 and rdx cannam@128: cannam@128: mov [save_rdi],rdi cannam@128: mov [save_rsi],rsi cannam@128: mov [save_rbx],rbx cannam@128: mov [save_rbp],rbp cannam@128: IFDEF INFOZIP cannam@128: mov r8d,ecx cannam@128: ELSE cannam@128: mov r8d,edx cannam@128: ENDIF cannam@128: mov [save_r12],r12 cannam@128: mov [save_r13],r13 cannam@128: ; mov [save_r14],r14 cannam@128: ; mov [save_r15],r15 cannam@128: cannam@128: cannam@128: ;;; uInt wmask = s->w_mask; cannam@128: ;;; unsigned chain_length = s->max_chain_length; cannam@128: ;;; if (s->prev_length >= s->good_match) { cannam@128: ;;; chain_length >>= 2; cannam@128: ;;; } cannam@128: cannam@128: mov edi, prev_length cannam@128: mov esi, good_match cannam@128: mov eax, WMask cannam@128: mov ebx, max_chain_length cannam@128: cmp edi, esi cannam@128: jl LastMatchGood cannam@128: shr ebx, 2 cannam@128: LastMatchGood: cannam@128: cannam@128: ;;; chainlen is decremented once beforehand so that the function can cannam@128: ;;; use the sign flag instead of the zero flag for the exit test. cannam@128: ;;; It is then shifted into the high word, to make room for the wmask cannam@128: ;;; value, which it will always accompany. cannam@128: cannam@128: dec ebx cannam@128: shl ebx, 16 cannam@128: or ebx, eax cannam@128: cannam@128: ;;; on zlib only cannam@128: ;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; cannam@128: cannam@128: IFDEF INFOZIP cannam@128: mov [chainlenwmask], ebx cannam@128: ; on infozip nice_match = [nice_match] cannam@128: ELSE cannam@128: mov eax, nice_match cannam@128: mov [chainlenwmask], ebx cannam@128: mov r10d, Lookahead cannam@128: cmp r10d, eax cannam@128: cmovnl r10d, eax cannam@128: mov [nicematch],r10d cannam@128: ENDIF cannam@128: cannam@128: ;;; register Bytef *scan = s->window + s->strstart; cannam@128: mov r10, window_ad cannam@128: mov ebp, strstart cannam@128: lea r13, [r10 + rbp] cannam@128: cannam@128: ;;; Determine how many bytes the scan ptr is off from being cannam@128: ;;; dword-aligned. cannam@128: cannam@128: mov r9,r13 cannam@128: neg r13 cannam@128: and r13,3 cannam@128: cannam@128: ;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ? cannam@128: ;;; s->strstart - (IPos)MAX_DIST(s) : NIL; cannam@128: IFDEF INFOZIP cannam@128: mov eax,07efah ; MAX_DIST = (WSIZE-MIN_LOOKAHEAD) (0x8000-(3+8+1)) cannam@128: ELSE cannam@128: mov eax, window_size cannam@128: sub eax, MIN_LOOKAHEAD cannam@128: ENDIF cannam@128: xor edi,edi cannam@128: sub ebp, eax cannam@128: cannam@128: mov r11d, prev_length cannam@128: cannam@128: cmovng ebp,edi cannam@128: cannam@128: ;;; int best_len = s->prev_length; cannam@128: cannam@128: cannam@128: ;;; Store the sum of s->window + best_len in esi locally, and in esi. cannam@128: cannam@128: lea rsi,[r10+r11] cannam@128: cannam@128: ;;; register ush scan_start = *(ushf*)scan; cannam@128: ;;; register ush scan_end = *(ushf*)(scan+best_len-1); cannam@128: ;;; Posf *prev = s->prev; cannam@128: cannam@128: movzx r12d,word ptr [r9] cannam@128: movzx ebx, word ptr [r9 + r11 - 1] cannam@128: cannam@128: mov rdi, prev_ad cannam@128: cannam@128: ;;; Jump into the main loop. cannam@128: cannam@128: mov edx, [chainlenwmask] cannam@128: cannam@128: cmp bx,word ptr [rsi + r8 - 1] cannam@128: jz LookupLoopIsZero cannam@128: cannam@128: LookupLoop1: cannam@128: and r8d, edx cannam@128: cannam@128: movzx r8d, word ptr [rdi + r8*2] cannam@128: cmp r8d, ebp cannam@128: jbe LeaveNow cannam@128: sub edx, 00010000h cannam@128: js LeaveNow cannam@128: cannam@128: LoopEntry1: cannam@128: cmp bx,word ptr [rsi + r8 - 1] cannam@128: jz LookupLoopIsZero cannam@128: cannam@128: LookupLoop2: cannam@128: and r8d, edx cannam@128: cannam@128: movzx r8d, word ptr [rdi + r8*2] cannam@128: cmp r8d, ebp cannam@128: jbe LeaveNow cannam@128: sub edx, 00010000h cannam@128: js LeaveNow cannam@128: cannam@128: LoopEntry2: cannam@128: cmp bx,word ptr [rsi + r8 - 1] cannam@128: jz LookupLoopIsZero cannam@128: cannam@128: LookupLoop4: cannam@128: and r8d, edx cannam@128: cannam@128: movzx r8d, word ptr [rdi + r8*2] cannam@128: cmp r8d, ebp cannam@128: jbe LeaveNow cannam@128: sub edx, 00010000h cannam@128: js LeaveNow cannam@128: cannam@128: LoopEntry4: cannam@128: cannam@128: cmp bx,word ptr [rsi + r8 - 1] cannam@128: jnz LookupLoop1 cannam@128: jmp LookupLoopIsZero cannam@128: cannam@128: cannam@128: ;;; do { cannam@128: ;;; match = s->window + cur_match; cannam@128: ;;; if (*(ushf*)(match+best_len-1) != scan_end || cannam@128: ;;; *(ushf*)match != scan_start) continue; cannam@128: ;;; [...] cannam@128: ;;; } while ((cur_match = prev[cur_match & wmask]) > limit cannam@128: ;;; && --chain_length != 0); cannam@128: ;;; cannam@128: ;;; Here is the inner loop of the function. The function will spend the cannam@128: ;;; majority of its time in this loop, and majority of that time will cannam@128: ;;; be spent in the first ten instructions. cannam@128: ;;; cannam@128: ;;; Within this loop: cannam@128: ;;; ebx = scanend cannam@128: ;;; r8d = curmatch cannam@128: ;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask) cannam@128: ;;; esi = windowbestlen - i.e., (window + bestlen) cannam@128: ;;; edi = prev cannam@128: ;;; ebp = limit cannam@128: cannam@128: LookupLoop: cannam@128: and r8d, edx cannam@128: cannam@128: movzx r8d, word ptr [rdi + r8*2] cannam@128: cmp r8d, ebp cannam@128: jbe LeaveNow cannam@128: sub edx, 00010000h cannam@128: js LeaveNow cannam@128: cannam@128: LoopEntry: cannam@128: cannam@128: cmp bx,word ptr [rsi + r8 - 1] cannam@128: jnz LookupLoop1 cannam@128: LookupLoopIsZero: cannam@128: cmp r12w, word ptr [r10 + r8] cannam@128: jnz LookupLoop1 cannam@128: cannam@128: cannam@128: ;;; Store the current value of chainlen. cannam@128: mov [chainlenwmask], edx cannam@128: cannam@128: ;;; Point edi to the string under scrutiny, and esi to the string we cannam@128: ;;; are hoping to match it up with. In actuality, esi and edi are cannam@128: ;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is cannam@128: ;;; initialized to -(MAX_MATCH_8 - scanalign). cannam@128: cannam@128: lea rsi,[r8+r10] cannam@128: mov rdx, 0fffffffffffffef8h; -(MAX_MATCH_8) cannam@128: lea rsi, [rsi + r13 + 0108h] ;MAX_MATCH_8] cannam@128: lea rdi, [r9 + r13 + 0108h] ;MAX_MATCH_8] cannam@128: cannam@128: prefetcht1 [rsi+rdx] cannam@128: prefetcht1 [rdi+rdx] cannam@128: cannam@128: cannam@128: ;;; Test the strings for equality, 8 bytes at a time. At the end, cannam@128: ;;; adjust rdx so that it is offset to the exact byte that mismatched. cannam@128: ;;; cannam@128: ;;; We already know at this point that the first three bytes of the cannam@128: ;;; strings match each other, and they can be safely passed over before cannam@128: ;;; starting the compare loop. So what this code does is skip over 0-3 cannam@128: ;;; bytes, as much as necessary in order to dword-align the edi cannam@128: ;;; pointer. (rsi will still be misaligned three times out of four.) cannam@128: ;;; cannam@128: ;;; It should be confessed that this loop usually does not represent cannam@128: ;;; much of the total running time. Replacing it with a more cannam@128: ;;; straightforward "rep cmpsb" would not drastically degrade cannam@128: ;;; performance. cannam@128: cannam@128: cannam@128: LoopCmps: cannam@128: mov rax, [rsi + rdx] cannam@128: xor rax, [rdi + rdx] cannam@128: jnz LeaveLoopCmps cannam@128: cannam@128: mov rax, [rsi + rdx + 8] cannam@128: xor rax, [rdi + rdx + 8] cannam@128: jnz LeaveLoopCmps8 cannam@128: cannam@128: cannam@128: mov rax, [rsi + rdx + 8+8] cannam@128: xor rax, [rdi + rdx + 8+8] cannam@128: jnz LeaveLoopCmps16 cannam@128: cannam@128: add rdx,8+8+8 cannam@128: cannam@128: jnz short LoopCmps cannam@128: jmp short LenMaximum cannam@128: LeaveLoopCmps16: add rdx,8 cannam@128: LeaveLoopCmps8: add rdx,8 cannam@128: LeaveLoopCmps: cannam@128: cannam@128: test eax, 0000FFFFh cannam@128: jnz LenLower cannam@128: cannam@128: test eax,0ffffffffh cannam@128: cannam@128: jnz LenLower32 cannam@128: cannam@128: add rdx,4 cannam@128: shr rax,32 cannam@128: or ax,ax cannam@128: jnz LenLower cannam@128: cannam@128: LenLower32: cannam@128: shr eax,16 cannam@128: add rdx,2 cannam@128: LenLower: sub al, 1 cannam@128: adc rdx, 0 cannam@128: ;;; Calculate the length of the match. If it is longer than MAX_MATCH, cannam@128: ;;; then automatically accept it as the best possible match and leave. cannam@128: cannam@128: lea rax, [rdi + rdx] cannam@128: sub rax, r9 cannam@128: cmp eax, MAX_MATCH cannam@128: jge LenMaximum cannam@128: cannam@128: ;;; If the length of the match is not longer than the best match we cannam@128: ;;; have so far, then forget it and return to the lookup loop. cannam@128: ;/////////////////////////////////// cannam@128: cannam@128: cmp eax, r11d cannam@128: jg LongerMatch cannam@128: cannam@128: lea rsi,[r10+r11] cannam@128: cannam@128: mov rdi, prev_ad cannam@128: mov edx, [chainlenwmask] cannam@128: jmp LookupLoop cannam@128: cannam@128: ;;; s->match_start = cur_match; cannam@128: ;;; best_len = len; cannam@128: ;;; if (len >= nice_match) break; cannam@128: ;;; scan_end = *(ushf*)(scan+best_len-1); cannam@128: cannam@128: LongerMatch: cannam@128: mov r11d, eax cannam@128: mov match_start, r8d cannam@128: cmp eax, [nicematch] cannam@128: jge LeaveNow cannam@128: cannam@128: lea rsi,[r10+rax] cannam@128: cannam@128: movzx ebx, word ptr [r9 + rax - 1] cannam@128: mov rdi, prev_ad cannam@128: mov edx, [chainlenwmask] cannam@128: jmp LookupLoop cannam@128: cannam@128: ;;; Accept the current string, with the maximum possible length. cannam@128: cannam@128: LenMaximum: cannam@128: mov r11d,MAX_MATCH cannam@128: mov match_start, r8d cannam@128: cannam@128: ;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len; cannam@128: ;;; return s->lookahead; cannam@128: cannam@128: LeaveNow: cannam@128: IFDEF INFOZIP cannam@128: mov eax,r11d cannam@128: ELSE cannam@128: mov eax, Lookahead cannam@128: cmp r11d, eax cannam@128: cmovng eax, r11d cannam@128: ENDIF cannam@128: cannam@128: ;;; Restore the stack and return from whence we came. cannam@128: cannam@128: cannam@128: mov rsi,[save_rsi] cannam@128: mov rdi,[save_rdi] cannam@128: mov rbx,[save_rbx] cannam@128: mov rbp,[save_rbp] cannam@128: mov r12,[save_r12] cannam@128: mov r13,[save_r13] cannam@128: ; mov r14,[save_r14] cannam@128: ; mov r15,[save_r15] cannam@128: cannam@128: cannam@128: ret 0 cannam@128: ; please don't remove this string ! cannam@128: ; Your can freely use gvmat64 in any free or commercial app cannam@128: ; but it is far better don't remove the string in the binary! cannam@128: db 0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998, converted to amd 64 by Gilles Vollant 2005",0dh,0ah,0 cannam@128: longest_match ENDP cannam@128: cannam@128: match_init PROC cannam@128: ret 0 cannam@128: match_init ENDP cannam@128: cannam@128: cannam@128: END