Object spread hotspot N=100

// Object spread hotspot benchmark.
// Exercises repeated object-literal spread inference and property merging.

interface SpreadBase {
    common: string;
    enabled: boolean;
}

interface SpreadInput0 extends SpreadBase {
    value0: number;
    nested0: { readonly id: number; name: string };
}

declare const spreadInput0: SpreadInput0;
const spreadMerged0 = {
    ...spreadInput0,
    extra0: spreadInput0.value0,
    nested0: { ...spreadInput0.nested0, name: spreadInput0.common },
};
type SpreadResult0 = typeof spreadMerged0;
const spreadCheck0: SpreadResult0 = spreadMerged0;

interface SpreadInput1 extends SpreadBase {
    value1: number;
    nested1: { readonly id: number; name: string };
}

declare const spreadInput1: SpreadInput1;
const spreadMerged1 = {
    ...spreadInput1,
    extra1: spreadInput1.value1,
    nested1: { ...spreadInput1.nested1, name: spreadInput1.common },
};
type SpreadResult1 = typeof spreadMerged1;
const spreadCheck1: SpreadResult1 = spreadMerged1;

interface SpreadInput2 extends SpreadBase {
    value2: number;
    nested2: { readonly id: number; name: string };
}

declare const spreadInput2: SpreadInput2;
const spreadMerged2 = {
    ...spreadInput2,
    extra2: spreadInput2.value2,
    nested2: { ...spreadInput2.nested2, name: spreadInput2.common },
};
type SpreadResult2 = typeof spreadMerged2;
const spreadCheck2: SpreadResult2 = spreadMerged2;

interface SpreadInput3 extends SpreadBase {
    value3: number;
    nested3: { readonly id: number; name: string };
}

declare const spreadInput3: SpreadInput3;
const spreadMerged3 = {
    ...spreadInput3,
    extra3: spreadInput3.value3,
    nested3: { ...spreadInput3.nested3, name: spreadInput3.common },
};
type SpreadResult3 = typeof spreadMerged3;
const spreadCheck3: SpreadResult3 = spreadMerged3;

interface SpreadInput4 extends SpreadBase {
    value4: number;
    nested4: { readonly id: number; name: string };
}

declare const spreadInput4: SpreadInput4;
const spreadMerged4 = {
    ...spreadInput4,
    extra4: spreadInput4.value4,
    nested4: { ...spreadInput4.nested4, name: spreadInput4.common },
};
type SpreadResult4 = typeof spreadMerged4;
const spreadCheck4: SpreadResult4 = spreadMerged4;

interface SpreadInput5 extends SpreadBase {
    value5: number;
    nested5: { readonly id: number; name: string };
}

declare const spreadInput5: SpreadInput5;
const spreadMerged5 = {
    ...spreadInput5,
    extra5: spreadInput5.value5,
    nested5: { ...spreadInput5.nested5, name: spreadInput5.common },
};
type SpreadResult5 = typeof spreadMerged5;
const spreadCheck5: SpreadResult5 = spreadMerged5;

interface SpreadInput6 extends SpreadBase {
    value6: number;
    nested6: { readonly id: number; name: string };
}

declare const spreadInput6: SpreadInput6;
const spreadMerged6 = {
    ...spreadInput6,
    extra6: spreadInput6.value6,
    nested6: { ...spreadInput6.nested6, name: spreadInput6.common },
};
type SpreadResult6 = typeof spreadMerged6;
const spreadCheck6: SpreadResult6 = spreadMerged6;

interface SpreadInput7 extends SpreadBase {
    value7: number;
    nested7: { readonly id: number; name: string };
}

declare const spreadInput7: SpreadInput7;
const spreadMerged7 = {
    ...spreadInput7,
    extra7: spreadInput7.value7,
    nested7: { ...spreadInput7.nested7, name: spreadInput7.common },
};
type SpreadResult7 = typeof spreadMerged7;
const spreadCheck7: SpreadResult7 = spreadMerged7;

interface SpreadInput8 extends SpreadBase {
    value8: number;
    nested8: { readonly id: number; name: string };
}

declare const spreadInput8: SpreadInput8;
const spreadMerged8 = {
    ...spreadInput8,
    extra8: spreadInput8.value8,
    nested8: { ...spreadInput8.nested8, name: spreadInput8.common },
};
type SpreadResult8 = typeof spreadMerged8;
const spreadCheck8: SpreadResult8 = spreadMerged8;

interface SpreadInput9 extends SpreadBase {
    value9: number;
    nested9: { readonly id: number; name: string };
}

declare const spreadInput9: SpreadInput9;
const spreadMerged9 = {
    ...spreadInput9,
    extra9: spreadInput9.value9,
    nested9: { ...spreadInput9.nested9, name: spreadInput9.common },
};
type SpreadResult9 = typeof spreadMerged9;
const spreadCheck9: SpreadResult9 = spreadMerged9;

interface SpreadInput10 extends SpreadBase {
    value10: number;
    nested10: { readonly id: number; name: string };
}

declare const spreadInput10: SpreadInput10;
const spreadMerged10 = {
    ...spreadInput10,
    extra10: spreadInput10.value10,
    nested10: { ...spreadInput10.nested10, name: spreadInput10.common },
};
type SpreadResult10 = typeof spreadMerged10;
const spreadCheck10: SpreadResult10 = spreadMerged10;

interface SpreadInput11 extends SpreadBase {
    value11: number;
    nested11: { readonly id: number; name: string };
}

declare const spreadInput11: SpreadInput11;
const spreadMerged11 = {
    ...spreadInput11,
    extra11: spreadInput11.value11,
    nested11: { ...spreadInput11.nested11, name: spreadInput11.common },
};
type SpreadResult11 = typeof spreadMerged11;
const spreadCheck11: SpreadResult11 = spreadMerged11;

interface SpreadInput12 extends SpreadBase {
    value12: number;
    nested12: { readonly id: number; name: string };
}

