Conditional infer hotspot N=50

// 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;

type ConditionalInput25 = AsyncBox<{ id: 25; nested: Promise<{ value: string; index: 25 }> }>;
type ConditionalPayload25 = ExtractPayload<ConditionalInput25>;
type ConditionalDeep25 = DeepUnwrap<ConditionalInput25>;
declare const conditionalPayload25: ConditionalPayload25;
declare const conditionalDeep25: ConditionalDeep25;
const conditionalValue25 = conditionalPayload25.id + conditionalDeep25.id;

type ConditionalInput26 = AsyncBox<{ id: 26; nested: Promise<{ value: string; index: 26 }> }>;
type ConditionalPayload26 = ExtractPayload<ConditionalInput26>;
type ConditionalDeep26 = DeepUnwrap<ConditionalInput26>;
declare const conditionalPayload26: ConditionalPayload26;
declare const conditionalDeep26: ConditionalDeep26;
const conditionalValue26 = conditionalPayload26.id + conditionalDeep26.id;

type ConditionalInput27 = AsyncBox<{ id: 27; nested: Promise<{ value: string; index: 27 }> }>;
type ConditionalPayload27 = ExtractPayload<ConditionalInput27>;
type ConditionalDeep27 = DeepUnwrap<ConditionalInput27>;
declare const conditionalPayload27: ConditionalPayload27;
declare const conditionalDeep27: ConditionalDeep27;
const conditionalValue27 = conditionalPayload27.id + conditionalDeep27.id;

type ConditionalInput28 = AsyncBox<{ id: 28; nested: Promise<{ value: string; index: 28 }> }>;
type ConditionalPayload28 = ExtractPayload<ConditionalInput28>;
type ConditionalDeep28 = DeepUnwrap<ConditionalInput28>;
declare const conditionalPayload28: ConditionalPayload28;
declare const conditionalDeep28: ConditionalDeep28;
const conditionalValue28 = conditionalPayload28.id + conditionalDeep28.id;

type ConditionalInput29 = AsyncBox<{ id: 29; nested: Promise<{ value: string; index: 29 }> }>;
type ConditionalPayload29 = ExtractPayload<ConditionalInput29>;
type ConditionalDeep29 = DeepUnwrap<ConditionalInput29>;
declare const conditionalPayload29: ConditionalPayload29;
declare const conditionalDeep29: ConditionalDeep29;
const conditionalValue29 = conditionalPayload29.id + conditionalDeep29.id;

type ConditionalInput30 = AsyncBox<{ id: 30; nested: Promise<{ value: string; index: 30 }> }>;
type ConditionalPayload30 = ExtractPayload<ConditionalInput30>;
type ConditionalDeep30 = DeepUnwrap<ConditionalInput30>;
declare const conditionalPayload30: ConditionalPayload30;
declare const conditionalDeep30: ConditionalDeep30;
const conditionalValue30 = conditionalPayload30.id + conditionalDeep30.id;

type ConditionalInput31 = AsyncBox<{ id: 31; nested: Promise<{ value: string; index: 31 }> }>;
type ConditionalPayload31 = ExtractPayload<ConditionalInput31>;
type ConditionalDeep31 = DeepUnwrap<ConditionalInput31>;
declare const conditionalPayload31: ConditionalPayload31;
declare const conditionalDeep31: ConditionalDeep31;
const conditionalValue31 = conditionalPayload31.id + conditionalDeep31.id;

type ConditionalInput32 = AsyncBox<{ id: 32; nested: Promise<{ value: string; index: 32 }> }>;
type ConditionalPayload32 = ExtractPayload<ConditionalInput32>;
type ConditionalDeep32 = DeepUnwrap<ConditionalInput32>;
declare const conditionalPayload32: ConditionalPayload32;
declare const conditionalDeep32: ConditionalDeep32;
const conditionalValue32 = conditionalPayload32.id + conditionalDeep32.id;

