[Question]
  [
Using the 74 characters from the [2016 time capsule string](https://codegolf.stackexchange.com/questions/105398/2016-time-capsule-string-how-versatile-is-your-language)
```
H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%
```
write N code snippets all in the same language where:
* The 1st snippet outputs `1`.
* The 2nd snippet outputs `2`.
* The 3rd snippet outputs `3`.
* ... etc. ...
* The Nth snippet outputs `N` (the number, not the literal letter).
A "code snippet" is defined as any of these:
* A full program with no required input that outputs the number [normally](http://meta.codegolf.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods).
* A function with no required arguments that outputs/returns the number [normally](http://meta.codegolf.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods).
* A [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop) expression that evaluates to the number.
(You may mix and match these three variants in your N snippets.)
The characters you're allowed to use in the combined set of N snippets are **precisely the 74 characters of the time capsule, *plus* `floor(N/2)` extra "wildcard" bytes** that you may use anywhere.
For example, the time capsule contains three `@`'s so in the entirety of your N snippets there may only be up to three `@`'s present unless you decide to use some of your `floor(N/2)` wildcard bytes for additional `@`'s.
Thus, not counting wildcards, the combined set of characters in your N snippets must be a subset of the 74 time capsule characters. Their combined lengths cannot exceed 74.
**You may not reuse time capsule characters or wildcard bytes between snippets.**
# Notes
* The are no other limits on snippet length or how many wildcards may be used per snippet.
* You must write *all* snippets for 1 through N. It's not 0 to N-1, not k to N+k-1.
* The snippets must be individual, not one snippet that outputs the list `1, 2, 3, ..., N`.
* Outputs may be floats like `3.0` in place of `3` and you can use a base other than decimal if it is your [language's natural base](http://meta.codegolf.stackexchange.com/a/5349/26997). You must use the same base for all snippets.
* The wildcards are counted as bytes in *your language's encoding*. This will probably be [ASCII](https://en.wikipedia.org/wiki/ASCII) but e.g. if `∞` counts as one byte in your encoding then you can use it as a single wildcard byte.
* You may use wildcard bytes for multibyte characters. e.g. `∞` is [normally](https://mothereff.in/byte-counter) three bytes so you could use it in a snippet but it will cost three of your `floor(N/2)` wildcard bytes.
* [Newlines](https://en.wikipedia.org/wiki/Newline#Representations) such as `\r\n` may be considered one byte.
# Example
In Python, N = 4 is possible just using the REPL. There are `floor(4/2) = 2` wildcards.
1. `1` from the time capsule is an expression that evals to `1`.
2. `2` consists of a single wildcard, namely the `2`. Evals to `2`.
3. `3` also consists of a single wildcard. Evals to `3`. No more wildcards.
4. `4` is luckily in the time capsule and it evals to `4`.
These snippets are short and trivial. A real answer would likely be much more complex.
(Five and beyond in Python may certainly be possible but I'll leave it to the professionals.)
# Scoring
**The answer with the highest N wins;** i.e. the one that climbs the integer ladder the highest.
In case of a tie, the answer that used the fewest wildcard bytes wins.  
In case there is still a tie, the answer that used the fewest cumulative characters wins.  
If there is *still* a tie, the earlier answer wins.
  
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 23 snippets, 11 wildcards, 45 bytes
```
Q!
Q!)
Z
4
4)
6
7
8
9
A
B
C
D
E
F
G
H
I
J
QT|T+e`
O!)1
L!`e`(:)
6mf
```
[Try it online!](https://tio.run/nexus/cjam#Fcu5CsJAFEDR/n7FG0RwEBQhuHXuCxIZSWU1QZ9E0EEJwcLl10dtD5x4T@vPT/puozXZVaEUzQ@FXM5BJQ9HuVVloaXkEvTxx1aMzuCMZU9CYunSo8@AEWMmTJkxZ8GSFWtc9sqa6tka22FjvPrG8Deupy8 "CJam – TIO Nexus") | [wildcard counter](https://tio.run/nexus/jelly#DcvNCoJAFAbQ/fcUXbJwkgRhqBQC7VdDkIFZicTdjDuhZdFwX6Jn6rmmzv6E72cdQjAEQwo9NLTCBlvskKPCAUeccMYFV9RocIOx3iaO0ZHK0BI7jov/mMZQl7K6qyhlSbLKG/UQHnpqjLiiS6Vknvu8VHYcnOV9TMyehV7EamYkeqbaT1pkSe178QM "Jelly – TIO Nexus") (ignore the newlines)
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 25 snippets, 12 wildcards, 64 bytes
```
1
Q!)
Z
4
5
6
L``(*$)#
8
9
T!T
B
C
D
E
F
G
H
I
J
K
O`e`~~!!
B`:)
Q``$e`~~@~@=~+
Q!)4
Amf
```
[Try it online!](https://tio.run/nexus/cjam#U/pvyBWoqMkVxWXCZcplxuWTkKChpaKpzGXBZckVohjC5cTlzOXC5crlxuXO5cHlyeXF5c3ln5CaUFenqMjllGClyRWYkKAC4jvUOdjWaYNMM@FyzE37r@Snb2gXblNd51er/x8A "CJam – TIO Nexus")
Wildcards:
```
568BBCDEFGJK
```
I feel that I have to post quickly, before Dennis outgolfing me.
[Answer]
# JavaScript, 10 numbers, 5 wildcards
Remaining characters: `!!#$$%&())))*...:=@@@HILOQQQTTZ\^```eefmpy{|||~~~~~~~~~` 
5/5 bonus characters used: `37680`
Programs:
1. `1`
2. ```
!``+!``
```
3. `3`
4. `4`
5. `4|!```
6. `6`
7. `7`
8. `8`
9. `9`
10. `0xA`
I had hoped one of the strings I could make using `\xAB` would be a number, but unfortunately none of the combinations I tried would yield any. The `^` (XOR) character would also be interesting to use, but I currently don't see any opportunities where it can be used to make a great enough number.
If you see another feasible combination, let me know in the comments.
**Edit:** Added #10 thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)
[Answer]
## Pyth, 12 snippets, 20 bytes (6 wildcards)
```
f@
```
Find the first number where root(n,n) is truthy, starting from 1.
Output: 1
```
y!H
```
Double not `{}`.
Output: 2
```
3
```
Wildcard #1.
Output: 3
```
4
```
Output: 4.
```
5
```
Wildcard #2.
Output: 5
```
6
```
Wildcard #3.
Output: 6
```
7
```
Wildcard #4.
Output: 7
```
8
```
Wildcard #5.
Output: 8
```
9
```
Output: 9
```
T
```
Preinitialized variable.
Output: 10
```
+T!Z
```
Ten plus not zero.
Output: 11
```
12
```
Wildcard #6 (`2`).
Output: 12
[Answer]
# Octave, 6 numbers, 3 wildcards
```
1: ~~I          % not(not(sqrt(-1))) evaluates to true (or 1)
2: 2            % Wildcard
3: 3            % Wildcard
4: 4
5: (T=4)+~~T    % Create a variable T=4, then add not(not(T)) which evaluates to 1.
6: 6            % Wildcard
```
I still have `1`, `9` and `*` left, but I don't know if it will help me much. I'll see what I can do with those :)
Not easy getting many numbers when not using an Esolang. I'm hoping I'll be able to get one or two more, but I think it'll be hard.
[Answer]
# [Pushy](https://github.com/FTcode/Pushy), 10 numbers (4 wildcards)
All of these are snippets which leave the result on the stack. You can test this in the [**online interpreter**](https://tio.run/nexus/pushy#i1EISCwuSVUozsssKEgtUUhKzckvt/rvqPFfWSFGwb@0pKC0RCEHqEQhsyQ1VyE/T6G4JDE5W@8/AA) by appending `#` to each snippet (to print the number)
```
A(      \ 1:  Get alphabet and check that 'Z' >= 'Y'. Results in 1 (True)
x&+     \ 2:  Check stack equality (True - both are empty) then duplicate and sum.
3       \ 3:  Push 3 (1 wildcard)
4       \ 4:  Push 4
1 4+    \ 5:  1 + 4 in postfix, leaves 5 on the stack (1 wildcard)
`L`T%   \ 6:  Get character code of 'L' and modulo by T (ten) - leaves 6 on the stack
7       \ 7:  Push 7 (1 wildcard)
8       \ 8:  Push 8 (1 wildcard)
9       \ 9:  Push 9
T       \ 10: Push 10
```
This answer is not yet complete - although it seems unlikely I will get much further.
[Answer]
# 05AB1E, 12 numbers, 6 wildcards
```
 1:    1                                   -> 1
 2:    )O!x                                -> sum([])!*2
 3:    4L`\                                -> 2nd_last(range(1...4))
 4:    4                                   -> 4
 5:    5        # wildcard 1 = 5           -> 5
 6:    6        # wildcard 2 = 6           -> 6
 7:    Tf`~                                -> or(last2(prime_factors(10)))
 8:    8        # wildcard 3 = 8           -> 8
 9:    9                                   -> 9
10:    T                                   -> 10
11:    A`Q!T+   # wildcard 4 = T           -> (y==z)!+10
12:    TÌ       # wildcard 5,6 = T,Ì       -> 10+2
```
[Answer]
## [Hexagony](https://github.com/m-ender/hexagony), 6 numbers, 3 wildcards, 23 bytes
```
1!@
))!@
)|\@$!
4!%
4)!:
6!@
```
[Try it online!](https://tio.run/nexus/hexagony#@2@o6PD/PwA "Hexagony – TIO Nexus")
The entire sixth program is made from wildcards.
The only really interesting one is `3`. While I could do that as `4(!@`, that would leave me without a `4` to generate `5` easily, so I went with this instead:
```
 ) |
\ @ $
 ! .
```
Due to the `|`, the `)` on the first line is run twice, before the IP wraps to right-hand corner. `$` skips over the `@`, and then the `\` redirects the IP through the `)` a third time. The IP wraps to the bottom left corner, `!` prints the `3` and `@` terminates the program.
I don't think more than 6 snippets are possible, because there are only 5 printing commands (`!!!!!`) and 5 commands that can be used to terminate the program (`@@@%:`). So after the fifth snippet, we need at least two wildcards per snippet. Hence, even if I managed to get `6` without using a wildcard for it, there wouldn't be enough wildcards left to go to snippet seven.
[Answer]
# JavaScript, 8 numbers, 4 wildcards
```
 1: 1
 2: -~!``
 3: 4+~!$
 4: ~!``*~!``
 5: 4|!$
 6: 0xf^9
 7: 7
 8: 8
