Conditional infer hotspot N=100

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

type ConditionalInput50 = AsyncBox<{ id: 50; nested: Promise<{ value: string; index: 50 }> }>;
type ConditionalPayload50 = ExtractPayload<ConditionalInput50>;
type ConditionalDeep50 = DeepUnwrap<ConditionalInput50>;
declare const conditionalPayload50: ConditionalPayload50;
declare const conditionalDeep50: ConditionalDeep50;
const conditionalValue50 = conditionalPayload50.id + conditionalDeep50.id;

type ConditionalInput51 = AsyncBox<{ id: 51; nested: Promise<{ value: string; index: 51 }> }>;
type ConditionalPayload51 = ExtractPayload<ConditionalInput51>;
type ConditionalDeep51 = DeepUnwrap<ConditionalInput51>;
declare const conditionalPayload51: ConditionalPayload51;
declare const conditionalDeep51: ConditionalDeep51;
const conditionalValue51 = conditionalPayload51.id + conditionalDeep51.id;

type ConditionalInput52 = AsyncBox<{ id: 52; nested: Promise<{ value: string; index: 52 }> }>;
type ConditionalPayload52 = ExtractPayload<ConditionalInput52>;
type ConditionalDeep52 = DeepUnwrap<ConditionalInput52>;
declare const conditionalPayload52: ConditionalPayload52;
declare const conditionalDeep52: ConditionalDeep52;
const conditionalValue52 = conditionalPayload52.id + conditionalDeep52.id;

type ConditionalInput53 = AsyncBox<{ id: 53; nested: Promise<{ value: string; index: 53 }> }>;
type ConditionalPayload53 = ExtractPayload<ConditionalInput53>;
type ConditionalDeep53 = DeepUnwrap<ConditionalInput53>;
declare const conditionalPayload53: ConditionalPayload53;
declare const conditionalDeep53: ConditionalDeep53;
const conditionalValue53 = conditionalPayload53.id + conditionalDeep53.id;

type ConditionalInput54 = AsyncBox<{ id: 54; nested: Promise<{ value: string; index: 54 }> }>;
type ConditionalPayload54 = ExtractPayload<ConditionalInput54>;
type ConditionalDeep54 = DeepUnwrap<ConditionalInput54>;
declare const conditionalPayload54: ConditionalPayload54;
declare const conditionalDeep54: ConditionalDeep54;
const conditionalValue54 = conditionalPayload54.id + conditionalDeep54.id;

type ConditionalInput55 = AsyncBox<{ id: 55; nested: Promise<{ value: string; index: 55 }> }>;
type ConditionalPayload55 = ExtractPayload<ConditionalInput55>;
type ConditionalDeep55 = DeepUnwrap<ConditionalInput55>;
declare const conditionalPayload55: ConditionalPayload55;
declare const conditionalDeep55: ConditionalDeep55;
const conditionalValue55 = conditionalPayload55.id + conditionalDeep55.id;

type ConditionalInput56 = AsyncBox<{ id: 56; nested: Promise<{ value: string; index: 56 }> }>;
type ConditionalPayload56 = ExtractPayload<ConditionalInput56>;
type ConditionalDeep56 = DeepUnwrap<ConditionalInput56>;
declare const conditionalPayload56: ConditionalPayload56;
declare const conditionalDeep56: ConditionalDeep56;
const conditionalValue56 = conditionalPayload56.id + conditionalDeep56.id;

type ConditionalInput57 = AsyncBox<{ id: 57; nested: Promise<{ value: string; index: 57 }> }>;
type ConditionalPayload57 = ExtractPayload<ConditionalInput57>;
type ConditionalDeep57 = DeepUnwrap<ConditionalInput57>;
declare const conditionalPayload57: ConditionalPayload57;
declare const conditionalDeep57: ConditionalDeep57;
const conditionalValue57 = conditionalPayload57.id + conditionalDeep57.id;

