Middle three digits: Difference between revisions

Show your output on this page.

<br><br>

 

=={{header|Ada}}==

 

 

procedure Middle_Three_Digits is

end loop;

 

 

{{out}}

 

=={{header|Aime}}==

m3(integer i)

{

 

return 0;

{{out}}

<pre> 123: 123

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.6.win32}}

# return either an integer on success or a error message if #

# the middle 3 digits couldn't be extracted #

print( ( newline ) )

OD

{{out}}

<pre>

 

=={{header|ALGOL W}}==

% record structure that will be used to return the middle 3 digits of a number %

% if the middle three digits can't be determined, isOk will be false and message %

end for_n

 

{{out}}

<pre>

0: Number must have at least 3 digits

</pre>

 

=={{header|ATS}}==

(* ****** ****** *)

//

 

(* ****** ****** *)

{{out}}

<pre>Middle-three-digits(123): 123

 

=={{header|AutoHotkey}}==

Loop, parse, Numbers, `,

{

log := log . A_LoopField . "`t: " . SubStr(n,((d-3)//2)+1,3) . "`n"

}

{{out}}

<pre>123 : 123

 

=={{header|AWK}}==

# use as: awk -f middle_three_digits.awk

 

}

}

{{out}}

<pre>

=={{header|BASIC}}==

==={{header|Applesoft BASIC}}===

110 DEF FN N(N) = VAL(MID$(STR$(INT(ABS(N))),(FN L(N)-1)/2,3))

120 DEF FN EVEN(N) = INT(N/2) = N/2

300 DATA123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345

310 DATA1,2,-1,-10,2002,-2002,0

{{out}}

<pre>

0: ?ONLY 1 DIGIT

</pre>

 

==={{header|BBC BASIC}}===

FOR i% = 1 TO 17

READ test%

OTHERWISE

= MID$(n$, LEN n$ / 2, 3)

{{out}}

<pre> 123 -> 123

 

==={{header|FBSL}}===

 

DIM numbers AS STRING = "123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345,1,2,-1,-10,2002,-2002,0"

RETURN m

END IF

Output

<pre> 123 --> 123

 

==={{header|IS-BASIC}}===

120 PRINT MIDDLE$(N)

130 DEF MIDDLE$(N)

170 LET P=(LEN(N$)-3)/2

180 LET MIDDLE$=N$(P+1:P+3)

 

 

==={{header|PureBasic}}===

Protected x$, digitCount

 

Print(#crlf$ + #crlf$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre> 123 : 123

 

==={{header|Run BASIC}}===

 

while word$(x$,i+1,",") <> ""

end if

wend

<pre>123 123

234 12345

-2002 length < 3 or is even

0 length < 3 or is even</pre>

 

=={{header|Batch File}}==

setlocal enabledelayedexpansion

 

)

goto :EOF

{{Out}}

<pre>123: 123

 

Press any key to continue . . .</pre>

 

=={{header|Befunge}}==

Reads the integer value from stdin and writes the middle three digits (or an error message) to stdout.

 

v+*86%+55:p00<

>\55+/:00g1+\|

2^,+55_,#!>#:<

>/>\#<$#-:#1_v

 

{{out}} (multiple runs)

 

=={{header|Bracmat}}==

= x p

. @(!arg:? [?p:? [(1/2*!p+-3/2) %?x [(1/2*!p+3/2) ?)

&

);

Output:

<pre>123

=={{header|Burlesque}}==

 

blsq ) {123 12345 1234567 987654321 -10001 -123}{XX{~-}{L[3.>}w!m]\[}m[uN

123

000

123

 

<tt>m]\[</tt> and <tt>uN</tt> are just for displaying it nicely.

=={{header|C}}==

This code is followed by its output.

#include <stdio.h>

#include <stdlib.h>

}

return 0;

 

<pre>

===Alternative Version===

This code has been extensively rewritten. The original was purely interactive and had to be invoked each time from the console. It also did not produce the correct answer.

#include <stdio.h>

#include <stdlib.h>

}

 

{{out}}

Error, 0 is too short.

The middle three digits of 1234567890 are 456.

</pre>

 

=={{header|C++}}==

 

std::string middleThreeDigits(int n)

}

}

{{out}}

<pre>middleThreeDigits(123): 123

middleThreeDigits(-2002): even number of digits

middleThreeDigits(0): less than three digits</pre>

 

=={{header|Clojure}}==

(cond

 

 

{{out}}

<pre>

</pre>

 

=={{header|COBOL}}==

program-id. middle3.

environment division.

add 1 to digit-counter

end-perform.

Output

<pre> 123 --> 123

0 --> Number too small</pre>

Optimised version

program-id. middle3.

environment division.

end-if.

 

Output

<pre> 123 --> 123

 

=={{header|Common Lisp}}==

(defun mid3 (n)

(let ((a (abs n))

((evenp hmd) (need "odd number of"))

(t (nbr (mod (truncate a (expt 10 (/ (- hmd 3) 2))) 1000)))))))

 

Test code:

 

(loop as n in '(123 12345 1234567 987654321

10001 -10001 -123 -100 100 -12345

1 2 -1 -10 2002 -2002 0)

do (format t "~d:~12t~a~%" n (mid3 n)))

{{out}}

<pre>123: 123

-2002: Need odd number of digits, not 4.

0: Zero is 1 digit</pre>

 

=={{header|D}}==

 

string middleThreeDigits(T)(in T n) pure nothrow if (isIntegral!T) {

foreach (immutable n; failing)

writefln("middleThreeDigits(%s): %s", n, middleThreeDigits(n));

{{out}}

<pre>middleThreeDigits(123): 123

===Alternative Version===

This longer version gives a stronger typed output, and it tries to be faster avoiding conversions to string.

 

/// Returns a string with the error, or the three digits.

writefln("middleThreeDigits(cast(short)%d): %s", n, mtd);

}

{{out}}

<pre>middleThreeDigits(123): 123

 

=={{header|Dart}}==

import'dart:math';

int length(int x)

}

}

=={{header|DCL}}==

$ i = 0

$ loop:

$ endif

$ i = i + 1

{{out}}

<pre>$ @middle_three_digits

-2002: has no middle three

0: has no middle three</pre>

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

{{out}}

<pre>

 

</pre>

=={{header|Elena}}==

middleThreeDigits(int n)

if(len<3)

{{out}}

<pre>

 

=={{header|Elixir}}==

def three(num) do

n = num |> abs |> to_string

e -> IO.puts e.message

end

 

{{out}}

 

=={{header|Erlang}}==

-module(middle_three_digits).

-export([main/0]).

loop(X,N) when X>0 ->

loop(X-1, N div 10).

{{out}}

<pre>123

 

=={{header|ERRE}}==

PROGRAM MIDDLE

 

END FOR

END PROGRAM

{{out}}

<pre>

 

=={{header|Factor}}==

sequences ;

IN: rosetta-code.middle-three-digits

 

 

 

abs number>string {

{ [ dup length 3 < ] [ drop too-short ] }

{ [ dup length even? ] [ drop number-even ] }

} cond ;

 

{{out}}

<pre>

=={{header|Forth}}==

This is a problem, which is easily solved in Forth. It converts the number to a string and checks it length. If the number does not represent a printable string, it returns an empty string.

abs s>d <# #s #> dup 2/ 0<> over 1 and 0<> and

if 2/ 1- chars + 3 else drop 0 then

=={{header|Fortran}}==

Please find compilation instructions along with the output for the examples in the comments at the beginning of the file. This program was produced in an Ubuntu distribution of the GNU/linux system.

!-*- mode: compilation; default-directory: "/tmp/" -*-

!Compilation started at Sat Jun 1 14:48:41

 

end program MiddleMuddle

 

=={{header|FreeBASIC}}==

 

Function middleThreeDigits (n As Integer) As String

Print

Print "Press any key to quit"

 

{{out}}

0 => Error: does not have 3 middle digits

</pre>

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=ed25e84978446d65895ccd909fc092fa Click this link to run this code]'''

Dim iList As Integer[] = [123, 12345, 1234567, 987654321, 10001,

-10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0] 'Array of integers to process

Next

 

Output:

<pre>

 

File m3.go:

 

import (

m := len(s) / 2

return s[m-1 : m+2], nil

File m3_test.go:

 

import (

t.Logf("d(%d) returns %q", tc.i, err)

}

{{out}}

Output of go test is normally terse:

 

=={{header|Gosu}}==

valid.each(\ num ->print(middleThree(num)))

 

var start = (s.length / 2) - 1

return s.substring(start, start + 3)

 

{{Output}}

 

=={{header|Groovy}}==

def text = Math.abs(number) as String

assert text.size() >= 3 : "'$number' must be more than 3 numeric digits"

int start = text.size() / 2 - 1

text[start..(start+2)]

Test Code:

def text = (number as String).padLeft(10)

try {

println "$text cannot be converted: $error.message"

}

Output:

<pre> 123: 123

 

=={{header|Haskell}}==

mid3 n

| otherwise = Right . take 3 $ drop ((lng - 3) `div` 2) s

where

lng = length s

 

main :: IO ()

main = do

, 0

]

(putStrLn . unlines) $

(\n ->

xs

Output:

<pre> 123 -> 123

100 -> 100

-12345 -> 234

 

=={{header|Icon}} and {{header|Unicon}}==

The following solution works in both languages.

 

every n := !a do write(right(n,15)," -> ",midM(n))

end

else "wrong number of digits"

else "too short"

 

with output:

 

=={{header|J}}==

'''Solution:'''

getPfxSize=: [: -:@| 3 -~ # NB. get size of prefix to drop before the 3 middle digits

getMid3=: (3 {. getPfxSize }. ,&'err') :: ('err'"_) NB. get 3 middle digits or return 'err'

'''Example:'''

getMiddle3 vals

123

err

err

 

=={{header|Java}}==

 

public static void main(String[] args) {

return s.substring(mid - 1, mid + 2);

}

<pre>middleThreeDigits(123): 123

middleThreeDigits(12345): 234

 

=={{header|JavaScript}}==

var n=''+Math.abs(x); var l=n.length-1;

if(l<2||l%2) throw new Error(x+': Invalid length '+(l+1));

1, 2, -1, -10, 2002, -2002, 0].forEach(function(n){

try{console.log(n,middleThree(n))}catch(e){console.error(e.message)}

 

<pre>123 "123"

Or, using an option type, composing a solution from existing generic primitives, and formatting the output a little:

{{Trans|Python}}

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>

 

=={{header|jq}}==

if . < 0 then -. else . end

| tostring as $s

 

(123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0)

123 => 123

12345 => 234

2002 => invalid length: 4

-2002 => invalid length: 4

=={{header|Julia}}==

{{works with|Julia|1.0.3}}

 

l = ndigits(n)

iseven(l) && error("n must have an odd number of digits")

-100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0]

@printf("%10d -> %s\n", n, try middle3(n) catch e e.msg end)

 

{{out}}

 

=={{header|K}}==

/ Rosetta code - Middle three digits

/ mid3.k

mid3: {qs:$x;:[qs[0]="-";qs: 1 _ qs];:[(#qs)<3;:"small";(1+#qs)!2;:"even"];p:(-3+#qs)%2;:(|p _|p _ qs)}

The output of the session:

{{out}}

"small")

</pre>

 

=={{header|Klong}}==

 

mid3::{[d k];:[3>k::#$#x;"small":|0=k!2;"even";(-d)_(d::_(k%2)-1)_$#x]}

Output:

<pre>[123 234 345 654 000 000 123 100 100 234 small small small small even even small]</pre>

 

=={{header|Kotlin}}==

val s = Math.abs(x).toString()

return when {

println(middleThree(123))// 123

println(middleThree(123555)) //null

 

=={{header|Lasso}}==

local(

pos_value = math_abs(#value),

'<br />'

^}

'''Output'''

<pre> 123: 123

 

=={{header|Logo}}==

if [less? :n 0] [make "n minus :n]

local "len make "len count :n

]

 

 

{{Output}}

 

=={{header|Lua}}==

if n < 0 then

n = -n

print(n, middle_three(n))

end

 

{{out}}

 

=={{header|Maple}}==

local nList, start;

nList := [seq(parse(i), i in convert (abs(n), string))];

middleDigits(i);

printf("\n");

{{out}}

<pre>

</pre>

 

Block[{digits = IntegerDigits[n], len},

len = Length[digits];

100, -12345, 1, 2, -1, -10, 2002, -2002, 0};

 

234

345

err: even number of digits

err: even number of digits

 

=={{header|MATLAB}} / {{header|Octave}}==

% http://rosettacode.org/wiki/Middle_three_digits

 

end;

 

Test with

Result

<pre>

0:*** error: number of digits must not be smaller than 3 ***

</pre>

 

=={{header|МК-61/52}}==

/ [x] ^ lg [x] 10^x П1 / {x} ИП1

* БП 00 1 + x=0 29 ИП0 С/П 0

 

''Instruction:'' enter the number in the РX (on display), the result after the execution of the same. In the case of an even or less than 3 number of digits the indicator displays an error message.

=={{header|ML}}==

==={{header|mLite}}===

val test_array = ["123","12345","1234567","987654321","10001","~10001","~123","~100","100","~12345","1","2","~1","~10","2002","~2002","0"];

;

Output:

<pre>123 --> 123

=={{header|MUMPS}}==

This sample shows the MUMPS code required to pass the specification.

MID3(N) ;

N LEN,N2

 

F I=123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345,1,2,-1,-10,2002,-2002,0 W !,$J(I,10),": ",$$MID3^MID3(I)

'''Output:'''

<pre>

=={{header|NetRexx}}==

This sample goes the extra mile and provides a method that can display the middle N digits from the input value. To satisfy the requirements of this task, a static invocation of this general method is also provided with the value '''<tt>3</tt>''' hard coded as the digit count.

options replace format comments java crossref symbols nobinary

 

end

return text

'''Output:'''

<pre>

 

=={{header|NewLISP}}==

(define (middle3 x)

(if (even? (length x))

 

(map middle3 lst)

'''Output:'''

<pre>

 

=={{header|Nim}}==

var s = $abs(i)

if s.len < 3 or s.len mod 2 == 0:

let mid = s.len div 2

return s[mid-1..mid+1]

const passing = @[123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345]

const failing = @[1, 2, -1, -10, 2002, -2002, 0]

for i in passing & failing:

var answer = try: middleThreeDigits(i)

<pre>middleThreeDigits(123) returned: 123

middleThreeDigits(12345) returned: 234

 

=={{header|Objeck}}==

class Test {

function : Main(args : String[]) ~ Nil {

}

 

 

<pre>

=={{header|OCaml}}==

 

 

let middle_three_digits x =

print_endline "Should fail:";

List.iter print failing;

 

{{out}}

=={{header|Oforth}}==

 

| s sz |

abs asString dup ->s size ->sz

sz 3 < ifTrue: [ "Too short" println return ]

sz isEven ifTrue: [ "Not odd number of digits" println return ]

 

{{out}}

=={{header|PARI/GP}}==

{{works with|PARI/GP|2.6.0}}

Output:

<pre>%1 = [123, 234, 345, 654, 0, 0, 123, 100, 100, 234, "no middle 3 digits", "no middle 3 digits", "no middle 3 digits", "no middle 3 digits", "no middle 3 digits", "no middle 3 digits", "no middle 3 digits"]</pre>

 

If for some reason you want to see the leading digits, you can run

 

For earlier versions <code>digits</code> can be defined as

or more efficiently as

=={{header|Pascal}}==

{{works with|Free Pascal}}

{$IFDEF FPC}

{$MODE Delphi} //result /integer => Int32 aka longInt etc..

writeln(n:9,': ',GetMid3dig(Test[i]));

end;

{{out}}

<pre> 123: 123

0: got too few digits

</pre>

=={{header|Perl}}==

use strict ;

use warnings ;

1, 2, -1, -10, 2002, -2002, 0 ) ;

map { middlethree( $_ ) } @numbers ;

{{out}}

<pre>Middle 3 digits of 123 : 123 !

Middle 3 digits can't be shown : 0 too short!

</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|PHP}}==

// 64-bit builds of PHP: Integers can be from -9223372036854775808 to 9223372036854775807

 

{

echo $nums.' : '.middlethree($nums). '<br>';

Output:

<pre>123 : 123

-2002 : The value must contain an odd amount of digits...

0 : The value must contain at least three digits...</pre>

 

=={{header|PicoLisp}}==

(let (Lst (chop (abs N)) Len (length Lst))

(tab (10 -2 -30)

((bit? 1 Len)

(head 3 (nth Lst (/ Len 2))) )

Test:

(123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345

Output:

<pre> 123: 123

-2002: even number of digits

0: not enough digits</pre>

 

=={{header|PL/I}}==

middle: procedure options (main); /* 29 October 2013 */

declare n fixed (15);

 

end middle;

Output:

<pre>

-2002 not possible

0 not possible

</pre>

 

=={{header|PowerShell}}==

 

$str = [Math]::abs($inp)

$sample = 123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0

 

{{Out}}

<pre>123: 123

-2002: [ERROR] even number of digits.

0: [ERROR] too short.</pre>

 

=={{header|Prolog}}==

{{works with|SWI-Prolog|6}}

 

middle_3_digits(Number, [D1,D2,D3]) :-

verify_middle_3_able(Number, Digits),

; true

).

 

 

Test code:

 

test_correct :-

TestCases = [123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345],

format('Middle 3 digits of ~w ~30|: ~w~n', [TestCase, Result])

).

 

 

 

=={{header|Python}}==

s = str(abs(i))

length = len(s)

middle_three_digits(-2002) returned: AssertionError('Need odd and >= 3 digits',)

middle_three_digits(0) returned: AssertionError('Need odd and >= 3 digits',)

 

{{Trans|Haskell}}

 

 

# mid3digits :: Int -> Either String String

def mid3digits(n):

m = abs(n)

s = str(m)

return Left('Less than 3 digits') if (100 > m) else (

)

 

# TEST ----------------------------------------------------

def main():

)

 

 

# GENERIC -------------------------------------------------

 

 

# compose (<<<) :: (b -> c) -> (a -> b) -> a -> c

def compose(g):

return lambda f: lambda x: g(f(x))

 

# either :: (a -> c) -> (b -> c) -> Either a b -> c

def either(fl):

return lambda fr: lambda e: fl(e['Left']) if (

None is e['Right']

# even :: Int -> Bool

def even(x):

return 0 == x % 2

 

 

)

 

 

if __name__ == '__main__':

{{Out}}

12345 -> 234

1234567 -> 345

-2002 -> (Even digit count)

0 -> (Less than 3 digits)</pre>

 

=={{header|Racket}}==

(define (middle x)

(cond

 

(map middle (list 123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345))

The output:

'("error: number too small" "error: number too small" "error: number too small" "error: number too small"

 

=={{header|REXX}}==

===version 1===

* 03.02.2013 Walter Pachl

* 19.04.2013 mid 3 is now a function returning the middle 3 digits

End

End

Output:

<pre>

<br><br>This REXX version is limited to numbers whose length is &nbsp; <big>≤</big> &nbsp; 100,000 &nbsp; decimal digits.

<br>(The decimal digits limit is defined via the &nbsp; '''numeric digits''' &nbsp; statement in the first line of the subroutine/procedure.)

n= '123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345',

'+123 0123 2 -1 -10 2002 -2002 0 abc 1e3 -17e-3 1234567.',

if L<3 then return er "argument is less than three digits."

if L//2==0 then return er "argument isn't an odd number of digits."

'''output'''

<pre>

 

=={{header|Ring}}==

n = 1234567

middle(n)

but lennr%2=0 see "Number must have an odd number of digits"

else cnr = substr(string(nr),mnr,3) see cnr + nl ok

 

=={{header|Ruby}}==

 

# minus sign doesn't factor into digit count,

# and calling #abs acts as a duck-type assertion

return str[length/2 - 1, 3].to_i

 

Testing program:

 

123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345,

1, 2, -1, -10, 2002, -2002, 0

puts e

end

{{out}}

<pre>

 

=={{header|Rust}}==

let s: String = x.abs().to_string();

let len = s.len();

print_result(*i);

}

 

{{Out}}

course just list the numbers backwards.

</pre>

define m3(i)

{

#endif

1, 2, -1, -10, 2002, -2002, 0 } );

{{out}}<pre>

" 123: 123"

 

=={{header|Scala}}==

* Optionally return the middle three digits of an integer.

*

case Some(v) => "%03d".format(v) // Format the value, force leading zeroes

} mkString("\n")

{{out}}

<pre>123

No middle three

No middle three

</pre>

 

=={{header|Seed7}}==

 

const func string: middle3 (in integer: number) is func

writeln(number <& ": " <& middle3(number));

end for;

 

{{out}}

-2002: error

0: error

</pre>

 

=={{header|Sidef}}==

if (l < 3) {

"#{n} is too short"

"#{n} has an even number of digits"

} else {

}

}

123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345

1 2 -1 -10 2002 -2002 0

{{out}}

<pre>

 

=={{header|SQL}}==

AS (SELECT CAST(ABS(NUMBER) AS NVARCHAR(MAX)) charNum,

NUMBER,

END Output,

NUMBER Input

 

<pre>

</pre>

=={{header|Swift}}==

if num<0{num = -num}

var numArray:[Int]=[]

i=i/2

print("\(numArray[i+1]),\(numArray[i]),\(numArray[i-1])")

<pre>

123: 123

0: Invalid Input

</pre>

 

=={{header|Tcl}}==

if {$n < 0} {

set n [expr {-$n}]

set idx [expr {$idx / 2}]

string range $n $idx [expr {$idx+2}]

Demonstrating:

123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345

1 2 -1 -10 2002 -2002 0

puts "found for ${n}: $mid"

}

{{out}}

<pre>

error for 0: no middle three digits: insufficient digits

</pre>

 

=={{header|UNIX Shell}}==

{{works with|Z Shell}}

 

{

typeset -i n="${1#-}"

printf "%10d: " $n

middle3digits "$n"

 

Output: <pre> 123: 123

=={{header|VBA}}==

 

Option Explicit

 

End If

End Function

{{out}}

<pre>123 Return : 123

 

=={{header|VBScript}}==

 

Function mid3n(n)

WScript.StdOut.Write n & ": " & mid3n(n)

WScript.StdOut.WriteLine

{{Out}}

<pre>

 

=={{header|Vedit macro language}}==

#1 = Get_Num("Enter a number, or 0 to stop: ", STATLINE)

Ins_Text("Input: ") Num_Ins(#1, COUNT, 10)

}

Buf_Quit(OK)

 

Output:

Input: -2002 Result: Not odd number of digits!

Input: 0 Result: Too few digits! </pre>

 

=={{header|Wart}}==

 

withs (digits (with outstring # itoa

(pr abs.n))

mid (int max/2))

if (and odd?.max (max >= 3))

 

'''Output'''

(mid3 0)

=> nil</pre>

 

=={{header|XPL0}}==

 

func Mid3Digits(I); \Return the middle three digits of I

Text(0, Mid3Digits(Passing(X))); CrLf(0);

];

 

{{out}}

 

=={{header|zkl}}==

ns.apply("toString").apply('-("-"))

.apply(fcn(n){nl:=n.len();

}

middle(T(123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345)).println()

{{out}}

<pre>