v2 state

format

How golf's rows are kept in store: strings, never golf's own types (a value of a realm's type kept in another realm would carry this realm's methods into it, and would not outlive these rules). Each is its format's version, then its fields, each as its length, ":" and itself (store's own rows are so): a row reads back by its lengths, not by a scan of every byte (a scan, as strings.Split, costs several times more gas), whatever its fields hold. A later version of the rules reads every format ever written, row by row.

join

fields

fields is a row's fields, its format checked: n of them, or it panics.

itoa

i64

ftoa

btoa

atoi

atoi64

atof

encodeEntry

decodeEntry

encodeRound

decodeRound

encodeRow

decodeRow

wearCells

maxData

maxData bounds a version's data: a hole at every limit of the format is about 21 KB.

Publish

Publish puts a course hole's data into its slot as its next version and returns the new id ("garden/7/v2"). Only the owner can. hexData is the hole as course.Encode wrote it, in hex. slot must be the data's own world and order ("garden/7", order 1 to 999), so a mis-edited file cannot replace the wrong hole; the course holds at most 9999 slots (maxCourse). Data identical to the current version's is refused. The version it replaces is archived: its records stay, its bests leave the course standings. note (at most 140 characters, cleaned) says why.

publishNow

PublishMine

PublishMine publishes a community hole of the caller's own and returns its id: "\<caller>/\<slug>/v1", then v2 and on. Anyone can while publishing is open (SetPublishing); only the same address adds versions. slug is 1 to 32 of a-z, 0-9 and "-". The data is checked as Publish checks it, its world and order aside; its name and note carry no web address. It is playable and recorded, in no cup and not in the course ranking; a new version of a hidden hole stays hidden. The publisher pays the storage deposit (about half a GNOT a version), and nothing published can be deleted.

publishMineNow

newestRow

newestRow is the height of an author's newest row in byAuthor ("\<address> \<height> \<slug>"), "" if they have none.

newestRowBut

newestRowBut is newestRow with the row but left out ("" if it was their only one).

moveAuthor

moveAuthor moves an author's own row in byAuthor (recentKey(height, address)) from the height was to now, "" for none: it stays at their newest row's, and goes with their last.

linkish

linkish spots a web address in a community hole's name or note: "www.", a dot between a letter or digit and two letters ("claim.xyz", "t.me"; not "e.g."), or an IP address, look-alike dots (．。․﹒) read as dots, letters in any case. Basic (the owner can Hide what gets past) and strict on purpose ("St.Andrews" is refused). It reads s a byte at a time: every mark is ASCII, so a non-ASCII character is decoded only to tell İ and the Kelvin sign (which lower-case to ASCII), the look-alike dots and spaces apart.

isLower

isDigit

decodeData

decodeData checks a version's data as it arrives: hex, GG1 within the format's limits, stored lengths bit-exact (DecodeChecked: every later Decode trusts them), and in the one form Encode gives.

nothingNew

nothingNew refuses data identical to the alias's current version: it would reset the hole's ranking for nothing.

dataEntry

worlds

worlds is the course's worlds in play order, with their names on the page.

worldRank

worldRank is a world's place among worlds; any other comes after.

slotKey

slotKey is a slot's key: its world's rank, the world, and the order in three digits, so the slots tree is in course order.

slotKeyOf

slotKeyOf reads a slot, "world/order" (as "garden/7"), into its key.

validSlug

HoleData

HoleData is a version's GG1, in hex, as it was published (an alias gives its current version's): what a later version of the rules or an auditor reads back.

Current

Current is the id of the version an alias ("garden/7", "\<address>/\<slug>") plays now, "" if the alias has none.

Versions

Versions is every version of an alias, oldest first (the newest pageMax if there are more): its id, number, the height it was published at, by whom, its data's sha256, its note, and the version that took its place. slot is the alias, "" (and no versions) for one that has none.

firstVersion

firstVersion is the oldest of now's versions a list shows: the newest pageMax are (now is its alias's current version).

BestOf

BestOf is a player's best finished round on a hole in a mode, 0 if none.

featuredRead

