Object spread hotspot N=200

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

interface SpreadInput100 extends SpreadBase {
    value100: number;
    nested100: { readonly id: number; name: string };
}

declare const spreadInput100: SpreadInput100;
const spreadMerged100 = {
    ...spreadInput100,
    extra100: spreadInput100.value100,
    nested100: { ...spreadInput100.nested100, name: spreadInput100.common },
};
type SpreadResult100 = typeof spreadMerged100;
const spreadCheck100: SpreadResult100 = spreadMerged100;

interface SpreadInput101 extends SpreadBase {
    value101: number;
    nested101: { readonly id: number; name: string };
}

declare const spreadInput101: SpreadInput101;
const spreadMerged101 = {
    ...spreadInput101,
    extra101: spreadInput101.value101,
    nested101: { ...spreadInput101.nested101, name: spreadInput101.common },
};
type SpreadResult101 = typeof spreadMerged101;
const spreadCheck101: SpreadResult101 = spreadMerged101;

interface SpreadInput102 extends SpreadBase {
    value102: number;
    nested102: { readonly id: number; name: string };
}

declare const spreadInput102: SpreadInput102;
const spreadMerged102 = {
    ...spreadInput102,
    extra102: spreadInput102.value102,
    nested102: { ...spreadInput102.nested102, name: spreadInput102.common },
};
type SpreadResult102 = typeof spreadMerged102;
const spreadCheck102: SpreadResult102 = spreadMerged102;

interface SpreadInput103 extends SpreadBase {
    value103: number;
    nested103: { readonly id: number; name: string };
}

declare const spreadInput103: SpreadInput103;
const spreadMerged103 = {
    ...spreadInput103,
    extra103: spreadInput103.value103,
    nested103: { ...spreadInput103.nested103, name: spreadInput103.common },
};
type SpreadResult103 = typeof spreadMerged103;
const spreadCheck103: SpreadResult103 = spreadMerged103;

interface SpreadInput104 extends SpreadBase {
    value104: number;
    nested104: { readonly id: number; name: string };
}

declare const spreadInput104: SpreadInput104;
const spreadMerged104 = {
    ...spreadInput104,
    extra104: spreadInput104.value104,
    nested104: { ...spreadInput104.nested104, name: spreadInput104.common },
};
type SpreadResult104 = typeof spreadMerged104;
const spreadCheck104: SpreadResult104 = spreadMerged104;

interface SpreadInput105 extends SpreadBase {
    value105: number;
    nested105: { readonly id: number; name: string };
}

declare const spreadInput105: SpreadInput105;
const spreadMerged105 = {
    ...spreadInput105,
    extra105: spreadInput105.value105,
    nested105: { ...spreadInput105.nested105, name: spreadInput105.common },
};
type SpreadResult105 = typeof spreadMerged105;
const spreadCheck105: SpreadResult105 = spreadMerged105;

interface SpreadInput106 extends SpreadBase {
    value106: number;
    nested106: { readonly id: number; name: string };
}

declare const spreadInput106: SpreadInput106;
const spreadMerged106 = {
    ...spreadInput106,
    extra106: spreadInput106.value106,
    nested106: { ...spreadInput106.nested106, name: spreadInput106.common },
};
type SpreadResult106 = typeof spreadMerged106;
const spreadCheck106: SpreadResult106 = spreadMerged106;

interface SpreadInput107 extends SpreadBase {
    value107: number;
    nested107: { readonly id: number; name: string };
}

declare const spreadInput107: SpreadInput107;
const spreadMerged107 = {
    ...spreadInput107,
    extra107: spreadInput107.value107,
    nested107: { ...spreadInput107.nested107, name: spreadInput107.common },
};
type SpreadResult107 = typeof spreadMerged107;
const spreadCheck107: SpreadResult107 = spreadMerged107;

interface SpreadInput108 extends SpreadBase {
    value108: number;
    nested108: { readonly id: number; name: string };
}

declare const spreadInput108: SpreadInput108;
const spreadMerged108 = {
    ...spreadInput108,
    extra108: spreadInput108.value108,
    nested108: { ...spreadInput108.nested108, name: spreadInput108.common },
};
type SpreadResult108 = typeof spreadMerged108;
const spreadCheck108: SpreadResult108 = spreadMerged108;

interface SpreadInput109 extends SpreadBase {
    value109: number;
    nested109: { readonly id: number; name: string };
}

declare const spreadInput109: SpreadInput109;
const spreadMerged109 = {
    ...spreadInput109,
    extra109: spreadInput109.value109,
    nested109: { ...spreadInput109.nested109, name: spreadInput109.common },
};
type SpreadResult109 = typeof spreadMerged109;
const spreadCheck109: SpreadResult109 = spreadMerged109;

interface SpreadInput110 extends SpreadBase {
    value110: number;
    nested110: { readonly id: number; name: string };
}

declare const spreadInput110: SpreadInput110;
const spreadMerged110 = {
    ...spreadInput110,
    extra110: spreadInput110.value110,
    nested110: { ...spreadInput110.nested110, name: spreadInput110.common },
};
type SpreadResult110 = typeof spreadMerged110;
const spreadCheck110: SpreadResult110 = spreadMerged110;

interface SpreadInput111 extends SpreadBase {
    value111: number;
    nested111: { readonly id: number; name: string };
}

declare const spreadInput111: SpreadInput111;
const spreadMerged111 = {
    ...spreadInput111,
    extra111: spreadInput111.value111,
    nested111: { ...spreadInput111.nested111, name: spreadInput111.common },
};
type SpreadResult111 = typeof spreadMerged111;
const spreadCheck111: SpreadResult111 = spreadMerged111;

interface SpreadInput112 extends SpreadBase {
    value112: number;
    nested112: { readonly id: number; name: string };
}

