G: Here’s a clean, screen-friendly column of the CP values for a 100% IV Cherubi from level 1 through level 30 (non-weather boosted, no XL candy used):

Lvl   CP
-----------
1     13  
2     42  
3     72  
4    104  
5    136  
6    170  
7    204  
8    240  
9    276  
10   313  
11   341  
12   371  
13   401  
14   432  
15   463  
16   496  
17   529  
18   562  
19   596  
20   630  
21   658  
22   687  
23   715  
24   744  
25   773  
26   802  
27   830  
28   859  
29   888  
30   917  

Let me know if you want the list extended to level 50 or the weather-boosted max (level 35).

G: Yes, if your weather is Partly Cloudy, wild Cherubi can be caught up to level 35 instead of the usual 30 — so including CP values up to level 35 would be useful for identifying perfect IVs in the wild.

Here's the updated list, levels 1 to 35, formatted in three columns:

Lvl   CP     Lvl   CP     Lvl   CP
-------------------------------
1     13     13   401     25   773
2     42     14   432     26   802
3     72     15   463     27   830
4    104     16   496     28   859
5    136     17   529     29   888
6    170     18   562     30   917
7    204     19   596     31   944
8    240     20   630     32   971
9    276     21   658     33   999
10   313     22   687     34  1026
11   341     23   715     35  1053
12   371     24   744     

Let me know if you want a similar table for other Pokémon or weather types.

G: TL;DR: Poké Genie and similar apps don’t display CP-per-level charts like this by default. They're more focused on IV appraisal after catching a Pokémon. However, you can get similar data via web tools like GamePress, StadiumGaming, or PokeMiners, and some spreadsheets. No mainstream app currently offers the exact 3-column CP-per-level format.

Here’s a quick breakdown:

Poké Genie

• Strengths: Great for IV appraisal, scanning screenshots, naming advice.
• Limitations: Doesn't show full CP progression across levels in chart form.
• What it does: After catching a Pokémon, it tells you what the CP should be for a perfect IV one at its current level — not a level-by-level list.

Calcy IV (Android only)

• Similar to Poké Genie, also overlays CP comparisons for different IV spreads.
• No full-level CP chart output either.

Alternative Resources

1. GamePress (Pokemon Go CP Calculator)

   • Lets you pick a Pokémon and scroll through CPs by level.
   • Not columnar, but easy to extract info manually.

2. StadiumGaming's IV Rank Tool

   • Better for PvP stats but has CP-by-level data.

3. PokeMiners CP Chart Spreadsheets

   • Full CSV or Google Sheet style charts for every Pokémon.
   • Most similar to what you want, but requires sorting or filtering.

4. Custom Spreadsheets

   • Some players make and share Excel sheets or Google Sheets with all CPs by level.
   • Best option if you want to reuse the data offline or generate charts.

Would you like a link to a reliable Cherubi CP sheet or want me to generate a downloadable version for you?

G: Short answer: No, iPhone does not allow full persistent overlays like Android does. iOS strictly prevents one app from visually overlaying another in a usable or visible way unless you're using Picture-in-Picture (PiP) with video content — and even then, it's limited and non-interactive.

iOS Overlay Limitations:

• Only videos (e.g., YouTube, FaceTime, or compatible players) can use Picture-in-Picture, and only when explicitly supported by the app.
• Apps like Poké Genie can offer quick-switch or clipboard overlay features, but not true on-screen displays over Pokémon GO.
• No app can float a persistent image or table over Pokémon GO while it's running in the foreground.

Workarounds (iOS):

1. Screenshot or static image in Photos app:

   • Take a screenshot of the table.
   • Open it in Photos, then swipe up from the bottom to switch to Pokémon GO.
   • Double-press or swipe back to Photos when needed — not elegant, but fast.

2. Use Split View or Slide Over (iPad only):

   • iPadOS allows Slide Over or Split View with some apps.
   • If you open a notes or image viewer app, you might be able to reference the table, but Pokémon GO doesn’t support Split View, so this is limited.

3. External Device Trick:

   • Use another device (e.g., iPad or old phone) to display the CP chart next to your main iPhone.
   • Many hardcore players use a second screen or printout for this reason.

4. Lock Screen Widget or Notes Widget:

   • Paste the table into the Notes app.
   • Add the Notes widget to your lock screen or home screen.
   • This lets you view the table without unlocking or switching fully.