featuredRead is how much of the course ranking the picks look at: its first page; podium, its first places, which get no card of their own.

podium

featuredRead is how much of the course ranking the picks look at: its first page; podium, its first places, which get no card of their own.

pick

pick is a player put forward, and why.

today

today is the day, a number: the picks hold for it and change with it (block time).

draw

draw is a player's draw for a day: FNV-1a over their address, seeded with the day (featured.ts draw: the same numbers, so the same picks).

featured

featured is up to n picks from the course ranking in mode m: a fast start (a third of the course or less, at par or better), the best average against par (a third of the course played, nine holes at least), and today's picks for the rest; never the first three places.

countTag

max1

nine

featuredRows

featuredRows is the hub's records to beat in mode m, as markdown lines.

maxPower

maxShots

errShot

The refusals said in more than one place.

errFine

The refusals said in more than one place.

errStrokeLimit

The refusals said in more than one place.

errShotTooHeavy

The refusals said in more than one place.

errTooStormy

The refusals said in more than one place.

errUnknownHole

The refusals said in more than one place.

entry

courseHoles

The versions: the course's, current and archived, and everyone else's: id -> encodeEntry.

community

The versions: the course's, current and archived, and everyone else's: id -> encodeEntry.

saveEntry

saveEntry keeps a version as it is now: every call that changes one ends with it.

record

record is the hole's record in one mode: who holds it, in how many strokes, 0 if never completed.

bestsOf

bestOf

bestOf is how a best is kept: "\<strokes> \<height> \<period> \<shots>". The height ranks it before a later tie (boardKey); the period and shots let Ghost replay it in its own weather. The mode is in the key.

errBest

errBest is a best not as bestOf writes it: never written, refused if read.

bestStrokes

bestStrokes is a kept best's strokes, 0 for none ("").

bestFields

bestFields is a kept best's height, period and shots.

newEntry

draining

draining is an archived hole's drain, per mode: the next player to take out, and whether all are out. The players whose first finish came after it was archived (never counted, so never taken out) are its fresh rows.

copiesOf

copyAngle

// degrees, round the circle

copyPower

How near a round must be to a record already on the board, shot for shot, to be that record sent again: a player's pull never lands this close to another's, three shots running.

copyMin

// shots: two people keying a short round send alike

copyDepth

// the board's first page: the records worth copying

copyOf

copyOf reports whether shots are a record of a board's first page (either mode's: the modes differ by the client's aim line alone, so a round replays the same in both; another player's) sent again: as many shots, each within copyAngle and copyPower, three shots or more, one of them pulled (not keyed: a whole degree, or a power on 0.5, the keyboard's and a typed form's). The tick is not compared: on most holes it changes nothing, and on a timed one another tick of the same beat plays the same.

keyed

keyed is a shot a keyboard or a form sends: a whole degree, or a power on 0.5.

alike

round

assisted

A round is played in one of two modes, each with its own records and rankings: assisted (the full aim preview) or pro (the preview cut short). The chain cannot see a screen: the mode is the player's word.

pro

A round is played in one of two modes, each with its own records and rankings: assisted (the full aim preview) or pro (the preview cut short). The chain cannot see a screen: the mode is the player's word.

modes

A round is played in one of two modes, each with its own records and rankings: assisted (the full aim preview) or pro (the preview cut short). The chain cannot see a screen: the mode is the player's word.

modeOf

modeOf reads a mode's name: "assisted" (or "") or "pro"; anything else panics rather than answer for another mode.

modeNames

modeTitles

modeTitles is how the pages head a mode's board.

holeData

The indexes: collections of store (kv.gno), shared by every version and mode, made at its deploy: a first player pays for their own rows only.

slots

The indexes: collections of store (kv.gno), shared by every version and mode, made at its deploy: a first player pays for their own rows only.

aliases

The indexes: collections of store (kv.gno), shared by every version and mode, made at its deploy: a first player pays for their own rows only.

byAuthor

The indexes: collections of store (kv.gno), shared by every version and mode, made at its deploy: a first player pays for their own rows only.

hidden