type ConditionalInput58 = AsyncBox<{ id: 58; nested: Promise<{ value: string; index: 58 }> }>;
type ConditionalPayload58 = ExtractPayload<ConditionalInput58>;
type ConditionalDeep58 = DeepUnwrap<ConditionalInput58>;
declare const conditionalPayload58: ConditionalPayload58;
declare const conditionalDeep58: ConditionalDeep58;
const conditionalValue58 = conditionalPayload58.id + conditionalDeep58.id;

type ConditionalInput59 = AsyncBox<{ id: 59; nested: Promise<{ value: string; index: 59 }> }>;
type ConditionalPayload59 = ExtractPayload<ConditionalInput59>;
type ConditionalDeep59 = DeepUnwrap<ConditionalInput59>;
declare const conditionalPayload59: ConditionalPayload59;
declare const conditionalDeep59: ConditionalDeep59;
const conditionalValue59 = conditionalPayload59.id + conditionalDeep59.id;

type ConditionalInput60 = AsyncBox<{ id: 60; nested: Promise<{ value: string; index: 60 }> }>;
type ConditionalPayload60 = ExtractPayload<ConditionalInput60>;
type ConditionalDeep60 = DeepUnwrap<ConditionalInput60>;
declare const conditionalPayload60: ConditionalPayload60;
declare const conditionalDeep60: ConditionalDeep60;
const conditionalValue60 = conditionalPayload60.id + conditionalDeep60.id;

type ConditionalInput61 = AsyncBox<{ id: 61; nested: Promise<{ value: string; index: 61 }> }>;
type ConditionalPayload61 = ExtractPayload<ConditionalInput61>;
type ConditionalDeep61 = DeepUnwrap<ConditionalInput61>;
declare const conditionalPayload61: ConditionalPayload61;
declare const conditionalDeep61: ConditionalDeep61;
const conditionalValue61 = conditionalPayload61.id + conditionalDeep61.id;

type ConditionalInput62 = AsyncBox<{ id: 62; nested: Promise<{ value: string; index: 62 }> }>;
type ConditionalPayload62 = ExtractPayload<ConditionalInput62>;
type ConditionalDeep62 = DeepUnwrap<ConditionalInput62>;
declare const conditionalPayload62: ConditionalPayload62;
declare const conditionalDeep62: ConditionalDeep62;
const conditionalValue62 = conditionalPayload62.id + conditionalDeep62.id;

type ConditionalInput63 = AsyncBox<{ id: 63; nested: Promise<{ value: string; index: 63 }> }>;
type ConditionalPayload63 = ExtractPayload<ConditionalInput63>;
type ConditionalDeep63 = DeepUnwrap<ConditionalInput63>;
declare const conditionalPayload63: ConditionalPayload63;
declare const conditionalDeep63: ConditionalDeep63;
const conditionalValue63 = conditionalPayload63.id + conditionalDeep63.id;

type ConditionalInput64 = AsyncBox<{ id: 64; nested: Promise<{ value: string; index: 64 }> }>;
type ConditionalPayload64 = ExtractPayload<ConditionalInput64>;
type ConditionalDeep64 = DeepUnwrap<ConditionalInput64>;
declare const conditionalPayload64: ConditionalPayload64;
declare const conditionalDeep64: ConditionalDeep64;
const conditionalValue64 = conditionalPayload64.id + conditionalDeep64.id;

type ConditionalInput65 = AsyncBox<{ id: 65; nested: Promise<{ value: string; index: 65 }> }>;
type ConditionalPayload65 = ExtractPayload<ConditionalInput65>;
type ConditionalDeep65 = DeepUnwrap<ConditionalInput65>;
declare const conditionalPayload65: ConditionalPayload65;
declare const conditionalDeep65: ConditionalDeep65;
const conditionalValue65 = conditionalPayload65.id + conditionalDeep65.id;

type ConditionalInput66 = AsyncBox<{ id: 66; nested: Promise<{ value: string; index: 66 }> }>;
type ConditionalPayload66 = ExtractPayload<ConditionalInput66>;
type ConditionalDeep66 = DeepUnwrap<ConditionalInput66>;
declare const conditionalPayload66: ConditionalPayload66;
declare const conditionalDeep66: ConditionalDeep66;
const conditionalValue66 = conditionalPayload66.id + conditionalDeep66.id;