declare const spreadInput12: SpreadInput12;
const spreadMerged12 = {
    ...spreadInput12,
    extra12: spreadInput12.value12,
    nested12: { ...spreadInput12.nested12, name: spreadInput12.common },
};
type SpreadResult12 = typeof spreadMerged12;
const spreadCheck12: SpreadResult12 = spreadMerged12;

interface SpreadInput13 extends SpreadBase {
    value13: number;
    nested13: { readonly id: number; name: string };
}

declare const spreadInput13: SpreadInput13;
const spreadMerged13 = {
    ...spreadInput13,
    extra13: spreadInput13.value13,
    nested13: { ...spreadInput13.nested13, name: spreadInput13.common },
};
type SpreadResult13 = typeof spreadMerged13;
const spreadCheck13: SpreadResult13 = spreadMerged13;

interface SpreadInput14 extends SpreadBase {
    value14: number;
    nested14: { readonly id: number; name: string };
}

declare const spreadInput14: SpreadInput14;
const spreadMerged14 = {
    ...spreadInput14,
    extra14: spreadInput14.value14,
    nested14: { ...spreadInput14.nested14, name: spreadInput14.common },
};
type SpreadResult14 = typeof spreadMerged14;
const spreadCheck14: SpreadResult14 = spreadMerged14;

interface SpreadInput15 extends SpreadBase {
    value15: number;
    nested15: { readonly id: number; name: string };
}

declare const spreadInput15: SpreadInput15;
const spreadMerged15 = {
    ...spreadInput15,
    extra15: spreadInput15.value15,
    nested15: { ...spreadInput15.nested15, name: spreadInput15.common },
};
type SpreadResult15 = typeof spreadMerged15;
const spreadCheck15: SpreadResult15 = spreadMerged15;

interface SpreadInput16 extends SpreadBase {
    value16: number;
    nested16: { readonly id: number; name: string };
}

declare const spreadInput16: SpreadInput16;
const spreadMerged16 = {
    ...spreadInput16,
    extra16: spreadInput16.value16,
    nested16: { ...spreadInput16.nested16, name: spreadInput16.common },
};
type SpreadResult16 = typeof spreadMerged16;
const spreadCheck16: SpreadResult16 = spreadMerged16;

interface SpreadInput17 extends SpreadBase {
    value17: number;
    nested17: { readonly id: number; name: string };
}

declare const spreadInput17: SpreadInput17;
const spreadMerged17 = {
    ...spreadInput17,
    extra17: spreadInput17.value17,
    nested17: { ...spreadInput17.nested17, name: spreadInput17.common },
};
type SpreadResult17 = typeof spreadMerged17;
const spreadCheck17: SpreadResult17 = spreadMerged17;

interface SpreadInput18 extends SpreadBase {
    value18: number;
    nested18: { readonly id: number; name: string };
}

declare const spreadInput18: SpreadInput18;
const spreadMerged18 = {
    ...spreadInput18,
    extra18: spreadInput18.value18,
    nested18: { ...spreadInput18.nested18, name: spreadInput18.common },
};
type SpreadResult18 = typeof spreadMerged18;
const spreadCheck18: SpreadResult18 = spreadMerged18;

interface SpreadInput19 extends SpreadBase {
    value19: number;
    nested19: { readonly id: number; name: string };
}

declare const spreadInput19: SpreadInput19;
const spreadMerged19 = {
    ...spreadInput19,
    extra19: spreadInput19.value19,
    nested19: { ...spreadInput19.nested19, name: spreadInput19.common },
};
type SpreadResult19 = typeof spreadMerged19;
const spreadCheck19: SpreadResult19 = spreadMerged19;

interface SpreadInput20 extends SpreadBase {
    value20: number;
    nested20: { readonly id: number; name: string };
}

declare const spreadInput20: SpreadInput20;
const spreadMerged20 = {
    ...spreadInput20,
    extra20: spreadInput20.value20,
    nested20: { ...spreadInput20.nested20, name: spreadInput20.common },
};
type SpreadResult20 = typeof spreadMerged20;
const spreadCheck20: SpreadResult20 = spreadMerged20;

interface SpreadInput21 extends SpreadBase {
    value21: number;
    nested21: { readonly id: number; name: string };
}

declare const spreadInput21: SpreadInput21;
const spreadMerged21 = {
    ...spreadInput21,
    extra21: spreadInput21.value21,
    nested21: { ...spreadInput21.nested21, name: spreadInput21.common },
};
type SpreadResult21 = typeof spreadMerged21;
const spreadCheck21: SpreadResult21 = spreadMerged21;

interface SpreadInput22 extends SpreadBase {
    value22: number;
    nested22: { readonly id: number; name: string };
}

declare const spreadInput22: SpreadInput22;
const spreadMerged22 = {
    ...spreadInput22,
    extra22: spreadInput22.value22,
    nested22: { ...spreadInput22.nested22, name: spreadInput22.common },
};
type SpreadResult22 = typeof spreadMerged22;
const spreadCheck22: SpreadResult22 = spreadMerged22;

interface SpreadInput23 extends SpreadBase {
    value23: number;
    nested23: { readonly id: number; name: string };
}

declare const spreadInput23: SpreadInput23;
const spreadMerged23 = {
    ...spreadInput23,
    extra23: spreadInput23.value23,
    nested23: { ...spreadInput23.nested23, name: spreadInput23.common },
};
type SpreadResult23 = typeof spreadMerged23;
const spreadCheck23: SpreadResult23 = spreadMerged23;

interface SpreadInput24 extends SpreadBase {
    value24: number;
    nested24: { readonly id: number; name: string };
}

declare const spreadInput24: SpreadInput24;
const spreadMerged24 = {
    ...spreadInput24,
    extra24: spreadInput24.value24,
    nested24: { ...spreadInput24.nested24, name: spreadInput24.common },
};
type SpreadResult24 = typeof spreadMerged24;
const spreadCheck24: SpreadResult24 = spreadMerged24;