The indexes: collections of store (kv.gno), shared by every version and mode, made at its deploy: a first player pays for their own rows only.

archived

The indexes: collections of store (kv.gno), shared by every version and mode, made at its deploy: a first player pays for their own rows only.

totals

The indexes: collections of store (kv.gno), shared by every version and mode, made at its deploy: a first player pays for their own rows only.

ranks

The indexes: collections of store (kv.gno), shared by every version and mode, made at its deploy: a first player pays for their own rows only.

idle

The indexes: collections of store (kv.gno), shared by every version and mode, made at its deploy: a first player pays for their own rows only.

meta

The indexes: collections of store (kv.gno), shared by every version and mode, made at its deploy: a first player pays for their own rows only.

archiving

archiving is the archived holes still in the standings, oldest first (drain).

setArchiving

row

row is one player's standing across the course: their best on each hole counted, summed, and those holes' pars, summed. Its score against par, strokes - par, is what ranks it after its holes.

topSize

named

named reports whether a player has a gno.land name (r/sys/users). Only named players rank: a name takes a registration, so a script cannot fill the boards with free addresses. Every finish is still kept.

nameOf

nameOf is a named player's name, "" for anyone else.

nameish

nameish is a name as r/sys/users registers it (a-z, then a-z, 0-9, "\_" and "-", at most 64), checked again because the pages print names in links.

find

find is the hole with this exact id, nil if none. Within a call that writes (begin), a version is one object, however often it is found: a finish on an archived hole and the drain it runs change the same one, and the call keeps it once as it ends (flush forgets them all). A read caches nothing: called within another realm's transaction, it would keep its cache in this realm's state, stale once the rules change.

current

current is the id an alias points at now: a course slot's or a community hole's current version; "" if it is neither.

mustHole

mustHole is the hole a write names: its exact id. An alias is refused: a new version may have taken its place since the round's shots were chosen.

readHole

readHole is the hole a read names: an exact id, or an alias for its current version.

recentKey

recentKey orders by height, then by what is at that height.

pad

pad writes n in width digits, zeros first: keys that sort as numbers.

rankKey

rankKey orders the course ranking: most holes first, then the best score against par (a hole at par counts the same whatever its par), then the first there, then the address. The score is signed: vsParBias puts it in seven digits. The holes take five: a standing can count more than the course's slots while a republished hole drains (its old best still counts, its new one adds a hole), so they get room well past maxCourse.

maxCourse

maxCourse bounds the course's slots (Publish); a standing's holes are at most those plus the archived versions drain has not taken it out of yet. vsParBias is more than a standing can be under or over par: a hole is -18 to +59 (1 to 60 strokes, par 1 to 19), so a full course at most 9999 \* 59 = 589,941 over, 179,982 under, and the seven digits hold 55,555 holes.

vsParBias

maxCourse bounds the course's slots (Publish); a standing's holes are at most those plus the archived versions drain has not taken it out of yet. vsParBias is more than a standing can be under or over par: a hole is -18 to +59 (1 to 60 strokes, par 1 to 19), so a full course at most 9999 \* 59 = 589,941 over, 179,982 under, and the seven digits hold 55,555 holes.

boardKey

