Sequence of primes by trial division: Difference between revisions

*   [[partition an integer X into N primes]]

<br><br>

 

=={{header|Ada}}==

Use the generic function Prime_Numbers.Is_Prime, as specified in [[Prime decomposition#Ada]]. The program reads two numbers A and B from the command line and prints all primes between A and B (inclusive).

 

 

procedure Sequence_Of_Primes is

end if;

end loop;

 

{{out}}

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

Simple bounded sequence using the "is prime" routine from [[Primality by trial division#ALGOL 68]]

MODE ISPRIMEINT = INT;

PROC is prime = ( ISPRIMEINT p )BOOL:

print( ( " ", whole( primes[ p ], 0 ) ) )

OD;

{{out}}

<pre>

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

Uses the ALGOL W isPrime procedure from the Primality by Trial Division task.

% use the isPrime procedure from the Primality by Trial Division task %

logical procedure isPrime ( integer value n ) ; algol "isPrime" ;

end

 

{{out}}

<pre>

=={{header|ALGOL-M}}==

The approach here follows an example given by Edsger Dijkstra in his classic 1969 paper, Notes on Structured Programming. Only odd numbers above 2 are checked for primality, and only the prime numbers previously found (up to the square root of the number under examination) are tested as divisors.

BEGIN

 

 

END

 

{{out}}

9: 23

10: 29

</pre>

 

=={{header|ATS}}==

// Lazy-evaluation:

// sieve for primes

end // end of [main0]

 

 

=={{header|AWK}}==

# syntax: GAWK -f SEQUENCE_OF_PRIMES_BY_TRIAL_DIVISION.AWK

BEGIN {

return(1)

}

{{out}}

<pre>

25 prime numbers found in range 1-100

</pre>

 

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

@echo off

::Prime list using trial division

set lin=!cnt1:~-5!:

goto:eof

{{Out}}

<pre>

280: 1823 1831 1847 1861 1867 1871 1873 1877 1879 1889

</pre>

 

=={{header|Befunge}}==

Based on the test in the [[Primality_by_trial_division#Befunge|Primality by trial division]] task, this list all primes between 2 and 1,000,000.

 

v_v#`\*:%*:*84\/*:*84::+<

v#>::48*:*/\48*:*%%!#v_1^

 

{{out}}

 

=={{header|C}}==

#include<stdio.h>

 

return 0;

}

Output :

<pre>

 

=={{header|C sharp}}==

using System.Collections.Generic;

using System.Linq;

}

 

static bool IsPrime(int n) => Enumerable.Range(2, (int)Math.Sqrt(n)-1).All(i => n % i != 0);

{{out}}

<pre>

 

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

#include <math.h>

#include <iostream>

return 0;

}

{{out}}

<pre>

 

=={{header|Clojure}}==

(:require [clojure.math.numeric-tower :as math]))

 

a))

 

 

{{Output}}

 

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

"Compute all primes up to MAX-NUMBER using trial division"

(loop for n from 2 upto max-number

(lambda (x) (integerp (/ n x))))

 

Output: <pre>(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97)</pre>

=={{header|Crystal}}==

See https://rosettacode.org/wiki/Primality_by_trial_division#Crystal

 

def primep5?(n) # P5 Prime Generator primality test

 

# Create sequence of primes from 1_000_000_001 to 1_000_000_201

{{out}}

<pre>1000000007

{{trans|Haskell}}

This is a quite inefficient prime generator.

std.numeric, std.concurrency;

 

.take(20)

.writeln;

{{out}}

<pre>[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71]</pre>

 

=={{header|EchoLisp}}==

===Trial division===

(define (is-prime? p)

(cond

(for/and ((d [3 5 .. (1+ (sqrt p))] )) (!zero? (modulo p d)))]))

 

 

===Bounded - List filter ===

 

=== Unbounded - Sequence filter ===

→ # 👓 filter: #sequence [2 3 .. Infinity[

 