declare const spreadInput112: SpreadInput112;
const spreadMerged112 = {
    ...spreadInput112,
    extra112: spreadInput112.value112,
    nested112: { ...spreadInput112.nested112, name: spreadInput112.common },
};
type SpreadResult112 = typeof spreadMerged112;
const spreadCheck112: SpreadResult112 = spreadMerged112;

interface SpreadInput113 extends SpreadBase {
    value113: number;
    nested113: { readonly id: number; name: string };
}

declare const spreadInput113: SpreadInput113;
const spreadMerged113 = {
    ...spreadInput113,
    extra113: spreadInput113.value113,
    nested113: { ...spreadInput113.nested113, name: spreadInput113.common },
};
type SpreadResult113 = typeof spreadMerged113;
const spreadCheck113: SpreadResult113 = spreadMerged113;

interface SpreadInput114 extends SpreadBase {
    value114: number;
    nested114: { readonly id: number; name: string };
}

declare const spreadInput114: SpreadInput114;
const spreadMerged114 = {
    ...spreadInput114,
    extra114: spreadInput114.value114,
    nested114: { ...spreadInput114.nested114, name: spreadInput114.common },
};
type SpreadResult114 = typeof spreadMerged114;
const spreadCheck114: SpreadResult114 = spreadMerged114;

interface SpreadInput115 extends SpreadBase {
    value115: number;
    nested115: { readonly id: number; name: string };
}

declare const spreadInput115: SpreadInput115;
const spreadMerged115 = {
    ...spreadInput115,
    extra115: spreadInput115.value115,
    nested115: { ...spreadInput115.nested115, name: spreadInput115.common },
};
type SpreadResult115 = typeof spreadMerged115;
const spreadCheck115: SpreadResult115 = spreadMerged115;

interface SpreadInput116 extends SpreadBase {
    value116: number;
    nested116: { readonly id: number; name: string };
}

declare const spreadInput116: SpreadInput116;
const spreadMerged116 = {
    ...spreadInput116,
    extra116: spreadInput116.value116,
    nested116: { ...spreadInput116.nested116, name: spreadInput116.common },
};
type SpreadResult116 = typeof spreadMerged116;
const spreadCheck116: SpreadResult116 = spreadMerged116;

interface SpreadInput117 extends SpreadBase {
    value117: number;
    nested117: { readonly id: number; name: string };
}

declare const spreadInput117: SpreadInput117;
const spreadMerged117 = {
    ...spreadInput117,
    extra117: spreadInput117.value117,
    nested117: { ...spreadInput117.nested117, name: spreadInput117.common },
};
type SpreadResult117 = typeof spreadMerged117;
const spreadCheck117: SpreadResult117 = spreadMerged117;

interface SpreadInput118 extends SpreadBase {
    value118: number;
    nested118: { readonly id: number; name: string };
}

declare const spreadInput118: SpreadInput118;
const spreadMerged118 = {
    ...spreadInput118,
    extra118: spreadInput118.value118,
    nested118: { ...spreadInput118.nested118, name: spreadInput118.common },
};
type SpreadResult118 = typeof spreadMerged118;
const spreadCheck118: SpreadResult118 = spreadMerged118;

interface SpreadInput119 extends SpreadBase {
    value119: number;
    nested119: { readonly id: number; name: string };
}

declare const spreadInput119: SpreadInput119;
const spreadMerged119 = {
    ...spreadInput119,
    extra119: spreadInput119.value119,
    nested119: { ...spreadInput119.nested119, name: spreadInput119.common },
};
type SpreadResult119 = typeof spreadMerged119;
const spreadCheck119: SpreadResult119 = spreadMerged119;

interface SpreadInput120 extends SpreadBase {
    value120: number;
    nested120: { readonly id: number; name: string };
}

declare const spreadInput120: SpreadInput120;
const spreadMerged120 = {
    ...spreadInput120,
    extra120: spreadInput120.value120,
    nested120: { ...spreadInput120.nested120, name: spreadInput120.common },
};
type SpreadResult120 = typeof spreadMerged120;
const spreadCheck120: SpreadResult120 = spreadMerged120;

interface SpreadInput121 extends SpreadBase {
    value121: number;
    nested121: { readonly id: number; name: string };
}

declare const spreadInput121: SpreadInput121;
const spreadMerged121 = {
    ...spreadInput121,
    extra121: spreadInput121.value121,
    nested121: { ...spreadInput121.nested121, name: spreadInput121.common },
};
type SpreadResult121 = typeof spreadMerged121;
const spreadCheck121: SpreadResult121 = spreadMerged121;

interface SpreadInput122 extends SpreadBase {
    value122: number;
    nested122: { readonly id: number; name: string };
}

declare const spreadInput122: SpreadInput122;
const spreadMerged122 = {
    ...spreadInput122,
    extra122: spreadInput122.value122,
    nested122: { ...spreadInput122.nested122, name: spreadInput122.common },
};
type SpreadResult122 = typeof spreadMerged122;
const spreadCheck122: SpreadResult122 = spreadMerged122;

interface SpreadInput123 extends SpreadBase {
    value123: number;
    nested123: { readonly id: number; name: string };
}

declare const spreadInput123: SpreadInput123;
const spreadMerged123 = {
    ...spreadInput123,
    extra123: spreadInput123.value123,
    nested123: { ...spreadInput123.nested123, name: spreadInput123.common },
};
type SpreadResult123 = typeof spreadMerged123;
const spreadCheck123: SpreadResult123 = spreadMerged123;

interface SpreadInput124 extends SpreadBase {
    value124: number;
    nested124: { readonly id: number; name: string };
}

declare const spreadInput124: SpreadInput124;
const spreadMerged124 = {
    ...spreadInput124,
    extra124: spreadInput124.value124,
    nested124: { ...spreadInput124.nested124, name: spreadInput124.common },
};
type SpreadResult124 = typeof spreadMerged124;
const spreadCheck124: SpreadResult124 = spreadMerged124;