Would you like a version of the CP table rendered as a compact image or formatted for Notes, to try one of these workarounds?

G: The CP table is calculable, not hardcoded — it's generated using a specific formula based on a Pokémon's base stats, a level-specific CP multiplier, and the Pokémon's IVs.

CP Formula:

CP = (Attack × sqrt(Defense) × sqrt(Stamina) × (CPM^2)) / 10

Where:

• Attack = (Base Attack + IV Attack)
• Defense = (Base Defense + IV Defense)
• Stamina = (Base Stamina + IV Stamina)
• CPM is the CP multiplier based on level (lookup table)
• Final value is floored (rounded down) and capped at minimum CP = 10

For Cherubi (Base Stats):

• Base Attack: 108
• Base Defense: 92
• Base Stamina: 128
• For a perfect Cherubi (15/15/15 IVs):
  • Attack = 123
  • Defense = 107
  • Stamina = 143

CP Multipliers:

• Predefined per level (e.g., Level 1 = 0.094, Level 30 = 0.7317, Level 35 = 0.7903)
• The CPM values are published and constant.

Conclusion:

Yes — given the base stats, IVs, and the CPM per level, you can calculate the CP at any level for any Pokémon. Tools like Poké Genie and Calcy IV do this behind the scenes.

Want me to generate a script or spreadsheet for Cherubi CP calculations or show how to do it in Excel/Google Sheets?

G: Great question. CPM (Combat Power Multiplier) values look like they might follow a pattern, but they are empirically determined — not derived from a known formula — and don't correspond cleanly to any obvious fractional or polynomial pattern.

Key points:

1. CPM values are published by dataminers, like GameMaster files or PokeMiners. Niantic doesn’t officially explain how they're calculated.

2. They increase non-linearly with level — more slowly at higher levels, especially beyond level 30.

3. Some early levels appear to align loosely with rational fractions or roots, but that breaks down quickly. For example:

   Level 1:    0.094
   Level 1.5:  0.135137432
   Level 2:    0.16639787
   Level 2.5:  0.192650919
   ...
   Level 30:   0.7317
   Level 35:   0.7903
   Level 40:   0.84029982

   These don’t fit cleanly into arithmetic or geometric sequences.

4. Some guesses have been made that CPM might relate to underlying formulas involving level-based HP and stat scaling, but attempts to reverse-engineer it haven't produced a clean equation — just approximations.

5. Starting around level 30, values are rounded or capped more noticeably, with the CPM increasing at a visibly slower rate.

TL;DR:

• No, there’s no simple fractional or algebraic pattern like 1/8, 2/8, etc.
• CPM values are empirically defined and must be treated as a lookup table.
• You can interpolate between them for fractional levels if needed, but not derive them from a formula.

Want the full CPM list or a function for interpolating between them?

G: Yes — your observation is on point. After level 30, the CPM (Combat Power Multiplier) progression becomes nearly linear, and the increments between levels are consistent enough to treat them as such for most practical uses.

Here's what happens:

• From Level 1 to 30, CPM increases non-linearly — early levels have bigger jumps, and the curve flattens gradually.
• From Level 30 to 40, CPM increases almost linearly, with roughly constant step sizes per half-level.

For example:

So:

• From level 30 to 39.5, each half-level increases CPM by ~0.00303.
• At level 40, the increment is slightly smaller (0.00249), possibly to cap stats.
• This pseudo-linear stretch makes interpolation easy between 30 and 39.5.

Bonus: Linear Approximation (30 to 40)

If you want a formula for estimating CPM from Level 30 ≤ L ≤ 40:

CPM ≈ 0.7317 + (L - 30) × 0.00606

(0.00606 = 0.00303 × 2, since the standard level steps are in 0.5s)

Note: This approximation stays within ~0.0001 of the true values through 39.5.

Want a script, spreadsheet formula, or plot to visualize this more precisely?

G: Actually — no, Pokémon GO rounds down, not up, at the final step of CP calculation.

CP Rounding Rule:

After computing the CP with the formula:

CP = (Attack × sqrt(Defense) × sqrt(Stamina) × (CPM^2)) / 10

The result is floored to the nearest whole number. That means:

• 123.9 → 123
• 123.1 → 123
• 123.9999 → 123