type ConditionalInput67 = AsyncBox<{ id: 67; nested: Promise<{ value: string; index: 67 }> }>;
type ConditionalPayload67 = ExtractPayload<ConditionalInput67>;
type ConditionalDeep67 = DeepUnwrap<ConditionalInput67>;
declare const conditionalPayload67: ConditionalPayload67;
declare const conditionalDeep67: ConditionalDeep67;
const conditionalValue67 = conditionalPayload67.id + conditionalDeep67.id;

type ConditionalInput68 = AsyncBox<{ id: 68; nested: Promise<{ value: string; index: 68 }> }>;
type ConditionalPayload68 = ExtractPayload<ConditionalInput68>;
type ConditionalDeep68 = DeepUnwrap<ConditionalInput68>;
declare const conditionalPayload68: ConditionalPayload68;
declare const conditionalDeep68: ConditionalDeep68;
const conditionalValue68 = conditionalPayload68.id + conditionalDeep68.id;

type ConditionalInput69 = AsyncBox<{ id: 69; nested: Promise<{ value: string; index: 69 }> }>;
type ConditionalPayload69 = ExtractPayload<ConditionalInput69>;
type ConditionalDeep69 = DeepUnwrap<ConditionalInput69>;
declare const conditionalPayload69: ConditionalPayload69;
declare const conditionalDeep69: ConditionalDeep69;
const conditionalValue69 = conditionalPayload69.id + conditionalDeep69.id;

type ConditionalInput70 = AsyncBox<{ id: 70; nested: Promise<{ value: string; index: 70 }> }>;
type ConditionalPayload70 = ExtractPayload<ConditionalInput70>;
type ConditionalDeep70 = DeepUnwrap<ConditionalInput70>;
declare const conditionalPayload70: ConditionalPayload70;
declare const conditionalDeep70: ConditionalDeep70;
const conditionalValue70 = conditionalPayload70.id + conditionalDeep70.id;

type ConditionalInput71 = AsyncBox<{ id: 71; nested: Promise<{ value: string; index: 71 }> }>;
type ConditionalPayload71 = ExtractPayload<ConditionalInput71>;
type ConditionalDeep71 = DeepUnwrap<ConditionalInput71>;
declare const conditionalPayload71: ConditionalPayload71;
declare const conditionalDeep71: ConditionalDeep71;
const conditionalValue71 = conditionalPayload71.id + conditionalDeep71.id;

type ConditionalInput72 = AsyncBox<{ id: 72; nested: Promise<{ value: string; index: 72 }> }>;
type ConditionalPayload72 = ExtractPayload<ConditionalInput72>;
type ConditionalDeep72 = DeepUnwrap<ConditionalInput72>;
declare const conditionalPayload72: ConditionalPayload72;
declare const conditionalDeep72: ConditionalDeep72;
const conditionalValue72 = conditionalPayload72.id + conditionalDeep72.id;

type ConditionalInput73 = AsyncBox<{ id: 73; nested: Promise<{ value: string; index: 73 }> }>;
type ConditionalPayload73 = ExtractPayload<ConditionalInput73>;
type ConditionalDeep73 = DeepUnwrap<ConditionalInput73>;
declare const conditionalPayload73: ConditionalPayload73;
declare const conditionalDeep73: ConditionalDeep73;
const conditionalValue73 = conditionalPayload73.id + conditionalDeep73.id;

type ConditionalInput74 = AsyncBox<{ id: 74; nested: Promise<{ value: string; index: 74 }> }>;
type ConditionalPayload74 = ExtractPayload<ConditionalInput74>;
type ConditionalDeep74 = DeepUnwrap<ConditionalInput74>;
declare const conditionalPayload74: ConditionalPayload74;
declare const conditionalDeep74: ConditionalDeep74;
const conditionalValue74 = conditionalPayload74.id + conditionalDeep74.id;