(take f-primes 25)

 

=== Unbounded - Stream ===

(for ((p [n (+ n 2) .. ] ))

#:break (is-prime? p) => (cons p (+ p 2))))

 

(take s-primes 25)

 

=== Unbounded - Generator ===

(define next

(for ((p [n .. ] )) #:break (is-prime? p) => p ))

 

(take g-primes 25)

 

=== Unbounded - Background task ===

(lib 'bigint)

 

1000000000121

1000000000163

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

{{out}}

<pre>

 

=={{header|Elena}}==

import system'routines;

import system'math;

isPrime =

Primes =

public program()

{

console.printLine(Primes(100))

{{out}}

<pre>

 

=={{header|Elixir}}==

def sequence do

Stream.iterate(2, &(&1+1)) |> Stream.filter(&is_prime/1)

end

 

 

{{out}}

 

=={{header|ERRE}}==

PROGRAM PRIME_GENERATOR

 

END LOOP

END PROGRAM

You must press Ctrl+Break to stop the program.

{{out}}

 

=={{header|F Sharp}}==

(*

Nigel Galloway April 7th., 2017.

yield n; yield! fg (Seq.cache(Seq.filter (fun g->g%n<>0) (Seq.skip 1 ng)))}

fg (Seq.initInfinite(id)|>Seq.skip 2)

Let's print the sequence Prime[23] to Prime[42].

{{out}}

[23..42] |> Seq.iter(fun n->printf "%d " (Seq.item n SofE))

<pre>

89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191

 

=={{header|Factor}}==

math.ranges prettyprint sequences ;

 

 

! Show the first fifteen primes.

{{out}}

<pre>

 

=={{header|FileMaker}}==

Set Error Capture [On]

Allow User Abort [Off]

End If

#

 

=={{header|Forth}}==

This program stores the generated primes into a user allocated array and uses the primes generated so far to test divisibility of subsequent candidates. In FORTH, the PAD can be used as a large memory area that is always available, and the main .primes word makes use of that.

variable p-start \ beginning of prime buffer

variable p-end \ end of prime buffer

i @ 5 .r

cell +loop ;

{{Out}}

<pre>

This method avoids considering multiples of two and three, leading to the need to pre-load array PRIME and print the first few values explicitly rather than flounder about with special startup tricks. Even so, in order not to pre-load with 7, and to correctly start the factor testing with 5, the first few primes are found with some wasted effort because 5 is not needed at the start. Storing the primes as found has the obvious advantage of enabling divisions only by prime numbers, but care with the startup is needed to ensure that primes have indeed been stored before they are called for.

 

CONCOCTED BY R.N.MCLEAN, APPLIED MATHS COURSE, AUCKLAND UNIVERSITY, MCMLXXI.

INTEGER ENUFF,PRIME(44)

40 IF (N - 32767) 10,41,41

41 WRITE (6,34) (ALINE(I), I = 1,LL)

 

Start of output:

 

=={{header|FreeBASIC}}==

 

Function isPrime(n As Integer) As Boolean

Print : Print

Print "Press any key to quit"

 

{{out}}

=={{header|Go}}==

An unbounded cascading filtering method using channels, adapted from the classic concurrent prime sieve example in the "Try Go" window at http://golang.org/, improved by postponing the initiation of the filtering by a prime until the prime's square is seen in the input.

import "fmt"

}

fmt.Println()

{{out}}

<pre>

</pre>

A simple iterative method, also unbounded and starting with 2.

 

import "fmt"

}

fmt.Println()

{{out}}

<pre>

=={{header|Haskell}}==

The most basic:

 

With trial division emulated by additions (the seeds of Sieve):

 

With recursive filtering (in wrong order, from bigger to smaller natural numbers):

 

With iterated sieving (in right order, from smaller to bigger primes):

 

A proper [[Primality by trial division#Haskell|primality testing by trial division]] can be used to produce short ranges of primes more efficiently:

 

The standard optimal trial division version has <code>isPrime</code> in the above inlined:

 

primes = 2 : [n | n <- [3..], foldr (\p r-> p*p > n || rem n p > 0 && r)

 

It is easy to amend this to test only odd numbers by only odd primes, or automatically skip the multiples of ''3'' (also, ''5'', etc.) by construction as well (a ''wheel factorization'' technique):

 

True (drop 1 primes)]

= [2,3,5] ++ [n | n <- scanl (+) 7 (cycle [4,2]),

foldr (\p r-> p*p > n || rem n p > 0 && r)

True (drop 2 primes)]

 

It is also easy to extend the above in generating the factorization wheel automatically as follows:

 

wheelGen :: Int -> ([Int],Int,[Int])

wheelGen n = loop 1 3 [2] [2] where

| any ((==) 0 . rem n)

(takeWhile ((<= n) . flip (^) 2) bps) = xtrprms (n + g) gs'

 

This is likely about the fastest of the trial division prime generators at just a few seconds to generate the primes up to ten million, which is about the limit of its practical range. An incremental Sieve of Eratosthenes sieve will extend the useful range about ten times this and isn't that much more complex.

===Sieve by trial division===

The classic David Turner's 1983 (1976? 1975?) SASL code repeatedly ''sieves'' a stream of candidate numbers from those divisible by a prime at a time, and works even for unbounded streams, thanks to lazy evaluation:

where

sieve (p:xs) = p : sieve [x | x <- xs, rem x p /= 0]

-- map head

 

As shown in Melissa O'Neill's paper [http://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf "The Genuine Sieve of Eratosthenes"], its complexity is quadratic in number of primes produced whereas that of optimal trial division is <math>O(n^{1.5}/(\log n)^{0.5})</math>, and of true SoE it is <math>O(n\log n\log\log n)</math>, in ''n'' primes produced.

===Bounded sieve by trial division===

Bounded formulation has normal trial division complexity, because it can stop early via an explicit guard:

where

sieve (p:xs) | p*p > m = p : xs

| otherwise = p : sieve [x | x <- xs, rem x p /= 0]

-- (\(a,b:_) -> map head a ++ b) . span ((< m).(^2).head)

 

===Postponed sieve by trial division===

{{trans|Racket}}

To make it unbounded, the guard cannot be simply discarded. The firing up of a filter by a prime should be ''postponed'' until its ''square'' is seen amongst the candidates (so a bigger chunk of input numbers are taken straight away as primes, between each opening up of a new filter, instead of just one head element in the non-postponed algorithm):

where

sieve ~(p:ps) (x:xs) = x : after (p*p) xs

| otherwise = f (x:xs)

-- fix $ concatMap (fst.fst) . iterate (\((_,t),p:ps) ->

 

<code>~(p:ps)</code> is a lazy pattern: the matching will be delayed until any of its variables are actually needed. Here it means that on the very first iteration the head of <code>primesPT</code> will be safely accessed only after it is already defined (by <code>x : after (p*p) ...</code>).

Note that the above introduced laziness for the evaluation of the head of the base primes list in order to avoid a race isn't necessary for the usual method of just introducing the first of the base primes before starting the computation as follows (use the same `wheelGen` as above for this wheel factorized version):

 

primesPTDW() = -- causes mucho allocation of deferred thunks!

wheelPrimes ++ _Y ((firstSievePrime :) . sieve cndts) where

q = bp * bp

after (x:xs') | x >= q = sieve (filter ((> 0) . (`rem` bp)) xs') bps'

 

However, these postponed solutions are slower than the last of the basic trial division prime generators as the (nested) filters add greatly the the deferred "thunks" stored to the heap rather than the more direct (and more strict) determination of whether a number is prime as it's output.

===Segmented Generate and Test===

Explicating the run-time list of ''filters'' (created implicitly by the sieves above) as a list of ''factors to test by'' on each segment between the consecutive squares of primes (so that no testing is done prematurely), and rearranging to avoid recalculations, leads to the following:

 

primesST = 2 : 3 : sieve 5 9 (drop 2 primesST) (inits $ tail primesST)

where

sieve x q ps (fs:ft) = filter (\y-> all ((/=0).rem y) fs) [x,x+2..q-2]

<code>inits</code> makes a stream of (progressively growing) prefixes of an input stream, starting with an empty prefix, here making the <code>fs</code> parameter to get a sequence of values <code>[], [3], [3,5], ...</code>.

 

 

Implementation:

try=. i.&.(p:inv) %: >./ y

candidate=. (y>1)*y=<.y

y #~ candidate*(y e.try) = +/ 0= try|/ y

 

Example use:

 

 

Note that this is a filter - it selects values from its argument which are prime. If no suitable values are found the resulting sequence of primes will be empty.

=={{header|Java}}==

{{works with|Java|8}}

 

public class Test {

getPrimes(0, 100).forEach(p -> System.out.printf("%d, ", p));

}

 

<pre>2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,</pre>

 

This entry uses is_prime/0 as defined at [[Primality_by_trial_division#jq]].

def primes(m; n):

([m,2] | max) as $m

elif $m == 2 then 2, primes(3;n)

else (1 + (2 * range($m/2 | floor; (n + 1) /2 | floor))) | select( is_prime )

 

'''Examples:'''

3

5

Produce an array of primes, p, satisfying 50 <= p <= 99:

[53,59,61,67,71,73,79,83,89,97]

 

I've chosen to solve this task by creating a new iterator type, <tt>TDPrimes</tt>. <tt>TDPrimes</tt> contains the upper limit of the sequence. The iteration state is the list of computed primes, and the item returned with each iteration is the current prime. The core of the solution is the <tt>next</tt> method for <tt>TDPrimes</tt>, which computes the next prime by trial division of the previously determined primes contained in the iteration state.

 

uplim::T

end

end

 

 

{{out}}

 

=={{header|Kotlin}}==

 

fun isPrime(n: Int): Boolean {

if (count % 15 == 0) println()

}

 

{{out}}

=={{header|Lambdatalk}}==

 

{def prime

{def prime.rec

{map prime {serie 9901 10000 2}}

-> 9901 9907 9923 9929 9931 9941 9949 9967 9973

More to see in [http://epsilonwiki.free.fr/lambdaway/?view=primes2]

 

=={{header|Liberty BASIC}}==

print "Rosetta Code - Sequence of primes by trial division"

print: print "Prime numbers between 1 and 50"

isPrime=1

end function

{{out}}

<pre>

 

=={{header|Lua}}==

function isprime (x)

if x < 2 then return false end

-- Main procedure

show(primes(100))

{{out}}

<pre>2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149</pre>

 

=={{header|MATLAB}}==

 

list = (2:lastNumber); %Construct list of numbers

primeList = [primeList list]; %The rest of the numbers in the list are primes

sieveOfEratosthenes(30)

=={{header|Nim}}==

{{trans|Kotlin}}

 

func isPrime(n: int): bool =

write(stdout, fmt"{i:5}")

if count mod 15 == 0:

 

{{out}}

1993 1997 1999

</pre>

 

=={{header|Oforth}}==

isPrime function is from Primality by trial division page

 

 

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

if(n < 4, return(n > 1)); /* Handle negatives */

forprime(p=2,sqrt(n),

};

 

 

=={{header|Pascal}}==

{{libheader|primTrial}} {{works with|Free Pascal}}

Hiding the work in a existing unit.

program PrimeRng;

uses

write(Range[i]:12);

writeln;

;output:

<pre> 1000000007 1000000009 1000000021 1000000033 1000000087 1000000093 1000000097</pre>

 

=={{header|Perl}}==

}

 

{{out}}

<pre>2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

 

=={{header|Phix}}==

<pre>

</pre>

 

=={{header|PicoLisp}}==

(or

(= N 2)

(filter prime? (range A B)) )

 

{{out}}

<pre>(53 59 61 67 71 73 79 83 89 97)</pre>

 

=={{header|PowerShell}}==

function eratosthenes ($n) {

if($n -ge 1){

}

"$(sieve-start-end 100 200)"

<b>Output:</b>

<pre>

=={{header|Prolog}}==

Creates a 2,3,5 factorization wheel to eliminate the majority of divisors and prime candidates before filtering.

wheel235(L) :-

W = [6, 4, 2, 4, 2, 4, 6, 2 | W],

lazy_list(accumulate, 1/W, L).

 

 

roll235wheel(Limit, A) :-

roll235wheel(Limit, Candidates),

include(prime235, Candidates, Primes).

{{Out}}

<pre>

X = 997.

</pre>

=={{header|PureBasic}}==

#SPC=Chr(32)

#TB=~"\t"

Print(~"\nPrimes= "+Str(*count\i))

Input()

{{out}}

<pre>Input (n1<n2 & n1>0)

=={{header|Python}}==

Using the basic ''prime()'' function from: [http://rosettacode.org/wiki/Primality_by_trial_division#Python "Primality by trial division"]

def prime(a):

return not (a < 2 or any(a % x == 0 for x in xrange(2, int(a**0.5) + 1)))

def primes_below(n):

return [i for i in range(n) if prime(i)]

{{out}}

<pre>>>> primes_below(100)

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]</pre>

 

=={{header|Racket}}==

This example uses infinite lists (streams) to implement a sieve algorithm that produces all prime numbers.

 

(define nats (cons 1 (map add1 nats)))

(define (sift n l) (filter (λ(x) (not (zero? (modulo x n)))) l))

(define (sieve l) (cons (first l) (sieve (sift (first l) (rest l)))))

(define primes (sieve (rest nats)))

 

==== Optimized with postponed processing ====

Since a prime's multiples that count start from its square, we should only add them when we reach that square.

 

(define nats (cons 1 (map add1 nats)))

(define (sift n l) (filter (λ(x) (not (zero? (modulo x n)))) l))

(λ(t) (sieve (sift (car ps) t) (cdr ps))))))

(define primes (sieve (cdr nats) primes))

 

=== Using threads and channels ===

Same algorithm as above, but now using threads and channels to produce a channel of all prime numbers (similar to newsqueak). The macro at the top is a convenient wrapper around definitions of channels using a thread that feeds them.

 

(define-syntax (define-thread-loop stx)

(syntax-case stx ()

(let ([x (channel-get c)]) (out! x) (set! c (sift x c))))

(define primes (let ([ns (nats)]) (channel-get ns) (sieve ns)))

 

=== Using generators ===

Yet another variation of the same algorithm as above, this time using generators.

 

(require racket/generator)

(define nats (generator () (for ([i (in-naturals 1)]) (yield i))))

(generator () (let loop ([g g]) (let ([x (g)]) (yield x) (loop (sift x g))))))

(define primes (begin (nats) (sieve nats)))

 

=={{header|Raku}}==

(formerly Perl 6)

Here is a straightforward implementation of the naive algorithm.

 

{{out}}

<pre>2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541</pre>

 

Usage note: &nbsp; by using a negative number (for the program's argument), the list of primes is suppressed, but the prime count is still shown.

parse arg n . /*get optional number of primes to find*/

if n=='' | n=="," then n= 26 /*Not specified? Then use the default.*/

end /*j*/ /* [↑] only display N number of primes*/

/* [↓] display number of primes found.*/

{{out|output|text=&nbsp; when using the default input: &nbsp; &nbsp; <tt> 26 </tt>}}

<pre>

This version shows how the REXX program may be optimized further by extending the list of low primes and

<br>the special low prime divisions &nbsp; (the &nbsp; <big>'''//'''</big> &nbsp; tests, &nbsp; which is the &nbsp; ''remainder'' &nbsp; when doing division).

parse arg N . /*get optional number of primes to find*/

if N=='' | N=="," then N= 26 /*Not specified? Then assume default.*/

end /*j*/ /* [↑] only display N number of primes*/

/* [↓] display number of primes found.*/

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}} <br><br>

 

=={{header|Ring}}==

for i = 1 to 100

if isPrime(i) see "" + i + " " ok

next

return true

 

=={{header|Ruby}}==

The Prime class in the standard library has several Prime generators. In some methods it can be specified which generator will be used. The generator can be used on it's own:

 

pg = Prime::TrialDivisionGenerator.new

p pg.take(10) # => [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

 

===By Trial Division w/Prime Generator===

See https://rosettacode.org/wiki/Primality_by_trial_division#Ruby

# P5 = 30*k + {7,11,13,17,19,23,29,31} # P5 primes candidates sequence

return [2, 3, 5].include?(n) if n < 7 # for small and negative values

 

# Create sequence of primes from 1_000_000_001 to 1_000_000_201

{{out}}

<pre>1000000007

1000000123

1000000181</pre>

 

=={{header|S-BASIC}}==

comment

Prime number generator in S-BASIC. Only odd numbers are

 

$constant false = 0

 

var i, k, m, n, s, nprimes, divisible = integer

if s <= n then k = k + 1

divisible = false

while (m <= k) and (divisible = false) do

begin

print "All done. Goodbye"

end

{{out}}

<pre>

===Odds-Only "infinite" primes generator using Streams and Co-Inductive Streams===

Using Streams, [http://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf the "unfaithful sieve"], i.e. '''sub-optimal trial division sieve'''.

Stream.cons(nums.head, sieve((nums.tail).filter(_ % nums.head != 0)))

val primes = 2 #:: sieve(Stream.from(3, 2))

 

println(primes take 10 toList) // //List(2, 3, 5, 7, 11, 13, 17, 19, 23, 29)

{{out}}Both println statements give the same results:

<pre>List(2, 3, 5, 7, 11, 13, 17, 19, 23, 29)</pre>

=={{header|Sidef}}==

Using the ''is_prime()'' function from: [http://rosettacode.org/wiki/Primality_by_trial_division#Sidef "Primality by trial division"]

var (counter, number) = (0, 0);

while (counter < amount) {

}

 

 

=={{header|Spin}}==

{{works with|HomeSpun}}

{{works with|OpenSpin}}

_clkmode = xtal1+pll16x

_clkfreq = 80_000_000

 

waitcnt(_clkfreq + cnt)

{{Out}}

<pre>

 

=={{header|Swift}}==

 

extension SequenceType {

}

return pastPrimes.last

===Simple version===

{{works with|Swift 2 and Swift 3}}

 

func trialPrimes(_ max:Int){

 

trialPrimes(100)

{{out}}

<pre>

=={{header|Tailspin}}==

Simplest version

templates ifPrime

def n: $;

end ifPrime

 

100 -> primes -> '$;

' -> !OUT::write

{{out}}

<pre>

=={{header|Tcl}}==

As we're generating a sequence of primes, we can use that sequence of primes to describe what we're filtering against.

proc havePrime n {

global primes

}

}

{{out}}

<pre>

2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

Using a simple generator.

 

var primeSeq = Fiber.new {

if (count%15 == 0) System.print()

if (count == limit) break

 

{{out}}

1993 1997 1999 2003 2011 2017 2027 2029 2039 2053 2063 2069 2081 2083 2087

</pre>

 

=={{header|zkl}}==

The code in [[Extensible prime generator#zkl]] is a much better solution to this problem.

{{trans|Python}}

(p>=2) and (not [2 .. p.toFloat().sqrt()].filter1('wrap(n){ p%n==0 }))

}

The Method filter1 stops at the first non False result, which, if there is one, is the first found diviser, thus short cutting the rest of the test.

{{out}}

<pre>