interface SpreadInput125 extends SpreadBase {
    value125: number;
    nested125: { readonly id: number; name: string };
}

declare const spreadInput125: SpreadInput125;
const spreadMerged125 = {
    ...spreadInput125,
    extra125: spreadInput125.value125,
    nested125: { ...spreadInput125.nested125, name: spreadInput125.common },
};
type SpreadResult125 = typeof spreadMerged125;
const spreadCheck125: SpreadResult125 = spreadMerged125;

interface SpreadInput126 extends SpreadBase {
    value126: number;
    nested126: { readonly id: number; name: string };
}

declare const spreadInput126: SpreadInput126;
const spreadMerged126 = {
    ...spreadInput126,
    extra126: spreadInput126.value126,
    nested126: { ...spreadInput126.nested126, name: spreadInput126.common },
};
type SpreadResult126 = typeof spreadMerged126;
const spreadCheck126: SpreadResult126 = spreadMerged126;

interface SpreadInput127 extends SpreadBase {
    value127: number;
    nested127: { readonly id: number; name: string };
}

declare const spreadInput127: SpreadInput127;
const spreadMerged127 = {
    ...spreadInput127,
    extra127: spreadInput127.value127,
    nested127: { ...spreadInput127.nested127, name: spreadInput127.common },
};
type SpreadResult127 = typeof spreadMerged127;
const spreadCheck127: SpreadResult127 = spreadMerged127;

interface SpreadInput128 extends SpreadBase {
    value128: number;
    nested128: { readonly id: number; name: string };
}

declare const spreadInput128: SpreadInput128;
const spreadMerged128 = {
    ...spreadInput128,
    extra128: spreadInput128.value128,
    nested128: { ...spreadInput128.nested128, name: spreadInput128.common },
};
type SpreadResult128 = typeof spreadMerged128;
const spreadCheck128: SpreadResult128 = spreadMerged128;

interface SpreadInput129 extends SpreadBase {
    value129: number;
    nested129: { readonly id: number; name: string };
}

declare const spreadInput129: SpreadInput129;
const spreadMerged129 = {
    ...spreadInput129,
    extra129: spreadInput129.value129,
    nested129: { ...spreadInput129.nested129, name: spreadInput129.common },
};
type SpreadResult129 = typeof spreadMerged129;
const spreadCheck129: SpreadResult129 = spreadMerged129;

interface SpreadInput130 extends SpreadBase {
    value130: number;
    nested130: { readonly id: number; name: string };
}

declare const spreadInput130: SpreadInput130;
const spreadMerged130 = {
    ...spreadInput130,
    extra130: spreadInput130.value130,
    nested130: { ...spreadInput130.nested130, name: spreadInput130.common },
};
type SpreadResult130 = typeof spreadMerged130;
const spreadCheck130: SpreadResult130 = spreadMerged130;

interface SpreadInput131 extends SpreadBase {
    value131: number;
    nested131: { readonly id: number; name: string };
}

declare const spreadInput131: SpreadInput131;
const spreadMerged131 = {
    ...spreadInput131,
    extra131: spreadInput131.value131,
    nested131: { ...spreadInput131.nested131, name: spreadInput131.common },
};
type SpreadResult131 = typeof spreadMerged131;
const spreadCheck131: SpreadResult131 = spreadMerged131;

interface SpreadInput132 extends SpreadBase {
    value132: number;
    nested132: { readonly id: number; name: string };
}

declare const spreadInput132: SpreadInput132;
const spreadMerged132 = {
    ...spreadInput132,
    extra132: spreadInput132.value132,
    nested132: { ...spreadInput132.nested132, name: spreadInput132.common },
};
type SpreadResult132 = typeof spreadMerged132;
const spreadCheck132: SpreadResult132 = spreadMerged132;

interface SpreadInput133 extends SpreadBase {
    value133: number;
    nested133: { readonly id: number; name: string };
}

declare const spreadInput133: SpreadInput133;
const spreadMerged133 = {
    ...spreadInput133,
    extra133: spreadInput133.value133,
    nested133: { ...spreadInput133.nested133, name: spreadInput133.common },
};
type SpreadResult133 = typeof spreadMerged133;
const spreadCheck133: SpreadResult133 = spreadMerged133;

interface SpreadInput134 extends SpreadBase {
    value134: number;
    nested134: { readonly id: number; name: string };
}

declare const spreadInput134: SpreadInput134;
const spreadMerged134 = {
    ...spreadInput134,
    extra134: spreadInput134.value134,
    nested134: { ...spreadInput134.nested134, name: spreadInput134.common },
};
type SpreadResult134 = typeof spreadMerged134;
const spreadCheck134: SpreadResult134 = spreadMerged134;

interface SpreadInput135 extends SpreadBase {
    value135: number;
    nested135: { readonly id: number; name: string };
}

declare const spreadInput135: SpreadInput135;
const spreadMerged135 = {
    ...spreadInput135,
    extra135: spreadInput135.value135,
    nested135: { ...spreadInput135.nested135, name: spreadInput135.common },
};
type SpreadResult135 = typeof spreadMerged135;
const spreadCheck135: SpreadResult135 = spreadMerged135;

interface SpreadInput136 extends SpreadBase {
    value136: number;
    nested136: { readonly id: number; name: string };
}

declare const spreadInput136: SpreadInput136;
const spreadMerged136 = {
    ...spreadInput136,
    extra136: spreadInput136.value136,
    nested136: { ...spreadInput136.nested136, name: spreadInput136.common },
};
type SpreadResult136 = typeof spreadMerged136;
const spreadCheck136: SpreadResult136 = spreadMerged136;

interface SpreadInput137 extends SpreadBase {
    value137: number;
    nested137: { readonly id: number; name: string };
}