```
I might try again later - I'm kind of wasting characters on 2 and 6, when you get down to it.
[Answer]
# Befunge-98, 4 snippets, 18 bytes, 2 wildcards
```
!.@
!:+.@
41-.@    wildcard 1 = -
4.#A9H   wildcard 2 = .
```
[**Characters left:**](https://jsfiddle.net/7v424bc4/7/)  `!!!$$%&())))*=ILOQQQTTZ\^`````````eefmpxy{||||~~~~~~~~~`
I doubt more are possible, since every extra program will require a form of output, and all `.,` are already used up. If I can figure out a way to make 3 and 5 without a wildcard, then it's possible.
The last program will eventually terminate due to the stack filling up. `A` and `H` with no fingerprints loaded will reflect, and the program will keep pushing 9's.
[Answer]
# SmileBASIC, 12 snippets, 5 wildcards, 31 bytes
```
!.     '. is parsed as the number 0.0; taking the logical not gives 1
!.+!.  'Previous value added to itself
@Q||Q  '@Q is a label string and Q is a variable. For some reason, certain comparison/logical operations between strings and numbers return 3 rather than 1 or 0. 
4      '4
#TLIme 'Constant for the text color lime green, value is 5.
6      '6 (wildcard)
7      '7 (wildcard)
8      '8 (wildcard)
9      '9
&HA    'Hexadecimal A
11     '11 (one of them is a wildcard)
4*3    '4 multiplied by 3 (3 is wildcard)
```
I could've also used a variable instead of `.` (variables start at 0), and a string variable (like `Q$`) instead of `@Q`
Characters used: `!!!#&*+...1449@AHILQQTem||`
Wildcards used: `67813`
unused characters:  `!!$$%()))):=@@OQTZ\\^`````````efpxy{||~~~~~~~~~`
]