[Question]
  [
The challenge today is very simple. The task is to determine the TI calculator for which the submitted datafile was made.
The datafiles always start with a string `**TI`, the version (described below), and other data you can ignore.
Now, the versions you need to recognize are:
```
95* => TI-95
92P => TI-92+
92* => TI-92
89* => TI-89
86* => TI-86
85* => TI-85
84P => TI-84+
84* => TI-84
83* => TI-83
83P => TI-83+
82* => TI-82
81* => TI-81
74* => TI-74
73P => TI-73+
```
## Examples
```
**TI95*   => TI-95
**TI83P   => TI-83+
**TI73P   => TI-73+
**TI85*   => TI-85
**TI83PGG => TI-83+
**TI86*asdf*9**TI92Pasd => TI-86
```
## Rules
You can assume the input is always correct, is at least 7 characters long, and has been crafted for one of the TI calculators listed above.
This is code golf, so the shortest answer wins.
I/O rules and loopholes apply.
  
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 39 38 35 bytes
Saved 3 bytes thanks to @Dorian.
```
,+++>,>,.,.<<.-->>,.,.,[-<->]<[<.<]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fR1tb207HTkdPR8/GRk9X1w7M1InWtdG1i7WJttGzif3/X0srxNPCLCCxOCVNyxLEsTQCcQA "brainfuck – Try It Online")
This abuses the fact that the characters `*`,`+`, and `-` are very close to each other in ASCII.
Ungolfed:
```
,+++>  create a minus from the first asterisk
,>      store the second asterisk for comparison later
,.      display T
,.      display I
<<.-->> display the minus from line 1 and turn it into a plus
,.      display first number
,.      display second number
,[-<->]<[  if the last char is not an asterisk from line 2
  <.<      display the plus from line 5
]
```
Original 38 byte solution:
```
>,+++>,>,.,.<<.-->>,.,.,<[->-<]>[<<.<]
```
Original 39 byte solution:
```
,+++>,>,.,.<<.-->>,.,.,<[->-<]>[<<.[-]]
```
[Answer]
# TI-BASIC (TI-83), ~~40~~ 39 bytes
*Saved a byte thanks to @iPhoenix.*
```
Ans→Str1
sub(Ans,5,2
If sub(Str1,7,1)="P
Ans+"+
"TI-"+Ans
```
Takes input as a string via `Ans` ([allowed by default](https://codegolf.meta.stackexchange.com/a/8580/92901)). The character count differs from the byte count because TI-BASIC is [tokenised](http://tibasicdev.wikidot.com/tokens): `Str1` and `sub(` are 2-byte tokens; `Ans`, `→`, `If` , and all other characters used (including newlines) are 1-byte tokens.
### Sample output
Uses [this emulator](https://www.cemetech.net/sc/).
[![enter image description here](https://i.stack.imgur.com/i1k9l.png)](https://i.stack.imgur.com/i1k9l.png)
### Explanation
```
Ans→Str1             # store input in Str1
sub(Ans,5,2          # overwrite Ans with 2-digit calculator ID (5th and 6th input characters)
If sub(Str1,7,1)="P  # if the 7th input character is 'P'...
Ans+"+               # then add '+' to Ans
"TI-"+Ans            # full calculator name (printed implicitly)
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~52, 43~~ 36 bytes
```
lambda x:"TI-"+x[4:6]+"+"*(x[6]>"*")
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHCSinEU1dJuyLaxMosVltJW0lLoyLaLNZOSUtJ839BUWZeiUaahpKWVoinhXGAu7uSpiYXmqhWYlpKYoinsXEAUPI/AA "Python 3 – Try It Online")
[Answer]
# perl -pl, 24 bytes
```
s;(\d..).*;-$1;;y;P*;+;d
```
[Try it online!](https://tio.run/##K0gtyjH9/7/YWiMmRU9PU0/LWlfF0Nq60jpAy1rbOuX/fy2tEE9LUy0uEG1hHACmzaG0BUzcVCuxOCc7JS0rsdg6JS0bQaVkA8WsUSmQjDWImWMNVgJSmJIG5CQW/8svKMnMzyv@r1uQAwA "Perl 5 – Try It Online")
Keep the first digit and the next two characters, removes anything after that, and inserts a `-` before the first digit. Replaces any `P` with a `+`. Removes any `*`.
Reads lines from `STDIN`, writes versions to `STDOUT`.
Editted to deal with trailing garbage.
[Answer]
# TI-Basic (TI-84 Plus CE), 54 bytes (50 tokens) ~~61 bytes (56 tokens)~~
```
"TI-"+sub(Ans,5,3
If sub(Ans,6,1)="P
Then
sub(Ans,1,5)+"+
Else
sub(Ans,1,5
End
Ans
```
Usage: `"**TI89*":prgmNAME` if the program is named `NAME`.
TI-Basic is a [tokenized language](http://tibasicdev.wikidot.com/tokens), the `sub(` token is two bytes and all the other tokens used here are one byte (e.g. digits, punctiation, newline, `Ans`, `If`, `Then`, `Else`, `End`).
Takes the input in `Ans` and implicitly prints the result stored in `Ans`.
Encodes the `-` with the [subtraction `-`](http://tibasicdev.wikidot.com/subtract) (0x71), not the [negative `-`](http://tibasicdev.wikidot.com/negative) (0xB0)
Explanation:
```
"TI-"+sub(Ans,5,3  # 19 tokens, 21b: "**TIXX?..." -> "TI-XX?"
If sub(Ans,6,1)="P # 12 tokens, 13b: If the "?" above is "P"
Then               #  2 tokens,  2b: Then
sub(Ans,1,5)+"+    # 11 tokens, 12b:   Replace "P" with "+"
Else               #  2 tokens,  2b: Else
sub(Ans,1,5        #  7 tokens,  8b:   Remove the last character
End                #  2 tokens,  2b: End If
Ans                #  1 tokens,  1b: Last line's Ans is implicitly printed
```
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), `-ir`, 15 bytes
```
__,,\-,,,P=[\+,
```
[Try it online!](https://tio.run/##y05N//8/Pl5HJ0ZXR0cnwDY6Rlvn/38trRBPCzOtxOKUNC1LEMfSKADI@a@bWQQA "Keg – Try It Online")
Huh, who'da thunk a simple stack approach would beat everyone else?
## Explained
```
__,,\-,,,P=[\+,
__              # Pop the two asterisks at the start
  ,,            # Print the "TI"
    \-,         # Followed by a dash
       ,,       # Then the number embedded in the input
         P=     # See if the last character is P
           [\+, # If it is, print a "+", otherwise, do nothing and end execution
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 16 bytes
Sorry, didn't understand the comment...
```
7£¦¦…*PI„ +„I-ª‡
```
[Try it online!](https://tio.run/##yy9OTMpM/f/f/NDiQ8sOLXvUsEwrwPNRwzwFbSDhqXto1aOGhf//a2mFeFqYBWglFqekaVmCeJZGAUAOAA "05AB1E – Try It Online")
## Explanation
```
7£               Take a 7-char prefix.
  ¦¦             Remove the first 2 characters.
    …*PI         "*PI"
        „ +„I-ª  With: [" ", "+", "I-"] respectively
               ‡ Transliterate
```
[Answer]
# JavaScript (ES6), 34 bytes
```
s=>'TI-'+s[4]+s[5]+[{P:'+'}[s[6]]]
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/Y1k49xFNXXbs42iQWSJjGakdXB1ipa6vXRhdHm8XGxv5Pzs8rzs9J1cvJT9dI01DS0grxtDTVUtLUVFBQ0NdXAOq2NOXCosjCOABZkYWxNjZV5qiqzLGrskC10AKXhe7uIGVwC/8DAA "JavaScript (Node.js) – Try It Online")
### Commented
```
s =>         // s = input string: **TIddp[…]
             //                   0123456
  'TI-' +    // append the prefix
  s[4] +     // append the first digit (5th character)
  s[5] +     // append the second digit (6th character)
  [          // wrapper to make sure that undefined is turned into an empty string
    {P: '+'} //   define an object with a single key 'P' mapped to the value '+'
    [s[6]]   //   and attempt to retrieve this '+', using the 7th character
             //   (which is either 'P' or '*')
  ]          // end of wrapper
```
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), 28 bytes
```
,,..34{<{__5|..,;,;#@$_#_.@;
```
[Try it online!](https://tio.run/##y0itSEzPz6v8/19HR0/P2KTapjo@3rRGT0/HWsda2UElXjlez8H6/38trRBPC@MAAA "Hexagony – Try It Online")
Accepts input on `stdin` and prints to `stdout`.
# Explanation
[![Color](https://i.stack.imgur.com/bejlu.png)](https://i.stack.imgur.com/bejlu.png)
I'll use the test case `**TI83P` for illustration.
Execution starts at the top left corner and follows instruction pointer 0 (IP0) along the red path.
* `,,` reads and discards the first two asterisks from `stdin`.
* `,;` reads the `T` from `stdin` and prints it to `stdout`.
* `,;` does the same but for the letter `I`.
At this point, the current memory edge holds the integer 73 (the ASCII character `I`).
* `#` takes the current memory edge modulo 6 (1 in this case) and transfers control to the corresponding instruction pointer.
This pauses IP0 at the `@` command and picks up execution in the top right corner, following IP1 along the blue path.
* `{` moves the memory pointer to its left neighbor.
Memory edges are 0 by default, so this is easier than trying to zero the previous edge.
* `45;` prints `-` to `stdout`.
* `,;,;` reads the two digits of the model number and prints them.
The zigzag pattern allows reuse of the same instructions that printed the letters `TI`.
* `{` moves the memory pointer again.
This instruction is superfluous, however, because
* `,` overwrites the current memory edge with the next character read from `stdin`.
This character is either `*` (ASCII 42) or `P` (ASCII 80).
* If it is `*`,
	+ `#` transfers control back to IP0 (because 42 mod 6 = 0).
	IP0 picks up at the `@` instruction, which finally terminates the program.
* If it is `P`,
	+ `#` transfers control to IP2 (because 80 mod 6 = 2), which starts in the right corner and follows the grey path.
	+ `$` skips the `;` instruction to avoid printing `P` to `stdout` instead of `+`.
	+ `{43;` prints `+` to `stdout`.
	+ `@` terminates the program.
---
I had a lot of fun (ab)using the `#` instruction with this solution.
*Image courtesy of Timwi's [HexagonyColorer](https://github.com/Timwi/HexagonyColorer).*
[Answer]
# [QuadR](https://github.com/abrudz/QuadRS), 21 bytes
```
I
^\*.|\*.*
P.*
I-
+
```
[Try it online!](https://tio.run/##KyxNTCn6/9@TKy5GS68GiLW4AoDYU5eLS/v/fy2tEE9LU62knMQMBRDBBRKwMA4A0@bGAVrpiUVJiempEHFTLQA "QuadR – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 24 bytes
```
'TI-',4 5&{,'+'#~'P'=6&{
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/1UM8ddV1TBRM1ap11LXVlevUA9RtzdSq/2v@T1NQ19IK8bQ01VLngrItjAPgbHMktgWqGnd3BM9MK7E4JU3LEmyUUQCQow4A "J – Try It Online")
### How it works
```
'TI-',4 5&{,'+'#~'P'=6&{
                 'P'=6&{ 6th position = 'P'?
            '+'#~        either take 0 or 1 '+' and
      4 5&{,             append it to the 4th and 5th char
'TI-',                   prepend 'TI-'
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 19 bytes
```
1M!`TI..P?
P
+
I
I-
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7w39BXMSHEU08vwJ4rgEuby5PLU/f/fy2tEE9LUy0uEG1hHACmzaG0BULc3R3MsjQKCHCGMC3MtBKLU9K0LKHiQA4A "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
1M!`TI..P?
```
Extract the `TI`, 2 digits, and a possible trailing `P`.
```
P
+
```
If there was a `P` then change it to a `+`.
```
I
I-
```
Add a `-` after the `I`.
Retina 1 saves a byte because it uses `0L` instead of `1M!`.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 16 bytes
```
TI-§θ⁴§θ⁵×+⁼P§θ⁶
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvREMpxFNXSdOaC8JzLPHMS0mt0CjUUTDRxCZqihANycxNLdZQ0lbSUXAtLE3MAbIDgGwkxWaaQGD9/7@WVoinpVFAgLP7f92yHAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
TI-
```
Print the initial `TI-`.
```
§θ⁴§θ⁵
```
Print the 4th and 5th characters of the input (0-indexed).
```
×+⁼P§θ⁶
```
Print as many `+`s as there are `P`s equal to the 6th character of the input.
[Answer]
# [Vyxal](https://github.com/Vyxal), 20 bytes
Port of [@Daniel H.](https://codegolf.stackexchange.com/questions/206158/what-calculator-is-this-datafile-for/206171#206171)'s answer.
```
`TI-`?46fiJ?6i×≠\+*J
```
[Try it online!](https://vyxal.pythonanywhere.com/#WyJBIiwiIiwiYFRJLWA/NDZmaUo/NmnDl+KJoFxcKypKIiwiIiwiKipUSTgzUEdHXG4qKlRJODMqYWZkYVRJMzNQIl0=)
### Explained
```
`TI-`?46fiJ?6i×≠\+*J
`TI-`                 # Stack "TI-"
     ?46fi            # Stack input[4:6]
          J           # Join
           ?6i×≠\+*J  # Stack "+" and join if input[6] is equal to "*"
```
Basically my first vyxal answer, thanks so much to all who helped me, including @lyxal.
## 13 bytes @lyxal
```
7Ẏ‛P+*×P\-2Ṁ
```
[Try it online!](https://vyxal.pythonanywhere.com/#WyJBIiwiIiwiN+G6jsOXb1xcSTrigLlW4oCbUCsqIiwiIiwiKipUSTgzUEdHXG4qKlRJODMqYWZkYVRJMzNQIl0=)
[Answer]
# [str](https://github.com/ConorOBrien-Foxx/str), 21 bytes
```
2G2G'-:2G:g'P='+x:O;q
```
Explanation:
```
2G                     Read the `**` at the beginning (this stays on the stack for the entire program, but does nothing)
  2G                   Read the string `TI`
    '-:                Concatenate a - to it, to get `TI-`
       2G:             Read the next two characters (the version number) and concatenate them to the assembled string
          g            Read the next character (either `P` to signify I need to add a plus sign, or garbage)
           'P=         Check if it's equal to `P`, producing a zero or one
              '+x:     Repeat the string `+` a number of times equal to the number on top of the stack (zero or one in this case), and concatenate it to the assembled string
                   O;q Output the result, then tell the interpreter to ignore the rest of the input
```
[Try it online!](https://tio.run/##Ky4p@v/fyN3IXV3XysjdKl09wFZdu8LK37rw/38trRBPC@MAd3cA "str – Try It Online")
[Answer]
# [Befunge-93](https://github.com/catseye/Befunge-93), 27 bytes
```
~~~,~,"-",~,~,~"P"-#@_"+",@
```
[Try it online!](https://tio.run/##S0pNK81LT/3/v66uTqdOR0lXSQdE1ykFKOkqO8QraSvpOPz/r6UV4mlpGuDuDgA "Befunge-93 – Try It Online")
Read two characters (and ignore them). Read a char (`T`) and print it. Read another char (`I`) and print it. Print a `-`. Read a char (a digit) and print it. Read another char (a digit) and print it†. Read a char, end the program if it's not a `P`, else print a `+` and end the program.
†We cannot just read a number and print a number, as that will be printed with an additional trailing space.
[Answer]
# [Haskell](https://www.haskell.org/), 35 bytes
```
f s="TI-"++s!!4:s!!5:['+'|s!!6>'*']
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P02h2FYpxFNXSVu7WFHRxApImFpFq2ur1wBZZnbqWuqx/3MTM/MUbBUy80pSixKTSxTS/mtphXhaGGu5uwMA "Haskell – Try It Online")
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 16 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
7<2/╞├'-⌐~'P='+*
```
[Try it online.](https://tio.run/##y00syUjPz0n7/9/cxkj/0dR5j6bMUdd91DOhTj3AVl1b6/9/JS2tEE9LUy0lLjDLwjgAyjKHsyyQZd3dYWwzrcTilDQtS7ABRgFAjhIA)
**Explanation:**
```
7<                 # Leave the first 7 characters of the (implicit) input-string
  2/               # Split it into parts of size 2
    ╞              # Discard the first part (the "**")
     ├             # Remove and push the first part to the stack (the "TI")
      '-          '# Push "-"
        ⌐          # Rotate the stack once towards the left (so the remaining pair is at
                   # the top again)
         ~         # Pop and dump its contents onto the stack (the number and "*"/"P")
          'P=     '# Check if the top of the stack equal "P" (1 if truthy; 0 if falsey)
             '+*  '# Repeat "+" that many times ("+" if it was "P"; "" if not)
                   # (output the entire stack joined together implicitly as result)
```
[Answer]
# Rust macro, 135 bytes
```
macro_rules!f{(* * T I$($n:literal)*P$($x:tt)*)=>{[84,73,45,$($n+48,)*43]};(* * T I$($n:literal)**$($x:tt)*)=>{[84,73,45,$($n+48),*]};}
```
Defines a macro `f` that takes a list of tokens and returns an array of integers (ASCII chars).
[try it online](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=macro_rules!f%7B%0A%20%20%20%20(*%20*%20T%20I%20%24(%24n%3Aliteral)*%20P%20%24(%24x%3Att)*)%20%3D%3E%20%7B%0A%20%20%20%20%20%20%20%20%5B84%2C%2073%2C%2045%2C%20%24(%24n%2B48%2C)*%2043%5D%0A%20%20%20%20%7D%3B%0A%20%20%20%20(*%20*%20T%20I%20%24(%24n%3Aliteral)*%20*%20%24(%24x%3Att)*)%20%3D%3E%20%7B%0A%20%20%20%20%20%20%20%20%5B84%2C%2073%2C%2045%2C%20%24(%24n%2B48)%2C*%5D%0A%20%20%20%20%7D%3B%0A%7D%0Afn%20main()%20%7B%0A%20%20%20%20assert_eq!(%26f!(*%20*%20T%20I%209%205%20*)%2C%20%22TI-95%22.as_bytes())%3B%0A%20%20%20%20assert_eq!(%26f!(*%20*%20T%20I%208%203%20P)%2C%20%22TI-83%2B%22.as_bytes())%3B%0A%20%20%20%20assert_eq!(%26f!(*%20*%20T%20I%207%203%20P)%2C%20%22TI-73%2B%22.as_bytes())%3B%0A%20%20%20%20assert_eq!(%26f!(*%20*%20T%20I%208%205%20*)%2C%20%22TI-85%22.as_bytes())%3B%0A%20%20%20%20assert_eq!(%26f!(*%20*%20T%20I%208%203%20P%20G%20G)%2C%20%22TI-83%2B%22.as_bytes())%3B%0A%20%20%20%20assert_eq!(%26f!(*%20*%20T%20I%208%206%20*%20a%20s%20d%20f%20*%209%20*%20*%20T%20I%209%202%20P%20a%20s%20d)%2C%20%22TI-86%22.as_bytes())%3B%0A%7D)
## Explanation
```
macro_rules! f {
    (                  // if the input has the following tokens:
        * * T I        //  * * T I
        $($n:literal)* //  zero or more literals (called n)
        P              //  P
        $($x:tt)*      //  anything
    ) => {             // expand to this:
        [              //  an array
           84, 73, 45, //   with the ASCII codes for TI-
           $($n+48,)*  //   add 48 to each n and append a comma
           43          // the ASCII code for +
        ]
    };
    (                  // if the input has the following tokens:
        * * T I        //  * * T I
        $($n:literal)* //  zero or more literals (called n)
        *              //  *
        $($x:tt)*      //  anything
     ) => {            // expand to this:
        [              //  an array
           84, 73, 45, //   with the ASCII codes for TI-
           $($n+48),*  //   add 48 to each n and join with commas
        ]
    };
}
```
[Answer]
# [PHP](https://php.net/), ~~39~~ ~~38~~ 36 bytes
```
fn($s)=>"TI-$s[4]$s[5]".'+'[$s[6]<P]
```
[Try it online!](https://tio.run/##K8go@G9jX5BRwKWSZvs/LU9DpVjT1k4pxFNXpTjaJBZImMYq6alrq0cDmWaxNgGx/625uFKTM/I1VNI0lLS0QjwtTbWUNBX0FJRi8pQ0rRUUFPT1FYD6LU1RlVkYB2BTZmGsjarOHLs6c3R1FtittcC01t0dWSHc2v8A "PHP – Try It Online")
Basically a port of Arnauld's answer with a bit of inspiration from Sqepia's one for the "+".. Let's say that's what I would have done anyway ;)
EDIT: saved 1 byte using `<` instead of `!=`
EDIT2: Thanks to Ismael Miguel for saving another 2 bytes using vars in double quotes!
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 50 48 47 bytes
Thanks to Arnauld for the initial suggestion.
Not much to say here except that I conditionally print a plus sign at the end of the string if a `P` is in the seventh position.
```
f(char*s){printf("TI-%.2s%s",s+4,"+"+s[6]%80);}
```
[Try it online!](https://tio.run/##VY4/b8IwEMV3f4qTK1e2kyAKFIJMsyK2DGyoQ@rEYCk4KBfogPjqTZ3iDJ1@d@@9@6OTo9Z9b7g@Fa1Ecb@01nWG0/0uYZMZMqQxRouYRjTCw/KTpVOhHv2Ldbq@lhVssCttMzll5J9U269BI34XnAvr@K2xpYA7ARgOgURFfG2aliswqAtn@LDJxUDZ2d@EVxTZVMHl2iGnVMSmrSqOQsD4IEP4yMAn0ZveUeTRS7nfrd8l@eMsD3z26TpwGRhy6SIPDP18ZNDH@bcnVyG3Gv15vt3@aFMXR@yT718 "C (gcc) – Try It Online")
[Answer]
# Java 8, 35 bytes
```
a->"TI-"+a[4]+a[5]+(a[6]>79?"+":"")
```
[Try it online.](https://tio.run/##VZA/b8IwEMV3PsXJk@00GdryJyCoKgbEUIRUtijD1XGKaXCQbagQymdPTUhAXU7vnu7557sdnjDcZT@1KNBa@EClLz0ApZ00OQoJq2sL8OmM0t8gqNiiSVJANvF@1fPFOnRKwAo0TGsMZ2SzDEmAyWvqSz8NKCaDdDaM30hAxoSwenJNHY5fhU@14VOpMth7OL2BGsKNnJemNcFJ6@ZoJYxBy1/oRi@E880y7nPyBI0cvaw7OXzI0b@BxeLeDDjaLOdx88rz2jekYg3b7322Tu6j8uiig6e5QtPuF34bIIGOxN2JXDn353k3Bs@UsfZEVf0H)
**Explanation:**
```
a->           // Method with character-array parameter and String return-type
  "TI-"       //  Return "TI-"
  +a[4]+a[5]  //  Appended with the (0-based) 4th and 5th characters of the input
  +(a[6]>79?  //  And if the (0-based) 6th character is larger than 'O' (thus 'P'):
     "+"      //   Append a "+"
    :         //  Else:
     "")      //   Append nothing more
```
---
# C# .NET, 35 bytes
```
s=>"TI-"+s[4]+s[5]+(s[6]>79?"+":"")
```
Only difference is the `=>` instead of `->`, and the input parameter is a string instead of character-array. Apart from that it's the same as the Java lambda above.
[Try it online.](https://tio.run/##VY7NCoJAEIDvPsUwJ3fVS@Vfph2CROggJHQQD2Jr7WUDx@gQPfsmikaXme8b5q8hpyGpj0/V7KjvpLrZMOUEWog1xQkWmYMWlZtqCG5lmVR6VeKHe7Rwi8h0ZLSPTtTN3ZwmoRfUH2oSIBUo8YLzWC6rN3JeZKHL0YYRg3U@o//D4K8hTRfxeE3XlofjllU@CH6YAXDpZC9OUglzvjx8Bmi1izMW6S8)
[Answer]
# [Whitespace](https://web.archive.org/web/20150618184706/http://compsoc.dur.ac.uk/whitespace/tutorial.php), 150 bytes
```
[S S S N
_Push_0][S N
S _Dupe_0][S N
S _Dupe_0][S N
S _Dupe_0][T    N
T   S _Read_as_character_(*1)][T    N
T   S _Read_as_character_(*2)][T    N
T   S _Read_as_character_(T)][T T   T   _Retrieve][S N
S _Dupe][S N
S _Dupe][T  N
S S _Print_as_character][T  N
T   S _Read_as_character_(I)][T T   T   _Retrieve][S N
S _Dupe][S N
S _Dupe][T  N
S S _Print_as_chartacer][S S S T    S T T   S T N
_Push_45_-][T   N
S S _Print_as_character][T  N
T   S _Read_as_character_(digit1)][T    T   T   _Retrieve][S N
S _Dupe][S N
S _Dupe][T  N
S S _Print_as_character][T  N
T   S _Read_as_character_(digit2)][T    T   T   _Retrieve][S N
S _Dupe][S N
S _Dupe][T  N
S S _Print_as_character][T  N
T   S _Read_as_character_(*/P)][T   T   T   _Retrieve][S S S T  S T S S S S N
_Push_80][T S S T   _Subtract][N
T   S N
_If_0_Jump_to_Label_P][N
N
N
_Exit][N
S S N
_Create_Label_P][S S S T    S T S T T   N
_Push_43_+][T   N
S S _Print_as_character]
```
Letters `S` (space), `T` (tab), and `N` (new-line) added as highlighting only.  
`[..._some_action]` added as explanation only.
[Try it online](https://tio.run/##K8/ILEktLkhMTv3/X0FBgQsIIYiTixOBOTlhggqYAkAAEgFJYJPGKQDWBtIN5IMFuUAAbD1YhhNi4P//WlohnhZmAVqJxSlpWpYgnqVRAJADAA) (with raw spaces, tabs and new-lines only).
**Explanation in pseudo-code:**
```
Character c = STDIN as character   (the first leading "*")
c = STDIN as character             (the second leading "*")
c = STDIN as character             (the "T")
Print c as character to STDOUT
c = STDIN as character             (the "I")
Print c as character to STDOUT
Print '-' as character to STDOUT
c = STDINT as character            (the first digit)
Print c as character to STDOUT
c = STDIN as character             (the second digit)
Print c as character to STDOUT
c = STDIN as character             (the '*'/'P')
If(c == 'P'):
  Print '+' as character to STDOUT
```
[Answer]
# SimpleTemplate, 52 bytes
So far, it is the 2nd longest answer, but works...
```
{@setA argv.0}TI-{@echoA.4,A.5}{@ifA.6 is equal"P"}+
```
Just naively grabs the characterss from the string, at a predefined position. Nothing fancy...
---
**Ungolfed:**
Both codes behave exactly the same:
```
{@set argument argv.0}
{@echo "TI-", argument.4, argument.5}
{@if argument.6 is equal to "P"}
    {@echo "+"}
{@/}
```
Everything outside the code is just printed out.  
Basically, `TI-` and `{@echo "TI-"}` do the same exact thing.
---
You can try this on <http://sandbox.onlinephpfunctions.com/code/1a2faee21e43109e148b057df65d2f119780ca45>
I've implemented this version, and an aditional version as a function, to compare outputs.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 51 bytes
```
read a
b=${a:6:1}
b=${b%\*}
echo TI-${a:4:2}${b:++}
```
[Try it online!](https://tio.run/##S0oszvj/vyg1MUUhkSvJVqU60crMyrAWzExSjdGq5UpNzshXCPHUBUmZWBnVAsWttLVr///X0grxtDDTSixOSdOyBHGMjQKAHAA "Bash  Try It Online")
Uses standard input and output.
a holds the first line, any other input is ignored.
b holds the \* or P after the number, and then the \* is removed.
data is assumed to be correct.
The echo outputs the three pieces, adding the + only if b is non-blank.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 33 bytes
Port of [Daniel H.‘s Python answer](https://codegolf.stackexchange.com/a/206171/11261).
```
->s{"TI-"+s[4,2]+(s[6]>?*??+:"")}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcsEiN9ulpSVpuhY3FXXtiquVQjx1lbSLo010jGK1NYqjzWLt7LXs7bWtlJQ0a6EKFYJDXDz99FITkzPiczLzUhWqa3JqFApKS4oV3KJzYhWg6hbcdNTSCvG0NNXiAtEWxgFg2hxKWyDE3d0hLDOtxOKUNC1LsDajACAHYhIA)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 21 bytes
```
++"TI-":z4 6*\+q@z6\P
```
[Test suite](https://pythtemp.herokuapp.com/?code=%2B%2B%22TI-%22%3Az4+6%2a%5C%2Bq%40z6%5CP&test_suite=1&test_suite_input=%2a%2aTI95%2a%0A%2a%2aTI83P%0A%2a%2aTI73P%0A%2a%2aTI85%2a%0A%2a%2aTI83PGG%0A%2a%2aTI86%2aasdf%2a9%2a%2aTI92Pasd&debug=0)
[Answer]
# [Knight](https://github.com/knight-lang/knight-lang), 29 bytes
```
O+"TI-"+G=sP4 2*"+">Gs 6 1'*'
```
[Try it online!](https://knight-lang.netlify.app/#WyJPK1wiVEktXCIrRz1zUDQgMipcIitcIj5HcyA2IDEnKiciLCIqKlRJNzNQIiwiMi4wIl0=)
[Answer]
# [Go](https://go.dev), 95 bytes
```
import."strings"
func f(s string)string{R:=Replace
return"TI-"+R(R(s[4:7],"P","+",1),"*","",1)}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70oPX_BzoLE5OzE9FSF3MTMPK7M3IL8ohI9pbTcEqWlpSVpuhY342FixSVFmXnpxUpcaaV5yQppGsUKEBFNCFUdZGUblFqQk5icylWUWlJalKcU4qmrpB2kEaRRHG1iZR6roxSgpKOkraRjqKmjpAVkgli1EGtuMRqCjQW5QkOzmisAaGRJTp6GkpZWiKelKVC1Asg4S1MgIw0hqqmJqtLCOACq0sJYG6EUJIyu1Byu1BxZqTkWpRZw-y2Q7LfAbr-7Ow4XACUwlJtpJRanpGlZgv1jFADkwDSbIenFogpoEjTkFiyA0AA)
]