declare const spreadInput137: SpreadInput137;
const spreadMerged137 = {
    ...spreadInput137,
    extra137: spreadInput137.value137,
    nested137: { ...spreadInput137.nested137, name: spreadInput137.common },
};
type SpreadResult137 = typeof spreadMerged137;
const spreadCheck137: SpreadResult137 = spreadMerged137;

interface SpreadInput138 extends SpreadBase {
    value138: number;
    nested138: { readonly id: number; name: string };
}

declare const spreadInput138: SpreadInput138;
const spreadMerged138 = {
    ...spreadInput138,
    extra138: spreadInput138.value138,
    nested138: { ...spreadInput138.nested138, name: spreadInput138.common },
};
type SpreadResult138 = typeof spreadMerged138;
const spreadCheck138: SpreadResult138 = spreadMerged138;

interface SpreadInput139 extends SpreadBase {
    value139: number;
    nested139: { readonly id: number; name: string };
}

declare const spreadInput139: SpreadInput139;
const spreadMerged139 = {
    ...spreadInput139,
    extra139: spreadInput139.value139,
    nested139: { ...spreadInput139.nested139, name: spreadInput139.common },
};
type SpreadResult139 = typeof spreadMerged139;
const spreadCheck139: SpreadResult139 = spreadMerged139;

interface SpreadInput140 extends SpreadBase {
    value140: number;
    nested140: { readonly id: number; name: string };
}

declare const spreadInput140: SpreadInput140;
const spreadMerged140 = {
    ...spreadInput140,
    extra140: spreadInput140.value140,
    nested140: { ...spreadInput140.nested140, name: spreadInput140.common },
};
type SpreadResult140 = typeof spreadMerged140;
const spreadCheck140: SpreadResult140 = spreadMerged140;

interface SpreadInput141 extends SpreadBase {
    value141: number;
    nested141: { readonly id: number; name: string };
}

declare const spreadInput141: SpreadInput141;
const spreadMerged141 = {
    ...spreadInput141,
    extra141: spreadInput141.value141,
    nested141: { ...spreadInput141.nested141, name: spreadInput141.common },
};
type SpreadResult141 = typeof spreadMerged141;
const spreadCheck141: SpreadResult141 = spreadMerged141;

interface SpreadInput142 extends SpreadBase {
    value142: number;
    nested142: { readonly id: number; name: string };
}

declare const spreadInput142: SpreadInput142;
const spreadMerged142 = {
    ...spreadInput142,
    extra142: spreadInput142.value142,
    nested142: { ...spreadInput142.nested142, name: spreadInput142.common },
};
type SpreadResult142 = typeof spreadMerged142;
const spreadCheck142: SpreadResult142 = spreadMerged142;

interface SpreadInput143 extends SpreadBase {
    value143: number;
    nested143: { readonly id: number; name: string };
}

declare const spreadInput143: SpreadInput143;
const spreadMerged143 = {
    ...spreadInput143,
    extra143: spreadInput143.value143,
    nested143: { ...spreadInput143.nested143, name: spreadInput143.common },
};
type SpreadResult143 = typeof spreadMerged143;
const spreadCheck143: SpreadResult143 = spreadMerged143;

interface SpreadInput144 extends SpreadBase {
    value144: number;
    nested144: { readonly id: number; name: string };
}

declare const spreadInput144: SpreadInput144;
const spreadMerged144 = {
    ...spreadInput144,
    extra144: spreadInput144.value144,
    nested144: { ...spreadInput144.nested144, name: spreadInput144.common },
};
type SpreadResult144 = typeof spreadMerged144;
const spreadCheck144: SpreadResult144 = spreadMerged144;

interface SpreadInput145 extends SpreadBase {
    value145: number;
    nested145: { readonly id: number; name: string };
}

declare const spreadInput145: SpreadInput145;
const spreadMerged145 = {
    ...spreadInput145,
    extra145: spreadInput145.value145,
    nested145: { ...spreadInput145.nested145, name: spreadInput145.common },
};
type SpreadResult145 = typeof spreadMerged145;
const spreadCheck145: SpreadResult145 = spreadMerged145;

interface SpreadInput146 extends SpreadBase {
    value146: number;
    nested146: { readonly id: number; name: string };
}

declare const spreadInput146: SpreadInput146;
const spreadMerged146 = {
    ...spreadInput146,
    extra146: spreadInput146.value146,
    nested146: { ...spreadInput146.nested146, name: spreadInput146.common },
};
type SpreadResult146 = typeof spreadMerged146;
const spreadCheck146: SpreadResult146 = spreadMerged146;

interface SpreadInput147 extends SpreadBase {
    value147: number;
    nested147: { readonly id: number; name: string };
}

declare const spreadInput147: SpreadInput147;
const spreadMerged147 = {
    ...spreadInput147,
    extra147: spreadInput147.value147,
    nested147: { ...spreadInput147.nested147, name: spreadInput147.common },
};
type SpreadResult147 = typeof spreadMerged147;
const spreadCheck147: SpreadResult147 = spreadMerged147;

interface SpreadInput148 extends SpreadBase {
    value148: number;
    nested148: { readonly id: number; name: string };
}

declare const spreadInput148: SpreadInput148;
const spreadMerged148 = {
    ...spreadInput148,
    extra148: spreadInput148.value148,
    nested148: { ...spreadInput148.nested148, name: spreadInput148.common },
};
type SpreadResult148 = typeof spreadMerged148;
const spreadCheck148: SpreadResult148 = spreadMerged148;

interface SpreadInput149 extends SpreadBase {
    value149: number;
    nested149: { readonly id: number; name: string };
}

declare const spreadInput149: SpreadInput149;
const spreadMerged149 = {
    ...spreadInput149,
    extra149: spreadInput149.value149,
    nested149: { ...spreadInput149.nested149, name: spreadInput149.common },
};
type SpreadResult149 = typeof spreadMerged149;
const spreadCheck149: SpreadResult149 = spreadMerged149;

