[Question]
  [
You are given an integer `n` as input, and, regardless of the current date, must return the calendar year (Gregorian calendar, other calendars not allowed) taking place `n` seconds from now.
## Rules
* You may **not** assume that the current year is 2021. In other words, imagine a user testing your solution in five years.
* Standard loopholes forbidden.
* Shortest answer in **bytes** wins.
* Built-in date functions are allowed.
* You must also support negative numbers.
* **On the topic of the year zero: Your answer must follow the ISO specifications, meaning there *is* a year zero.**
* You may assume that the input is always an integer **within bounds of your language number system**.
* If your language's date functions take leap seconds into account, then follow your language, otherwise do not take leap seconds into account.
## Examples (in this case, measured at the time of writing, which is February 15, 2021)
```
100000000000 -> 5190
1000 -> 2021
54398643 -> 2022
54398643234 -> 3744
-100000000000 -> -1148
```
  
[Answer]
# [Ohm v2](https://github.com/nickbclifford/Ohm), 5 bytes
```
υ!+υy
```
[Try it online!](https://tio.run/##y8/INfr//3yrovb51sr//3UNDRDgv24KAA "Ohm v2 – Try It Online")
**Explanation**:
```
υ!+υy
υ!     get the current timestamp in seconds
  +    sum with the implicit input
   υy  get the year from the resulting timestamp
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 16 bytes
```
date -d$1sec +%Y
```
[Try it online!](https://tio.run/##S0oszvifqKGpUP0/JbEkVUE3RcWwODVZQVs18n8tF1eigqEBAkC5QMrUxNjSwszEGIlpZGwC5Okiq/8PAA "Bash – Try It Online")
### Credits
* Saved 12 bytes thanks to @manatwork
[Answer]
# [PHP](https://php.net/), 27 bytes
```
<?=date(Y,time()+$argv[1]);
```
[Try it online!](https://tio.run/##K8go@P/fxt42JbEkVSNSpyQzN1VDU1slsSi9LNowVtP6////hgYIoAAA "PHP – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 116 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
"`т‰0Kθ4ÖUD2Qi\28X+ë<7%É31α}"Vžežfžg)IŽª+·÷ÄF©IdiY.V‹i®¬>0ë®1¾ǝDÅsD12‹i>1ë\1Dǝ¤>2}}ǝëć©ić©i<D_-12š31šë®<šDY.Všë®<š]θ
```
Here we go again..
[Try it online](https://tio.run/##yy9OTMpM/f9fKeFi06OGDQbe53aYHJ4W6mIUmBljZBGhfXi1jbnq4U5jw3Mba5XCju5LPbov7ei@dE3Po3sPrdI@tP3w9sMtbodWeqZkRuqFPWrYmXlo3aE1dgaHVx9aZ3ho3/G5Lodbi10MjUAydoaHV8cYuhyfe2iJnVFt7fG5h1cfaT@0MhNM2LjE6xoaHV1obHh0IUizzdGFLkAT4ZzYczv@/9c1NTG2tDAzMQYA) or [try it only with custom specified starting date](https://tio.run/##PYy/S8NAHMX3/hVfAlJLidwlRauETkEo0kGwRSGisXfaA/OD3GXoECiiiP@AW4eCS40UnVoHHe4M2Qr@C/1HYtrBNzx4vM97AXevGC20LqfgQj/mIvCACzcSzL8B4goKIoAwooL6BJgAxiGKfQh8EANXlMTwADSnop0MKDA/jDcEW7cUroPIK5kqIdDpwLBUFbZ56PapTugt85igpLaZV7AJGAFCyCi0y9@71egdHS0XDfXctY1j5hjN07pKrb0t9WTi5Uei9Wrt7Eu@1uVczdX9oZy2CTvb6a1Gn0zO5FsLqVTOsPzOx7Z64DY21k0Lq9TBdj6WLy0jSfKxSn8e5ZRtzLIvdGxkExNnk/XYyiZ2@fgfzpeLotAxapj7zd2G@Qc). (Pretty slow for large inputs, so won't be able to output the larger test cases with the current date.)
**Explanation:**
Since 05AB1E doesn't have any date builtins (except for the current day/time), I've calculated things manually before. I've used the code of going to the next day from [this answer of mine](https://codegolf.stackexchange.com/a/173126/52210), which in turns also uses the leap year calculation of [this answer of mine](https://codegolf.stackexchange.com/a/177019/52210).  
Since this challenge also asks to go back in time, I've modified the program accordingly to support that as well.
Step 1: Create a function to calculate the amount of days in a month for a given year/month:
```
"`т‰0Kθ4ÖUD2Qi\28X+ë<7%É31α}"  # Push this string
                             V # Pop and store it in variable `Y`
 `                             # Pop the list and push all values separated to the stack
                               # (the year will be at the top; month below it)
  т‰                           # Take the divmod-100 of the year
    0K                         # Remove the 0s
      θ                        # Pop and push its last item
       4Ö                      # Check if it's divisible by 4
         U                     # Pop and store this in variable `X`
                               # (X=1 for leap years; X=0 for non-leap years)
          D                    # Duplicate the current month
           2Qi                 # If it's equal to 2 (thus February):
              \                #  Discard the duplicated month
               28X+            #  Push 28 + isLeapYear from variable `X`
             ë                 # Else:
              <                #  Decrease the month by 1
               7%              #  Modulo-7
                 É             #  Modulo-2
                  31α          #  Absolute difference with 31
             }                 # Close the if-else statement
```
Step 2: Now we determine the current date, and loop an amount of times depending on the input:
```
že                             # Push the current day
  žf                           # Push the current month
    žg                         # Push the current year
      )                        # Wrap all three into a list
       I                       # Push the input-integer
        Žª+                    # Push compressed integer 42300
           ·                   # Double it to 84600 (60*60*24)
            ÷                  # Integer-divide the input by 84600
             Ä                 # Take its absolute value
              F                # And loop that many times:
```
Step 3: If the input was positive, calculate the next date:
```
©                              #  Store the current date in variable `®` (without popping)
 Idi                           #  If the input is non-negative:
    Y.V                        #   Execute string `Y` as 05AB1E code to get the amount
                               #   of days for the current month/year
       ‹i                      #   If this is smaller than the current days:
         ®                     #    Push the current date again
          ¬                    #    Get its first item (the days)
           >                   #    Increase the day by 1
            0                  #    Push index 0
        ë                      #   Else:
         ®                     #    Push the current date again
          1                    #    Push day=1
           ¾                   #    Push index 0
            ǝ                  #    Insert days=1 at index 0 into the date
             D                 #    Duplicate it
              Ås               #    Pop and push its middle item (the month)
                D              #    Duplicate that month
                 12‹i          #    If it's smaller than 12:
                     >         #     Increase the month by 1
                      1        #     Push index 1
                    ë          #    Else:
                     \         #     Discard the duplicated month
                      1        #     Push month=1
                       D       #     Push index 1
                        ǝ      #     Insert month=1 at index 1 into the date
                         ¤     #     Push its last item (the year)
                          >    #     Increase the year by 1
                           2   #     Push index 2
                    }          #    Close the if-else statement
        }                      #   Close the if-else statement
         ǝ                     #   Insert the value at the given index into the date
```
Step 4: If the input was negative instead, calculate the previous date:
```
ë                              #  Else (the input is negative):
 ć                             #   Extract head; push [month,year] and day separated
  ©                            #   Store the day in variable `®` (without popping)
   i                           #   If day == 1:
    ć                          #    Extract head; push [year] and month separated
     ©                         #    Store the month in variable `®` (without popping)
      i                        #    If month == 1:
       <                       #     Decrease the [year] by 1
        D                      #     Duplicate it
         _                     #     Check if it's equal to 0 (1 if 0; 0 otherwise)
          -                    #     Subtract that (so we go from year 1 to -1)
           12š31š              #     Prepend 12 and 31: [31,12,year-1-(year-1==0)]
      ë                        #    Else:
       ®<š                     #     Prepend month-1 to the [year] list
          D                    #     Duplicate it
           Y.V                 #     Execute string `Y` as 05AB1E code to get the amount
                               #     of days for this month/year
              š                #     Prepend this to the [month-1,year] list
   ë                           #   Else:
    ®<š                        #    Prepend day-1 to the [month,year] list
```
Step 5: After the loop, extract the year to output:
```
]                              # Close both the if-else and loop
 θ                             # Pop the date, and only leave its last item (the year)
                               # (after which it is output implicitly as result)
```
[See this 05AB1E tips of mine (section *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `Žª+` is `42300`.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 21 bytes
```
->n{[*Time.now+n][5]}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vOlorJDM3VS8vv1w7LzbaNLb2f4mCrUI0l4KCoQEC6ChABcAMUxNjSwszE2MUjpGxCVcsV4leamJyhkK1Qk1ejUKBQlp0XqxCLaaoLkj4PwA "Ruby – Try It Online")
Shorter by a byte than the more obvious `->n{(Time.now+n).year}`.
[Answer]
# [Octave](https://www.gnu.org/software/octave/) / MATLAB, 27 bytes
```
@(x)datestr(x/86400+now,10)
```
[Try it online!](https://tio.run/##y08uSSxL/Z9mq6en999Bo0IzJbEktbikSKNC38LMxMBAOy@/XMfQQPN/moahAQJockH4INrUxNgSqNYYmW1kbALi6qLo@Q8A "Octave – Try It Online")
### How it works
```
@(x)                          % Define anonymous function with input x
            x/86400           % Divide input by 86400, to convert to days
                    now       % Current time in days since "January 0, 0000"
                   +          % Add 
    datestr(           ,10)   % Convert to string with format 10, which is year
```
[Answer]
# JavaScript (ES6), 42 bytes
```
n=>new Date(+new Date+n*1e3).getFullYear()
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/P1i4vtVzBJbEkVUMbxtLO0zJMNdbUS08tcSvNyYlMTSzS0PyfnJ9XnJ@TqpeTn66RpmFogACamgr6@gqmhpYGXJiKgJIwAFRkZGBkiKbI1MTY0sLMxBiqEKLICIciI2MTkDqgImNzE5P/AA "JavaScript (Node.js) – Try It Online")
[Answer]
# [jq](https://stedolan.github.io/jq/), ~~20~~ 15 characters
```
now+.|gmtime[0]
```
Sample run:
```
bash-5.0$ jq 'now+.|gmtime[0]' <<< 100000000000
5190
```
[Try it online!](https://tio.run/##yyr8/z8vv1xbryY9tyQzNzXaIPb/f0MDBOACcbhMTYwtLcxMjOEMI2MTLl1kdQA "jq – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~32~~ ~~26~~ 23 bytes
```
date|% *dds* @args|% y*
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/PyWxJLVGVUErJaVYS8EhsSi9GMir1Pr//7@hAQIAAA "PowerShell – Try It Online")
-3 bytes thanks to mazzy and ZaelinGoodman
[Answer]
# [Python 3](https://docs.python.org/3/), ~~74~~ ~~72~~ 65 bytes
```
lambda x:(date.today()+timedelta(0,x)).year
from datetime import*
```
[Try it online!](https://tio.run/##FcrBCoQgEADQe1/hcaYNibSlXehPukyoJGSKzCG/fqLze6XxkS8jYd3kpLQ7UvcfHLHXnB01wA/H5J0/mWAcbkTdPNUu1JzU215VMZVcuZdS48UQYLbmt3ytmYxFFHkA "Python 3 – Try It Online")
-7 bytes thanks to @Eric
[Answer]
# [Japt](https://petershaggynoble.github.io/Japt-Interpreter), ~~12~~ 10 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
ÐKj +Ue3)i
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=0EtqICtVZTMpaQ&input=MTAwMDAwMDAwMDAw)
-2 bytes from AZTECCO.
This transpiles to the following JS:
```
new Date(K.j() + U * 1e3).i()
```
where `K.j()` is the current time converted to milliseconds, `U` is the input, and `.i()` gets the year from the date constructor.
[Answer]
# R, 12 bytes
```
Sys.time()+n
```
This returns a full date, the year is at the beginning of the string. This is according to the rules, which didn't say to print *just* the year; and this is not in the [list of "standard loopholes"](https://codegolf.meta.stackexchange.com/q/1061) by the time of this answer.
To print *just* a year, R would need 25 bytes:
```
format(Sys.time()+n,"%Y")
```
[Answer]
# IBM/Lotus Notes Formula Language, ~~34~~ 32 Bytes
```
@Year(@Adjust(@Now;0;0;0;0;0;i))
```
Takes input from a field named `i`. Unfortunately, Formula only supports 32 bit signed integers so it is restricted to a maximum input of +/- 2,147,483,647.
There is no TIO for Formula so here are a couple of screenshots:
[![enter image description here](https://i.stack.imgur.com/wx7iU.png)](https://i.stack.imgur.com/wx7iU.png)
[![enter image description here](https://i.stack.imgur.com/PKFax.png)](https://i.stack.imgur.com/PKFax.png)
[![enter image description here](https://i.stack.imgur.com/7XJaw.png)](https://i.stack.imgur.com/7XJaw.png)
[![enter image description here](https://i.stack.imgur.com/OQ4Be.png)](https://i.stack.imgur.com/OQ4Be.png)
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 11 bytes
```
12L/Z'+10XO
```
Try it out at [MATL Online](https://matl.io/?code=12L%2FZ%27%2B10XO&inputs=54398643&version=22.4.0)
**Explanation**
```
        % Implicitly grab input as an integer (seconds)
12L     % Push the literal 86400 to the stack (seconds in a day)
/       % Divide the input (in seconds) by the seconds in a day to convert to days
Z'      % Get the current time in days as a float
+       % Add the current time and the seconds in the future together
10XQ    % Determine the year of this date
        % Implicitly display the result
```
[Answer]
# [Julia](http://julialang.org/), 38 bytes
```
using Dates
f(x)=Year(now()+Second(x))
```
[Try it online!](https://tio.run/##Xc3BCoMwDAbge54ix5YhmLZuenCnvcFOQzzIrKND4rDKfPvOytjY/kvI90Nyn3vX0BLC7B3f8NRM1kMnFllebDMKHp5C7s72OnC7ogxrPXkssQJKv8HyiBkV6YZxUakiyIwu8r3Rb1AfUNpE0wdjIPm/kxCZHGqAbhgxvkPH2/SAax6j46lnEUX@SLdZRbWUYLkNLw "Julia 1.0 – Try It Online")
[Answer]
# [Raku](http://raku.org/), 28 bytes
```
{DateTime.new($_+time).year}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/2iWxJDUkMzdVLy@1XEMlXrsEyNbUq0xNLKr9X5xYqaCkEq/waN5Cheo0BZX4WiWFtPwiBRtDAwRQAHEUTE2MLS3MTIzhDCNjEwVdZHV2/wE "Perl 6 – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 51 bytes
```
lambda x:gmtime(time()+x).tm_year
from time import*
```
[Try it online!](https://tio.run/##TYpBCsIwFAX3PcWjq0RTsSaKLdSLqEjERgP@JIQs0tNH7abOYngML0zp5Z0sBgMu5a3p/tDI/ZOSpZHN4uvMN4lu06hjZaIn/DIsBR/TqhgfkWEdzu12QaCdvVeyOx6UXNZOKoHm/3vtK3wJ0brEskDdnGoBwzLn5QM "Python 3 – Try It Online")
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 30
```
$1=strftime("%Y",$1+systime())
```
[Try it online!](https://tio.run/##SyzP/v9fxdC2uKQorSQzN1VDSTVSSUfFULu4shjM19T8/9/QAAG4QBwuUxNjSwszE2M4w8jYhEsXRR0A "AWK – Try It Online")
* 5 bytes saved thanks to @manatwork.
[Answer]
# GNU coreutils (16 bytes)
```
date +%Y -d$1sec
```
Saved 4 bytes, thanks to @ovs.
[Answer]
# MySQL, 35 bytes
`select year(now()+interval [input] second)`
[Answer]
# [Java (JDK)](http://jdk.java.net/), 57 bytes
```
n->java.time.LocalDateTime.now().plusSeconds(n).getYear()
```
[Try it online!](https://tio.run/##lY9BS8QwEIXv/RVzTIQG11ZRFhcEEYR66l5EPIxpWlLTSWimK4vsb6@xCF481LkMj3nvfUyPB8z75n22Q/AjQ5@0mtg61U6k2XpSZ9ss0w5jhCe0BJ8ZQJjenNUQGTmtg7cNDOkmah4tdS@vgGMX5WIFqDx1e/9I/PDTCO3tTPluQbEdjKq8RnePbPbfivyHkCq4KdZGe2qiIKk6w88GRyHn7VJaHyObQfmJVUhMdiRahSG4411MKLE5/51KyvWh1ebLsri5viqLfwcuinJ1Jv/jj1N2mr8A "Java (JDK) – Try It Online")
Beats the `Date` API (71 bytes):
```
n->new java.util.Date(System.currentTimeMillis()+n*1000).getYear()+1900
```
[Try it online!](https://tio.run/##lY/BSgMxEIbv@xRzTCobUncVS1EQRBDaU3sR8RC32SVrdhKSSaVIn32NpYIHD@tchpn5v/lnerVXZb97H83gXSDocy0SGSvahA0Zh2K2LIrGqhhhrQzCZwHg05s1DURSlNPemR0MecY2FAx2L6@gQhf5SQqwctht3RPS43kjtLcjlneoP37ZPSjSbHOIpAfRpBA00tYMem2sNZHxC5zNpZRcdJqetQq5M19IOS5PFmfOJRI@X0AWWSuU9/ZwH7Mx@0Z/YsX5dGiy@KquFjfXdfVv4LKqJzPlH38ci@P4BQ "Java (JDK) – Try It Online")
Note that this one returns the year in absolute form (no negative year).
And I don't even speak about the Calendar API.
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 98 bytes
```
public class E{public static void m(double x){Console.WriteLine(DateTime.Now.AddSeconds(x).Year);}
```
[Try it online!](https://tio.run/##bYyxCgIxEER/JWVSGLS@Ss7r1OYEscwliywkWcnm9CTct8cUgo3TDG94jOWNpQR1Zox3Mb45Q@jqY548WmG9YRZD@SJnk1s9CZ0I0lFbQSyq9BSZPOhrwgxHjCAPJsMFA@gzvfTeuREsRcdyUfoGJqlurX8@TwajVGXQQe62vzR7rR8 "C# (.NET Core) – Try It Online")
Didn't count the `using System;` and calling function in `Main()`, if they needed to be added, please inform me!
[Answer]
# [Visual Basic .NET (VBC)](http://www.mono-project.com/docs/about-mono/releases/5.12.0/#vbnet-compiler), 89 bytes
```
public class E
Shared sub m(x)
Console.WriteLine(DateTime.Now.AddSeconds(x).Year)
end Sub
```
[Try it online!](https://tio.run/##Tc69CsIwFAXgPU@RMR0a9BGkdhC0SwRxzM8FL@Sn5CZVnz5WHfQsZ/k4nAWpat8bTWj7CKVfjG2HMKdciKsnFQhtrsaj5dZrIj4yddMZHKdqeBCPjg0pUvIgLxkLHDGC2OsCZwwgp3SXO@cU2BQdrVheQeeOQXRcVdP@pk4ao@jYKIPYbn752hV8enhfaC8 "Visual Basic .NET (VBC) – Try It Online")
[Answer]
# VBScript, 52 bytes
```
MsgBox Year(DateAdd("s",Wscript.Arguments(0),Now()) 
```
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 34 bytes
```
x=>DateTime.Now.AddSeconds(x).Year
```
[Try it online!](https://tio.run/##Sy7WTS7O/O9Wmpdsk5JfmpSTqpOZV2KXZvu/wtbOJbEkNSQzN1XPL79czzElJTg1OT8vpVijQlMvMjWx6L81V1p@UWpicoZGWWKRQrJCZp5CXmp5dKxCtaEBAugoGIJJUxNjSwszE2MEy8jYpFaTK7wosyTVJzMvVUNFqTq5VkHXTqE6TSNZs1ZJ0/o/AA "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [AppleScript](https://developer.apple.com/library/archive/documentation/AppleScript/Conceptual/AppleScriptLangGuide/introduction/ASLR_intro.html) function, 46
```
to y(s)
(current date+s/60*minutes)'s year
end
```
### Test driver:
```
repeat with sec in {100000000000, 1000, 54398643, 54398643234, -100000000000}
    log y(sec)
end repeat
```
Save the function and the test driver as text to `nseconds.applescript`, then run in the terminal:
```
osascript nseconds.applescript
```
Or run in the AppleScript Editor app.
[Answer]
# T-SQL, 42 bytes
```
select year(dateadd(s,a,getdate()))from t;
```
Uses the standard input method for T-SQL of taking input from a table. You can create a suitable table like this:
```
create table t (a int not null);
insert into t values (1000000000), (1000), (54398643), (-1000000000);
```
Note that T-SQL is limited to 32-bit integers for the number of seconds. To avoid that and allow the resulting year to vary between 0 and 9999 costs 6 bytes:
```
select year(dateadd(d,a/86400,getdate()))from t;
```
Don't forget to declare `a` as `bigint` if you do this. (Note that hours is represented by `hh` so it's no shorter, and minutes won't let you reach 9999.)
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 20 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?") ([SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set"))
Full program, prompting for `n` from stdin.
```
⊃⊃20 ¯1⎕DT⎕+20⎕DT'J'
```
`20⎕DT'J'` get current local\* (**J**uliett) **D**ate**T**ime as UNIX time (code 20; seconds from beginning of 1970)
`⎕+` prompt for `n` and use that to increment the UNIX time.
`20 ¯1` interpret as UNIX times (code 20) and convert to an array of time stamps (code -1)
`⊃` extract the first (and only) time stamp
`⊃` extract the first element (the year)
[Try APL!](https://tryapl.org/?clear&q=%7B%E2%8A%83%E2%8A%8320%20%C2%AF1%E2%8E%95DT%E2%8D%B5%2B20%E2%8E%95DT%27J%27%7D%C2%A810000000000%201000%2054398643%2054398643234%20%C2%AF1000000000&run "TryAPL") (first and last case scaled down by a factor of 10 to avoid hitting date-time limits, 1 January 0001 though 28 February 4000; turned into function for ease of use)
\* could also have `'Z'` (**Z**ulu) to use the current UTC time instead of local time.
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 23 bytes
```
$_=gmtime$^T+$_;s/.* //
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3jY9tyQzN1UlLkRbJd66WF9PS0Ff//9/QwMEUNC1UzA1tDTgMoRyjAyMDLlMTYwtLcxMjKECRnABI2MTkJixuYkJly66ObqGhiYW//ILSjLz84r/6xbkAAA "Perl 5 – Try It Online")
[Answer]
# Mathematica, 43 bytes
```
IntegerPart@DatePlus[#/86400]["YearExact"]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78H1iamVoSHVCUmVei76Dx3zOvJDU9tSggsajEwSWxJDUgp7Q4WlnfwszEwCA2WikyNbHItSIxuUQpVu2/vkO1oQEC6IA4OqYmxpZA1cZwhpGxiY4usrpazdj/AA "Wolfram Language (Mathematica) – Try It Online")
Thanks to [@LegionMammal978](https://codegolf.stackexchange.com/users/33208/legionmammal978) for hinting that `DatePlus[#/86400][[1,1]]&` fails for negative years
]