Conditional infer hotspot N=25

// Conditional infer hotspot benchmark.
// Exercises nested conditional extraction seen in utility-heavy projects.

type AsyncBox<T> = Promise<{ payload: T[]; meta: { created: string } }>;
type ExtractPayload<T> = T extends Promise<{ payload: (infer U)[] }> ? U : never;
type DeepUnwrap<T> =
    T extends Promise<infer U> ? DeepUnwrap<U> :
    T extends { payload: infer P } ? DeepUnwrap<P> :
    T extends (infer E)[] ? DeepUnwrap<E> :
    T;

type ConditionalInput0 = AsyncBox<{ id: 0; nested: Promise<{ value: string; index: 0 }> }>;
type ConditionalPayload0 = ExtractPayload<ConditionalInput0>;
type ConditionalDeep0 = DeepUnwrap<ConditionalInput0>;
declare const conditionalPayload0: ConditionalPayload0;
declare const conditionalDeep0: ConditionalDeep0;
const conditionalValue0 = conditionalPayload0.id + conditionalDeep0.id;

type ConditionalInput1 = AsyncBox<{ id: 1; nested: Promise<{ value: string; index: 1 }> }>;
type ConditionalPayload1 = ExtractPayload<ConditionalInput1>;
type ConditionalDeep1 = DeepUnwrap<ConditionalInput1>;
declare const conditionalPayload1: ConditionalPayload1;
declare const conditionalDeep1: ConditionalDeep1;
const conditionalValue1 = conditionalPayload1.id + conditionalDeep1.id;

type ConditionalInput2 = AsyncBox<{ id: 2; nested: Promise<{ value: string; index: 2 }> }>;
type ConditionalPayload2 = ExtractPayload<ConditionalInput2>;
type ConditionalDeep2 = DeepUnwrap<ConditionalInput2>;
declare const conditionalPayload2: ConditionalPayload2;
declare const conditionalDeep2: ConditionalDeep2;
const conditionalValue2 = conditionalPayload2.id + conditionalDeep2.id;

type ConditionalInput3 = AsyncBox<{ id: 3; nested: Promise<{ value: string; index: 3 }> }>;
type ConditionalPayload3 = ExtractPayload<ConditionalInput3>;
type ConditionalDeep3 = DeepUnwrap<ConditionalInput3>;
declare const conditionalPayload3: ConditionalPayload3;
declare const conditionalDeep3: ConditionalDeep3;
const conditionalValue3 = conditionalPayload3.id + conditionalDeep3.id;

type ConditionalInput4 = AsyncBox<{ id: 4; nested: Promise<{ value: string; index: 4 }> }>;
type ConditionalPayload4 = ExtractPayload<ConditionalInput4>;
type ConditionalDeep4 = DeepUnwrap<ConditionalInput4>;
declare const conditionalPayload4: ConditionalPayload4;
declare const conditionalDeep4: ConditionalDeep4;
const conditionalValue4 = conditionalPayload4.id + conditionalDeep4.id;

type ConditionalInput5 = AsyncBox<{ id: 5; nested: Promise<{ value: string; index: 5 }> }>;
type ConditionalPayload5 = ExtractPayload<ConditionalInput5>;
type ConditionalDeep5 = DeepUnwrap<ConditionalInput5>;
declare const conditionalPayload5: ConditionalPayload5;
declare const conditionalDeep5: ConditionalDeep5;
const conditionalValue5 = conditionalPayload5.id + conditionalDeep5.id;

type ConditionalInput6 = AsyncBox<{ id: 6; nested: Promise<{ value: string; index: 6 }> }>;
type ConditionalPayload6 = ExtractPayload<ConditionalInput6>;
type ConditionalDeep6 = DeepUnwrap<ConditionalInput6>;
declare const conditionalPayload6: ConditionalPayload6;
declare const conditionalDeep6: ConditionalDeep6;
const conditionalValue6 = conditionalPayload6.id + conditionalDeep6.id;

type ConditionalInput7 = AsyncBox<{ id: 7; nested: Promise<{ value: string; index: 7 }> }>;
type ConditionalPayload7 = ExtractPayload<ConditionalInput7>;
type ConditionalDeep7 = DeepUnwrap<ConditionalInput7>;
declare const conditionalPayload7: ConditionalPayload7;
declare const conditionalDeep7: ConditionalDeep7;
const conditionalValue7 = conditionalPayload7.id + conditionalDeep7.id;