interface SpreadInput150 extends SpreadBase {
    value150: number;
    nested150: { readonly id: number; name: string };
}

declare const spreadInput150: SpreadInput150;
const spreadMerged150 = {
    ...spreadInput150,
    extra150: spreadInput150.value150,
    nested150: { ...spreadInput150.nested150, name: spreadInput150.common },
};
type SpreadResult150 = typeof spreadMerged150;
const spreadCheck150: SpreadResult150 = spreadMerged150;

interface SpreadInput151 extends SpreadBase {
    value151: number;
    nested151: { readonly id: number; name: string };
}

declare const spreadInput151: SpreadInput151;
const spreadMerged151 = {
    ...spreadInput151,
    extra151: spreadInput151.value151,
    nested151: { ...spreadInput151.nested151, name: spreadInput151.common },
};
type SpreadResult151 = typeof spreadMerged151;
const spreadCheck151: SpreadResult151 = spreadMerged151;

interface SpreadInput152 extends SpreadBase {
    value152: number;
    nested152: { readonly id: number; name: string };
}

declare const spreadInput152: SpreadInput152;
const spreadMerged152 = {
    ...spreadInput152,
    extra152: spreadInput152.value152,
    nested152: { ...spreadInput152.nested152, name: spreadInput152.common },
};
type SpreadResult152 = typeof spreadMerged152;
const spreadCheck152: SpreadResult152 = spreadMerged152;

interface SpreadInput153 extends SpreadBase {
    value153: number;
    nested153: { readonly id: number; name: string };
}

declare const spreadInput153: SpreadInput153;
const spreadMerged153 = {
    ...spreadInput153,
    extra153: spreadInput153.value153,
    nested153: { ...spreadInput153.nested153, name: spreadInput153.common },
};
type SpreadResult153 = typeof spreadMerged153;
const spreadCheck153: SpreadResult153 = spreadMerged153;

interface SpreadInput154 extends SpreadBase {
    value154: number;
    nested154: { readonly id: number; name: string };
}

declare const spreadInput154: SpreadInput154;
const spreadMerged154 = {
    ...spreadInput154,
    extra154: spreadInput154.value154,
    nested154: { ...spreadInput154.nested154, name: spreadInput154.common },
};
type SpreadResult154 = typeof spreadMerged154;
const spreadCheck154: SpreadResult154 = spreadMerged154;

interface SpreadInput155 extends SpreadBase {
    value155: number;
    nested155: { readonly id: number; name: string };
}

declare const spreadInput155: SpreadInput155;
const spreadMerged155 = {
    ...spreadInput155,
    extra155: spreadInput155.value155,
    nested155: { ...spreadInput155.nested155, name: spreadInput155.common },
};
type SpreadResult155 = typeof spreadMerged155;
const spreadCheck155: SpreadResult155 = spreadMerged155;

interface SpreadInput156 extends SpreadBase {
    value156: number;
    nested156: { readonly id: number; name: string };
}

declare const spreadInput156: SpreadInput156;
const spreadMerged156 = {
    ...spreadInput156,
    extra156: spreadInput156.value156,
    nested156: { ...spreadInput156.nested156, name: spreadInput156.common },
};
type SpreadResult156 = typeof spreadMerged156;
const spreadCheck156: SpreadResult156 = spreadMerged156;

interface SpreadInput157 extends SpreadBase {
    value157: number;
    nested157: { readonly id: number; name: string };
}

declare const spreadInput157: SpreadInput157;
const spreadMerged157 = {
    ...spreadInput157,
    extra157: spreadInput157.value157,
    nested157: { ...spreadInput157.nested157, name: spreadInput157.common },
};
type SpreadResult157 = typeof spreadMerged157;
const spreadCheck157: SpreadResult157 = spreadMerged157;

interface SpreadInput158 extends SpreadBase {
    value158: number;
    nested158: { readonly id: number; name: string };
}

declare const spreadInput158: SpreadInput158;
const spreadMerged158 = {
    ...spreadInput158,
    extra158: spreadInput158.value158,
    nested158: { ...spreadInput158.nested158, name: spreadInput158.common },
};
type SpreadResult158 = typeof spreadMerged158;
const spreadCheck158: SpreadResult158 = spreadMerged158;

interface SpreadInput159 extends SpreadBase {
    value159: number;
    nested159: { readonly id: number; name: string };
}

declare const spreadInput159: SpreadInput159;
const spreadMerged159 = {
    ...spreadInput159,
    extra159: spreadInput159.value159,
    nested159: { ...spreadInput159.nested159, name: spreadInput159.common },
};
type SpreadResult159 = typeof spreadMerged159;
const spreadCheck159: SpreadResult159 = spreadMerged159;

interface SpreadInput160 extends SpreadBase {
    value160: number;
    nested160: { readonly id: number; name: string };
}

declare const spreadInput160: SpreadInput160;
const spreadMerged160 = {
    ...spreadInput160,
    extra160: spreadInput160.value160,
    nested160: { ...spreadInput160.nested160, name: spreadInput160.common },
};
type SpreadResult160 = typeof spreadMerged160;
const spreadCheck160: SpreadResult160 = spreadMerged160;

interface SpreadInput161 extends SpreadBase {
    value161: number;
    nested161: { readonly id: number; name: string };
}

declare const spreadInput161: SpreadInput161;
const spreadMerged161 = {
    ...spreadInput161,
    extra161: spreadInput161.value161,
    nested161: { ...spreadInput161.nested161, name: spreadInput161.common },
};
type SpreadResult161 = typeof spreadMerged161;
const spreadCheck161: SpreadResult161 = spreadMerged161;

interface SpreadInput162 extends SpreadBase {
    value162: number;
    nested162: { readonly id: number; name: string };
}