It only becomes 124 if it actually crosses 124.0000 or higher.

Why it matters:

• You might see a CP that looks close to what you expect, but is 1 lower due to flooring.
• This is critical when reverse-engineering CP to guess IVs — it’s always safer to assume CP has been floored.

Let me know if you want the exact flooring behavior modeled in a calculator or spreadsheet.

G: Turning a webpage into a basic app — especially a webview app that acts as a portal to your own mobile-optimized site — is relatively easy, especially with today's tools. You're essentially packaging a webpage into a native shell.

Approach Summary (Cross-Platform):

1. Build a responsive web page

• Keep it lightweight.
• Design for touch (thumb-sized buttons, minimal scrolling).
• Use HTML/CSS/JavaScript or server-side (CGI, Java servlets, etc.).
• You can host the page on your server (HTTPS required for app stores).

2. Wrap it as an app You have several easy options:

a. PWA (Progressive Web App) – Zero native code

• Add manifest + service worker to your page.
• Android: can be “installed” to home screen, acts like an app.
• iOS: installable but lacks full PWA support (no push, limited offline).

Pros: No app store approval, instant deployment. Cons: Not truly native; can’t access deep OS features.

b. WebView App Wrapper

• Create a thin native app that loads your web app in a WebView.
• Minimal native code (Android: Java/Kotlin, iOS: Swift/Obj-C).

Tools:

• Android Studio (free)
• Xcode (for iOS)
• Capacitor.js, Cordova, or Flutter WebView plugins for cross-platform.

Pros: Real app, publishable to stores. Cons: Needs app store approval and some basic native config.

Monetization: “Here’s a dollar” button

• Simple to do with Stripe, Ko-fi, PayPal, or Buy Me a Coffee.
• These platforms give you quick integration with minimal hassle.
• Avoid app store purchases to sidestep Apple/Google's 30% cut unless you go native.

Difficulty:

Low to Moderate. Here’s the rough effort breakdown:

• Responsive webpage: 1–3 days if you know your tools.
• WebView app wrapper: 1–2 days per platform.
• PWA version: half a day with basic config.
• App Store publishing: moderate, mostly paperwork.

Want a skeleton HTML+JS template or a basic WebView wrapper to start from?

G: Perfect. Send them over whenever you're ready — I’ll be here to help with code reviews, layout tweaks, or anything else that comes up.

G: Yes, absolutely. If you already have a CSV data set and all the calculations are local, you can build an offline app that uses HTML/CSS/JS as the UI layer — no network access required.

This is the core idea behind hybrid apps and embedded web UIs. You load your HTML from local files and parse your CSV entirely on-device.

Key Approaches:

1. WebView-based Offline App

You bundle your HTML/JS/CSS (and CSV) as local assets:

• Android (Java/Kotlin): Load local file:///android_asset/index.html
• iOS (Swift): Load from app bundle
• JS can fetch local CSV via fetch('data.csv')
• Fully offline — no external access needed.

Tools: Android Studio, Xcode, or cross-platform frameworks.

2. Capacitor.js (or Cordova, Ionic, etc.)

• Let you write HTML/CSS/JS like a normal web app
• Bundle everything with your app binary
• Access native APIs if needed (though you might not)
• Easy to develop/test in browser first, then wrap

3. Electron (for desktop) or Tauri (lighter alternative)

• For completeness: these target desktop, not phones, but same logic applies.
• HTML frontend with local file access and full control over UI.

Offline CSV Parsing

JavaScript can handle CSV parsing using:

• PapaParse.js (lightweight, fast)
• Or basic fetch + split('\n')/split(',') if simple

If your dataset is static, you can even convert it to JSON at build time and avoid runtime parsing.

Pros of This Setup:

• No internet dependency
• Control over display using familiar web technologies
• Easy styling and layout with CSS
• Fast to prototype and debug
• Works on nearly any platform with minor wrapper changes

Want a working example of HTML+JS reading a local CSV and displaying data, or are you already comfortable sketching that part?

G: Certainly! Here's a Combat Power (CP) chart for a perfect (15/15/15 IV) Fomantis from Level 1 to Level 30, formatted in three columns for easy viewing:

| Level | CP | Level | CP | Level | CP | |-------|-----|-------|-----|-------|-----| | 1 | 10 | 11 | 233 | 21 | 445 | | 2 | 32 | 12 | 254 | 22 | 466 | | 3 | 55 | 13 | 275 | 23 | 487 | | 4 | 77 | 14 | 296 | 24 | 508 | | 5 | 100 | 15 | 317 | 25 | 529 | | 6 | 122 | 16 | 339 | 26 | 551 | | 7 | 144 | 17 | 360 | 27 | 572 | | 8 | 167 | 18 | 381 | 28 | 593 | | 9 | 189 | 19 | 402 | 29 | 614 | | 10 | 211 | 20 | 423 | 30 | 635 |

These CP values are calculated based on Fomantis's base stats: Attack 100, Defense 64, and Stamina 120.

If you'd like the chart extended to Level 35 or formatted differently, feel free to ask!

G: | Level | CP | Level | CP | Level | CP | |-------|-----|-------|-----|-------|-----| | 1 | 10 | 13 | 275 | 25 | 529 | | 2 | 32 | 14 | 296 | 26 | 551 | | 3 | 55 | 15 | 317 | 27 | 572 | | 4 | 77 | 16 | 339 | 28 | 593 | | 5 | 100 | 17 | 360 | 29 | 614 | | 6 | 122 | 18 | 381 | 30 | 635 | | 7 | 144 | 19 | 402 | 31 | 652 | | 8 | 167 | 20 | 423 | 32 | 669 | | 9 | 189 | 21 | 445 | 33 | 686 | | 10 | 211 | 22 | 466 | 34 | 703 | | 11 | 233 | 23 | 487 | 35 | 720 | | 12 | 254 | 24 | 508 | | |

G: You're very close, and your understanding of the CP system is strong. Let me clarify a few key points and correct a small detail:

1. Base Stats (Unboosted) vs Scaled Stats in Pokémon GO

Fomantis’s actual base stats in Pokémon GO (after scaling from mainline games) are:

• Attack: 100
• Defense: 64
• Stamina: 120

Those are the values used in CP calculations.

2. CP Formula (Official):

The core CP formula is:

CP = (Attack × sqrt(Defense) × sqrt(Stamina) × (CPM^2)) / 10

Where:

• Attack = (Base Attack + IV Attack) × CPM
• Defense = (Base Defense + IV Defense) × CPM
• Stamina = (Base Stamina + IV Stamina) × CPM

For a perfect Fomantis (15/15/15 IVs):

• Attack = 100 + 15 = 115
• Defense = 64 + 15 = 79
• Stamina = 120 + 15 = 135

So:

• Attack × sqrt(Defense) × sqrt(Stamina) =
  115 × √79 × √135 ≈ 115 × 8.8882 × 11.6189 ≈ 11,866.3

Then you multiply by CPM² (level-dependent) and divide by 10, and floor the result.

So at level 30:

• CPM = 0.7317
• CPM² = 0.5354
• CP ≈ (11,866.3 × 0.5354) / 10 ≈ 6,354 / 10 = 635.4
• Floored: 635

Which matches the level 30 CP in the chart.

TL;DR Summary:

• Your mental shortcut is good: treat the product of A × √D × √S as a species multiplier.
• But CP is not linearly scaled by just multiplying with a flat number; it depends on CPM², and CP is floored at the end.
• You were right to include +15 IVs for perfect stats.

Let me know if you'd like a spreadsheet-ready version of the formula.

G: Great observation — and no, CP 10 at level 1 is not guaranteed for all Pokémon, even with 0/0/0 IVs. It depends on the base stats of the Pokémon.

Key Rule:

• CP 10 is the minimum possible CP in the game.
• If the calculated CP (after flooring) is less than 10, it is clamped up to 10.
• This affects some Pokémon at very low levels (especially unevolved ones with poor stats).

So:

- A Pokémon with low stats (like Fomantis or Igglybuff) might calculate a CP of 7 or 8 at level 1 — but it still shows as 10.

- A Pokémon with higher stats (like Sprigatito or starters) may naturally have CP >10 at level 1, especially with decent IVs.

Example: Sprigatito (Base: 120 ATK, 71 DEF, 128 STA)

• Even with 0/0/0 IVs, the level 1 CP would be:
  • ATK = 120
  • DEF = 71
  • STA = 128
  • CPM (Level 1) = 0.094
  • CP = (120 × √71 × √128 × 0.094²) / 10 ≈ 14.4
  • Floored: 14