type ConditionalInput75 = AsyncBox<{ id: 75; nested: Promise<{ value: string; index: 75 }> }>;
type ConditionalPayload75 = ExtractPayload<ConditionalInput75>;
type ConditionalDeep75 = DeepUnwrap<ConditionalInput75>;
declare const conditionalPayload75: ConditionalPayload75;
declare const conditionalDeep75: ConditionalDeep75;
const conditionalValue75 = conditionalPayload75.id + conditionalDeep75.id;

type ConditionalInput76 = AsyncBox<{ id: 76; nested: Promise<{ value: string; index: 76 }> }>;
type ConditionalPayload76 = ExtractPayload<ConditionalInput76>;
type ConditionalDeep76 = DeepUnwrap<ConditionalInput76>;
declare const conditionalPayload76: ConditionalPayload76;
declare const conditionalDeep76: ConditionalDeep76;
const conditionalValue76 = conditionalPayload76.id + conditionalDeep76.id;

type ConditionalInput77 = AsyncBox<{ id: 77; nested: Promise<{ value: string; index: 77 }> }>;
type ConditionalPayload77 = ExtractPayload<ConditionalInput77>;
type ConditionalDeep77 = DeepUnwrap<ConditionalInput77>;
declare const conditionalPayload77: ConditionalPayload77;
declare const conditionalDeep77: ConditionalDeep77;
const conditionalValue77 = conditionalPayload77.id + conditionalDeep77.id;

type ConditionalInput78 = AsyncBox<{ id: 78; nested: Promise<{ value: string; index: 78 }> }>;
type ConditionalPayload78 = ExtractPayload<ConditionalInput78>;
type ConditionalDeep78 = DeepUnwrap<ConditionalInput78>;
declare const conditionalPayload78: ConditionalPayload78;
declare const conditionalDeep78: ConditionalDeep78;
const conditionalValue78 = conditionalPayload78.id + conditionalDeep78.id;

type ConditionalInput79 = AsyncBox<{ id: 79; nested: Promise<{ value: string; index: 79 }> }>;
type ConditionalPayload79 = ExtractPayload<ConditionalInput79>;
type ConditionalDeep79 = DeepUnwrap<ConditionalInput79>;
declare const conditionalPayload79: ConditionalPayload79;
declare const conditionalDeep79: ConditionalDeep79;
const conditionalValue79 = conditionalPayload79.id + conditionalDeep79.id;

type ConditionalInput80 = AsyncBox<{ id: 80; nested: Promise<{ value: string; index: 80 }> }>;
type ConditionalPayload80 = ExtractPayload<ConditionalInput80>;
type ConditionalDeep80 = DeepUnwrap<ConditionalInput80>;
declare const conditionalPayload80: ConditionalPayload80;
declare const conditionalDeep80: ConditionalDeep80;
const conditionalValue80 = conditionalPayload80.id + conditionalDeep80.id;

type ConditionalInput81 = AsyncBox<{ id: 81; nested: Promise<{ value: string; index: 81 }> }>;
type ConditionalPayload81 = ExtractPayload<ConditionalInput81>;
type ConditionalDeep81 = DeepUnwrap<ConditionalInput81>;
declare const conditionalPayload81: ConditionalPayload81;
declare const conditionalDeep81: ConditionalDeep81;
const conditionalValue81 = conditionalPayload81.id + conditionalDeep81.id;

type ConditionalInput82 = AsyncBox<{ id: 82; nested: Promise<{ value: string; index: 82 }> }>;
type ConditionalPayload82 = ExtractPayload<ConditionalInput82>;
type ConditionalDeep82 = DeepUnwrap<ConditionalInput82>;
declare const conditionalPayload82: ConditionalPayload82;
declare const conditionalDeep82: ConditionalDeep82;
const conditionalValue82 = conditionalPayload82.id + conditionalDeep82.id;