declare const spreadInput162: SpreadInput162;
const spreadMerged162 = {
    ...spreadInput162,
    extra162: spreadInput162.value162,
    nested162: { ...spreadInput162.nested162, name: spreadInput162.common },
};
type SpreadResult162 = typeof spreadMerged162;
const spreadCheck162: SpreadResult162 = spreadMerged162;

interface SpreadInput163 extends SpreadBase {
    value163: number;
    nested163: { readonly id: number; name: string };
}

declare const spreadInput163: SpreadInput163;
const spreadMerged163 = {
    ...spreadInput163,
    extra163: spreadInput163.value163,
    nested163: { ...spreadInput163.nested163, name: spreadInput163.common },
};
type SpreadResult163 = typeof spreadMerged163;
const spreadCheck163: SpreadResult163 = spreadMerged163;

interface SpreadInput164 extends SpreadBase {
    value164: number;
    nested164: { readonly id: number; name: string };
}

declare const spreadInput164: SpreadInput164;
const spreadMerged164 = {
    ...spreadInput164,
    extra164: spreadInput164.value164,
    nested164: { ...spreadInput164.nested164, name: spreadInput164.common },
};
type SpreadResult164 = typeof spreadMerged164;
const spreadCheck164: SpreadResult164 = spreadMerged164;

interface SpreadInput165 extends SpreadBase {
    value165: number;
    nested165: { readonly id: number; name: string };
}

declare const spreadInput165: SpreadInput165;
const spreadMerged165 = {
    ...spreadInput165,
    extra165: spreadInput165.value165,
    nested165: { ...spreadInput165.nested165, name: spreadInput165.common },
};
type SpreadResult165 = typeof spreadMerged165;
const spreadCheck165: SpreadResult165 = spreadMerged165;

interface SpreadInput166 extends SpreadBase {
    value166: number;
    nested166: { readonly id: number; name: string };
}

declare const spreadInput166: SpreadInput166;
const spreadMerged166 = {
    ...spreadInput166,
    extra166: spreadInput166.value166,
    nested166: { ...spreadInput166.nested166, name: spreadInput166.common },
};
type SpreadResult166 = typeof spreadMerged166;
const spreadCheck166: SpreadResult166 = spreadMerged166;

interface SpreadInput167 extends SpreadBase {
    value167: number;
    nested167: { readonly id: number; name: string };
}

declare const spreadInput167: SpreadInput167;
const spreadMerged167 = {
    ...spreadInput167,
    extra167: spreadInput167.value167,
    nested167: { ...spreadInput167.nested167, name: spreadInput167.common },
};
type SpreadResult167 = typeof spreadMerged167;
const spreadCheck167: SpreadResult167 = spreadMerged167;

interface SpreadInput168 extends SpreadBase {
    value168: number;
    nested168: { readonly id: number; name: string };
}

declare const spreadInput168: SpreadInput168;
const spreadMerged168 = {
    ...spreadInput168,
    extra168: spreadInput168.value168,
    nested168: { ...spreadInput168.nested168, name: spreadInput168.common },
};
type SpreadResult168 = typeof spreadMerged168;
const spreadCheck168: SpreadResult168 = spreadMerged168;

interface SpreadInput169 extends SpreadBase {
    value169: number;
    nested169: { readonly id: number; name: string };
}

declare const spreadInput169: SpreadInput169;
const spreadMerged169 = {
    ...spreadInput169,
    extra169: spreadInput169.value169,
    nested169: { ...spreadInput169.nested169, name: spreadInput169.common },
};
type SpreadResult169 = typeof spreadMerged169;
const spreadCheck169: SpreadResult169 = spreadMerged169;

interface SpreadInput170 extends SpreadBase {
    value170: number;
    nested170: { readonly id: number; name: string };
}

declare const spreadInput170: SpreadInput170;
const spreadMerged170 = {
    ...spreadInput170,
    extra170: spreadInput170.value170,
    nested170: { ...spreadInput170.nested170, name: spreadInput170.common },
};
type SpreadResult170 = typeof spreadMerged170;
const spreadCheck170: SpreadResult170 = spreadMerged170;

interface SpreadInput171 extends SpreadBase {
    value171: number;
    nested171: { readonly id: number; name: string };
}

declare const spreadInput171: SpreadInput171;
const spreadMerged171 = {
    ...spreadInput171,
    extra171: spreadInput171.value171,
    nested171: { ...spreadInput171.nested171, name: spreadInput171.common },
};
type SpreadResult171 = typeof spreadMerged171;
const spreadCheck171: SpreadResult171 = spreadMerged171;

interface SpreadInput172 extends SpreadBase {
    value172: number;
    nested172: { readonly id: number; name: string };
}

declare const spreadInput172: SpreadInput172;
const spreadMerged172 = {
    ...spreadInput172,
    extra172: spreadInput172.value172,
    nested172: { ...spreadInput172.nested172, name: spreadInput172.common },
};
type SpreadResult172 = typeof spreadMerged172;
const spreadCheck172: SpreadResult172 = spreadMerged172;

interface SpreadInput173 extends SpreadBase {
    value173: number;
    nested173: { readonly id: number; name: string };
}

declare const spreadInput173: SpreadInput173;
const spreadMerged173 = {
    ...spreadInput173,
    extra173: spreadInput173.value173,
    nested173: { ...spreadInput173.nested173, name: spreadInput173.common },
};
type SpreadResult173 = typeof spreadMerged173;
const spreadCheck173: SpreadResult173 = spreadMerged173;

interface SpreadInput174 extends SpreadBase {
    value174: number;
    nested174: { readonly id: number; name: string };
}

declare const spreadInput174: SpreadInput174;
const spreadMerged174 = {
    ...spreadInput174,
    extra174: spreadInput174.value174,
    nested174: { ...spreadInput174.nested174, name: spreadInput174.common },
};
type SpreadResult174 = typeof spreadMerged174;
const spreadCheck174: SpreadResult174 = spreadMerged174;