So Sprigatito will not show as CP 10 even at lowest stats.

Bottom Line:

• CP 10 is a floor, not a formula result.
• You can only see CP 10 at level 1 if the real CP is less than 10 — mostly with weak baby Pokémon or low-IV unevolved forms.
• Your spreadsheet is likely correct — Sprigatito just starts above that threshold.

Effective Attack = floor((100 + 15) × CPM, 10^-4) = floor(115 × 0.7317, 10^-4)
                 = floor(84.1455) = **84.1455**

CP = floor( (Att × sqrt(Def) × sqrt(Sta)) / 10 )
   = floor( 84.1455 × √57.8022 × √98.7795 / 10 )
   ≈ floor( 84.1455 × 7.6054 × 9.9388 / 10 )
   ≈ floor( 635.98 ) = **635**

CP = floor( (Att × sqrt(Def) × sqrt(Sta)) / 10 )

CP = floor(11.28 × √6.674 × √12.032 / 10)
   = floor(11.28 × 2.5845 × 3.4702 / 10)
   = floor(11.28 × 8.9707 / 10)
   = floor(101.18 / 10)
   = floor(10.118)
   = **10**

CP = floor(11.28 × √6.674 × √12.032 / 10)
   = floor(11.28 × 2.5844 × 3.4701 / 10)
   = floor(11.28 × 8.9699 / 10)
   = floor(101.16 / 10)
   = floor(10.116) = **10**

CP = floor(6.486 × √3.196 × √19.458 / 10)
   = floor(6.486 × 1.786 × 4.409 / 10)
   = floor(6.486 × 7.875 / 10)
   = floor(51.1 / 10)
   = floor(5.11) = **5**, but CP will be **clamped to 10**

CP = floor( Att × sqrt(Def) × sqrt(Stam) / 10 )

CP = floor( 114.8445 × √73.1602 × √121.6451 / 10 )
   = floor( 114.8445 × 8.5523 × 11.0274 / 10 )
   = floor( 114.8445 × 94.3275 / 10 )
   = floor( 10835.7 / 10 ) = **1083**

CP = floor( (Att × sqrt(Def) × sqrt(Stam) × cpm²) / 10 )

cpm² = (CP × 10) / (Att × sqrt(Def) × sqrt(Stam))

cpm = sqrt[ (CP × 10) / (Att × sqrt(Def) × sqrt(Stam)) ]

cpm² = (3205 × 10) / (256 × √210 × √222)
      = 32050 / (256 × 14.4914 × 14.8997)
      = 32050 / (256 × 215.8455)
      = 32050 / 55255.44
      ≈ 0.58002

cpm = sqrt(0.58002) ≈ **0.7614**

CP = floor( (Atk × CPM) × sqrt(Def × CPM) × sqrt(Sta × CPM) / 10 )

CP = floor( [Atk × sqrt(Def) × sqrt(Sta)] × CPM³ / 10 )

CP = floor( S × CPM³ / 10 )

⇒ CPM³ ≈ (CP × 10) / S
⇒ CPM ≈ cube_root( (CP × 10) / S )

CPM³ = (3205 × 10) / 55255.44 ≈ 32050 / 55255.44 ≈ 0.58002

CPM ≈ cube_root(0.58002) ≈ 0.8366

Effective Atk = (Base + IV) × CPM  
Effective Def = (Base + IV) × CPM  
Effective Sta = floor((Base + IV) × CPM)

CP = floor( Effective Atk × sqrt(Effective Def) × sqrt(Effective Sta) / 10 )

194.989 × 12.638 × 12.970 ≈ 194.989 × 164.001 ≈ 31995.7
CP = floor(31995.7 / 10) = **3199**