type ConditionalInput33 = AsyncBox<{ id: 33; nested: Promise<{ value: string; index: 33 }> }>;
type ConditionalPayload33 = ExtractPayload<ConditionalInput33>;
type ConditionalDeep33 = DeepUnwrap<ConditionalInput33>;
declare const conditionalPayload33: ConditionalPayload33;
declare const conditionalDeep33: ConditionalDeep33;
const conditionalValue33 = conditionalPayload33.id + conditionalDeep33.id;

type ConditionalInput34 = AsyncBox<{ id: 34; nested: Promise<{ value: string; index: 34 }> }>;
type ConditionalPayload34 = ExtractPayload<ConditionalInput34>;
type ConditionalDeep34 = DeepUnwrap<ConditionalInput34>;
declare const conditionalPayload34: ConditionalPayload34;
declare const conditionalDeep34: ConditionalDeep34;
const conditionalValue34 = conditionalPayload34.id + conditionalDeep34.id;

type ConditionalInput35 = AsyncBox<{ id: 35; nested: Promise<{ value: string; index: 35 }> }>;
type ConditionalPayload35 = ExtractPayload<ConditionalInput35>;
type ConditionalDeep35 = DeepUnwrap<ConditionalInput35>;
declare const conditionalPayload35: ConditionalPayload35;
declare const conditionalDeep35: ConditionalDeep35;
const conditionalValue35 = conditionalPayload35.id + conditionalDeep35.id;

type ConditionalInput36 = AsyncBox<{ id: 36; nested: Promise<{ value: string; index: 36 }> }>;
type ConditionalPayload36 = ExtractPayload<ConditionalInput36>;
type ConditionalDeep36 = DeepUnwrap<ConditionalInput36>;
declare const conditionalPayload36: ConditionalPayload36;
declare const conditionalDeep36: ConditionalDeep36;
const conditionalValue36 = conditionalPayload36.id + conditionalDeep36.id;

type ConditionalInput37 = AsyncBox<{ id: 37; nested: Promise<{ value: string; index: 37 }> }>;
type ConditionalPayload37 = ExtractPayload<ConditionalInput37>;
type ConditionalDeep37 = DeepUnwrap<ConditionalInput37>;
declare const conditionalPayload37: ConditionalPayload37;
declare const conditionalDeep37: ConditionalDeep37;
const conditionalValue37 = conditionalPayload37.id + conditionalDeep37.id;

type ConditionalInput38 = AsyncBox<{ id: 38; nested: Promise<{ value: string; index: 38 }> }>;
type ConditionalPayload38 = ExtractPayload<ConditionalInput38>;
type ConditionalDeep38 = DeepUnwrap<ConditionalInput38>;
declare const conditionalPayload38: ConditionalPayload38;
declare const conditionalDeep38: ConditionalDeep38;
const conditionalValue38 = conditionalPayload38.id + conditionalDeep38.id;

type ConditionalInput39 = AsyncBox<{ id: 39; nested: Promise<{ value: string; index: 39 }> }>;
type ConditionalPayload39 = ExtractPayload<ConditionalInput39>;
type ConditionalDeep39 = DeepUnwrap<ConditionalInput39>;
declare const conditionalPayload39: ConditionalPayload39;
declare const conditionalDeep39: ConditionalDeep39;
const conditionalValue39 = conditionalPayload39.id + conditionalDeep39.id;

type ConditionalInput40 = AsyncBox<{ id: 40; nested: Promise<{ value: string; index: 40 }> }>;
type ConditionalPayload40 = ExtractPayload<ConditionalInput40>;
type ConditionalDeep40 = DeepUnwrap<ConditionalInput40>;
declare const conditionalPayload40: ConditionalPayload40;
declare const conditionalDeep40: ConditionalDeep40;
const conditionalValue40 = conditionalPayload40.id + conditionalDeep40.id;

type ConditionalInput41 = AsyncBox<{ id: 41; nested: Promise<{ value: string; index: 41 }> }>;
type ConditionalPayload41 = ExtractPayload<ConditionalInput41>;
type ConditionalDeep41 = DeepUnwrap<ConditionalInput41>;
declare const conditionalPayload41: ConditionalPayload41;
declare const conditionalDeep41: ConditionalDeep41;
const conditionalValue41 = conditionalPayload41.id + conditionalDeep41.id;