interface SpreadInput175 extends SpreadBase {
    value175: number;
    nested175: { readonly id: number; name: string };
}

declare const spreadInput175: SpreadInput175;
const spreadMerged175 = {
    ...spreadInput175,
    extra175: spreadInput175.value175,
    nested175: { ...spreadInput175.nested175, name: spreadInput175.common },
};
type SpreadResult175 = typeof spreadMerged175;
const spreadCheck175: SpreadResult175 = spreadMerged175;

interface SpreadInput176 extends SpreadBase {
    value176: number;
    nested176: { readonly id: number; name: string };
}

declare const spreadInput176: SpreadInput176;
const spreadMerged176 = {
    ...spreadInput176,
    extra176: spreadInput176.value176,
    nested176: { ...spreadInput176.nested176, name: spreadInput176.common },
};
type SpreadResult176 = typeof spreadMerged176;
const spreadCheck176: SpreadResult176 = spreadMerged176;

interface SpreadInput177 extends SpreadBase {
    value177: number;
    nested177: { readonly id: number; name: string };
}

declare const spreadInput177: SpreadInput177;
const spreadMerged177 = {
    ...spreadInput177,
    extra177: spreadInput177.value177,
    nested177: { ...spreadInput177.nested177, name: spreadInput177.common },
};
type SpreadResult177 = typeof spreadMerged177;
const spreadCheck177: SpreadResult177 = spreadMerged177;

interface SpreadInput178 extends SpreadBase {
    value178: number;
    nested178: { readonly id: number; name: string };
}

declare const spreadInput178: SpreadInput178;
const spreadMerged178 = {
    ...spreadInput178,
    extra178: spreadInput178.value178,
    nested178: { ...spreadInput178.nested178, name: spreadInput178.common },
};
type SpreadResult178 = typeof spreadMerged178;
const spreadCheck178: SpreadResult178 = spreadMerged178;

interface SpreadInput179 extends SpreadBase {
    value179: number;
    nested179: { readonly id: number; name: string };
}

declare const spreadInput179: SpreadInput179;
const spreadMerged179 = {
    ...spreadInput179,
    extra179: spreadInput179.value179,
    nested179: { ...spreadInput179.nested179, name: spreadInput179.common },
};
type SpreadResult179 = typeof spreadMerged179;
const spreadCheck179: SpreadResult179 = spreadMerged179;

interface SpreadInput180 extends SpreadBase {
    value180: number;
    nested180: { readonly id: number; name: string };
}

declare const spreadInput180: SpreadInput180;
const spreadMerged180 = {
    ...spreadInput180,
    extra180: spreadInput180.value180,
    nested180: { ...spreadInput180.nested180, name: spreadInput180.common },
};
type SpreadResult180 = typeof spreadMerged180;
const spreadCheck180: SpreadResult180 = spreadMerged180;

interface SpreadInput181 extends SpreadBase {
    value181: number;
    nested181: { readonly id: number; name: string };
}

declare const spreadInput181: SpreadInput181;
const spreadMerged181 = {
    ...spreadInput181,
    extra181: spreadInput181.value181,
    nested181: { ...spreadInput181.nested181, name: spreadInput181.common },
};
type SpreadResult181 = typeof spreadMerged181;
const spreadCheck181: SpreadResult181 = spreadMerged181;

interface SpreadInput182 extends SpreadBase {
    value182: number;
    nested182: { readonly id: number; name: string };
}

declare const spreadInput182: SpreadInput182;
const spreadMerged182 = {
    ...spreadInput182,
    extra182: spreadInput182.value182,
    nested182: { ...spreadInput182.nested182, name: spreadInput182.common },
};
type SpreadResult182 = typeof spreadMerged182;
const spreadCheck182: SpreadResult182 = spreadMerged182;

interface SpreadInput183 extends SpreadBase {
    value183: number;
    nested183: { readonly id: number; name: string };
}

declare const spreadInput183: SpreadInput183;
const spreadMerged183 = {
    ...spreadInput183,
    extra183: spreadInput183.value183,
    nested183: { ...spreadInput183.nested183, name: spreadInput183.common },
};
type SpreadResult183 = typeof spreadMerged183;
const spreadCheck183: SpreadResult183 = spreadMerged183;

interface SpreadInput184 extends SpreadBase {
    value184: number;
    nested184: { readonly id: number; name: string };
}

declare const spreadInput184: SpreadInput184;
const spreadMerged184 = {
    ...spreadInput184,
    extra184: spreadInput184.value184,
    nested184: { ...spreadInput184.nested184, name: spreadInput184.common },
};
type SpreadResult184 = typeof spreadMerged184;
const spreadCheck184: SpreadResult184 = spreadMerged184;

interface SpreadInput185 extends SpreadBase {
    value185: number;
    nested185: { readonly id: number; name: string };
}

declare const spreadInput185: SpreadInput185;
const spreadMerged185 = {
    ...spreadInput185,
    extra185: spreadInput185.value185,
    nested185: { ...spreadInput185.nested185, name: spreadInput185.common },
};
type SpreadResult185 = typeof spreadMerged185;
const spreadCheck185: SpreadResult185 = spreadMerged185;

interface SpreadInput186 extends SpreadBase {
    value186: number;
    nested186: { readonly id: number; name: string };
}

declare const spreadInput186: SpreadInput186;
const spreadMerged186 = {
    ...spreadInput186,
    extra186: spreadInput186.value186,
    nested186: { ...spreadInput186.nested186, name: spreadInput186.common },
};
type SpreadResult186 = typeof spreadMerged186;
const spreadCheck186: SpreadResult186 = spreadMerged186;

interface SpreadInput187 extends SpreadBase {
    value187: number;
    nested187: { readonly id: number; name: string };
}