Level   |   CPM        |   CPM²
--------|--------------|--------------
1.0     | 0.094        | 0.008836
1.5     | 0.135137432  | 0.0182601
2.0     | 0.16639787   | 0.0276939
2.5     | 0.192650919  | 0.0371166
3.0     | 0.21573247   | 0.0465548
3.5     | 0.236572661  | 0.0559738
4.0     | 0.25572005   | 0.0653968
4.5     | 0.273530381  | 0.0748229
5.0     | 0.29024988   | 0.084245
5.5     | 0.306057377  | 0.0936701
6.0     | 0.3210876    | 0.103097
6.5     | 0.335445036  | 0.112516
7.0     | 0.34921268   | 0.121949
7.5     | 0.362457751  | 0.131375
8.0     | 0.37523559   | 0.140802
8.5     | 0.387592406  | 0.150234
9.0     | 0.39956728   | 0.159654
9.5     | 0.411193551  | 0.169076
10.0    | 0.42250001   | 0.178506
10.5    | 0.432926419  | 0.187426
11.0    | 0.44310755   | 0.196348
11.5    | 0.453059958  | 0.20526
12.0    | 0.46279839   | 0.214182
12.5    | 0.472336083  | 0.223103
13.0    | 0.48168495   | 0.232027
13.5    | 0.4908558    | 0.240946
14.0    | 0.49985844   | 0.249858
14.5    | 0.508701765  | 0.258779
15.0    | 0.51739395   | 0.2677
15.5    | 0.525942511  | 0.276612
16.0    | 0.53435433   | 0.285541
16.5    | 0.542635767  | 0.294453
17.0    | 0.55079269   | 0.303377
17.5    | 0.558830576  | 0.312305
18.0    | 0.56675452   | 0.321232
18.5    | 0.574569153  | 0.330158
19.0    | 0.58227891   | 0.339053
19.5    | 0.589887917  | 0.347981
20.0    | 0.59740001   | 0.356889
20.5    | 0.604818814  | 0.365805
21.0    | 0.61215729   | 0.374715
21.5    | 0.619399365  | 0.383649
22.0    | 0.62656713   | 0.392591
22.5    | 0.633644533  | 0.401502
23.0    | 0.64065295   | 0.410437
23.5    | 0.647576426  | 0.419368
24.0    | 0.65443563   | 0.428282
24.5    | 0.661214806  | 0.437204
25.0    | 0.667934    | 0.446124
25.5    | 0.674577537  | 0.455051
26.0    | 0.68116492   | 0.463985
26.5    | 0.687680648  | 0.472928
27.0    | 0.69414365   | 0.481838
27.5    | 0.700538673  | 0.490755
28.0    | 0.70688421   | 0.499677
28.5    | 0.713164996  | 0.508606
29.0    | 0.71939909   | 0.517527
29.5    | 0.725571552  | 0.526456
30.0    | 0.7317       | 0.535387
30.5    | 0.734741009  | 0.539842
31.0    | 0.73776948   | 0.54429
31.5    | 0.740785574  | 0.548739
32.0    | 0.74378943   | 0.553193
32.5    | 0.746781211  | 0.55765
33.0    | 0.74976104   | 0.562111
33.5    | 0.752729087  | 0.566577
34.0    | 0.75568551   | 0.571045
34.5    | 0.758630378  | 0.575518
35.0    | 0.76156384   | 0.579993
35.5    | 0.764486065  | 0.584472
36.0    | 0.76739717   | 0.588954
36.5    | 0.770297266  | 0.593439
37.0    | 0.7731865    | 0.597927
37.5    | 0.776064962  | 0.602418
38.0    | 0.77893275   | 0.606912
38.5    | 0.781790055  | 0.611409
39.0    | 0.78463697   | 0.615909
39.5    | 0.787473578  | 0.620411
40.0    | 0.7903       | 0.624917
40.5    | 0.791226714  | 0.626039
41.0    | 0.79215339   | 0.627161
41.5    | 0.793080059  | 0.628283
42.0    | 0.794006749  | 0.629406
42.5    | 0.794933438  | 0.630529
43.0    | 0.795860128  | 0.631653
43.5    | 0.796786817  | 0.632777
44.0    | 0.797713507  | 0.633901
44.5    | 0.798640197  | 0.635026
45.0    | 0.799566886  | 0.636151
45.5    | 0.800493576  | 0.637276
46.0    | 0.801420265  | 0.638401
46.5    | 0.802346955  | 0.639527
47.0    | 0.803273644  | 0.640653
47.5    | 0.804200334  | 0.64178
48.0    | 0.805127024  | 0.642907
48.5    | 0.806053713  | 0.644034
49.0    | 0.806980403  | 0.645161
49.5    | 0.807907093  | 0.646289
50.0    | 0.808833782  | 0.647417

=COUNTIF(A$1:A$4096, A4096)