type ConditionalInput8 = AsyncBox<{ id: 8; nested: Promise<{ value: string; index: 8 }> }>;
type ConditionalPayload8 = ExtractPayload<ConditionalInput8>;
type ConditionalDeep8 = DeepUnwrap<ConditionalInput8>;
declare const conditionalPayload8: ConditionalPayload8;
declare const conditionalDeep8: ConditionalDeep8;
const conditionalValue8 = conditionalPayload8.id + conditionalDeep8.id;

type ConditionalInput9 = AsyncBox<{ id: 9; nested: Promise<{ value: string; index: 9 }> }>;
type ConditionalPayload9 = ExtractPayload<ConditionalInput9>;
type ConditionalDeep9 = DeepUnwrap<ConditionalInput9>;
declare const conditionalPayload9: ConditionalPayload9;
declare const conditionalDeep9: ConditionalDeep9;
const conditionalValue9 = conditionalPayload9.id + conditionalDeep9.id;

type ConditionalInput10 = AsyncBox<{ id: 10; nested: Promise<{ value: string; index: 10 }> }>;
type ConditionalPayload10 = ExtractPayload<ConditionalInput10>;
type ConditionalDeep10 = DeepUnwrap<ConditionalInput10>;
declare const conditionalPayload10: ConditionalPayload10;
declare const conditionalDeep10: ConditionalDeep10;
const conditionalValue10 = conditionalPayload10.id + conditionalDeep10.id;

type ConditionalInput11 = AsyncBox<{ id: 11; nested: Promise<{ value: string; index: 11 }> }>;
type ConditionalPayload11 = ExtractPayload<ConditionalInput11>;
type ConditionalDeep11 = DeepUnwrap<ConditionalInput11>;
declare const conditionalPayload11: ConditionalPayload11;
declare const conditionalDeep11: ConditionalDeep11;
const conditionalValue11 = conditionalPayload11.id + conditionalDeep11.id;

type ConditionalInput12 = AsyncBox<{ id: 12; nested: Promise<{ value: string; index: 12 }> }>;
type ConditionalPayload12 = ExtractPayload<ConditionalInput12>;
type ConditionalDeep12 = DeepUnwrap<ConditionalInput12>;
declare const conditionalPayload12: ConditionalPayload12;
declare const conditionalDeep12: ConditionalDeep12;
const conditionalValue12 = conditionalPayload12.id + conditionalDeep12.id;

type ConditionalInput13 = AsyncBox<{ id: 13; nested: Promise<{ value: string; index: 13 }> }>;
type ConditionalPayload13 = ExtractPayload<ConditionalInput13>;
type ConditionalDeep13 = DeepUnwrap<ConditionalInput13>;
declare const conditionalPayload13: ConditionalPayload13;
declare const conditionalDeep13: ConditionalDeep13;
const conditionalValue13 = conditionalPayload13.id + conditionalDeep13.id;

type ConditionalInput14 = AsyncBox<{ id: 14; nested: Promise<{ value: string; index: 14 }> }>;
type ConditionalPayload14 = ExtractPayload<ConditionalInput14>;
type ConditionalDeep14 = DeepUnwrap<ConditionalInput14>;
declare const conditionalPayload14: ConditionalPayload14;
declare const conditionalDeep14: ConditionalDeep14;
const conditionalValue14 = conditionalPayload14.id + conditionalDeep14.id;

type ConditionalInput15 = AsyncBox<{ id: 15; nested: Promise<{ value: string; index: 15 }> }>;
type ConditionalPayload15 = ExtractPayload<ConditionalInput15>;
type ConditionalDeep15 = DeepUnwrap<ConditionalInput15>;
declare const conditionalPayload15: ConditionalPayload15;
declare const conditionalDeep15: ConditionalDeep15;
const conditionalValue15 = conditionalPayload15.id + conditionalDeep15.id;