interface SpreadInput25 extends SpreadBase {
    value25: number;
    nested25: { readonly id: number; name: string };
}

declare const spreadInput25: SpreadInput25;
const spreadMerged25 = {
    ...spreadInput25,
    extra25: spreadInput25.value25,
    nested25: { ...spreadInput25.nested25, name: spreadInput25.common },
};
type SpreadResult25 = typeof spreadMerged25;
const spreadCheck25: SpreadResult25 = spreadMerged25;

interface SpreadInput26 extends SpreadBase {
    value26: number;
    nested26: { readonly id: number; name: string };
}

declare const spreadInput26: SpreadInput26;
const spreadMerged26 = {
    ...spreadInput26,
    extra26: spreadInput26.value26,
    nested26: { ...spreadInput26.nested26, name: spreadInput26.common },
};
type SpreadResult26 = typeof spreadMerged26;
const spreadCheck26: SpreadResult26 = spreadMerged26;

interface SpreadInput27 extends SpreadBase {
    value27: number;
    nested27: { readonly id: number; name: string };
}

declare const spreadInput27: SpreadInput27;
const spreadMerged27 = {
    ...spreadInput27,
    extra27: spreadInput27.value27,
    nested27: { ...spreadInput27.nested27, name: spreadInput27.common },
};
type SpreadResult27 = typeof spreadMerged27;
const spreadCheck27: SpreadResult27 = spreadMerged27;

interface SpreadInput28 extends SpreadBase {
    value28: number;
    nested28: { readonly id: number; name: string };
}

declare const spreadInput28: SpreadInput28;
const spreadMerged28 = {
    ...spreadInput28,
    extra28: spreadInput28.value28,
    nested28: { ...spreadInput28.nested28, name: spreadInput28.common },
};
type SpreadResult28 = typeof spreadMerged28;
const spreadCheck28: SpreadResult28 = spreadMerged28;

interface SpreadInput29 extends SpreadBase {
    value29: number;
    nested29: { readonly id: number; name: string };
}

declare const spreadInput29: SpreadInput29;
const spreadMerged29 = {
    ...spreadInput29,
    extra29: spreadInput29.value29,
    nested29: { ...spreadInput29.nested29, name: spreadInput29.common },
};
type SpreadResult29 = typeof spreadMerged29;
const spreadCheck29: SpreadResult29 = spreadMerged29;

interface SpreadInput30 extends SpreadBase {
    value30: number;
    nested30: { readonly id: number; name: string };
}

declare const spreadInput30: SpreadInput30;
const spreadMerged30 = {
    ...spreadInput30,
    extra30: spreadInput30.value30,
    nested30: { ...spreadInput30.nested30, name: spreadInput30.common },
};
type SpreadResult30 = typeof spreadMerged30;
const spreadCheck30: SpreadResult30 = spreadMerged30;

interface SpreadInput31 extends SpreadBase {
    value31: number;
    nested31: { readonly id: number; name: string };
}

declare const spreadInput31: SpreadInput31;
const spreadMerged31 = {
    ...spreadInput31,
    extra31: spreadInput31.value31,
    nested31: { ...spreadInput31.nested31, name: spreadInput31.common },
};
type SpreadResult31 = typeof spreadMerged31;
const spreadCheck31: SpreadResult31 = spreadMerged31;

interface SpreadInput32 extends SpreadBase {
    value32: number;
    nested32: { readonly id: number; name: string };
}

declare const spreadInput32: SpreadInput32;
const spreadMerged32 = {
    ...spreadInput32,
    extra32: spreadInput32.value32,
    nested32: { ...spreadInput32.nested32, name: spreadInput32.common },
};
type SpreadResult32 = typeof spreadMerged32;
const spreadCheck32: SpreadResult32 = spreadMerged32;

interface SpreadInput33 extends SpreadBase {
    value33: number;
    nested33: { readonly id: number; name: string };
}

declare const spreadInput33: SpreadInput33;
const spreadMerged33 = {
    ...spreadInput33,
    extra33: spreadInput33.value33,
    nested33: { ...spreadInput33.nested33, name: spreadInput33.common },
};
type SpreadResult33 = typeof spreadMerged33;
const spreadCheck33: SpreadResult33 = spreadMerged33;

interface SpreadInput34 extends SpreadBase {
    value34: number;
    nested34: { readonly id: number; name: string };
}

declare const spreadInput34: SpreadInput34;
const spreadMerged34 = {
    ...spreadInput34,
    extra34: spreadInput34.value34,
    nested34: { ...spreadInput34.nested34, name: spreadInput34.common },
};
type SpreadResult34 = typeof spreadMerged34;
const spreadCheck34: SpreadResult34 = spreadMerged34;

interface SpreadInput35 extends SpreadBase {
    value35: number;
    nested35: { readonly id: number; name: string };
}

declare const spreadInput35: SpreadInput35;
const spreadMerged35 = {
    ...spreadInput35,
    extra35: spreadInput35.value35,
    nested35: { ...spreadInput35.nested35, name: spreadInput35.common },
};
type SpreadResult35 = typeof spreadMerged35;
const spreadCheck35: SpreadResult35 = spreadMerged35;

interface SpreadInput36 extends SpreadBase {
    value36: number;
    nested36: { readonly id: number; name: string };
}

declare const spreadInput36: SpreadInput36;
const spreadMerged36 = {
    ...spreadInput36,
    extra36: spreadInput36.value36,
    nested36: { ...spreadInput36.nested36, name: spreadInput36.common },
};
type SpreadResult36 = typeof spreadMerged36;
const spreadCheck36: SpreadResult36 = spreadMerged36;

interface SpreadInput37 extends SpreadBase {
    value37: number;
    nested37: { readonly id: number; name: string };
}

