# 3c: Urbit Time
## `+year`
Date to `@da`.
Accept a parsed date of form `[[a=? y=@ud] m=@ud t=tarp]` and produce its `@da` representation.
#### Accepts
`.det` is a `$date`.
#### Produces
A `@da`.
#### Source
```hoon
++ year
|= det=date
^- @da
=+ ^= yer
?: a.det
(add 292.277.024.400 y.det)
(sub 292.277.024.400 (dec y.det))
=+ day=(yawn yer m.det d.t.det)
(yule day h.t.det m.t.det s.t.det f.t.det)
```
#### Examples
```
> (year [[a=%.y y=2.014] m=8 t=[d=4 h=20 m=4 s=57 f=~[0xd940]]])
~2014.8.4..20.04.57..d940
```
***
## `+yore`
Date from atomic date.
Produces a `$date` from a `@da`.
#### Accepts
`.now` is a time `$atom`, `@da`.
#### Produces
A `$date`.
#### Source
```hoon
++ yore
|= now=@da
^- date
=+ rip=(yell now)
=+ ger=(yall d.rip)
:- ?: (gth y.ger 292.277.024.400)
[a=& y=(sub y.ger 292.277.024.400)]
[a=| y=+((sub 292.277.024.400 y.ger))]
[m.ger d.ger h.rip m.rip s.rip f.rip]
```
#### Examples
```
> (yore ~2014.6.6..21.09.15..0a16)
[[a=%.y y=2.014] m=6 t=[d=6 h=21 m=9 s=15 f=~[0xa16]]]
```
***
## `+yell`
Tarp from atomic date.
Produce a [`$tarp`](/hoon/stdlib/2q.md#tarp) time format from a`@da`.
#### Accepts
`.now` is a `@da`.
#### Produces
A `$tarp`.
#### Source
```hoon
++ yell
|= now=@d
^- tarp
=+ sec=(rsh 6 now)
=+ ^= fan
=+ [muc=4 raw=(end 6 now)]
|- ^- (list @ux)
?: |(=(0 raw) =(0 muc))
~
=> .(muc (dec muc))
[(cut 4 [muc 1] raw) $(raw (end [4 muc] raw))]
=+ day=(div sec day:yo)
=> .(sec (mod sec day:yo))
=+ hor=(div sec hor:yo)
=> .(sec (mod sec hor:yo))
=+ mit=(div sec mit:yo)
=> .(sec (mod sec mit:yo))
[day hor mit sec fan]
```
#### Examples
```
> (yell ~2014.3.20..05.42.53..7456)
[d=106.751.991.820.094 h=5 m=42 s=53 f=~[0x7456]]
```
```
> (yell ~2014.6.9..19.09.40..8b66)
[d=106.751.991.820.175 h=19 m=9 s=40 f=~[0x8b66]]
```
```
> (yell ~1776.7.4)
[d=106.751.991.733.273 h=0 m=0 s=0 f=~]
```
***
## `+yule`
Daily time to time `$atom`.
Accepts a [`$tarp`](/hoon/stdlib/2q.md#tarp), a parsed daily time, and produces a `@da`.
#### Accepts
`+rip` is a `$tarp`.
#### Produces
A time `$atom`, `@da`.
#### Source
```hoon
++ yule
|= rip=tarp
^- @d
=+ ^= sec ;: add
(mul d.rip day:yo)
(mul h.rip hor:yo)
(mul m.rip mit:yo)
s.rip
==
=+ ^= fac =+ muc=4
|- ^- @
?~ f.rip
0
=> .(muc (dec muc))
(add (lsh [4 muc] i.f.rip) $(f.rip t.f.rip))
(con (lsh 6 sec) fac)
```
#### Examples
```
> =murica (yell ~1776.7.4)
> murica
[d=106.751.991.733.273 h=0 m=0 s=0 f=~]
> (yule murica)
0x8000000b62aaf5800000000000000000
> `@da`(yule murica)
~1776.7.4
```
```
> `@da`(yule (yell ~2014.3.20..05.42.53..7456))
~2014.3.20..05.42.53..7456
> `tarp`[31 12 30 0 ~]
[d=31 h=12 m=30 s=0 f=~]
> `@dr`(yule `tarp`[31 12 30 0 ~])
~d31.h12.m30
```
***
## `+yall`
Time since beginning of time.
Produce the date tuple of `[y=@ud m=@ud d=@ud]` of the year, month, and day from a number of days from the beginning of the Gregorian calendar.
#### Accepts
`+day` is a `@ud`.
#### Produces
A cell of unsigned decimals.
#### Source
```hoon
++ yall
|= day=@ud
^- [y=@ud m=@ud d=@ud]
=+ [era=0 cet=0 lep=*?]
=> .(era (div day era:yo), day (mod day era:yo))
=> ^+ .
?: (lth day +(cet:yo))
.(lep &, cet 0)
=> .(lep |, cet 1, day (sub day +(cet:yo)))
.(cet (add cet (div day cet:yo)), day (mod day cet:yo))
=+ yer=(add (mul 400 era) (mul 100 cet))
|- ^- [y=@ud m=@ud d=@ud]
=+ dis=?:(lep 366 365)
?. (lth day dis)
=+ ner=+(yer)
$(yer ner, day (sub day dis), lep =(0 (end [0 2] ner)))
|- ^- [y=@ud m=@ud d=@ud]
=+ [mot=0 cah=?:(lep moy:yo moh:yo)]
|- ^- [y=@ud m=@ud d=@ud]
=+ zis=(snag mot cah)
?: (lth day zis)
[yer +(mot) +(day)]
$(mot +(mot), day (sub day zis))
```
#### Examples
```
> (yall 198)
[y=0 m=7 d=17]
```
```
> (yall 90.398)
[y=247 m=7 d=3]
```
```
> (yall 0)
[y=0 m=1 d=1]
```
***
## `+yawn`
Days since beginning of time.
Inverse of `+yall`, computes number of days A.D. from y/m/d date as the tuple `[yer=@ud mot=@ud day=@ud]`.
#### Accepts
`.yer` is an unsigned decimal.
`.mon` is an unsigned decimal.
`.day` is an unsigned decimal.
#### Produces
An unsigned decimal.
#### Source
```hoon
++ yawn
|= [yer=@ud mot=@ud day=@ud]
^- @ud
=> .(mot (dec mot), day (dec day))
=> ^+ .
%= .
day
=+ cah=?:((yelp yer) moy:yo moh:yo)
|- ^- @ud
?: =(0 mot)
day
$(mot (dec mot), cah (slag 1 cah), day (add day (snag 0 cah)))
==
|- ^- @ud
?. =(0 (mod yer 4))
=+ ney=(dec yer)
$(yer ney, day (add day ?:((yelp ney) 366 365)))
?. =(0 (mod yer 100))
=+ nef=(sub yer 4)
$(yer nef, day (add day ?:((yelp nef) 1.461 1.460)))
?. =(0 (mod yer 400))
=+ nec=(sub yer 100)
$(yer nec, day (add day ?:((yelp nec) 36.525 36.524)))
(add day (mul (div yer 400) (add 1 (mul 4 36.524))))
```
#### Examples
```
> (yawn 2.018 7 4)
737.244
```
```
> (yawn 1.776 7 4)
648.856
```
```
> (yawn 1.990 10 11)
727.116
```
***
## `+yelp`
Leap year?
Determines whether a year is a leap year. Produces a `$flag`.
#### Accepts
`.yer` is an unsigned decimal.
#### Produces
A `$flag`.
#### Source
```hoon
++ yelp
|= yer=@ud ^- ?
&(=(0 (mod yer 4)) |(!=(0 (mod yer 100)) =(0 (mod yer 400))))
```
#### Examples
```
> (yelp 2.014)
%.n
```
```
> (yelp 2.008)
%.y
```
```
> (yelp 0)
%.y
```
```
> (yelp 14.011)
%.n
```
***
## `+yo`
Time constants core.
Core whose arms contain constants for interacting with Earth time.
#### Source
```hoon
++ yo
```
***
### `+cet:yo`
Days in a century.
Derived by multiplying the number of days in a year (365) by the number of years in a century (100), then adding the number days from leap-years in a century (24).
#### Produces
An `$atom`.
#### Source
```hoon
++ cet 36.524
```
#### Examples
```
> cet:yo
36.524
```
```
> (add 365 cet:yo)
36.889
```
```
> (sub (add 24 (mul 100 365)) cet:yo)
0
```
***
### `+day:yo`
Seconds in day.
The number of seconds in a day.
#### Produces
An `$atom`.
#### Source
```hoon
++ day 86.400
```
#### Examples
```
> day:yo
86.400
```
```
> (add 60 day:yo)
86.460
```
***
### `+era:yo`
Leap-year period.
The number of days in a 400-year period, arrived at by multiplying `+cet` by four and adding one. This is done because every 400 years, there is a leap-year where there would otherwise not be.
#### Produces
An `$atom`.
#### Source
```hoon
++ era 146.097
```
#### Examples
```
> era:yo
146.097
```
```
> (sub era:yo (mul 4 cet:yo))
1
```
#### Discussion
A year is a leap-year if it's divisible by 4, **unless** it's divisible by 100, **or** if it's divisible by 400.
***
### `+hor:yo`
Seconds in hour.
The number of seconds in an hour. Derived by multiplying the number of seconds in a minute by the minutes in an hour.
#### Produces
An `$atom`.
#### Source
```hoon
++ hor 3.600
```
#### Examples
```
> hor:yo
3.600
```
```
> (div hor:yo 60)
60
```
***
### `+jes:yo`
Maximum 64-bit timestamp.
This is the number of days (starting from 1970) that can be represented in a 64-bit timestamp. Derived by multiplying `+era:yo` by 730,692,561.
#### Produces
An `$atom`.
#### Source
```hoon
++ jes 106.751.991.084.417
```
#### Examples
```
> jes:yo
106.751.991.084.417
```
#### Discussion
The date is December 4, 292,277,026,596.
***
### `+mit:yo`
Seconds in minute.
The number of seconds in a minute.
#### Produces
An `$atom`.
#### Source
```hoon
++ mit 60
```
#### Examples
```
> mit:yo
60
```
***
### `+moh:yo`
Days in month.
The days in each month of the Gregorian common year. A list of unsigned decimal `$atom`s (Either `28`, `30`, or `31`) denoting the number of days in the month at the year at that index.
#### Produces
A `+list` of `@ud`
#### Source
```hoon
++ moh `(list @ud)`[31 28 31 30 31 30 31 31 30 31 30 31 ~]
```
#### Examples
```
> moh:yo
~[31 28 31 30 31 30 31 31 30 31 30 31]
```
```
> (snag 4 moh:yo)
31
```
***
### `+moy:yo`
Days in months of leap-year.
The days in each month of the Gregorian leap-year. A list of unsigned decimal `$atom`s (Either `29`, `30`, or `31`) denoting the number of days in the month at the leap-year at that index.
#### Produces
A `+list` of `@ud`.
#### Source
```hoon
++ moy `(list @ud)`[31 29 31 30 31 30 31 31 30 31 30 31 ~]
```
#### Examples
```
> moy:yo
~[31 29 31 30 31 30 31 31 30 31 30 31]
```
```
> (snag 1 moy:yo)
29
```
***
### `+qad:yo`
Seconds in 4 years.
The number of seconds in four years. Derived by adding one second to the number of seconds in four years.
#### Produces
An `$atom`.
#### Source
```hoon
++ qad 126.144.001
```
#### Examples
```
> qad:yo
126.144.001
```
***
### `+yer:yo`
Seconds in year.
The number of seconds in a year. Derived by multiplying the number of seconds in a day by 365.
#### Produces
An `$atom`.
#### Source
```hoon
++ yer 31.536.000
```
#### Examples
```
> yer:yo
31.536.000
```
***
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs.urbit.org/hoon/stdlib/3c.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.