type ConditionalInput16 = AsyncBox<{ id: 16; nested: Promise<{ value: string; index: 16 }> }>;
type ConditionalPayload16 = ExtractPayload<ConditionalInput16>;
type ConditionalDeep16 = DeepUnwrap<ConditionalInput16>;
declare const conditionalPayload16: ConditionalPayload16;
declare const conditionalDeep16: ConditionalDeep16;
const conditionalValue16 = conditionalPayload16.id + conditionalDeep16.id;

type ConditionalInput17 = AsyncBox<{ id: 17; nested: Promise<{ value: string; index: 17 }> }>;
type ConditionalPayload17 = ExtractPayload<ConditionalInput17>;
type ConditionalDeep17 = DeepUnwrap<ConditionalInput17>;
declare const conditionalPayload17: ConditionalPayload17;
declare const conditionalDeep17: ConditionalDeep17;
const conditionalValue17 = conditionalPayload17.id + conditionalDeep17.id;

type ConditionalInput18 = AsyncBox<{ id: 18; nested: Promise<{ value: string; index: 18 }> }>;
type ConditionalPayload18 = ExtractPayload<ConditionalInput18>;
type ConditionalDeep18 = DeepUnwrap<ConditionalInput18>;
declare const conditionalPayload18: ConditionalPayload18;
declare const conditionalDeep18: ConditionalDeep18;
const conditionalValue18 = conditionalPayload18.id + conditionalDeep18.id;

type ConditionalInput19 = AsyncBox<{ id: 19; nested: Promise<{ value: string; index: 19 }> }>;
type ConditionalPayload19 = ExtractPayload<ConditionalInput19>;
type ConditionalDeep19 = DeepUnwrap<ConditionalInput19>;
declare const conditionalPayload19: ConditionalPayload19;
declare const conditionalDeep19: ConditionalDeep19;
const conditionalValue19 = conditionalPayload19.id + conditionalDeep19.id;

type ConditionalInput20 = AsyncBox<{ id: 20; nested: Promise<{ value: string; index: 20 }> }>;
type ConditionalPayload20 = ExtractPayload<ConditionalInput20>;
type ConditionalDeep20 = DeepUnwrap<ConditionalInput20>;
declare const conditionalPayload20: ConditionalPayload20;
declare const conditionalDeep20: ConditionalDeep20;
const conditionalValue20 = conditionalPayload20.id + conditionalDeep20.id;

type ConditionalInput21 = AsyncBox<{ id: 21; nested: Promise<{ value: string; index: 21 }> }>;
type ConditionalPayload21 = ExtractPayload<ConditionalInput21>;
type ConditionalDeep21 = DeepUnwrap<ConditionalInput21>;
declare const conditionalPayload21: ConditionalPayload21;
declare const conditionalDeep21: ConditionalDeep21;
const conditionalValue21 = conditionalPayload21.id + conditionalDeep21.id;

type ConditionalInput22 = AsyncBox<{ id: 22; nested: Promise<{ value: string; index: 22 }> }>;
type ConditionalPayload22 = ExtractPayload<ConditionalInput22>;
type ConditionalDeep22 = DeepUnwrap<ConditionalInput22>;
declare const conditionalPayload22: ConditionalPayload22;
declare const conditionalDeep22: ConditionalDeep22;
const conditionalValue22 = conditionalPayload22.id + conditionalDeep22.id;

type ConditionalInput23 = AsyncBox<{ id: 23; nested: Promise<{ value: string; index: 23 }> }>;
type ConditionalPayload23 = ExtractPayload<ConditionalInput23>;
type ConditionalDeep23 = DeepUnwrap<ConditionalInput23>;
declare const conditionalPayload23: ConditionalPayload23;
declare const conditionalDeep23: ConditionalDeep23;
const conditionalValue23 = conditionalPayload23.id + conditionalDeep23.id;

type ConditionalInput24 = AsyncBox<{ id: 24; nested: Promise<{ value: string; index: 24 }> }>;
type ConditionalPayload24 = ExtractPayload<ConditionalInput24>;
type ConditionalDeep24 = DeepUnwrap<ConditionalInput24>;
declare const conditionalPayload24: ConditionalPayload24;
declare const conditionalDeep24: ConditionalDeep24;
const conditionalValue24 = conditionalPayload24.id + conditionalDeep24.id;