declare const spreadInput37: SpreadInput37;
const spreadMerged37 = {
    ...spreadInput37,
    extra37: spreadInput37.value37,
    nested37: { ...spreadInput37.nested37, name: spreadInput37.common },
};
type SpreadResult37 = typeof spreadMerged37;
const spreadCheck37: SpreadResult37 = spreadMerged37;

interface SpreadInput38 extends SpreadBase {
    value38: number;
    nested38: { readonly id: number; name: string };
}

declare const spreadInput38: SpreadInput38;
const spreadMerged38 = {
    ...spreadInput38,
    extra38: spreadInput38.value38,
    nested38: { ...spreadInput38.nested38, name: spreadInput38.common },
};
type SpreadResult38 = typeof spreadMerged38;
const spreadCheck38: SpreadResult38 = spreadMerged38;

interface SpreadInput39 extends SpreadBase {
    value39: number;
    nested39: { readonly id: number; name: string };
}

declare const spreadInput39: SpreadInput39;
const spreadMerged39 = {
    ...spreadInput39,
    extra39: spreadInput39.value39,
    nested39: { ...spreadInput39.nested39, name: spreadInput39.common },
};
type SpreadResult39 = typeof spreadMerged39;
const spreadCheck39: SpreadResult39 = spreadMerged39;

interface SpreadInput40 extends SpreadBase {
    value40: number;
    nested40: { readonly id: number; name: string };
}

declare const spreadInput40: SpreadInput40;
const spreadMerged40 = {
    ...spreadInput40,
    extra40: spreadInput40.value40,
    nested40: { ...spreadInput40.nested40, name: spreadInput40.common },
};
type SpreadResult40 = typeof spreadMerged40;
const spreadCheck40: SpreadResult40 = spreadMerged40;

interface SpreadInput41 extends SpreadBase {
    value41: number;
    nested41: { readonly id: number; name: string };
}

declare const spreadInput41: SpreadInput41;
const spreadMerged41 = {
    ...spreadInput41,
    extra41: spreadInput41.value41,
    nested41: { ...spreadInput41.nested41, name: spreadInput41.common },
};
type SpreadResult41 = typeof spreadMerged41;
const spreadCheck41: SpreadResult41 = spreadMerged41;

interface SpreadInput42 extends SpreadBase {
    value42: number;
    nested42: { readonly id: number; name: string };
}

declare const spreadInput42: SpreadInput42;
const spreadMerged42 = {
    ...spreadInput42,
    extra42: spreadInput42.value42,
    nested42: { ...spreadInput42.nested42, name: spreadInput42.common },
};
type SpreadResult42 = typeof spreadMerged42;
const spreadCheck42: SpreadResult42 = spreadMerged42;

interface SpreadInput43 extends SpreadBase {
    value43: number;
    nested43: { readonly id: number; name: string };
}

declare const spreadInput43: SpreadInput43;
const spreadMerged43 = {
    ...spreadInput43,
    extra43: spreadInput43.value43,
    nested43: { ...spreadInput43.nested43, name: spreadInput43.common },
};
type SpreadResult43 = typeof spreadMerged43;
const spreadCheck43: SpreadResult43 = spreadMerged43;

interface SpreadInput44 extends SpreadBase {
    value44: number;
    nested44: { readonly id: number; name: string };
}

declare const spreadInput44: SpreadInput44;
const spreadMerged44 = {
    ...spreadInput44,
    extra44: spreadInput44.value44,
    nested44: { ...spreadInput44.nested44, name: spreadInput44.common },
};
type SpreadResult44 = typeof spreadMerged44;
const spreadCheck44: SpreadResult44 = spreadMerged44;

interface SpreadInput45 extends SpreadBase {
    value45: number;
    nested45: { readonly id: number; name: string };
}

declare const spreadInput45: SpreadInput45;
const spreadMerged45 = {
    ...spreadInput45,
    extra45: spreadInput45.value45,
    nested45: { ...spreadInput45.nested45, name: spreadInput45.common },
};
type SpreadResult45 = typeof spreadMerged45;
const spreadCheck45: SpreadResult45 = spreadMerged45;

interface SpreadInput46 extends SpreadBase {
    value46: number;
    nested46: { readonly id: number; name: string };
}

declare const spreadInput46: SpreadInput46;
const spreadMerged46 = {
    ...spreadInput46,
    extra46: spreadInput46.value46,
    nested46: { ...spreadInput46.nested46, name: spreadInput46.common },
};
type SpreadResult46 = typeof spreadMerged46;
const spreadCheck46: SpreadResult46 = spreadMerged46;

interface SpreadInput47 extends SpreadBase {
    value47: number;
    nested47: { readonly id: number; name: string };
}

declare const spreadInput47: SpreadInput47;
const spreadMerged47 = {
    ...spreadInput47,
    extra47: spreadInput47.value47,
    nested47: { ...spreadInput47.nested47, name: spreadInput47.common },
};
type SpreadResult47 = typeof spreadMerged47;
const spreadCheck47: SpreadResult47 = spreadMerged47;

interface SpreadInput48 extends SpreadBase {
    value48: number;
    nested48: { readonly id: number; name: string };
}

declare const spreadInput48: SpreadInput48;
const spreadMerged48 = {
    ...spreadInput48,
    extra48: spreadInput48.value48,
    nested48: { ...spreadInput48.nested48, name: spreadInput48.common },
};
type SpreadResult48 = typeof spreadMerged48;
const spreadCheck48: SpreadResult48 = spreadMerged48;

interface SpreadInput49 extends SpreadBase {
    value49: number;
    nested49: { readonly id: number; name: string };
}

declare const spreadInput49: SpreadInput49;
const spreadMerged49 = {
    ...spreadInput49,
    extra49: spreadInput49.value49,
    nested49: { ...spreadInput49.nested49, name: spreadInput49.common },
};
type SpreadResult49 = typeof spreadMerged49;
const spreadCheck49: SpreadResult49 = spreadMerged49;

