Calendar: Difference between revisions

{{task|Date and time}}

Create a routine that will generate a text calendar for any year.

:*   [[Five weekends]]

<br><br>

=={{header|360 Assembly}}==

{{trans|Free Basic}}

This program uses no external functions but two ASSIST macros (XDECO, XPRNT) to keep the code as short as possible.

CALENDAR CSECT

USING CALENDAR,R13 base register

31

</pre>

=={{header|Ada}}==

 

the [[Calendar_-_for_"real"_programmers#Ada]] task.

 

 

package Printable_Calendar is

We continue with the implementation (printable_calendar.ads):

 

 

package body Printable_Calendar is

Now, the main program is really simple:

 

 

procedure Cal is

 

To get a 132-character-wide output, you just have to replace "Init_80" by "Init_132" in the main program.

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

{{works with|ALGOL 68|Revision 1 - no extensions to language used}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

 

PROC print calendar = (INT year, page width)VOID: (

30

</pre>

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

{{trans|Simula}} which is a {{trans|C}}

<br>In Algol W, the condition of a "while" loop can be a block and the boolean "and" operator short circuits, which allow us to avoid the goto statements.

<br>Also, the Algol W string type is fixed length, unlike the Simula text type.

INTEGER WIDTH, YEAR;

INTEGER COLS, LEAD, GAP;

 

 

</pre>

 

=={{header|AutoHotkey}}==

LastDay := [], Day := []

Titles =

return res

}</syntaxhighlight>

Gui, add, edit, vYr w40 r1 Limit4 Number, 1969

Gui, add, edit, vEdit2 w580 r38

26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31

30 </pre>

=={{header|AutoIt}}==

#include <Date.au3>

 

</pre>

--[[User:BugFix|BugFix]] ([[User talk:BugFix|talk]]) 00:40, 15 November 2013 (UTC)

=={{header|AWK}}==

 

Works with Gnu awk version 3.1.5 and with BusyBox v1.20.0.git awk

 

</pre>

Choosing 132 character output.

DECLARE month[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }

year$ = "1969"

 

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

::Batch File Implementation

 

 

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

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

{{works with|BBC BASIC for Windows}}

The day and month names are in the language for which the PC is configured.

VDU 23,22,640;570;8,15,16,128

26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31

30</pre>

=={{header|Befunge}}==

This is quite closely based on the [[Calendar#C|C]] sample, although the centering calculation has been adjusted to fix an off-by-one error, and the months have been made a constant height, regardless of how much space they require, to try and produce a more balanced layout.

The year is read from stdin, and the width is specified by the first value on the stack (set to 80 - <tt>"P"</tt> - in the current implementation).

 

J!F?M!A M!J J!A!S O!N D!SaFrThWeTuMoSuvp01:_1#!-#%:#\>#+6<v-2g1+1g01p1p01:<

January February March April >:45**00g\-\1-:v:<<6>+7%:10g2+:38*\`|

2:+g01$_55+,^ > > > > #^>#g>#0>#2_v v*2!!\%+55:\/+55:**`0\!`g05:::\< >2-^^

->:> >#^>#<>#<^#!:-1g04$$ < < < < < >4+8*+\:!!2*4+8*+,,48*,1+\1-:>#^_$$1+\1</syntaxhighlight>

=={{header|C}}==

With arbitrary display width (>= 20 though) and auto spacing.

#include <stdlib.h>

#include <string.h>

exit(1);

}</syntaxhighlight>

 

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

An attempt to abuse the DateTime class for all static information. In the event that the number of days and months changes, so long as the DateTime class is updated accordingly, this should still print properly. It also abuses iterators to allow for a concise month printing method, but with the ability to still print x months per line.

 

 

using System;

 

</syntaxhighlight>

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

#include <windows.h>

#include <iostream>

+----------------------+----------------------+----------------------+

</pre>

=={{header|Clojure}}==

{{trans|Common Lisp}}Java interop version.<br>

Written by Kyuvi.<br>

 

 

(def day-row "Su Mo Tu We Th Fr Sa")

 

nil</pre>

=={{header|COBOL}}==

the program calls subroutine DATE2DOW to convert any YYYY-MM-DD to Day of Week (1=Sunday). the group names WS-CFGN

and WS-CFGW may be moved to WS-CFG to use narrow or wide print line size respectively.

IDENTIFICATION DIVISION.

PROGRAM-ID. CALEND.

30

</pre>

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

Depends on quicklisp.

 

(defparameter *day-row* "Su Mo Tu We Th Fr Sa")

30

NIL</pre>

=={{header|D}}==

 

void printCalendar(in uint year, in uint nCols)

{{libheader| System.DateUtils}}

{{Trans|D}}

program Calendar;

 

28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31

30</pre>

 

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

let day_of_week month year =

let t = [|0; 3; 2; 5; 0; 3; 5; 1; 4; 6; 2; 4|]

 

=={{header|Factor}}==

math.ranges prettyprint sequences sequences.interleaved ;

IN: rosetta-code.calendar

30

</pre>

 

=={{header|Fortran}}==

Already having a routine to produce a calendar simplified matters. However, it added to each row of days a row of annotations for those days (Xmas, etc. and also +2hh and -2hh for the days with two half-hour changes in length due to daylight saving: NZ also had daylight saving with changes of one half-hour) which meant that the field allowance was always four. With the annotations abandoned, this could be reduced to three, and, the first day column on a line does not need a leading space. Since the method employed variables for the layout, it could easily be twiddled to have three months per line (thus fitting into a line length of 80) or six (using most of a line length of 132) and so it became a matter of pulling together the needed routines from various places.

MODULE DATEGNASH !Assorted vexations. Time and calendar games, with local flavourings added.

 

31 30

</pre>

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28 20 21 22 23 24 25 26 17 18 19 20 21 22 23 22 23 24 25 26 27 28

28 29 30 31 25 26 27 28 29 30 31 29 30 27 28 29 30 31 24 25 26 27 28 29 30 29 30 31 </pre>

=={{header|FutureBasic}}==

Legacy version:

 

Str255 a

 

Modern version:

 

local fn RunCommand( command as CFStringRef ) as CFStringRef

30

</pre>

=={{header|Gambas}}==

 

Shell "cal 1969"

30

</pre>

=={{header|Go}}==

 

import (

30

</pre>

=={{header|Haskell}}==

import Data.Time

import Data.Time.Calendar

26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31

30</pre>

=={{header|Huginn}}==

import Algorithms as algo;

import Text as text;

20 21 22 23 24 25 26 17 18 19 20 21 22 23 22 23 24 25 26 27 28

27 28 29 30 31 24 25 26 27 28 29 30 29 30 31</pre>

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

The procedures ''printCalendar'' handles formatting of large components and uses co-expressions to keep the formatting of week elements in each column synchronized. The procedure ''CalendarFormatWeek'' is a generator that returns heading elements, alignment spacing, and individual days.

printCalendar(\A[1]|1969)

end

26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31

30</pre>

=={{header|J}}==

'''Solution:'''

require 'dates general/misc/format' NB. J7.x

calBody=: (1 1 }. _1 _1 }. ":)@(-@(<.@%&22)@[ ]\ calendar@])

formatCalendar=: calTitle , calBody</syntaxhighlight>

'''Example use:'''

[Insert Snoopy here]

1969

26 27 28 29 30 31 │ 23 24 25 26 27 28 29│ 28 29 30 31

│ 30 │ </syntaxhighlight>

=={{header|Java}}==

{{trans|D}}

import java.util.*;

 

26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31

30 </pre>

=={{header|JavaScript}}==

* Given a width, return a function that takes a string, and

* pads it at both ends to the given width

30

</pre>

 

=={{header|Julia}}==

using Dates

=={{header|Kotlin}}==

{{trans|D}}

import java.text.DateFormatSymbols

import java.text.MessageFormat

{{out}}

See D output.

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

rem Adapted from LB examples included with software

[start]

 

</pre>

=={{header|Lingo}}==

-- @desc Class "Calendar"

-- @file parent script "Calendar"

 

Usage:

calStr = calObj.make(1969)

put calStr</syntaxhighlight>

27 28 29 30 31 24 25 26 27 28 29 30 29 30 31

</pre>

=={{header|Lua}}==

local months={"JANUARY","FEBRUARY","MARCH","APRIL","MAY","JUNE",

"JULY","AUGUST","SEPTEMBER","OCTOBER","NOVEMBER","DECEMBER"}

27 28 29 30 31 24 25 26 27 28 29 30 29 30 31

</pre>

=={{header|M2000 Interpreter}}==

Set console to 80 character by 43 lines. Produce calendar line by line, three columns of months.

Module Calendar get the Year and the Language Id (1033 for English, 1032 for Greek and any other which support the Window OS).

 

Module Calendar (Year, LocaleId) {

Function GetMax(Year, Month) {

Calendar 2018, 1032 ' Greek

</syntaxhighlight>

=={{header|Mathematica}}/{{header|Wolfram Language}}==

 

Therefore, I've chosen to implement "raw" textual grids from scratch with a function called DataGrid. There are two versions of DataGrid. The first version allows you to specify exactly the height and width of each row and column in terms of number of string characters. The second version allows you to specify just the "macro" grid dimensions, and the actual size of each cell will be determined by calculating the width among cells in the same column and max height among cells in the same row. With those max values, it calls the first GridData function. The cell dimensions do not account for spacing and borders, which are added after the cell is scaled to the correct character dimensions. A variety of decoration options can also be supplied. The effect of these will be demonstrated in the examples below. Each version acts on a list of cells that are already rectangular arrays of data (though their dimensions obviously don't already need to be identical--that's part of the job of DataGrid, and it's why DataGrid can be composed/nested). Also, the list of cells is "flat", and its length does not need to conform to an exact rectangle (again, this is a job of DataGrid).

 

rowHeights:{__Integer},

colWidths:{__Integer},

To illustrate how DataGrid works, I'll create some sample data-grids and assemble them together into a larger data-grid, and then I'll use DataGrid itself to present all of these results. Notice the options for alignment, borders, spacings, etc.

 

GridA = DataGrid[{2},{5},{0,0},{{1,1},{1,1}},<|"border"->"*","alignment"->{1,-1}|>,{DataA}];

DataB = {{"B"},{"B"}};

HeaderGrid is a helper that defers the "gridding" of the individual header cells and data cells to functions that get passed in. There are some assumptions about presentation that feed into this design, but if your requirements differ, it's fairly easy to follow this same basic pattern of accepting functions that do the lower level work--you would just need to organize that work differently.

 

finalSpacings:{_Integer,_Integer},

finalBorderWidths:{{_Integer,_Integer},{_Integer,_Integer}},

MonthGrid will use HeadedGrid for the main part of the month, and it will take another gridding function to handle the title (month name). I could have simplified the method signature by having the caller pass in a HeadedGrid function directly, but I liked exposing more control with this function. MonthGrid offers the convenience of specifying a leading offset for the month (month and week boundaries don't typically align, so this allows for starting on the correct day of the week without requiring the caller to munge the data).

 

finalSpacings:{_Integer,_Integer},

finalBorderWidths:{{_Integer,_Integer},{_Integer,_Integer}},

FractalChars takes a string and rasterizes each character and then replaces each black pixel with the original character. The output is a matrix of characters suitable as a datum in the argument to DataGrid.

 

ReplaceAll[ImageData[ImageCrop[Binarize[Rasterize[Style[char,FontFamily->font],RasterSize->rasterSize]]]],{1->" ",0->char}];

FractalChars[rasterSize_,font_,word_String]:=FractalChars[rasterSize,font,#]&/@Characters[word];

Fortunately, Mathematica has many powerful calendar-related functions. Unfortunately, the semantics of calendars is sufficiently complicated that there is no practical way to create just a few standard data generators that will cover all of the implied cases. For example, the seemingly simple concept of "first day of the year" is ambiguous. The Jewish year uses one start day for religious holidays and another day for civil/secular purposes. The task definition referenced the switch-over from the Julian calendar to the Gregorian calendar, but this did not happen simultaneously around the globe, and many regions adopted the Gregorian calendar surprisingly recently. Assigning a number to a year is not standardized across calendars (e.g. consider the Chinese and Jewish calendars). The Cotsworth Calendar (effectively the International Fixed Calendar) has days that aren't assigned to any month or week--they're just dangling special days. So, we can provide some simple, general helper functions, but we assume that the calendar maker will be responsible for dealing with special cases.

 

MonthNames[]:=MonthNames["Gregorian"];

MonthNames[calType_]:=Lookup[CalendarData[calType,"PropertyAssociation"],"MonthNames"];

For the year 1969 on the Gregorian calendar, Mathematica can give us all of the data we need.

 

InitialOffset1969=QuantityMagnitude[DateDifference[PreviousDate[DateObject[{1969,1,1}],Sunday],DateObject[{1969,1,1}]]];

MonthLengths1969=Length/@Values[Data1969];

It's a bit more involved to create the data for a calendar that displays the switch from Julian to Gregorian. A few major European Catholic countries made the switch in 1582, so I'll generate data for that scenario. The switch happened in October, with Thursday Oct 4 being followed by Friday Oct 15. Mathematica provides tools to both fetch the calendar data and then fiddle with the structures so that I can highlight the relevant month and dates.

 

Join[

DateRange[DateObject[{1582,1,1},CalendarType->"Julian"],DateObject[{1582,10,4},CalendarType->"Julian"],CalendarType->"Julian"],

WidestFitDimensions will output data about the best fit it found, including the dimensions (which could be used in DataGrid) and the width of the best fit grid. There is no guarantee that a strict fit can be found, so it also provides the actual width of the best fit, and the user can determine what to do with the results. One could create another helper gridding function that uses WidestFitDimensions to automatically generate the grid, but I've already demonstrated such helper functions, so I'll just focus on computing the grid dimensions here.

 

targetWidth_Integer,

columnSpacings_Integer,

 

Checking best fit for our 1969 calendar for a few widths.

WidestFitDimensions[80,4,{0,0},MonthGrids1969]</syntaxhighlight>

{{out}}

<pre><|dimensions->{4,3},width->68|></pre>

WidestFitDimensions[132,4,{0,0},MonthGrids1969]</syntaxhighlight>

{{out}}

<pre><|dimensions->{3,5},width->116|></pre>

WidestFitDimensions[20,4,{0,0},MonthGrids1969]</syntaxhighlight>

{{out}}

<pre><|dimensions->{12,1},width->20|></pre>

=={{header|Nim}}==

{{trans|D}}

import strformat

 

 

</pre>

=={{header|OCaml}}==

 

 

let lang = "en" (* language: English *)

</pre>

=={{header|Perl}}==

 

use strict; # https://rosettacode.org/wiki/Calendar

31 30

</pre>

=={{header|Phix}}==

Gregorian calender only.

{{out}}

[Spot Reserved For Snoopy]

1969

=={{header|Phixmonti}}==

{{trans|Lua}}

 

32 var space

 

=== Press any key to exit ===</pre>

=={{header|PicoLisp}}==

This "calendar" is nicely formatted, and fits into 20 columns ;-)

(prinl "====== " Year " ======")

(for Dat (range (date Year 1 1) (date Year 12 31))

30 Tue

31 Wed</pre>

=={{header|Pike}}==

 

this script also highlights holidays by region. regions may be chosen by 2-letter country name, as well as some special 'regions': christianity, orthodox, bahai, islamic, among others.

 

 

int main(int argc, array(string) argv)

27 28 29 30 31 24 25 26 27 28 29 30 29 30 31

</pre>

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

calendar: procedure (year) options (main);

declare year character (4) varying;

28 29 30 31 25 26 27 28 25 26 27 28 29 30 31

</pre>

=={{header|PowerShell}}==

Param([int]$Year = 1969)

Begin {

}

</syntaxhighlight>

=={{header|Prolog}}==

Call the write_calendar(Year) predicate to print a calendar for a year.

Works with swi-prolog and requires the day_of_the_week library call.

 

% to write out the static parts in place and insert the generated parts into that format.

write_calendar(Year) :-

0 is Year mod 100 -> 0 is Year mod 400

; 0 is Year mod 4.</syntaxhighlight>

=={{header|Python}}==

The Python [https://docs.python.org/3/library/calendar.html calendar].prcal function prints calendars with the following formatting options: optional parameters w, l, and c are for date column width, lines per week, and number of spaces between month columns, respectively.

 

>>> help(calendar.prcal)

Help on method pryear in module calendar:

20 21 22 23 24 25 26 17 18 19 20 21 22 23 22 23 24 25 26 27 28

27 28 29 30 31 24 25 26 27 28 29 30 29 30 31</syntaxhighlight>

 

=={{header|Racket}}==

(require racket/date net/base64 file/gunzip)

(define (calendar yr)

26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31

30</pre>

=={{header|Raku}}==

(formerly Perl 6)

my @weekday-names = <Mo Tu We Th Fr Sa Su>;

my @month-names = <Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec>;

(' ' if $_ < 7) ~ (' ' xx 7-$_).join(' ') given Date.new($year, $month, $date.days-in-month).day-of-week;

}</syntaxhighlight>

=={{header|Rebol}}==

do [if "" = y: ask "Year (ENTER for current):^/^/" [prin y: now/year]

foreach m system/locale/months [

<br>specified. &nbsp; The choice could've been performed programmatically, but I never believe that a program

<br>could best choose over what the user wants, as it depends on esthetics and looks (fashion).

 

@abc='abcdefghijklmnopqrstuvwxyz'; @abcU=@abc; upper @abcU

| |

</pre>

=={{header|Ring}}==

# Project : Calendar

 

 

[https://www.dropbox.com/s/sj37yypiq45o5cd/CalmoSoftCalendar.jpg?dl=0 Calendar]

 

=={{header|Ruby}}==

<code>Date</code> class, from the standard library, knows how many days in a month, and which day is Sunday, for both Julian and Gregorian calendars. This program uses <code>Date</code> class, plus its own assumptions, to create the calendar. This program assumes that every year has 12 months and starts with January 1, and every month fits in 6 weeks starting with Sunday.

 

 

# Creates a calendar of _year_. Returns this calendar as a multi-line

 

=={{header|Rust}}==

// Command line:

// >>$ calendar 2019 150

}

</syntaxhighlight>

=={{header|Scala}}==

{{libheader|Scala}}

=== Scala Version 1 ===

 

import language.postfixOps

import collection.mutable.ListBuffer

{{works with|Scala|2.10.1}}

 

* Loosely based on the Ruby implementation.

*

}</syntaxhighlight>

 

* This provides extra classes needed for the main

* algorithm.

31

</pre>

=={{header|Seed7}}==

include "time.s7i";

 

</pre>

=={{header|Sidef}}==

{{trans|Raku}}

 

define months_per_col = 3

27 28 29 30 31 24 25 26 27 28 29 30 29 30 31

</pre>

=={{header|Simula}}==

{{trans|C}}

The subtleties of the post-increment logic which is used in the c program took me some time to detect.

For symmetry I also implemented the pre-increment.

INTEGER WIDTH, YEAR;

INTEGER COLS, LEAD, GAP;

 

</pre>

=={{header|Smalltalk}}==

 

This implementation has been developed using '''Cuis Smalltalk''' [https://github.com/Cuis-Smalltalk/Cuis-Smalltalk-Dev] with '''Aconcagua''' loaded.

"Instance Variables:

- yearToPrint: The year to print the calendar of

30

</pre>

=={{header|SPL}}==

#.output(#.str(year,">68<"))

> row, 0..3

</pre>

=={{header|Swift}}==

 

let monthWidth = 20

30

</pre>

=={{header|Tcl}}==

Due to the prevalence of 80 column devices instead of 132 column ones, this code produces 3 months at a time instead of 4.

 

# Produce information about the days in a month, without any assumptions about

</pre>

If a different year is chosen, it's printed…

cal 1969</syntaxhighlight>

<pre>

</pre>

The code also handles Julian/Gregorian switch dates correctly, but ''must'' be told what locale to format the switch as and for what timezone in that case. For example, Spain was one of the first countries to make the change:

cal 1582 :Europe/Madrid es_ES</syntaxhighlight>

<pre>

</pre>

As can be seen, a Real Programmer has many intricacies to deal with!

=={{header|uBasic/4tH}}==

The required "Snoopy" code is here. Use it when you feel like it.

Print " X XX"

Print " X *** X XXXXX"

Print " =========********** XXXXXXXXXXXXXXXXXXXXXX"</syntaxhighlight>

This is the code that generates the calendar:

 

Push 63 : Gosub _Space ' center year

 

0 OK, 0:2753</pre>

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

All Unix variations come with the cal command which makes the task very easy.

#!/bin/sh

echo "Snoopy goes here"

30

</pre>

 

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

This implementation uses the '''calendar.vdm''' macro that comes with Vedit. (So it serves as an example of how to call other macros from a macro.)

Calendar.vdm draws one month calendar. That is then copied as columnar block and pasted to the 1969 calendar.

 

Config_Tab(5,30,55)

#9 = 1 // first day of week: 0=Su, 1=Mo

The code above creates calendar for 80x43 display. For 132 column display, change #3 (number of months per line) to 4 or 6, and adjust the tab positions if required.

The following would work with all widhts, but the left/right margin would not be balanced.

 

Output:

27 28 29 30 31 24 25 26 27 28 29 30 29 30 31

</pre>

=={{header|Visual Basic .NET}}==

'''Compiler:''' Roslyn Visual Basic (language version >= 15.8)

 

Options and imports statements (all parts must be in one file):

Option Explicit On

Option Infer On

 

Helper to parse command-line arguments.

ReadOnly _ArgDict As New Dictionary(Of String, String)()

 

 

Program:

Sub Main(args As String())

Dim dt As Date

</pre>

=={{header|Wren}}==

{{libheader|Wren-date}}

{{libheader|Wren-fmt}}

{{libheader|Wren-seq}}

 

var calendar = Fn.new { |year|

</pre>

 

=={{header|XLISP}}==

Targets the 132-column imaginary line printer. The day of the week on 1 January of a given year is found using Gauss's algorithm; <tt>LEAP-YEARP</tt> is taken from the Rosetta Code task on leap years.

(define months-list '(("JANUARY" 31) ("FEBRUARY" 28) ("MARCH" 31) ("APRIL" 30) ("MAY" 31) ("JUNE" 30) ("JULY" 31) ("AUGUST" 31) ("SEPTEMBER" 30) ("OCTOBER" 31) ("NOVEMBER" 30) ("DECEMBER" 31)))

(define days #(" Sunday " "Monday " "Tuesday " "Wednesday " "Thursday " "Friday " "Saturday"))

21 22 23 24 25 26 27

28 29 30 31 </pre>

=={{header|XPL0}}==

 

func WeekDay(Year, Month, Day); \Return day of week (0=Sun 1=Mon..6=Sat)

30

</pre>

=={{header|Yabasic}}==

{{trans|Lua}}

clear screen

 

print_cal(2018)

</syntaxhighlight>

=={{header|zkl}}==

Gregorian calender only. Hard coded to a fit on a 80x43 terminal (somewhat half assed).

 

fcn center(text,m) { String(" "*((m-text.len())/2),text) }