type ConditionalInput83 = AsyncBox<{ id: 83; nested: Promise<{ value: string; index: 83 }> }>;
type ConditionalPayload83 = ExtractPayload<ConditionalInput83>;
type ConditionalDeep83 = DeepUnwrap<ConditionalInput83>;
declare const conditionalPayload83: ConditionalPayload83;
declare const conditionalDeep83: ConditionalDeep83;
const conditionalValue83 = conditionalPayload83.id + conditionalDeep83.id;

type ConditionalInput84 = AsyncBox<{ id: 84; nested: Promise<{ value: string; index: 84 }> }>;
type ConditionalPayload84 = ExtractPayload<ConditionalInput84>;
type ConditionalDeep84 = DeepUnwrap<ConditionalInput84>;
declare const conditionalPayload84: ConditionalPayload84;
declare const conditionalDeep84: ConditionalDeep84;
const conditionalValue84 = conditionalPayload84.id + conditionalDeep84.id;

type ConditionalInput85 = AsyncBox<{ id: 85; nested: Promise<{ value: string; index: 85 }> }>;
type ConditionalPayload85 = ExtractPayload<ConditionalInput85>;
type ConditionalDeep85 = DeepUnwrap<ConditionalInput85>;
declare const conditionalPayload85: ConditionalPayload85;
declare const conditionalDeep85: ConditionalDeep85;
const conditionalValue85 = conditionalPayload85.id + conditionalDeep85.id;

type ConditionalInput86 = AsyncBox<{ id: 86; nested: Promise<{ value: string; index: 86 }> }>;
type ConditionalPayload86 = ExtractPayload<ConditionalInput86>;
type ConditionalDeep86 = DeepUnwrap<ConditionalInput86>;
declare const conditionalPayload86: ConditionalPayload86;
declare const conditionalDeep86: ConditionalDeep86;
const conditionalValue86 = conditionalPayload86.id + conditionalDeep86.id;

type ConditionalInput87 = AsyncBox<{ id: 87; nested: Promise<{ value: string; index: 87 }> }>;
type ConditionalPayload87 = ExtractPayload<ConditionalInput87>;
type ConditionalDeep87 = DeepUnwrap<ConditionalInput87>;
declare const conditionalPayload87: ConditionalPayload87;
declare const conditionalDeep87: ConditionalDeep87;
const conditionalValue87 = conditionalPayload87.id + conditionalDeep87.id;

type ConditionalInput88 = AsyncBox<{ id: 88; nested: Promise<{ value: string; index: 88 }> }>;
type ConditionalPayload88 = ExtractPayload<ConditionalInput88>;
type ConditionalDeep88 = DeepUnwrap<ConditionalInput88>;
declare const conditionalPayload88: ConditionalPayload88;
declare const conditionalDeep88: ConditionalDeep88;
const conditionalValue88 = conditionalPayload88.id + conditionalDeep88.id;

type ConditionalInput89 = AsyncBox<{ id: 89; nested: Promise<{ value: string; index: 89 }> }>;
type ConditionalPayload89 = ExtractPayload<ConditionalInput89>;
type ConditionalDeep89 = DeepUnwrap<ConditionalInput89>;
declare const conditionalPayload89: ConditionalPayload89;
declare const conditionalDeep89: ConditionalDeep89;
const conditionalValue89 = conditionalPayload89.id + conditionalDeep89.id;

type ConditionalInput90 = AsyncBox<{ id: 90; nested: Promise<{ value: string; index: 90 }> }>;
type ConditionalPayload90 = ExtractPayload<ConditionalInput90>;
type ConditionalDeep90 = DeepUnwrap<ConditionalInput90>;
declare const conditionalPayload90: ConditionalPayload90;
declare const conditionalDeep90: ConditionalDeep90;
const conditionalValue90 = conditionalPayload90.id + conditionalDeep90.id;

type ConditionalInput91 = AsyncBox<{ id: 91; nested: Promise<{ value: string; index: 91 }> }>;
type ConditionalPayload91 = ExtractPayload<ConditionalInput91>;
type ConditionalDeep91 = DeepUnwrap<ConditionalInput91>;
declare const conditionalPayload91: ConditionalPayload91;
declare const conditionalDeep91: ConditionalDeep91;
const conditionalValue91 = conditionalPayload91.id + conditionalDeep91.id;