interface SpreadInput50 extends SpreadBase {
    value50: number;
    nested50: { readonly id: number; name: string };
}

declare const spreadInput50: SpreadInput50;
const spreadMerged50 = {
    ...spreadInput50,
    extra50: spreadInput50.value50,
    nested50: { ...spreadInput50.nested50, name: spreadInput50.common },
};
type SpreadResult50 = typeof spreadMerged50;
const spreadCheck50: SpreadResult50 = spreadMerged50;

interface SpreadInput51 extends SpreadBase {
    value51: number;
    nested51: { readonly id: number; name: string };
}

declare const spreadInput51: SpreadInput51;
const spreadMerged51 = {
    ...spreadInput51,
    extra51: spreadInput51.value51,
    nested51: { ...spreadInput51.nested51, name: spreadInput51.common },
};
type SpreadResult51 = typeof spreadMerged51;
const spreadCheck51: SpreadResult51 = spreadMerged51;

interface SpreadInput52 extends SpreadBase {
    value52: number;
    nested52: { readonly id: number; name: string };
}

declare const spreadInput52: SpreadInput52;
const spreadMerged52 = {
    ...spreadInput52,
    extra52: spreadInput52.value52,
    nested52: { ...spreadInput52.nested52, name: spreadInput52.common },
};
type SpreadResult52 = typeof spreadMerged52;
const spreadCheck52: SpreadResult52 = spreadMerged52;

interface SpreadInput53 extends SpreadBase {
    value53: number;
    nested53: { readonly id: number; name: string };
}

declare const spreadInput53: SpreadInput53;
const spreadMerged53 = {
    ...spreadInput53,
    extra53: spreadInput53.value53,
    nested53: { ...spreadInput53.nested53, name: spreadInput53.common },
};
type SpreadResult53 = typeof spreadMerged53;
const spreadCheck53: SpreadResult53 = spreadMerged53;

interface SpreadInput54 extends SpreadBase {
    value54: number;
    nested54: { readonly id: number; name: string };
}

declare const spreadInput54: SpreadInput54;
const spreadMerged54 = {
    ...spreadInput54,
    extra54: spreadInput54.value54,
    nested54: { ...spreadInput54.nested54, name: spreadInput54.common },
};
type SpreadResult54 = typeof spreadMerged54;
const spreadCheck54: SpreadResult54 = spreadMerged54;

interface SpreadInput55 extends SpreadBase {
    value55: number;
    nested55: { readonly id: number; name: string };
}

declare const spreadInput55: SpreadInput55;
const spreadMerged55 = {
    ...spreadInput55,
    extra55: spreadInput55.value55,
    nested55: { ...spreadInput55.nested55, name: spreadInput55.common },
};
type SpreadResult55 = typeof spreadMerged55;
const spreadCheck55: SpreadResult55 = spreadMerged55;

interface SpreadInput56 extends SpreadBase {
    value56: number;
    nested56: { readonly id: number; name: string };
}

declare const spreadInput56: SpreadInput56;
const spreadMerged56 = {
    ...spreadInput56,
    extra56: spreadInput56.value56,
    nested56: { ...spreadInput56.nested56, name: spreadInput56.common },
};
type SpreadResult56 = typeof spreadMerged56;
const spreadCheck56: SpreadResult56 = spreadMerged56;

interface SpreadInput57 extends SpreadBase {
    value57: number;
    nested57: { readonly id: number; name: string };
}

declare const spreadInput57: SpreadInput57;
const spreadMerged57 = {
    ...spreadInput57,
    extra57: spreadInput57.value57,
    nested57: { ...spreadInput57.nested57, name: spreadInput57.common },
};
type SpreadResult57 = typeof spreadMerged57;
const spreadCheck57: SpreadResult57 = spreadMerged57;

interface SpreadInput58 extends SpreadBase {
    value58: number;
    nested58: { readonly id: number; name: string };
}

declare const spreadInput58: SpreadInput58;
const spreadMerged58 = {
    ...spreadInput58,
    extra58: spreadInput58.value58,
    nested58: { ...spreadInput58.nested58, name: spreadInput58.common },
};
type SpreadResult58 = typeof spreadMerged58;
const spreadCheck58: SpreadResult58 = spreadMerged58;

interface SpreadInput59 extends SpreadBase {
    value59: number;
    nested59: { readonly id: number; name: string };
}

declare const spreadInput59: SpreadInput59;
const spreadMerged59 = {
    ...spreadInput59,
    extra59: spreadInput59.value59,
    nested59: { ...spreadInput59.nested59, name: spreadInput59.common },
};
type SpreadResult59 = typeof spreadMerged59;
const spreadCheck59: SpreadResult59 = spreadMerged59;

interface SpreadInput60 extends SpreadBase {
    value60: number;
    nested60: { readonly id: number; name: string };
}

declare const spreadInput60: SpreadInput60;
const spreadMerged60 = {
    ...spreadInput60,
    extra60: spreadInput60.value60,
    nested60: { ...spreadInput60.nested60, name: spreadInput60.common },
};
type SpreadResult60 = typeof spreadMerged60;
const spreadCheck60: SpreadResult60 = spreadMerged60;

interface SpreadInput61 extends SpreadBase {
    value61: number;
    nested61: { readonly id: number; name: string };
}

declare const spreadInput61: SpreadInput61;
const spreadMerged61 = {
    ...spreadInput61,
    extra61: spreadInput61.value61,
    nested61: { ...spreadInput61.nested61, name: spreadInput61.common },
};
type SpreadResult61 = typeof spreadMerged61;
const spreadCheck61: SpreadResult61 = spreadMerged61;

interface SpreadInput62 extends SpreadBase {
    value62: number;
    nested62: { readonly id: number; name: string };
}