boardKey orders a hole's board by each player's best v: fewest strokes, then the first to make them (a best's shots are public: whoever replays them ties it and ranks after), then the address.

boardStrokes

boardStrokes is the strokes of a board's key: always its three digits.

setRow

setRow moves a player's standing, as of height at, and keeps the ranking in step (and the standing itself). A standing with no hole left is not freed, nor its key, which moves to idle: its deposit is the player's, and freeing it would refund whoever drained it. It moves back at the player's next hole.

improve

improve moves a player's standing by a new best on an official hole of par par (was: their old best there, 0 if none): only those count, or anyone's own hole would be a way to the top. The standing is kept, not recomputed, so a finish costs the same however many play.

retire

retire archives an official hole replaced by next. Its bests stay there as its records but leave the course standings, in batches (drain): the Publish takes retireBatch, each course finish finishBatch, a Drain up to drainMax.

retireBatch

How many archived players a Publish, a course finish and a Drain take out of the standings: sized so none costs more however many played.

finishBatch

How many archived players a Publish, a course finish and a Drain take out of the standings: sized so none costs more however many played.

drainMax

How many archived players a Publish, a course finish and a Drain take out of the standings: sized so none costs more however many played.

drain

drain takes up to n archived players out of the standings, oldest archived hole first.

Drain

Drain takes up to n players (1 to 400) of archived holes out of the course standings, sooner than the finishes would, and returns how many archived holes still have players in them. Anyone can call it. A standing it empties is kept at 0 holes (setRow): nothing is refunded to the caller.

counts

counts reports whether a best on e by player (was: their previous best, 0 if none) moves their standing: e is a current official hole, or an archived one whose drain has not reached them yet and where they already counted. A first finish on an archived hole never counts.

Launch

Launch plays one shot of the caller's round on hole (an exact id): angle in degrees (0 = right, 90 = down), power in (0, 10]. It is how gnoweb plays, with no aim preview, so its rounds are pro rounds. It answers with where the ball stopped, or the score if holed; PlayRoundAt commits many shots.

launchNow

aim

aim is the angle, in the shot's degrees, and the straight-line distance from a ball to the cup: walls and slopes are the player's to allow for.

PlayRound

PlayRound is PlayRoundAt in the current period, for a caller with none to give (a form, a script); a round under way keeps its own. Prefer PlayRoundAt: a commit included after the weather turned is then played in the weather its shots were chosen in.

playRoundNow

PlayRoundAt

PlayRoundAt replays shots into the caller's assisted round on hole (an exact id), continuing it, in the weather of period: the current one or the one before, and a round under way keeps its own. The client sends decisions, never outcomes: the chain replays them. shots is "angle,power\[,tick];…" (MsgCall carries no slice), at most 12, fewer on a heavy hole: a commit past the work budget is refused with the number of shots that fit, and the rest goes in the next commit.

playRoundAtNow

PlayRoundPro

PlayRoundPro is PlayRoundAt for a round played in pro mode: the aim preview cut short. It counts on the pro records and rankings only.

playRoundProNow

playRound

otherMode

otherMode refuses to go on with a round in a mode it was not started in.

shotList

shotList is a commit's shots: the non-empty entries of "a,p;a,p;…", at least one and at most maxShots.

work

work is a commit's estimated gas so far. A shot counts the larger of its path's estimate and its Shot.Work's, plus its pulses' set-up, on top of what the commit spent before its shots (fixed: decoding, forecast). A shot that could pass workBudget is refused before anything is kept, and each is played under a work cap (physics.Field.Cap), so no commit can pass it; the client mirrors the model. An estimate, not a gas meter: see docs/golf.md, "The work budget".

workBudget

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

workPerShot

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

workPerWall

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

workPerPoint

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

workPerPiece

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

workPerUnit

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

workPerPulseWall

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

workPerPulsePost

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

decodeBase

Decoding a hole's data costs at most decodeBase and decodePerByte a byte.

decodePerByte

Decoding a hole's data costs at most decodeBase and decodePerByte a byte.

fixedGas

fixedGas is what a commit on e spends before its shots, in the forecast fc: decoding the hole, and drawing the forecast.

storeGas

storeGas is what a commit spends keeping its rows in store, on top of v1's work: reading the hole, its version and the round across the realm, decoding them, and its writes in one batch. Measured at 20.6M on the heaviest commit that does not finish (z\_worst\_play\_filetest, against v1's): 25M, counted before the shots and at publish (worstGas). A finish spends some 30M to 40M more there (its best, the board, the standing, the drain's share), outside the work budget, as v1's finish was: the room between the budget and what a transaction may ask covers it.

decodeGas

decodeGas bounds decoding size bytes of a hole's data.

maxShotGas

maxShotGas bounds a hole's heaviest shot (shotBound and its pulses' set-up): a hole past it is refused at publish.

minShotWork

