Object spread hotspot N=50

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