declare const spreadInput62: SpreadInput62;
const spreadMerged62 = {
    ...spreadInput62,
    extra62: spreadInput62.value62,
    nested62: { ...spreadInput62.nested62, name: spreadInput62.common },
};
type SpreadResult62 = typeof spreadMerged62;
const spreadCheck62: SpreadResult62 = spreadMerged62;

interface SpreadInput63 extends SpreadBase {
    value63: number;
    nested63: { readonly id: number; name: string };
}

declare const spreadInput63: SpreadInput63;
const spreadMerged63 = {
    ...spreadInput63,
    extra63: spreadInput63.value63,
    nested63: { ...spreadInput63.nested63, name: spreadInput63.common },
};
type SpreadResult63 = typeof spreadMerged63;
const spreadCheck63: SpreadResult63 = spreadMerged63;

interface SpreadInput64 extends SpreadBase {
    value64: number;
    nested64: { readonly id: number; name: string };
}

declare const spreadInput64: SpreadInput64;
const spreadMerged64 = {
    ...spreadInput64,
    extra64: spreadInput64.value64,
    nested64: { ...spreadInput64.nested64, name: spreadInput64.common },
};
type SpreadResult64 = typeof spreadMerged64;
const spreadCheck64: SpreadResult64 = spreadMerged64;

interface SpreadInput65 extends SpreadBase {
    value65: number;
    nested65: { readonly id: number; name: string };
}

declare const spreadInput65: SpreadInput65;
const spreadMerged65 = {
    ...spreadInput65,
    extra65: spreadInput65.value65,
    nested65: { ...spreadInput65.nested65, name: spreadInput65.common },
};
type SpreadResult65 = typeof spreadMerged65;
const spreadCheck65: SpreadResult65 = spreadMerged65;

interface SpreadInput66 extends SpreadBase {
    value66: number;
    nested66: { readonly id: number; name: string };
}

declare const spreadInput66: SpreadInput66;
const spreadMerged66 = {
    ...spreadInput66,
    extra66: spreadInput66.value66,
    nested66: { ...spreadInput66.nested66, name: spreadInput66.common },
};
type SpreadResult66 = typeof spreadMerged66;
const spreadCheck66: SpreadResult66 = spreadMerged66;

interface SpreadInput67 extends SpreadBase {
    value67: number;
    nested67: { readonly id: number; name: string };
}

declare const spreadInput67: SpreadInput67;
const spreadMerged67 = {
    ...spreadInput67,
    extra67: spreadInput67.value67,
    nested67: { ...spreadInput67.nested67, name: spreadInput67.common },
};
type SpreadResult67 = typeof spreadMerged67;
const spreadCheck67: SpreadResult67 = spreadMerged67;

interface SpreadInput68 extends SpreadBase {
    value68: number;
    nested68: { readonly id: number; name: string };
}

declare const spreadInput68: SpreadInput68;
const spreadMerged68 = {
    ...spreadInput68,
    extra68: spreadInput68.value68,
    nested68: { ...spreadInput68.nested68, name: spreadInput68.common },
};
type SpreadResult68 = typeof spreadMerged68;
const spreadCheck68: SpreadResult68 = spreadMerged68;

interface SpreadInput69 extends SpreadBase {
    value69: number;
    nested69: { readonly id: number; name: string };
}

declare const spreadInput69: SpreadInput69;
const spreadMerged69 = {
    ...spreadInput69,
    extra69: spreadInput69.value69,
    nested69: { ...spreadInput69.nested69, name: spreadInput69.common },
};
type SpreadResult69 = typeof spreadMerged69;
const spreadCheck69: SpreadResult69 = spreadMerged69;

interface SpreadInput70 extends SpreadBase {
    value70: number;
    nested70: { readonly id: number; name: string };
}

declare const spreadInput70: SpreadInput70;
const spreadMerged70 = {
    ...spreadInput70,
    extra70: spreadInput70.value70,
    nested70: { ...spreadInput70.nested70, name: spreadInput70.common },
};
type SpreadResult70 = typeof spreadMerged70;
const spreadCheck70: SpreadResult70 = spreadMerged70;

interface SpreadInput71 extends SpreadBase {
    value71: number;
    nested71: { readonly id: number; name: string };
}

declare const spreadInput71: SpreadInput71;
const spreadMerged71 = {
    ...spreadInput71,
    extra71: spreadInput71.value71,
    nested71: { ...spreadInput71.nested71, name: spreadInput71.common },
};
type SpreadResult71 = typeof spreadMerged71;
const spreadCheck71: SpreadResult71 = spreadMerged71;

interface SpreadInput72 extends SpreadBase {
    value72: number;
    nested72: { readonly id: number; name: string };
}

declare const spreadInput72: SpreadInput72;
const spreadMerged72 = {
    ...spreadInput72,
    extra72: spreadInput72.value72,
    nested72: { ...spreadInput72.nested72, name: spreadInput72.common },
};
type SpreadResult72 = typeof spreadMerged72;
const spreadCheck72: SpreadResult72 = spreadMerged72;

interface SpreadInput73 extends SpreadBase {
    value73: number;
    nested73: { readonly id: number; name: string };
}

declare const spreadInput73: SpreadInput73;
const spreadMerged73 = {
    ...spreadInput73,
    extra73: spreadInput73.value73,
    nested73: { ...spreadInput73.nested73, name: spreadInput73.common },
};
type SpreadResult73 = typeof spreadMerged73;
const spreadCheck73: SpreadResult73 = spreadMerged73;

interface SpreadInput74 extends SpreadBase {
    value74: number;
    nested74: { readonly id: number; name: string };
}

declare const spreadInput74: SpreadInput74;
const spreadMerged74 = {
    ...spreadInput74,
    extra74: spreadInput74.value74,
    nested74: { ...spreadInput74.nested74, name: spreadInput74.common },
};
type SpreadResult74 = typeof spreadMerged74;
const spreadCheck74: SpreadResult74 = spreadMerged74;