minShotWork is the work, in the physics' units, a commit's first shot may always do whatever the weather: four fifths of MaxWork. A shot is capped at what is left of the budget (work.next), so a hole whose dearest weather would leave less is refused at publish (worstGas): on a published hole, every shot of less than minShotWork plays out in any weather (as a commit's first, if need be), and an author whose board is too heavy is told at publish, not by a hole that misbehaves in the rain. A shot past it may be cut short; none is known: the course's heaviest real shot does 441,737 over the full grid of tee shots (mountain/16, full power, in a storm), and the heaviest found in an adversarial search 0.74 of MaxWork (docs/golf.md); the course's tightest room in its dearest weather is 839,278 (mountain/7), 39,278 over the floor.

worstGas

worstGas is what a commit on h (size bytes of data) spends up to a first shot of minShotWork in its dearest weather: decoding, the forecast at its most (course.WorstForecastWork), and the shot, its walls and its pulses' set-up, as work.next caps it.

newWork

newWork is a commit's work on a hole, before any shot: its walls and pieces, a pulse's as if always there, and the weather's.

shotBound

shotBound is the most one shot on a board of walls walls can cost: the physics ends a stroke at MaxWork, passing it by MaxWorkStep at most.

pieces

pieces counts what a ball is tested against: each wall, post and zone, and each edge of a zone's polygon.

Reset

Reset abandons the caller's round under way on hole (an exact id), freeing its storage: the next stroke starts a new one from the tee. A finished round is not kept (its best is), so a new one needs no Reset. With no round under way it does nothing, and says nothing.

resetNow

validShot

validShot refuses what would poison a round, and what the game cannot send (a step finer than 0.01), and returns the shot as recorded. NaN and infinities pass every comparison, so they are refused by name. The power is quantized before it is checked (0.00001 would round to 0). The angle is brought into (-360, 360), so a huge one cannot overflow to NaN in the physics, and again after rounding (-359.99996 is -0, not -360).

cents

cents reports whether x is a whole number of hundredths (as q4 left it).

resolve

resolve checks what the physics returned for a stroke: a path a read may print, and a ball that is a number. A hole is anyone's data.

back

back brings a ball that came to rest off the board (a leak in a hole's walls) back to from, where the shot started; the stroke counts, with no penalty. Every stroke golf plays or replays goes through it.

stroke

stroke resolves one shot into the round and reports whether it was holed.

seat

seat puts a named player where their best puts them: on the hole's board, in its record if it tops it, and in the course ranking if they stand in it. Every finish does it, improved or not, so a player named since ranks.

bestOfPlayer

bestOfPlayer is a player's kept best on e in mode m, "" for none.

Claim

Claim ranks the caller's bests kept while they had no name: on the boards of the course's current holes, in both modes, and in the course ranking. It returns how many bests it seated, and refuses a caller with no gno.land name. It reads the course's holes only, so it costs the same for everyone.

claimNow

maxRoundStrokes

maxRoundStrokes bounds a round's history (Round shows it); maxPath the path a hole may return for a stroke (an honest one: a few hundred points).

maxPath

maxRoundStrokes bounds a round's history (Round shows it); maxPath the path a hole may return for a stroke (an honest one: a few hundred points).

q4

q4 rounds to the precision a shot is recorded at.

maxTick

maxTick bounds the third field of a shot: any timed piece turns in fewer.

parseShot

parseShot reads "angle,power" or "angle,power,tick". The tick is where the timed pieces were when the player let go (0 if absent), clamped to 0..maxTick.

clampTick

clampTick reads a tick: an optional sign and digits, clamped to 0..maxTick, even past what an int holds.

roundOf

roundOf is the player's round under way on e, or a new one from the tee, not stored: its commit stores it if it does not finish it.

maxName

maxName and maxNote bound a hole's name and a version's note.

maxNote

maxName and maxNote bound a hole's name and a version's note.

cleanName

cleanName keeps a hole's name to one short line of plain text (cleanText), with at least a letter or a digit in it.

cleanText

cleanText keeps an author's text to one line of plain text, at most max characters: no control, format (Cf: bidi, zero-width, tags) or nonspacing (Mn: stacked accents, variation selectors) characters, no blank-looking ones, nothing that ends a markdown table cell or opens a link, a tag, an HTML entity, a strikethrough, a mention or an email link.

maxSkin

maxSkin bounds a skin's length.

cleanSkin

cleanSkin keeps a skin to what it is meant to be: a short lower-case id.

EventImported

EventImported is a v1 record copied in; EventNotImported one left on v1, a shot of it finer than v2 takes (validShot): its ghost would not replay here.

EventNotImported

EventImported is a v1 record copied in; EventNotImported one left on v1, a shot of it finer than v2 takes (validShot): its ghost would not replay here.

ImportHole

ImportHole copies v1's current version of a course slot, by its id ("garden/7/v3"): its data, provenance (by, height, note), plays and wear. Only the owner can, into a slot v2 has nothing in yet.

importHoleNow

importHole

importHole keeps the version id of slot key as v1 lists it: its data (hex), its row of Versions (ver), of Holes (row) and its HoleState (state).

ImportRecord

ImportRecord copies a player's v1 best on an imported hole in a mode (v1's Ghost: strokes, height, period, shots) and seats it as a finish would, onto the hole imported from v1 (the same data: its sha is v1's). Only the owner can, as the migration's script runs it: v1 plays on, with no near-copy rule, so a round played there later is not one to rank here. Idempotent: a record already as good stays; a better v1 one takes its place. A record with a shot finer than 0.01 (never one the game sends) stays on v1. It answers whether it copied anything.

importRecordNow

importRecord

importRecord copies p's best on e in mode m as v1's Ghost (g) has it; at is v1's standing's height (the course ranking's tie-break: the finish that last improved it, perhaps on a version since archived), 0 for none.

jobject

jobject is a v1 list from the object whose "id" is id on ("" if none): jget then reads that object's fields, which every object of the list has.

jget

jget is a field of v1's JSON, as v1 writes it (jstr): a string's value, unescaped, or a number's or an array's inside, "" if absent.

view

The data lives in store (the realm apart from these rules: a new version of the rules takes it on). A view is the rows of one of its collections under a prefix, read straight from store and written through this transaction's writes: queued as the call goes, read back by Get and Has, and sent to store in one batch as the entrypoint returns (flush). Iterate and ReverseIterate merge this call's writes into store's rows as they come; Size, index and IterateByOffset, a page by place, read store as it stands, so one over rows this call has written to panics instead (only the reads take them, which write nothing).

queued

// set/del ops, four strings each, in order

over

// collection + "\\x00" + key -> its value now; "\\x00" for removed

dirty

// the collections written to

seen

// the versions found in this call that writes: one object each (find)

begin

begin opens a call that writes: every crossing entrypoint that writes starts with it and ends with flush.

gone

queue

flush

flush sends this call's writes to store, in batches of what store takes in one call: every crossing entrypoint that writes ends with it, once it went through (begin opens it).

sortKeys

sortKeys sorts keys ascending, or descending for back (a handful: insertion sort).

firstRead

A page of store: the first a walk asks for, and the largest.

maxRead

A page of store: the first a walk asks for, and the largest.

nextRow

nextRow is a page's first row (store.Page: each length, ":", itself) and the rest.

field

owner

pending

self

self is golf's own pkgpath, hub its gnoweb path: every link follows from them, so the same code serves under any namespace.

hub

self is golf's own pkgpath, hub its gnoweb path: every link follows from them, so the same code serves under any namespace.

officialPrefix

// the namespace's realms, as "…/" (these rules are …/golf/v2)

dataRealm

// where the records are kept (kv.gno)

playURL

playURL is the 3D client every page links to (SetPlayURL moves it).

successor

successor is the realm that took this course over, "" until the owner names it, once (SetSuccessor).

init.211

setUp

setUp is init: the deployer owns the course, and community publishing starts closed. Only \`gno test\` (chain "dev") runs it with no signer: the owner stays "", which holds no power, and publishing starts open, since nobody there could open it.

Owner

Pending

Successor

Successor is the realm that took this course over, "" if none.

isOwner

isOwner is the one owner check: a live role, held by the caller.

Transfer

Transfer offers the role to another address, which takes it with Accept. Offering it to the owner themselves cancels an offer.