type ConditionalInput42 = AsyncBox<{ id: 42; nested: Promise<{ value: string; index: 42 }> }>;
type ConditionalPayload42 = ExtractPayload<ConditionalInput42>;
type ConditionalDeep42 = DeepUnwrap<ConditionalInput42>;
declare const conditionalPayload42: ConditionalPayload42;
declare const conditionalDeep42: ConditionalDeep42;
const conditionalValue42 = conditionalPayload42.id + conditionalDeep42.id;

type ConditionalInput43 = AsyncBox<{ id: 43; nested: Promise<{ value: string; index: 43 }> }>;
type ConditionalPayload43 = ExtractPayload<ConditionalInput43>;
type ConditionalDeep43 = DeepUnwrap<ConditionalInput43>;
declare const conditionalPayload43: ConditionalPayload43;
declare const conditionalDeep43: ConditionalDeep43;
const conditionalValue43 = conditionalPayload43.id + conditionalDeep43.id;

type ConditionalInput44 = AsyncBox<{ id: 44; nested: Promise<{ value: string; index: 44 }> }>;
type ConditionalPayload44 = ExtractPayload<ConditionalInput44>;
type ConditionalDeep44 = DeepUnwrap<ConditionalInput44>;
declare const conditionalPayload44: ConditionalPayload44;
declare const conditionalDeep44: ConditionalDeep44;
const conditionalValue44 = conditionalPayload44.id + conditionalDeep44.id;

type ConditionalInput45 = AsyncBox<{ id: 45; nested: Promise<{ value: string; index: 45 }> }>;
type ConditionalPayload45 = ExtractPayload<ConditionalInput45>;
type ConditionalDeep45 = DeepUnwrap<ConditionalInput45>;
declare const conditionalPayload45: ConditionalPayload45;
declare const conditionalDeep45: ConditionalDeep45;
const conditionalValue45 = conditionalPayload45.id + conditionalDeep45.id;

type ConditionalInput46 = AsyncBox<{ id: 46; nested: Promise<{ value: string; index: 46 }> }>;
type ConditionalPayload46 = ExtractPayload<ConditionalInput46>;
type ConditionalDeep46 = DeepUnwrap<ConditionalInput46>;
declare const conditionalPayload46: ConditionalPayload46;
declare const conditionalDeep46: ConditionalDeep46;
const conditionalValue46 = conditionalPayload46.id + conditionalDeep46.id;

type ConditionalInput47 = AsyncBox<{ id: 47; nested: Promise<{ value: string; index: 47 }> }>;
type ConditionalPayload47 = ExtractPayload<ConditionalInput47>;
type ConditionalDeep47 = DeepUnwrap<ConditionalInput47>;
declare const conditionalPayload47: ConditionalPayload47;
declare const conditionalDeep47: ConditionalDeep47;
const conditionalValue47 = conditionalPayload47.id + conditionalDeep47.id;

type ConditionalInput48 = AsyncBox<{ id: 48; nested: Promise<{ value: string; index: 48 }> }>;
type ConditionalPayload48 = ExtractPayload<ConditionalInput48>;
type ConditionalDeep48 = DeepUnwrap<ConditionalInput48>;
declare const conditionalPayload48: ConditionalPayload48;
declare const conditionalDeep48: ConditionalDeep48;
const conditionalValue48 = conditionalPayload48.id + conditionalDeep48.id;

type ConditionalInput49 = AsyncBox<{ id: 49; nested: Promise<{ value: string; index: 49 }> }>;
type ConditionalPayload49 = ExtractPayload<ConditionalInput49>;
type ConditionalDeep49 = DeepUnwrap<ConditionalInput49>;
declare const conditionalPayload49: ConditionalPayload49;
declare const conditionalDeep49: ConditionalDeep49;
const conditionalValue49 = conditionalPayload49.id + conditionalDeep49.id;