interface SpreadInput75 extends SpreadBase {
    value75: number;
    nested75: { readonly id: number; name: string };
}

declare const spreadInput75: SpreadInput75;
const spreadMerged75 = {
    ...spreadInput75,
    extra75: spreadInput75.value75,
    nested75: { ...spreadInput75.nested75, name: spreadInput75.common },
};
type SpreadResult75 = typeof spreadMerged75;
const spreadCheck75: SpreadResult75 = spreadMerged75;

interface SpreadInput76 extends SpreadBase {
    value76: number;
    nested76: { readonly id: number; name: string };
}

declare const spreadInput76: SpreadInput76;
const spreadMerged76 = {
    ...spreadInput76,
    extra76: spreadInput76.value76,
    nested76: { ...spreadInput76.nested76, name: spreadInput76.common },
};
type SpreadResult76 = typeof spreadMerged76;
const spreadCheck76: SpreadResult76 = spreadMerged76;

interface SpreadInput77 extends SpreadBase {
    value77: number;
    nested77: { readonly id: number; name: string };
}

declare const spreadInput77: SpreadInput77;
const spreadMerged77 = {
    ...spreadInput77,
    extra77: spreadInput77.value77,
    nested77: { ...spreadInput77.nested77, name: spreadInput77.common },
};
type SpreadResult77 = typeof spreadMerged77;
const spreadCheck77: SpreadResult77 = spreadMerged77;

interface SpreadInput78 extends SpreadBase {
    value78: number;
    nested78: { readonly id: number; name: string };
}

declare const spreadInput78: SpreadInput78;
const spreadMerged78 = {
    ...spreadInput78,
    extra78: spreadInput78.value78,
    nested78: { ...spreadInput78.nested78, name: spreadInput78.common },
};
type SpreadResult78 = typeof spreadMerged78;
const spreadCheck78: SpreadResult78 = spreadMerged78;

interface SpreadInput79 extends SpreadBase {
    value79: number;
    nested79: { readonly id: number; name: string };
}

declare const spreadInput79: SpreadInput79;
const spreadMerged79 = {
    ...spreadInput79,
    extra79: spreadInput79.value79,
    nested79: { ...spreadInput79.nested79, name: spreadInput79.common },
};
type SpreadResult79 = typeof spreadMerged79;
const spreadCheck79: SpreadResult79 = spreadMerged79;

interface SpreadInput80 extends SpreadBase {
    value80: number;
    nested80: { readonly id: number; name: string };
}

declare const spreadInput80: SpreadInput80;
const spreadMerged80 = {
    ...spreadInput80,
    extra80: spreadInput80.value80,
    nested80: { ...spreadInput80.nested80, name: spreadInput80.common },
};
type SpreadResult80 = typeof spreadMerged80;
const spreadCheck80: SpreadResult80 = spreadMerged80;

interface SpreadInput81 extends SpreadBase {
    value81: number;
    nested81: { readonly id: number; name: string };
}

declare const spreadInput81: SpreadInput81;
const spreadMerged81 = {
    ...spreadInput81,
    extra81: spreadInput81.value81,
    nested81: { ...spreadInput81.nested81, name: spreadInput81.common },
};
type SpreadResult81 = typeof spreadMerged81;
const spreadCheck81: SpreadResult81 = spreadMerged81;

interface SpreadInput82 extends SpreadBase {
    value82: number;
    nested82: { readonly id: number; name: string };
}

declare const spreadInput82: SpreadInput82;
const spreadMerged82 = {
    ...spreadInput82,
    extra82: spreadInput82.value82,
    nested82: { ...spreadInput82.nested82, name: spreadInput82.common },
};
type SpreadResult82 = typeof spreadMerged82;
const spreadCheck82: SpreadResult82 = spreadMerged82;

interface SpreadInput83 extends SpreadBase {
    value83: number;
    nested83: { readonly id: number; name: string };
}

declare const spreadInput83: SpreadInput83;
const spreadMerged83 = {
    ...spreadInput83,
    extra83: spreadInput83.value83,
    nested83: { ...spreadInput83.nested83, name: spreadInput83.common },
};
type SpreadResult83 = typeof spreadMerged83;
const spreadCheck83: SpreadResult83 = spreadMerged83;

interface SpreadInput84 extends SpreadBase {
    value84: number;
    nested84: { readonly id: number; name: string };
}

declare const spreadInput84: SpreadInput84;
const spreadMerged84 = {
    ...spreadInput84,
    extra84: spreadInput84.value84,
    nested84: { ...spreadInput84.nested84, name: spreadInput84.common },
};
type SpreadResult84 = typeof spreadMerged84;
const spreadCheck84: SpreadResult84 = spreadMerged84;

interface SpreadInput85 extends SpreadBase {
    value85: number;
    nested85: { readonly id: number; name: string };
}

declare const spreadInput85: SpreadInput85;
const spreadMerged85 = {
    ...spreadInput85,
    extra85: spreadInput85.value85,
    nested85: { ...spreadInput85.nested85, name: spreadInput85.common },
};
type SpreadResult85 = typeof spreadMerged85;
const spreadCheck85: SpreadResult85 = spreadMerged85;

interface SpreadInput86 extends SpreadBase {
    value86: number;
    nested86: { readonly id: number; name: string };
}

declare const spreadInput86: SpreadInput86;
const spreadMerged86 = {
    ...spreadInput86,
    extra86: spreadInput86.value86,
    nested86: { ...spreadInput86.nested86, name: spreadInput86.common },
};
type SpreadResult86 = typeof spreadMerged86;
const spreadCheck86: SpreadResult86 = spreadMerged86;

interface SpreadInput87 extends SpreadBase {
    value87: number;
    nested87: { readonly id: number; name: string };
}