declare const spreadInput187: SpreadInput187;
const spreadMerged187 = {
    ...spreadInput187,
    extra187: spreadInput187.value187,
    nested187: { ...spreadInput187.nested187, name: spreadInput187.common },
};
type SpreadResult187 = typeof spreadMerged187;
const spreadCheck187: SpreadResult187 = spreadMerged187;

interface SpreadInput188 extends SpreadBase {
    value188: number;
    nested188: { readonly id: number; name: string };
}

declare const spreadInput188: SpreadInput188;
const spreadMerged188 = {
    ...spreadInput188,
    extra188: spreadInput188.value188,
    nested188: { ...spreadInput188.nested188, name: spreadInput188.common },
};
type SpreadResult188 = typeof spreadMerged188;
const spreadCheck188: SpreadResult188 = spreadMerged188;

interface SpreadInput189 extends SpreadBase {
    value189: number;
    nested189: { readonly id: number; name: string };
}

declare const spreadInput189: SpreadInput189;
const spreadMerged189 = {
    ...spreadInput189,
    extra189: spreadInput189.value189,
    nested189: { ...spreadInput189.nested189, name: spreadInput189.common },
};
type SpreadResult189 = typeof spreadMerged189;
const spreadCheck189: SpreadResult189 = spreadMerged189;

interface SpreadInput190 extends SpreadBase {
    value190: number;
    nested190: { readonly id: number; name: string };
}

declare const spreadInput190: SpreadInput190;
const spreadMerged190 = {
    ...spreadInput190,
    extra190: spreadInput190.value190,
    nested190: { ...spreadInput190.nested190, name: spreadInput190.common },
};
type SpreadResult190 = typeof spreadMerged190;
const spreadCheck190: SpreadResult190 = spreadMerged190;

interface SpreadInput191 extends SpreadBase {
    value191: number;
    nested191: { readonly id: number; name: string };
}

declare const spreadInput191: SpreadInput191;
const spreadMerged191 = {
    ...spreadInput191,
    extra191: spreadInput191.value191,
    nested191: { ...spreadInput191.nested191, name: spreadInput191.common },
};
type SpreadResult191 = typeof spreadMerged191;
const spreadCheck191: SpreadResult191 = spreadMerged191;

interface SpreadInput192 extends SpreadBase {
    value192: number;
    nested192: { readonly id: number; name: string };
}

declare const spreadInput192: SpreadInput192;
const spreadMerged192 = {
    ...spreadInput192,
    extra192: spreadInput192.value192,
    nested192: { ...spreadInput192.nested192, name: spreadInput192.common },
};
type SpreadResult192 = typeof spreadMerged192;
const spreadCheck192: SpreadResult192 = spreadMerged192;

interface SpreadInput193 extends SpreadBase {
    value193: number;
    nested193: { readonly id: number; name: string };
}

declare const spreadInput193: SpreadInput193;
const spreadMerged193 = {
    ...spreadInput193,
    extra193: spreadInput193.value193,
    nested193: { ...spreadInput193.nested193, name: spreadInput193.common },
};
type SpreadResult193 = typeof spreadMerged193;
const spreadCheck193: SpreadResult193 = spreadMerged193;

interface SpreadInput194 extends SpreadBase {
    value194: number;
    nested194: { readonly id: number; name: string };
}

declare const spreadInput194: SpreadInput194;
const spreadMerged194 = {
    ...spreadInput194,
    extra194: spreadInput194.value194,
    nested194: { ...spreadInput194.nested194, name: spreadInput194.common },
};
type SpreadResult194 = typeof spreadMerged194;
const spreadCheck194: SpreadResult194 = spreadMerged194;

interface SpreadInput195 extends SpreadBase {
    value195: number;
    nested195: { readonly id: number; name: string };
}

declare const spreadInput195: SpreadInput195;
const spreadMerged195 = {
    ...spreadInput195,
    extra195: spreadInput195.value195,
    nested195: { ...spreadInput195.nested195, name: spreadInput195.common },
};
type SpreadResult195 = typeof spreadMerged195;
const spreadCheck195: SpreadResult195 = spreadMerged195;

interface SpreadInput196 extends SpreadBase {
    value196: number;
    nested196: { readonly id: number; name: string };
}

declare const spreadInput196: SpreadInput196;
const spreadMerged196 = {
    ...spreadInput196,
    extra196: spreadInput196.value196,
    nested196: { ...spreadInput196.nested196, name: spreadInput196.common },
};
type SpreadResult196 = typeof spreadMerged196;
const spreadCheck196: SpreadResult196 = spreadMerged196;

interface SpreadInput197 extends SpreadBase {
    value197: number;
    nested197: { readonly id: number; name: string };
}

declare const spreadInput197: SpreadInput197;
const spreadMerged197 = {
    ...spreadInput197,
    extra197: spreadInput197.value197,
    nested197: { ...spreadInput197.nested197, name: spreadInput197.common },
};
type SpreadResult197 = typeof spreadMerged197;
const spreadCheck197: SpreadResult197 = spreadMerged197;

interface SpreadInput198 extends SpreadBase {
    value198: number;
    nested198: { readonly id: number; name: string };
}

declare const spreadInput198: SpreadInput198;
const spreadMerged198 = {
    ...spreadInput198,
    extra198: spreadInput198.value198,
    nested198: { ...spreadInput198.nested198, name: spreadInput198.common },
};
type SpreadResult198 = typeof spreadMerged198;
const spreadCheck198: SpreadResult198 = spreadMerged198;

interface SpreadInput199 extends SpreadBase {
    value199: number;
    nested199: { readonly id: number; name: string };
}

declare const spreadInput199: SpreadInput199;
const spreadMerged199 = {
    ...spreadInput199,
    extra199: spreadInput199.value199,
    nested199: { ...spreadInput199.nested199, name: spreadInput199.common },
};
type SpreadResult199 = typeof spreadMerged199;
const spreadCheck199: SpreadResult199 = spreadMerged199;