type ConditionalInput92 = AsyncBox<{ id: 92; nested: Promise<{ value: string; index: 92 }> }>;
type ConditionalPayload92 = ExtractPayload<ConditionalInput92>;
type ConditionalDeep92 = DeepUnwrap<ConditionalInput92>;
declare const conditionalPayload92: ConditionalPayload92;
declare const conditionalDeep92: ConditionalDeep92;
const conditionalValue92 = conditionalPayload92.id + conditionalDeep92.id;

type ConditionalInput93 = AsyncBox<{ id: 93; nested: Promise<{ value: string; index: 93 }> }>;
type ConditionalPayload93 = ExtractPayload<ConditionalInput93>;
type ConditionalDeep93 = DeepUnwrap<ConditionalInput93>;
declare const conditionalPayload93: ConditionalPayload93;
declare const conditionalDeep93: ConditionalDeep93;
const conditionalValue93 = conditionalPayload93.id + conditionalDeep93.id;

type ConditionalInput94 = AsyncBox<{ id: 94; nested: Promise<{ value: string; index: 94 }> }>;
type ConditionalPayload94 = ExtractPayload<ConditionalInput94>;
type ConditionalDeep94 = DeepUnwrap<ConditionalInput94>;
declare const conditionalPayload94: ConditionalPayload94;
declare const conditionalDeep94: ConditionalDeep94;
const conditionalValue94 = conditionalPayload94.id + conditionalDeep94.id;

type ConditionalInput95 = AsyncBox<{ id: 95; nested: Promise<{ value: string; index: 95 }> }>;
type ConditionalPayload95 = ExtractPayload<ConditionalInput95>;
type ConditionalDeep95 = DeepUnwrap<ConditionalInput95>;
declare const conditionalPayload95: ConditionalPayload95;
declare const conditionalDeep95: ConditionalDeep95;
const conditionalValue95 = conditionalPayload95.id + conditionalDeep95.id;

type ConditionalInput96 = AsyncBox<{ id: 96; nested: Promise<{ value: string; index: 96 }> }>;
type ConditionalPayload96 = ExtractPayload<ConditionalInput96>;
type ConditionalDeep96 = DeepUnwrap<ConditionalInput96>;
declare const conditionalPayload96: ConditionalPayload96;
declare const conditionalDeep96: ConditionalDeep96;
const conditionalValue96 = conditionalPayload96.id + conditionalDeep96.id;

type ConditionalInput97 = AsyncBox<{ id: 97; nested: Promise<{ value: string; index: 97 }> }>;
type ConditionalPayload97 = ExtractPayload<ConditionalInput97>;
type ConditionalDeep97 = DeepUnwrap<ConditionalInput97>;
declare const conditionalPayload97: ConditionalPayload97;
declare const conditionalDeep97: ConditionalDeep97;
const conditionalValue97 = conditionalPayload97.id + conditionalDeep97.id;

type ConditionalInput98 = AsyncBox<{ id: 98; nested: Promise<{ value: string; index: 98 }> }>;
type ConditionalPayload98 = ExtractPayload<ConditionalInput98>;
type ConditionalDeep98 = DeepUnwrap<ConditionalInput98>;
declare const conditionalPayload98: ConditionalPayload98;
declare const conditionalDeep98: ConditionalDeep98;
const conditionalValue98 = conditionalPayload98.id + conditionalDeep98.id;

type ConditionalInput99 = AsyncBox<{ id: 99; nested: Promise<{ value: string; index: 99 }> }>;
type ConditionalPayload99 = ExtractPayload<ConditionalInput99>;
type ConditionalDeep99 = DeepUnwrap<ConditionalInput99>;
declare const conditionalPayload99: ConditionalPayload99;
declare const conditionalDeep99: ConditionalDeep99;
const conditionalValue99 = conditionalPayload99.id + conditionalDeep99.id;