declare const spreadInput87: SpreadInput87;
const spreadMerged87 = {
    ...spreadInput87,
    extra87: spreadInput87.value87,
    nested87: { ...spreadInput87.nested87, name: spreadInput87.common },
};
type SpreadResult87 = typeof spreadMerged87;
const spreadCheck87: SpreadResult87 = spreadMerged87;

interface SpreadInput88 extends SpreadBase {
    value88: number;
    nested88: { readonly id: number; name: string };
}

declare const spreadInput88: SpreadInput88;
const spreadMerged88 = {
    ...spreadInput88,
    extra88: spreadInput88.value88,
    nested88: { ...spreadInput88.nested88, name: spreadInput88.common },
};
type SpreadResult88 = typeof spreadMerged88;
const spreadCheck88: SpreadResult88 = spreadMerged88;

interface SpreadInput89 extends SpreadBase {
    value89: number;
    nested89: { readonly id: number; name: string };
}

declare const spreadInput89: SpreadInput89;
const spreadMerged89 = {
    ...spreadInput89,
    extra89: spreadInput89.value89,
    nested89: { ...spreadInput89.nested89, name: spreadInput89.common },
};
type SpreadResult89 = typeof spreadMerged89;
const spreadCheck89: SpreadResult89 = spreadMerged89;

interface SpreadInput90 extends SpreadBase {
    value90: number;
    nested90: { readonly id: number; name: string };
}

declare const spreadInput90: SpreadInput90;
const spreadMerged90 = {
    ...spreadInput90,
    extra90: spreadInput90.value90,
    nested90: { ...spreadInput90.nested90, name: spreadInput90.common },
};
type SpreadResult90 = typeof spreadMerged90;
const spreadCheck90: SpreadResult90 = spreadMerged90;

interface SpreadInput91 extends SpreadBase {
    value91: number;
    nested91: { readonly id: number; name: string };
}

declare const spreadInput91: SpreadInput91;
const spreadMerged91 = {
    ...spreadInput91,
    extra91: spreadInput91.value91,
    nested91: { ...spreadInput91.nested91, name: spreadInput91.common },
};
type SpreadResult91 = typeof spreadMerged91;
const spreadCheck91: SpreadResult91 = spreadMerged91;

interface SpreadInput92 extends SpreadBase {
    value92: number;
    nested92: { readonly id: number; name: string };
}

declare const spreadInput92: SpreadInput92;
const spreadMerged92 = {
    ...spreadInput92,
    extra92: spreadInput92.value92,
    nested92: { ...spreadInput92.nested92, name: spreadInput92.common },
};
type SpreadResult92 = typeof spreadMerged92;
const spreadCheck92: SpreadResult92 = spreadMerged92;

interface SpreadInput93 extends SpreadBase {
    value93: number;
    nested93: { readonly id: number; name: string };
}

declare const spreadInput93: SpreadInput93;
const spreadMerged93 = {
    ...spreadInput93,
    extra93: spreadInput93.value93,
    nested93: { ...spreadInput93.nested93, name: spreadInput93.common },
};
type SpreadResult93 = typeof spreadMerged93;
const spreadCheck93: SpreadResult93 = spreadMerged93;

interface SpreadInput94 extends SpreadBase {
    value94: number;
    nested94: { readonly id: number; name: string };
}

declare const spreadInput94: SpreadInput94;
const spreadMerged94 = {
    ...spreadInput94,
    extra94: spreadInput94.value94,
    nested94: { ...spreadInput94.nested94, name: spreadInput94.common },
};
type SpreadResult94 = typeof spreadMerged94;
const spreadCheck94: SpreadResult94 = spreadMerged94;

interface SpreadInput95 extends SpreadBase {
    value95: number;
    nested95: { readonly id: number; name: string };
}

declare const spreadInput95: SpreadInput95;
const spreadMerged95 = {
    ...spreadInput95,
    extra95: spreadInput95.value95,
    nested95: { ...spreadInput95.nested95, name: spreadInput95.common },
};
type SpreadResult95 = typeof spreadMerged95;
const spreadCheck95: SpreadResult95 = spreadMerged95;

interface SpreadInput96 extends SpreadBase {
    value96: number;
    nested96: { readonly id: number; name: string };
}

declare const spreadInput96: SpreadInput96;
const spreadMerged96 = {
    ...spreadInput96,
    extra96: spreadInput96.value96,
    nested96: { ...spreadInput96.nested96, name: spreadInput96.common },
};
type SpreadResult96 = typeof spreadMerged96;
const spreadCheck96: SpreadResult96 = spreadMerged96;

interface SpreadInput97 extends SpreadBase {
    value97: number;
    nested97: { readonly id: number; name: string };
}

declare const spreadInput97: SpreadInput97;
const spreadMerged97 = {
    ...spreadInput97,
    extra97: spreadInput97.value97,
    nested97: { ...spreadInput97.nested97, name: spreadInput97.common },
};
type SpreadResult97 = typeof spreadMerged97;
const spreadCheck97: SpreadResult97 = spreadMerged97;

interface SpreadInput98 extends SpreadBase {
    value98: number;
    nested98: { readonly id: number; name: string };
}

declare const spreadInput98: SpreadInput98;
const spreadMerged98 = {
    ...spreadInput98,
    extra98: spreadInput98.value98,
    nested98: { ...spreadInput98.nested98, name: spreadInput98.common },
};
type SpreadResult98 = typeof spreadMerged98;
const spreadCheck98: SpreadResult98 = spreadMerged98;

interface SpreadInput99 extends SpreadBase {
    value99: number;
    nested99: { readonly id: number; name: string };
}

declare const spreadInput99: SpreadInput99;
const spreadMerged99 = {
    ...spreadInput99,
    extra99: spreadInput99.value99,
    nested99: { ...spreadInput99.nested99, name: spreadInput99.common },
};
type SpreadResult99 = typeof spreadMerged99;
const spreadCheck99: SpreadResult99 = spreadMerged99;