diff --git a/redfish/internal/controller/http/v1/generated/server.gen.go b/redfish/internal/controller/http/v1/generated/server.gen.go
index 2dfe6a97..101e29ec 100644
--- a/redfish/internal/controller/http/v1/generated/server.gen.go
+++ b/redfish/internal/controller/http/v1/generated/server.gen.go
@@ -66,15 +66,24 @@ type ServerInterface interface {
 	// (POST /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.CancelKVMConsent)
 	PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelKVMConsent(c *gin.Context, computerSystemId string)
 
+	// (POST /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.CancelSolConsent)
+	PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent(c *gin.Context, computerSystemId string)
+
 	// (POST /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.GenerateRedirectionToken)
 	PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionToken(c *gin.Context, computerSystemId string)
 
 	// (POST /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.RequestKVMConsent)
 	PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestKVMConsent(c *gin.Context, computerSystemId string)
 
+	// (POST /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.RequestSolConsent)
+	PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent(c *gin.Context, computerSystemId string)
+
 	// (POST /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.SubmitKVMConsentCode)
 	PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCode(c *gin.Context, computerSystemId string)
 
+	// (POST /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.SubmitSolConsentCode)
+	PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode(c *gin.Context, computerSystemId string)
+
 	// (GET /redfish/v1/odata)
 	GetRedfishV1Odata(c *gin.Context)
 }
@@ -384,6 +393,32 @@ func (siw *ServerInterfaceWrapper) PostRedfishV1SystemsComputerSystemIdActionsOe
 	siw.Handler.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelKVMConsent(c, computerSystemId)
 }
 
+// PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent operation middleware
+func (siw *ServerInterfaceWrapper) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent(c *gin.Context) {
+
+	var err error
+
+	// ------------- Path parameter "ComputerSystemId" -------------
+	var computerSystemId string
+
+	err = runtime.BindStyledParameterWithOptions("simple", "ComputerSystemId", c.Param("ComputerSystemId"), &computerSystemId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
+	if err != nil {
+		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter ComputerSystemId: %w", err), http.StatusBadRequest)
+		return
+	}
+
+	c.Set(BasicAuthScopes, []string{})
+
+	for _, middleware := range siw.HandlerMiddlewares {
+		middleware(c)
+		if c.IsAborted() {
+			return
+		}
+	}
+
+	siw.Handler.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent(c, computerSystemId)
+}
+
 // PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionToken operation middleware
 func (siw *ServerInterfaceWrapper) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionToken(c *gin.Context) {
 
@@ -436,6 +471,32 @@ func (siw *ServerInterfaceWrapper) PostRedfishV1SystemsComputerSystemIdActionsOe
 	siw.Handler.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestKVMConsent(c, computerSystemId)
 }
 
+// PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent operation middleware
+func (siw *ServerInterfaceWrapper) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent(c *gin.Context) {
+
+	var err error
+
+	// ------------- Path parameter "ComputerSystemId" -------------
+	var computerSystemId string
+
+	err = runtime.BindStyledParameterWithOptions("simple", "ComputerSystemId", c.Param("ComputerSystemId"), &computerSystemId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
+	if err != nil {
+		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter ComputerSystemId: %w", err), http.StatusBadRequest)
+		return
+	}
+
+	c.Set(BasicAuthScopes, []string{})
+
+	for _, middleware := range siw.HandlerMiddlewares {
+		middleware(c)
+		if c.IsAborted() {
+			return
+		}
+	}
+
+	siw.Handler.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent(c, computerSystemId)
+}
+
 // PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCode operation middleware
 func (siw *ServerInterfaceWrapper) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCode(c *gin.Context) {
 
@@ -462,6 +523,32 @@ func (siw *ServerInterfaceWrapper) PostRedfishV1SystemsComputerSystemIdActionsOe
 	siw.Handler.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCode(c, computerSystemId)
 }
 
+// PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode operation middleware
+func (siw *ServerInterfaceWrapper) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode(c *gin.Context) {
+
+	var err error
+
+	// ------------- Path parameter "ComputerSystemId" -------------
+	var computerSystemId string
+
+	err = runtime.BindStyledParameterWithOptions("simple", "ComputerSystemId", c.Param("ComputerSystemId"), &computerSystemId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
+	if err != nil {
+		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter ComputerSystemId: %w", err), http.StatusBadRequest)
+		return
+	}
+
+	c.Set(BasicAuthScopes, []string{})
+
+	for _, middleware := range siw.HandlerMiddlewares {
+		middleware(c)
+		if c.IsAborted() {
+			return
+		}
+	}
+
+	siw.Handler.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode(c, computerSystemId)
+}
+
 // GetRedfishV1Odata operation middleware
 func (siw *ServerInterfaceWrapper) GetRedfishV1Odata(c *gin.Context) {
 
@@ -518,9 +605,12 @@ func RegisterHandlersWithOptions(router gin.IRouter, si ServerInterface, options
 	router.PATCH(options.BaseURL+"/redfish/v1/Systems/:ComputerSystemId", wrapper.PatchRedfishV1SystemsComputerSystemId)
 	router.POST(options.BaseURL+"/redfish/v1/Systems/:ComputerSystemId/Actions/ComputerSystem.Reset", wrapper.PostRedfishV1SystemsComputerSystemIdActionsComputerSystemReset)
 	router.POST(options.BaseURL+"/redfish/v1/Systems/:ComputerSystemId/Actions/Oem/IntelComputerSystem.CancelKVMConsent", wrapper.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelKVMConsent)
+	router.POST(options.BaseURL+"/redfish/v1/Systems/:ComputerSystemId/Actions/Oem/IntelComputerSystem.CancelSolConsent", wrapper.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent)
 	router.POST(options.BaseURL+"/redfish/v1/Systems/:ComputerSystemId/Actions/Oem/IntelComputerSystem.GenerateRedirectionToken", wrapper.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionToken)
 	router.POST(options.BaseURL+"/redfish/v1/Systems/:ComputerSystemId/Actions/Oem/IntelComputerSystem.RequestKVMConsent", wrapper.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestKVMConsent)
+	router.POST(options.BaseURL+"/redfish/v1/Systems/:ComputerSystemId/Actions/Oem/IntelComputerSystem.RequestSolConsent", wrapper.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent)
 	router.POST(options.BaseURL+"/redfish/v1/Systems/:ComputerSystemId/Actions/Oem/IntelComputerSystem.SubmitKVMConsentCode", wrapper.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCode)
+	router.POST(options.BaseURL+"/redfish/v1/Systems/:ComputerSystemId/Actions/Oem/IntelComputerSystem.SubmitSolConsentCode", wrapper.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode)
 	router.GET(options.BaseURL+"/redfish/v1/odata", wrapper.GetRedfishV1Odata)
 }
 
@@ -1043,6 +1133,36 @@ func (response PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystem
 	return json.NewEncoder(w).Encode(response.Body)
 }
 
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentRequestObject struct {
+	ComputerSystemId string `json:"ComputerSystemId"`
+	Body             *PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentJSONRequestBody
+}
+
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentResponseObject interface {
+	VisitPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentResponse(w http.ResponseWriter) error
+}
+
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent200JSONResponse RedfishError
+
+func (response PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent200JSONResponse) VisitPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentResponse(w http.ResponseWriter) error {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(200)
+
+	return json.NewEncoder(w).Encode(response)
+}
+
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentdefaultJSONResponse struct {
+	Body       RedfishError
+	StatusCode int
+}
+
+func (response PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentdefaultJSONResponse) VisitPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentResponse(w http.ResponseWriter) error {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(response.StatusCode)
+
+	return json.NewEncoder(w).Encode(response.Body)
+}
+
 type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionTokenRequestObject struct {
 	ComputerSystemId string `json:"ComputerSystemId"`
 	Body             *PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionTokenJSONRequestBody
@@ -1103,6 +1223,36 @@ func (response PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystem
 	return json.NewEncoder(w).Encode(response.Body)
 }
 
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentRequestObject struct {
+	ComputerSystemId string `json:"ComputerSystemId"`
+	Body             *PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentJSONRequestBody
+}
+
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentResponseObject interface {
+	VisitPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentResponse(w http.ResponseWriter) error
+}
+
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent200JSONResponse RedfishError
+
+func (response PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent200JSONResponse) VisitPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentResponse(w http.ResponseWriter) error {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(200)
+
+	return json.NewEncoder(w).Encode(response)
+}
+
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentdefaultJSONResponse struct {
+	Body       RedfishError
+	StatusCode int
+}
+
+func (response PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentdefaultJSONResponse) VisitPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentResponse(w http.ResponseWriter) error {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(response.StatusCode)
+
+	return json.NewEncoder(w).Encode(response.Body)
+}
+
 type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCodeRequestObject struct {
 	ComputerSystemId string `json:"ComputerSystemId"`
 	Body             *PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCodeJSONRequestBody
@@ -1133,6 +1283,36 @@ func (response PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystem
 	return json.NewEncoder(w).Encode(response.Body)
 }
 
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeRequestObject struct {
+	ComputerSystemId string `json:"ComputerSystemId"`
+	Body             *PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeJSONRequestBody
+}
+
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeResponseObject interface {
+	VisitPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeResponse(w http.ResponseWriter) error
+}
+
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode200JSONResponse RedfishError
+
+func (response PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode200JSONResponse) VisitPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeResponse(w http.ResponseWriter) error {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(200)
+
+	return json.NewEncoder(w).Encode(response)
+}
+
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodedefaultJSONResponse struct {
+	Body       RedfishError
+	StatusCode int
+}
+
+func (response PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodedefaultJSONResponse) VisitPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeResponse(w http.ResponseWriter) error {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(response.StatusCode)
+
+	return json.NewEncoder(w).Encode(response.Body)
+}
+
 type GetRedfishV1OdataRequestObject struct {
 }
 
@@ -1227,15 +1407,24 @@ type StrictServerInterface interface {
 	// (POST /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.CancelKVMConsent)
 	PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelKVMConsent(ctx context.Context, request PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelKVMConsentRequestObject) (PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelKVMConsentResponseObject, error)
 
+	// (POST /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.CancelSolConsent)
+	PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent(ctx context.Context, request PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentRequestObject) (PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentResponseObject, error)
+
 	// (POST /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.GenerateRedirectionToken)
 	PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionToken(ctx context.Context, request PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionTokenRequestObject) (PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionTokenResponseObject, error)
 
 	// (POST /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.RequestKVMConsent)
 	PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestKVMConsent(ctx context.Context, request PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestKVMConsentRequestObject) (PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestKVMConsentResponseObject, error)
 
+	// (POST /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.RequestSolConsent)
+	PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent(ctx context.Context, request PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentRequestObject) (PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentResponseObject, error)
+
 	// (POST /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.SubmitKVMConsentCode)
 	PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCode(ctx context.Context, request PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCodeRequestObject) (PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCodeResponseObject, error)
 
+	// (POST /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.SubmitSolConsentCode)
+	PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode(ctx context.Context, request PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeRequestObject) (PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeResponseObject, error)
+
 	// (GET /redfish/v1/odata)
 	GetRedfishV1Odata(ctx context.Context, request GetRedfishV1OdataRequestObject) (GetRedfishV1OdataResponseObject, error)
 }
@@ -1720,6 +1909,41 @@ func (sh *strictHandler) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComp
 	}
 }
 
+// PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent operation middleware
+func (sh *strictHandler) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent(ctx *gin.Context, computerSystemId string) {
+	var request PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentRequestObject
+
+	request.ComputerSystemId = computerSystemId
+
+	var body PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentJSONRequestBody
+	if err := ctx.ShouldBindJSON(&body); err != nil {
+		ctx.Status(http.StatusBadRequest)
+		ctx.Error(err)
+		return
+	}
+	request.Body = &body
+
+	handler := func(ctx *gin.Context, request interface{}) (interface{}, error) {
+		return sh.ssi.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent(ctx, request.(PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentRequestObject))
+	}
+	for _, middleware := range sh.middlewares {
+		handler = middleware(handler, "PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent")
+	}
+
+	response, err := handler(ctx, request)
+
+	if err != nil {
+		ctx.Error(err)
+		ctx.Status(http.StatusInternalServerError)
+	} else if validResponse, ok := response.(PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentResponseObject); ok {
+		if err := validResponse.VisitPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentResponse(ctx.Writer); err != nil {
+			ctx.Error(err)
+		}
+	} else if response != nil {
+		ctx.Error(fmt.Errorf("unexpected response type: %T", response))
+	}
+}
+
 // PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionToken operation middleware
 func (sh *strictHandler) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionToken(ctx *gin.Context, computerSystemId string) {
 	var request PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionTokenRequestObject
@@ -1790,6 +2014,41 @@ func (sh *strictHandler) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComp
 	}
 }
 
+// PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent operation middleware
+func (sh *strictHandler) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent(ctx *gin.Context, computerSystemId string) {
+	var request PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentRequestObject
+
+	request.ComputerSystemId = computerSystemId
+
+	var body PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentJSONRequestBody
+	if err := ctx.ShouldBindJSON(&body); err != nil {
+		ctx.Status(http.StatusBadRequest)
+		ctx.Error(err)
+		return
+	}
+	request.Body = &body
+
+	handler := func(ctx *gin.Context, request interface{}) (interface{}, error) {
+		return sh.ssi.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent(ctx, request.(PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentRequestObject))
+	}
+	for _, middleware := range sh.middlewares {
+		handler = middleware(handler, "PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent")
+	}
+
+	response, err := handler(ctx, request)
+
+	if err != nil {
+		ctx.Error(err)
+		ctx.Status(http.StatusInternalServerError)
+	} else if validResponse, ok := response.(PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentResponseObject); ok {
+		if err := validResponse.VisitPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentResponse(ctx.Writer); err != nil {
+			ctx.Error(err)
+		}
+	} else if response != nil {
+		ctx.Error(fmt.Errorf("unexpected response type: %T", response))
+	}
+}
+
 // PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCode operation middleware
 func (sh *strictHandler) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCode(ctx *gin.Context, computerSystemId string) {
 	var request PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCodeRequestObject
@@ -1825,6 +2084,41 @@ func (sh *strictHandler) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComp
 	}
 }
 
+// PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode operation middleware
+func (sh *strictHandler) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode(ctx *gin.Context, computerSystemId string) {
+	var request PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeRequestObject
+
+	request.ComputerSystemId = computerSystemId
+
+	var body PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeJSONRequestBody
+	if err := ctx.ShouldBindJSON(&body); err != nil {
+		ctx.Status(http.StatusBadRequest)
+		ctx.Error(err)
+		return
+	}
+	request.Body = &body
+
+	handler := func(ctx *gin.Context, request interface{}) (interface{}, error) {
+		return sh.ssi.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode(ctx, request.(PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeRequestObject))
+	}
+	for _, middleware := range sh.middlewares {
+		handler = middleware(handler, "PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode")
+	}
+
+	response, err := handler(ctx, request)
+
+	if err != nil {
+		ctx.Error(err)
+		ctx.Status(http.StatusInternalServerError)
+	} else if validResponse, ok := response.(PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeResponseObject); ok {
+		if err := validResponse.VisitPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeResponse(ctx.Writer); err != nil {
+			ctx.Error(err)
+		}
+	} else if response != nil {
+		ctx.Error(fmt.Errorf("unexpected response type: %T", response))
+	}
+}
+
 // GetRedfishV1Odata operation middleware
 func (sh *strictHandler) GetRedfishV1Odata(ctx *gin.Context) {
 	var request GetRedfishV1OdataRequestObject
diff --git a/redfish/internal/controller/http/v1/generated/spec.gen.go b/redfish/internal/controller/http/v1/generated/spec.gen.go
index fd334a27..c2633c8c 100644
--- a/redfish/internal/controller/http/v1/generated/spec.gen.go
+++ b/redfish/internal/controller/http/v1/generated/spec.gen.go
@@ -18,279 +18,298 @@ import (
 // Base64 encoded, gzipped, json marshaled Swagger object
 var swaggerSpec = []string{
 
-	"H4sIAAAAAAAC/+x9a3cbN5LoX8HhzjlJ7lKMnWSyE325o8h2onVk6UqyZ89mMibYDZJYNwEOgJbMyeq/",
-	"34MqvPpFNilKjmV/SWQ2HoVCoVBVqMfvg0wullIwYfTg8PeBzuZsQeHPo8xwKU7EVL49p4oumGHqarVk",
-	"8JGJcjE4/HXwo5QFo2IwHLwqFxOmwh9HStHVYDi4NIqLWfjD/3w2+R+WmfAH/vzbcGBWSzY4HGjf6/2B",
-	"nekZ05niSwsPzO5nPRwckQn+PYog2F8F/DmqgXM4OBKE2j+JnLo2ehTBge9sMWF5znLyn5dnr4iEL6Ma",
-	"pNWBkoYwmluzhQMXMqqtv9od2+jR4PZ22Ip1WDPNc24/0eJcySVThtudmNJCs+EgjwgaHA6u5oxwMZVq",
-	"Qe0vhE5kaQglSz8g4SIrSrtGLgglFyyfcj0nFOYmU6mImXNNFNOyVBmz4C+TSX8fHBWFvKGTgiF24bcm",
-	"DNS3sqhmimfkmhYl00QqkpcKgcOfhgiS5teMKCpmttE0fKPCQpoptmDC0IJow5Z+rABtXB3VhC6XBWc5",
-	"MRI/uqUZqmYMdpMbtgCwRVkUFsbBoVElq1Pg7XCgGM3PRLGqNaCOkt8fFFLMntUWb+FBjK2IntOiIFzk",
-	"PKOGEbMGMw+KhqFtkbMpF0gIFrAvws6mA7uTAgD4jdNfkKygpWYWQtvVU9HlkmV8atfKpRgR8kIqpHU9",
-	"dBBWEaPYUjHNhKlhJpmf0WzuzsuCwcEmpA3HUhQrMmHED+hgBwQHvAD54famP5o5NUQD7CtCwzJHsMXX",
-	"TGkuxZHlC4PDwfXTt9++fWKJI6DrnBrDlNh0EJbYbFeqrRNrB20m7LMfcWZSGAq8QLFZWVBF2HuLRA3T",
-	"W8zgoiZMd+/Stuv54KTRIIK+m/3Gzl+/lKrbnn61J6QHxj4IW/I7bxGc7wCzxXatJw5Ml0tGlecrmi6Y",
-	"v/FUjtRhfx9XcarHAb6tyaMX9E1y6djy79q2fOM99zjupD/emYatsD9c8n+xU/qeL6z42bYXC/zoriyg",
-	"AxiIFXBrapyR5R3nD4WmweGAC/P9d/05LheGzUD83eXgbQQaWDBAq5m65hkjulwupTKdZ7I5oZCmcTdK",
-	"cYAzbeaB37gDEXaBizW7gB+7F6TYP0uu/mjb0Bvqyaq6Gw+8Cc+ooVew4jbkgzoS5rWY6cCyFOxsOjj8",
-	"9ffBnxSbDg4H//Z11Aa/dqrg19164O0wKIJ2f367/a25MbvsQ88FWESwKS0LA8y5HRk5tkD20oGH+5aq",
-	"TA84CEcpOiu4JYxcMg3EslTymufIobckLj4l4wtHsWMPjCZju6jxiJCTKRl7ShrHGT3UY9RYx0O8wD3f",
-	"8Su7ZgpZOK7ISEIFuXhx/Jdv/vzDgdcqYCejDtxG0n9GknZMfc1OeibpOB/L97GnwlstOvfUsRQS1KA+",
-	"jNzhpJNrb31PVgfeRvDt4Dgty9rIfZ66rUI2uW6rHCP9Q2+Vg3H/W1UZ+MNu1Su66NgiYQVyp7lHJhQ2",
-	"CKU6O/p9MMP2ydcZpYDbv5Lr+f2JE2eDvMQUI9xytX1eA5Ng8txBzN4WLCQ+9p4ulgUbWpZeaqYAf1Tk",
-	"ZEm1vpEqTw0ZVDEil2gqRN5NJ5qJrIlxHSADYDLFciYMpwUOUmqW7+GmsXRrG6R7NyYwJvTecDGg2XW9",
-	"xJNTQ1FOsDKbcLbYgwnVLH+Yq96bRwDBFolecIGbEAy3lqzHf5UW1pGBKxelXLftm6/3CauKzck+3nAz",
-	"J7SKhzFiDvA/TozXYzQkdrKc+rDSEmwcWsNR9Lvd3I8j4anKrllOyc2cwQi1w55I00YSK3cWDI5IH+5z",
-	"hzN4B3BuQfP2C/8VuWt8tJD+TWNblrhvW/37A2dmPK8Y7f/x5a/04F9HB//99jf3x5ODH97+9n+++r9/",
-	"/RLI8n/d4P97yrSmM/bV3/8+au/yp7Zz2FxgNKde04LnBGax9OhXEYw9g1uL3GO5WJaGqcuVNmxxLIuC",
-	"wTLfdn3Y4WEkC53hkFRHHgc8Ei60oSJjuvn64Q6x3T723thf1ulP0Pjg+ru3vv3t0I/ADJ317g6NY1+e",
-	"9+7J86SfcVy0V09oDHpWgsbfeyqOFw6Vb9Pem3VGK2GyNa9KKEJpvM24Tja0YkPriZkLNr0HaypNnvcK",
-	"Lt5pNJetBz4uPBBYKbYhL9u6MYhg780vXLzrPU7okMiPvbYZGtsbmy1697Ft62zV7347OtIDUCXq4fYM",
-	"OZz2uiBP46cNDCPwCeDFkUFze4PAQ118RnoUbPktGoR2eZSm15SD+OWuL93nrfnfqtOPLphmG09FDWTs",
-	"0482a13P2MIv2OKiN2mBGNZUfXqi4NHQSmmklWyyC2bU6liKKZ+l/iPPuLbIsEcZWhwZwxZLo8O/ixu6",
-	"0v09Q8J4h/5PQj0IRNkRuZjZczyR0jirVDrR4QD/iL1oUaywZ7OPB/ZwcLRuEitdoi5iBTyHUs5yNyzw",
-	"NWD/uKZfqgRVXxfsEiqMbeol3QRJ7oZqLn3DyGAGhG0lN7woCN0JUz0mifZ3OxpHJ4g2XOILYoXE/Ezx",
-	"IRHVHWh6wRaUCy5mm/okinEdIDcCoa4TqgU1sv9RSrMDf7RrrGgDvVxxONV2vjOVM9U81PAzy6M8ApO4",
-	"u43azkzHi8+uDDQjq45rY69CaO8fbbXMODUsR9XQiTC4dEcbFSGsn6DYgrxLgK9FWrzdh2wm++DEWUvG",
-	"EZwxMnWg04AxvQZfUcqrosjp9zh9VMQ9hHm5LPBI4KPoiJA3XJmSFiRn1zzIGgJhJXouyyInhr4DTT5j",
-	"OZp7ru2WkeV8pe3hdH1HhCCeNVnQlSdjK58C4FMlF2RRFoYvCxamQ+eYOVUszNpltvnevRO2nrAOW2R8",
-	"b3PtmrxmPZNpvBcu/Ovkk2HXa/rd3grvBrN3i2DX3mrsOjKBNjxBmFLgomLJQAro2GnsfdqG83jZtinB",
-	"9pt3wZNTMpc3KRie73pwK0vp/3TYRxhoUwh32ZA7L2kdZi0PeOV0/SY2gUWcwS8XbMqUPX1jzz/sN4If",
-	"7SFbMmWJlVAiBTswfMGSc3czZyJlOGfXTCmesytwrgCj6fg1m3IPzrjNpLkPA/3aFb1+/uLEcblluKWk",
-	"YCSspuJZCG/lrlfdN/AK3w953vQ58cBZnhMlJgef9yONKD7DC8py1BFpw+FzAVLPmGgG3G58LO11V8pS",
-	"j9Eab5L3KgvHmo3wY1Q2g0xYBg6R7h3JBIkr+lgCFqhubL9rvcEWHndlBxPHGhkh9UZu33rno1y7+9Zc",
-	"fRaB3TICIcdzdG91dpGkp1ktA8sEo4AVmf0ZtoifsKlUYGlf4Z3HplOWmREhJ8aiu+DvWLFy0rB/UJ9y",
-	"kTuXs7861WV0iUjXY2KYWiBtJbKWc7idEg7DTmUp8mH6SL+g7xjajZk2sJQMVpWuxm2stsdgIXM+XXkR",
-	"K1oa4dUFyNudlS4Qt3MS26MNa49E0UEPL6TCw4G/+JdWrjuYR3AxgE+BtvscINvOieOrS5ZYkte/kibr",
-	"iL4pNb2o1IGHdeBg58szgN7te7PDWwjP5h0L23JNa0TBTl7cjnMn8iRId+dEut5kyqgpFbsTKtsB2ocw",
-	"Mj6Dw4HWwCqX9ytAzlK5gbA5qpcHNDP8mh2UwvDiIKMiY0VhNV7XHX13/B0E0w0TVxxkYe6rNxyMCZ0a",
-	"9+y15mLzRqk5vWbhFSwnuswypvW0tLJSjXmnmMgl3KO08FP9eHJ22cEMKgLbqJ1QTmXe8eQLA8NoC5mD",
-	"+5G9eUGASmjXNtAoW21YeEJoe6QrgH9fEu49L3mNG0nXGB3KRalU2Gt3dh2w3sDD3htv7NCG0dwfd2H1",
-	"uAI/oe4JPg/rxLmm31og+T1s5N42L+IBFpdsmN2qoT/bXjhIEYE8FoXlKBk0HOepEBIfG4K8rD1XWCNg",
-	"W2nZirFBx4iWr9QkEG5h3BaypGaOIhH4NcQRmls19lNESXnTJO3yRpwuKkAdphHnj/7AphE/a5Do1P0x",
-	"y2OmDEpDbAdl4GdjlhaJrxVvP8SvL06qC++hm6ZakZ1gXDHNlIofKL+Z96S3OqiDki3Iz1dX50Qq+L/j",
-	"njutBK7c6v7xwHdga+wFraIKOQwABe8d58sLYj4lz34+PgdvQ4yriDput8LcwaV/QC69wbq9yfaWmLar",
-	"Twh4pWxtZrsXF/0Ws1uEu26A24fJDd2kn3gvaOwyp+Aw14YxoDCcOEBYdbdaaxacboRsnXOYI9soClrV",
-	"reuto1zia1QQ7RB2B/Umi9ilkcBAzsQLWhYtksBJKsAjF9ZGLvEJDDwBd76e63Pv7Y72JpteoLdix+mZ",
-	"V6rUhuWnMi8L5n3lrqR/FmoeQ9eBYA9PRdBv4Xwkd0LVOkD2hbYesLfiyoXYrRMdOu6muhzipEf3k7uu",
-	"rGrrb7C+hlX37/syq3YBHjRblA19KN29SA539GGIj4/VuOD2t0uaPAo+FpeGmiGmlUIZRJ3TEIs6rnYa",
-	"BxjAmjiXHL2zWy0xiZpnN0HJomBqFyPbYJim7XC24GH9Abm3q0X94RmNN4nNyMX3pq3GlXWlSOg0LG2c",
-	"YffBOzbXaX6Jl8orKazEev7e/vdFIZfL1WA4OM4Hw8FrPRkMBz/n9u8fudSXzJRL+7vhBQcaHw6ecTqz",
-	"/7cc5nLOimKQcr3BcHD57Jiq3P1q5U3wm1hIw54pfs3ch/AIZT9mlmdskzIlwHYIKPVyAnAObT+QEkCG",
-	"t7Dj3DcLetnxM3tEnr15Ngorqo60oKKc0syUiqkvNMk5nQmpDc/gAM4UBQp02KuPPoWfSc71O5LbNY8c",
-	"VtOGlMypyuN32Jb6SE0TwshtXb3luWIH0Iz9F8tK4FnPxTVXUthri3x5/l/PvxqlyI7r9XztIGeazwR4",
-	"RCjXzK7WSlQQ97CgMzaq7WZ1SQq+4KKGVhqbw/uQIPzy+PIkiQ53RFLpLcjlM5JRBc48FRqp7k168QSb",
-	"ddSiEw7pLQejlBqrEMNgoFcJZm6kekcKGRWUSOQtIMCHUZX8uyFtPPutNzMkfBvPZRVsxzgswR/EkV9f",
-	"/piQSTy1a2m79M08Zdu9dn/qxJPrTUXo+T2lJCsAWb2tThouyDfZbmeGa+yve9WobJM32a1jbC1G+BZv",
-	"vDNU0qOJuj+rSfpUWDZaJh1GvX2mscXdQlogUrCLN5XxquGv4jFXgwF5BD77w0IPB2eCcPslWCazVVaw",
-	"YdOyGh6605fL+gtFEOGu5kwMuxYWbJjr7PajfrvpLeV+K39hM5rZW8oeqP5757q14IwLCEaMj//eCL0J",
-	"CR6G9jF3GK8FH9V/7uB513DrRn0qdfOiUaCSXqYK3t/Bx1DLqbmhih1cc80nRXzm1UO4EMC6eMPN3MeF",
-	"W9lzWVCRMP8FW0i1GpLj89f4UuRCsFKLIzcko4JQUN5HhDxjhvLCuURIncyLVqmJe1cFfwpaaAlxCcwC",
-	"rWQ5m29yM9xbzMuDxq0krurb+Cl5f28U6RwXb5f0nV7rNbnkksE7gS+oWgVTP1cLSxwPlXTAA+cSHTkY",
-	"3ftMsULqhadFS2WqFGDMAuCtFvH+L9/753j3Qo+EmDzRszj9gq6SPFK1qVt9JruQ416cttw1Z9N46Fil",
-	"nxRdznlGi2MptCzYllD/LLVpDHE7HNjfu6O3n726JHOpDTgoDIGfQNigWJFcLmoxhfdlzQgARJUTtxLc",
-	"vxRzrlTOnG2HoWBec/stFZmvlkxdcy3ViJCjEHrvCTGdp9E9dRPCTDgmepZHsY3O4BHmNHG9SVdliRbd",
-	"cvCS9mgf28ntVS8VWUjFyPi5JX3BzIkwTE1pxsYJi3Vo8WJMwATQ8kneOxzqJMdcGFHa7MqFEVtYEM+e",
-	"nwZn46jt33+2uCR5Qu1wVyFMmaMPdJNqdVkuLAfY8shU+9rBZM6KdkQtlczLrItM/blpAGybP0i4uHdS",
-	"rcwOr2TR7Bedxj3JD1Na556bdq9000J3jfQ7lzdMXRpq2HpPgKVtV3XsiVS6JYNO5ryv/ENrwLWLRvVe",
-	"qt2ot9H9dji4ZIrTwqevbXWKghb++au2vQ8lTrQBUUGN3ZZS9yYj19x2hDGueoh49aeg2LEeRtodJnqS",
-	"7zlWFBWD5HJyCGtPifqIbOGp5CJYZsC6femfwFN99OWb05Nzq24/P+2vjWKnELLgbd8h9x0lMw+A/W5l",
-	"J/t/4cJ1vWpDycs3pwcn5+RLxXKuYjDvS7aaSKryIXnDcyaH5FRCQttrpsjJ+Vd28UZmEixWFvC7QyLs",
-	"Ve3NT1kyQQtyW0XD/WSCbgLbyGQXWUtVEezc6XXE5t9DnM1+Pa7syNFKWY2jxvSNunek/3b0er+JAEzt",
-	"YWhEyBgofBzf8GOyjykoUSKXKrg6Oyr2RAOOKh72zlfWb0N+tWMp3IV8iZl9dd8UmiEnlus3JIrNqMoL",
-	"MHNPA0TDNI8WcsKMCg/kRg+SB8qtmQU8NBaWwF+ju5AObAOedwowb1MAz6UynTIt7n8vpN5L9JudmVCt",
-	"+Uz4VLCBhWzC0CU26/QBX5tAyG8Y14ThAG0ca89Zgjy+g8TTAGL9mnd8cg9KwiZ+Tdueeh+LiIHa3ilX",
-	"SmJVhShTOGvvcPDs5PR0MBz8vJooEPfgYbB/zgDbu2KdDte6/UQWfm7vvgy/FuyaFSNCTkTOr3le0gJ+",
-	"18DxJsz1QtJwgLXPQckcPjfncS2pyJMpdc853eNoMmPwlHZT11YHb4zOfr4FMlyrTnRQxTCRKQ2Jy+IY",
-	"3lqykDlrlYEadoIthR80pdess1yQGRNMgeOvobxoSjktVNeSzmQCD+Zo+3dZ19yEcYnxRqkd0sqVspNz",
-	"Vx3I+9KH97jOdWlFmVE828GXeWet80oaWiAuEZU/8R/bd9rYlhVP35o58gAfYuDFx6Hmy4uj06+GZMGo",
-	"hi5ckJ/4j6PdvGY3Jz9dt38LWQrjRB+/Arc5/iAsS7WUmpFrWVDDC4bg+7XAo1Rcx4xP+GRlmNvSUnBI",
-	"7fET/3F1fw5m8HTBhLHQOrAeq4tZknOok+UheazLsVTRNLdJuHTGFqMTYVgxOjq9Gh1D/NnLN6dWOGXC",
-	"bC/ewlhHC9MY6XZYn+wnIEfDLqKifiXfMbH7pJ0jNie/wEjefSy1OVRzustysuBJk2P3hL/bjK2j7Tdj",
-	"VX+CekQH8Y4WmLPnp4S9N0zoBFusW6BvHkfY4B3poqlY3pEgtl0ORGo8ZvUknMDTq2O0C3bHrEJDcnR6",
-	"hZFAFoVWgnD2RHSAqbiypy67R8dWxTk+3sJ8arscDo7yBRfEAUcsdD4QSZNpWRSE2gZcGyvQXDPy8s2p",
-	"cysJz0alRkdyn675GAY+xiwIlZGdAV4T9n5Z8IxX+/qcXc75y7n5uXwOybxcW4oSYNZamxYNV9gjpZib",
-	"CrcfUY+iTBM7Qxc7gJbGNnTgIu3WbVxcxNZdgGzBtIeyA+EW4iV6Ju2C87V0fkeOGE5BvEssGHJpduWQ",
-	"93PwdlLJOtjBfWlm2y/MRY+Fp+OcGaYWYF7OS6BpO5qPUUkHtdpfBkHGZMJcppOa+xj3vhFwbF++OY2q",
-	"WffjsFOlLO3Am2sZ8vpYskhfbBICuOvmRNjua2t2Xp4/sHEfhiRnil+zHF2Z/3Z5cEoF+WfJIKGVkWR8",
-	"dHr1NhFwnYl17NJMnJy+ffnmNP1+dD62lCCd/RIKcrp0mR4yB82QYEYjRsZVw20lWSIZ15nCGEjgtWbK",
-	"yaN9SKHCTh2yLD+IbGofe98E6r5pYPO6mpveOKnozJQT9t5VCIUcR/70MTLepM2Mh402bUqDqw8w3qAG",
-	"hlwhd48p28eN8Ajlyfvin57W4uXRlDaTSAD/UIPetBCNdM5EzsXMq7bDwXOl5DahYzjQ4eCoBUYsOsp1",
-	"4qeK+XAwjtooRhfOXF3z8e9ab5L0tuWcJUvcOIx/cwJ3WUZziDRDWSt5wgYuhSiJIyaj4LtwGtPdxGna",
-	"MWDkhnKwOUJRod4C9iYZ2m/GpsTCW+3VhJkbxkQMcHI507yffHUD+qc3XkfXfmz7/fLoPDw9+F3buPc7",
-	"z9yfNIZkUhoi5DrkVcmnF1AeECYgmzRmt/U0Bmns8OknYRYdRLclDbjsd5ASYWI3nGtdOjTU3kqpJ99A",
-	"uomWEqLyCmk5PBB1BzGvZZp7lzj6cMtX0oSCOFgbh2kDf/+EKpUlcSY4/HHFF0yWZov3SeyJgCfoUcze",
-	"tSxvpUy3L6MEhsYAiP7NA6TLOwSZLqDMkVWlLlFVWovY8Oze910quVgmlJNzvSzoyhFPSjCmvnC9tGOM",
-	"EmwG16x0aPZ+ieU6Q8bIdIB8o3khwfzGU5jANwf3982b02kxSHds24n7bGrnxNWd3jB5uYYQhol/fshQ",
-	"Fu0bXJCj41P37FulkV4cqIuEMP+kTGfbkZY2or0Gwg3VCQFPnK81TJHz3OEGqC6N/kre4wxOTpZMcbnB",
-	"BtPylLLt03is3Iz5BTWhZIm3QXVjPcn4k52QU9MSYzrSwv3CxTu7L1xcy3e+9MW65FDNZKbcFC3WnReK",
-	"M5G7m1MK8Gdvdt9GP3EDOQ0FcLMjah6dStIkO3dwf5T56oNR4Oed3cfOrnt43XFbZ25Iu7F6LpU5KMCI",
-	"lV5Ixs7x+PmIR0UfTHxCxLUf9rEVnX3ev73uHwpPOzjmebmLLOmqkDT3xkB4adiWXTy3cj6otVaE63Lh",
-	"escEagToWQxJHDjULP/2229/cNVYK/7UOTWYvvme6iDXoXF2u5YVQ3rHJmeueU5X8IYLLrXTyv7GJpcy",
-	"e8dMZXhamjkTJglN2n+QaArUf/7tygHmr1Zvy61csfVYrsbah/U9/+3uji4NkvSG5y7yT+rUPsJD3+oN",
-	"tSOLDjUSKlLWJ6lSeNGyDyY+BarajwywFYF93rgdNq7LW3HHDdMwnBXZKvjMZM4+Tb6ACNkGH58Ike2H",
-	"QdyZ3mpk3xQwG+PCGLhDg8PBP359cvDDb79/f/unwTZCVSgD35RXei6kLkulC/ntM7XuSq378IKL/g53",
-	"dxM+Or3a1Xm8xaVvLy4duy/v0bsNtyUR2VKD9rEwSz+U3j7M7VgqduyrzK8rDhAmIZlUTPsEF3FjPnxp",
-	"AIzRSsK86/jpAn1dcvJ+yPFlRJKt+AgQFMBuoaQa+LfDwS9yZhsHwu2FmQI7fWSI8VBvxsvaYnM7BzSu",
-	"z2fliHlhG8W6bC6Xnv1A/0cqblaVY6sbickeJmVQF7ybUDskSxd9n+DANwk0SE6S3CYHye8v6IIXK6Jj",
-	"qhfb7/IUUhtWsvGQZ5fnT55++x35ZvQXi72CGkgNfpew0rnFJBezXVIcuK6pRxFmPVm/lz0zHiR1Qcy6",
-	"9Af41F4UZBxwmqa7q85voXfeFbH51WqZZGT2NKHJ+Pj89RjLy4VSSnHVPjJ9U1qFP98hrcJWgaYJ0ivB",
-	"piQSmw49Xa7D6nQTRgq+4CbmyUjGhInZe5aVJlzbmfQFAmPNGJcWJu0aDLtyOkVrZSkyFB9cEvfHIitd",
-	"MM3uZnzUrFKe+1MwMkIe6bT6tctWFhNyhnhNTO3q8wNjdmGf/IYcHZ+fEMi5R34sjZGiSmcut/V5qefQ",
-	"CNuMK74zvhqXVIQtygKe0UTLwHaQYXAcHL+QKmNn02n7YK0jnIX6mplcLKQoVuSdkDcCKy5PZakONMuk",
-	"yMlcFqHoIKb7m8AQj+7c7Mu8uvEIwWx9MviFGzP2+Ezonwn9DoTeUosseOayayxyI1b4rX+Mgu9RTYaT",
-	"lAOLRaEFZF4OlcFw0ko/t5saGroSJaFgiA+ldwF4WElp6muNEZllpdKbvPhTcLudF6sF8qrLaE7pQpCc",
-	"9OF8152nZxRqhtjJnSgKxdj9gqnImPtOjCyYwh+sMk6XNHOSSkRYX8gzrDEBmZ7rdTrbUNdCNJWUo55e",
-	"zp1OPBgOXF3RwXBwdjkYhi/F6pwqA0wU3Llds/rPdjap0fP7/PU6slsqZpcIasLZZRUL0Tc6NLPC95Re",
-	"S1ez0XE7SO9ey0mjfQF+RsZn/puvbxCzNdx21/FwSzgcHDWS+mRSaKPKzPHZCUcvupAkdVLI7J0mRs5A",
-	"sxk5PLQNBWQTDghUA3KcV6MdEGskoOgLrnqCm6RUDrlcUGVenRyPcK9Av2rkC/eVGkbJXraBM+rca9t4",
-	"TlUO5R0m1MrfS/+502Dpqch2vnaVahc0m3PBYvEIn/BcNvS6VupKx7IXmi850Q+mtWyksufjeEbGUMXM",
-	"fx1Xs6/HChl2ewrWRiMQ35FzTWczxWauYJLXJ9MwRs/yQXLQvB7464moAdszq1f2AqtKb159Qjy5JKN6",
-	"J6prAnV22QWTIFghIqbAJ9ec3TTTY1dotTGB/9oxDaTPdyRLqL1mjTtT3swS14PxpQt8x/EZbtefhk5w",
-	"Kk13pZY0/X6wVUbpzef29XUjAJvV45nQTXoOG2C7j92AJoSDEiicSSuvdBzpESHeOU57oSG1i43rDwAu",
-	"VruS725csVFIO85NzapmO7lkWPE40QIKckWLQw3KtYylCzl731IPVHNHawwt7GJnXa2Ea10/ffsdVMVC",
-	"RnH99O3T79EcW+nacu1eP337TUfxrA3lXFuCZkMUTf8orxgC+UrWa6om5VS9mDNKZ7EbF9WVem9IzuQC",
-	"tELv9YFPfeIxacs8lWCwdkjXDejXYPltr0WAmR2UkLfu/zsliYSeMbbH30GhIAkzpcKw3nqayDBnc9h5",
-	"uaDiQDGaU0wLCG3vx8eya66InyM1062W6JCf2qOBqlm5cNeHFegVg/pRhpvSsOgVGZv5TMuuP8R7FVK+",
-	"Yzkpl/Wvis24NmpVSeHdMJvdYxruB14mIScYoAbXOl0wotmCCqiL6X4dJ1tUTauREqNvdeFG9jXKfGl6",
-	"RjKpXIyZPT/jc6qo4+N43KIRHt+6fFFznwTbo+yaKZNWW8eCl1jIKXB7mr6sYMOU3E7y9kPBc6utTHlS",
-	"QOJeD8Y4wDOGskQ+l7pD7hfhs/P//oJkBYUiANN1JRziQi+t7srNqrfZ62dGCzPvmSs89LJtwQm8sJdW",
-	"1WDT8AJnxj3+eeGh9kJRwfkHOYQXL46//+HJ05Da/j8vz16RpeRY8d4/jrlwzR4LGYLWv7QtFbd3SYO4",
-	"AHlaFqVpreX2WuO94lKjEV3OZkw7JVRgnR4JMlZx7cwR3JTOd9/yj4zCi8w9E7S3Z+IyPJH6CQlxOXow",
-	"I7Riy4JmrN6pdgTqHAutBhSFtODBk/TnIvRxnvK6ht5Lw5YdgfcF1wYtF5lcLJjIrYBnm++E3l41IKpw",
-	"va3+c3C7V7rew7Kc0a02mUu75WvO8Gnl5vBMaGyl63H8V3JyPLTjs5fjrnfVb3yG/sjS8kRQ7ko5q137",
-	"Ojn2ov84wQWjugXZm2xgDRz41Hjuade9eYfKs5Xa7P4seHYxRu6c3MIuWnuM7/sOdbvUTmrFUeudhFP1",
-	"u4nWHHm89HuedmwMZ54ulwXPMBmYbKnBUqGeVJFKyw+nHqdRJLhjlA7tLao7vPrL4tHWY3I/u2wxbQwX",
-	"U8CEkCashV3DWlOxYd0DdvpNhHwzfSf5q8Pa6Pl7AyzzRExlLx0l7C1aTaNRAQHwrXpfEXUdcvdLAfHQ",
-	"UDaQ3HuDfTscZK2O5kdeDk9EJBpv6UTa9bvQpnfdQ4zfnaG6HQ4WXdr0UV2/reCrpvf42p/uY4Vt3C8S",
-	"9g5knZECTUQ89eamHZzvIDLIbfyjNp7zOtislh3uPqANQG3idA1BtS4Q7uAlAfB48DTkPKuKgcGsj1AE",
-	"tSdK1S0O/WAJO/cBIB3ydAgQCd7fzj/i9cWJc1lLRHcLS4Up9suliaBY7vw2gaeZNfPusrTZcUmh1vfr",
-	"i5OOYi090NLp1nUfalyvRe1gIjhXXEbpvXl749fgbsucOlaZW/8xHLP7AmtVJi/vjp+M25wH5nw2Z9qE",
-	"IaFUUaYYhbc9pyHUK3vmLLRI+02JuZHh7q5Dg86twdrnOw5dxD/LnOqu8lgZuTFGUhDQCxO2Pc7eIJVY",
-	"2gnmphFxWKPNiu5D502NjhFckycObRHJzqnUyJgVehuga7zVu1a0pGJwNYRaBtmuIHArE0ePsnvK6LsW",
-	"dFi+UateoRGKGUjfvJkZfbDjF4HF5a4F2C8e6qNf0+IS/M86bi3uGoU0oR8BNjzMQ3sm0btOD8MCemAo",
-	"LZWEgQLgdXzsabvz6nJp+uxNIb2l3/XZ4S57iLCP7SFut3q1WLzCNZ++lFTq2vkKBtUEIhX28NudKzLu",
-	"IOEhuw13WN1QSBUL/De1GGbeCERJIWeECaNWQ5B3r4GtU4t5lFfBsS5IwokZ7iO2b6zj8snb+7Glvsy8",
-	"gYq58OAMhrBwuAbDwQvnKPJ6mVPDoI1m9gO41h6vsiL8eCWf4UWpwZWvKFhmnnE6E1Ibnj2jhm5byrp9",
-	"kEP/O8nDB3A8grohlSUd+n+7qsBwjhLTSm11h4Nz70AcPWRK+BaTAMe61ufR2/js+WkL9Qa+kiArnQN9",
-	"izP7e3X8xkYc+p+ccxr8OgrbkQ6K3t214arbc4i/ePHQcDEDS++UZkaqlRd4nA9okJWP/ZHZUt07iocN",
-	"teJQf8WeL9GZOgC7bBaJwujbCULVNT2IBFSBtPUxwb0m/CJnzy3P2iEOcnvviliOrALfQzlcpPa9OhSf",
-	"XTEevyvGJ+UAsYNt4kzxGRdn0wr73Y4prHvEv9z4aH+vXKH9cT5OmbzVOZfQ+3mh35TUYL8P9RWUfnwP",
-	"8un2HPkqFRkVGBzjTB/OEaVhppEiq42CfooLGao1VSLQujbmL82H9y19ia74gmlDF8sO+YIv6oBCbIwr",
-	"Fn6vGS8rdri1gLiKUUeVpJSXsNT2ZblgE6scVfoE1lpqpgSa4RxMVGuZcfAiCOExFRJ+CP349cUv/gmo",
-	"Brh/xw6+5i3gNhbltWfHVSYsRoeHpWkvr+qyMP51xJWBWCvGPUHafO0m7U5+BSAFiz3UIfljYHs34O4d",
-	"p/flJVHPmkFF7hIAaR8SVFFh2HuujY5lCZJavsTZaopKwM46zeejtjS0qFGJieGoYMruRZJ0BMIDL8sJ",
-	"xjBsEVwKQ4WaJfHqsFeX/TZqzNPSmKcNRhVIWlrDKwjcFy4CyDfeFFkaYO322+9SiuHRO0PTVIw0CoGy",
-	"zRVuP0WgviFZUC4MEyHEVEt75iGxChxKtOD61h4eFwmGPgsunlxiJSY7s2A3wYDSxHFveIPvdfc2wNtO",
-	"sGF6B9dQh7Hpqk2LG7rSwWW1qnBa4dFnNK5bPyp8pI2dp+zD54pJwuhfR064WLgA+fBGBzIKirA8VEPb",
-	"BxvfAFR8AgxdwYwUWPsXyXT9tZy6rJUwhLOXg+Hgb1QJXNOx4gYi9fobBX0PMCy5fyRbGIicLxYsB7/m",
-	"CrM9ewnRQmqBx9+DUjVTtfHpCjV0aaql4P8sWxTW9H6o1LIBS6bbHc0XvKAqRqXtiwrWgdOLCk7yHTb/",
-	"VafkkwoWlWsTNJAFw8CI/aw9zlW/o9PJ+iDBrmcHNDiVv91g2uUeXEn+uFX+ZWxRD2i140UDq1tuwEbl",
-	"Kd/qTsUqrnuTY1ESZ6c/WmlmOPjHr0cH/00P/gVT/PuftrHSnOGmVEUisPlfGnhXSNifsCxoOvWPAlzM",
-	"4KfwD/wEHu79eaLtFUpE4JZadNgxWU7kdOo2PK4jZUKhz4LP5qaSJgJcI45e/xeOBexTrJsJSNVB39IM",
-	"Poxqy7Wc17DFUiqqVljbM7wQO0m89woyKoih77zKLH3Ub5LKRU6niaaRbMJaOGwnAQvcGxyxFEJnjG7A",
-	"5PXTt0+/dfpPSy6gOoH57DhYFi9j07K4nJcmlzci+emCaUNBOof28Z+vFjwMAsRZTeBTf/27LPWSidzv",
-	"PD44lWAOeVEWRdK2N0GHBRwOrkqF+Dd4vZp4sRcr8qWQ4mDmFkS0W+RXowR+P4RoHWFUX/7hwKKK2GEq",
-	"M9ntTydzPynsFsYeNVd9CD9UXvs2r+WrESE/Mnv+NCn4O4YGMsipYDjIjgUXTA/JVBaFvEHZ1wIjVaOR",
-	"N5ukJrU6EaTL7rHEBlmt6R/O3cjR1uHgp1gbKHnEBV1DlUvjo1HAu8qlDRDk1emJ3cX3f/nex78PIcLf",
-	"yKVPDxSePfUQ7zFmWDoD9QVlqUjLLQ7JnBamlkSilXQCfxsc4v9TR6+EwiaACxfavZDX7tSH7EA6SQZA",
-	"yZRRUyoQKurJEWKuC918Sb4bRfkHaACQFlVSih8tSbE2EqqzhcPBJXcpvNAR0SUB8Zm0QsbfJKVWSN/i",
-	"ketYx6H7o4levESw/V2x6TnX4eBvivuMScD4ZcJvjCQ51+98RdSluzLCrcQxe8RNzNGNYxhJJswjMMcH",
-	"N39TTmj2jlR4f5sZIWWDa9M8JbpFURCjqHBZYCAMOV58WDkbr7CklUtsZQ95yhoJeb2EMgBQmNYyWHem",
-	"wBaAKTmClBNf/iCuNOjkwxaZ3Hmdnk2n4xqnvvsqxcMscs2qxLjlUtnfyoaETg1ToRW8s/g0II5X/3G2",
-	"2CGjfiNug45ldMqp36NUW0DWXnbwMu5fl/x1Zg/kFjjyXCbnU/AJdHbrcVzSGE051BBuvoCX8ayQGlOt",
-	"Eavk1cFeSq35pPAJFtl7atE+jNf80bHvQicF085SLggTdmTL31wyRJFc+1CqvdoRTWSxXLp3E6/R1NZc",
-	"ZIhzbzyFayavDLXt6b5/unV+48F+iN003lfYztUsVszVzXeW05xrw0VmKps+tVdEm0nSJ3CukBN1dm1O",
-	"gaLH1RM09kTpPYvQBrugK+f6CE/gkJxKOVunJ4968KdVTiKUMTFGv9727oPkhfVEzh6m1gUzl8YzZkrF",
-	"InLuhoWOxoV8LRX4bPpXZlfyWbfLsH8gLovdp1xpk5rLDdXvMDEVnVoRTQepuSXtauAKIDvYpgAING9k",
-	"qUNMz6U2LYn8nIiCnrKNqZ12yjTwFORcmRQCTZP6oW6JFqXiocSez7u1vdiGqtw2OzRbr/Yl9qU9ioEP",
-	"QrpeJ7wT5KjZPAzcaFoaN3TK3QSz6g1yV7GqdtclolWi54VklIXMaMH/xbyhQbN/lkxkieYZoZ7zgoFd",
-	"XYmgiHJNtIHloMG8fppNCS9E5NkxuZaFcU5lVs/F8kHTKIitb+p1vs8C2R3OWcPmsA3BThjG+mkfGdNu",
-	"k4CnBMthvY4A/bh0VZ2cWaO7vxXDJozkbMlEbsnamS6apgWfzzxM4LpmUkz5rFRWgq9YRT4+zhhtLNvA",
-	"jvskvB0+8dogN4obw2BNS6Y018ai2CX0jEdxozDwEJdkp2W/oRD7TJrxKvE2/xqDDsk6A03EhhHXrQ8G",
-	"jdcoX2xnmKbhvDRU5JPV2XRq9en4w+WSKgYOKFdMG/xdGbTiH000xgu9FvSacvBOiwM8Y1OmnL3//5Wc",
-	"6Qwmgqgb/yst+JQjKGymaL7++StNRBr7bpUGPF3VmoTebmVuaJ9rk0hFcuY1ICFNwlJ98B00MaAa+bsu",
-	"0Hgl/2tGl3SCFgwMRQsohLsNiR6VTD9pRgUGOmtDC1f0J2LZJbFxRRpCnLN/g7LHKpOLBRW5Bg32nyUr",
-	"bRt2E2oCj9KNwPHStaeverlrNkrJqAVflT6une0TKj6t75KUN3IUuKFDKXKmZhJYNdOY7V2hC1iaEBji",
-	"cujSlC4ZS2Q0U9jBSTmbcTEbVai0iuF/ls6bp/IYSLOMLQ1so6JiBoy/EpYVjkJ1tKSKld0cKFSRiPyg",
-	"fCoOGreLi/SbOWqe3n5IhYnoDeWYZTsISDQLDNS7dqGVvsISNsyxtIKfxAj8vBQ5FdkKILe82k9KppQX",
-	"8tqyaOWMKL2gQAa0AQLt2o3aGdQm+N15tjjKqHBJ5fxLdmBijU0s3RfMNw1P67ZfnB85hD886/0JK1yo",
-	"4w512b3aeRSFEdqCWXDs6HTU08WlznDW3e37ZUW9pIj6KQo6NgT4eLRDhb02xtWNYrqG4YStbeFru4wI",
-	"N0ORcg4k4ioDXE8OMYj8AXhiHyK4C5fsOf7e+ee6zUs3zPuP8GJVOekWEBTtM7lgyQUfbIoNrtvFZvuC",
-	"0mt6Whppd9Y9nabM2jPk4RoYwWM48Zn1by/ZHLaSi6jyUOFM48iREkJv4+TrSTpdpitk4/ODVaT+sTuC",
-	"4/WMf5eTmV4KlqH5zI9dN0NPwvV3htM7/Zdk72r3Bx4VRgDYwNUKds0KUFZjRSHbulbusFM7STm7S3Fa",
-	"4cFWu/gBfkyP//XTt/7HcGRD71b0u9yXFVzFlKprig/UpgVgGqoOFiLdMq+9ho5wZ6ce5/E1UeTESizZ",
-	"nBe5Yusi11uCBOM30ggbSV30qy7LW2YeawnY32fasZjqyT/hXLM0vAeXAIKPX0RYbGtoTHCpC0NYenc1",
-	"sSoJZqXyf1/IoiiX4y6fdv/eZAdSsihIuYylU5OJJMTWomDgQpH8SENSBjPPOGDyRLhs4h7J4xhF7yMX",
-	"f6SaEefESi5iIDVkVIt5qSoJAXDNjm9SFIBSOLOsBNGY6vRn6lNpXTdiHzrDJp/i4Yqe+S1pApDwE3NV",
-	"Sqf+4rZiI8YRckjS6Y1dFe/1LSk2xGbuLw9DlVybS2NVx3xZgges5jk6+XStLXEY1zWPcbgEpW6kEe72",
-	"FU9pun1L7E1s56jAHyguVkFKj8LHhn7PWu8V3Wjcj5dChDf1Yx8SzVhLfYgYoVOf5Rk1lEAR8v1E/Qdb",
-	"XfsV1cDeDruNU+xzs6ulB9vBvGsJam8ULuE2cQSV5F2tXNcfdXSlS3xwIaV5+wsX73YRZwrbzx4RlL7T",
-	"8nEuaYi/jeEY1dhH733aIflsgGw9TGCZAt+aEA8Idx0GK5YTqXJ7gTOoqdlYwKPYe9fEC8JcYwnUdubg",
-	"x3M3P8l9c5/ktymwXj/tLuLdmi7e1adyL6SDw8HXCpt8ff3069aK3GnM9vXTZrB2bcXJ3zvQ/DjpPo6x",
-	"lT7TMLAjKEE7bVvekPhCcE7b/CJZ3Rfk9cXJiJCjomicKAovSTzV6tPhwcthSq3E5IRhpwpb6raHgeUk",
-	"54plplihWh3+Fe75+g7UUsMDUY3sKWHvTe8sMb797dCPwPMtUswk/UyPStahp8GEW4NaXO2Wd1jae/NN",
-	"djscnOS9b+ITWFvgvOv6NFn17XDg4x97TQaNIROxzMvMdJYRsB9bkjAkPDhRAO4rUYQrblyLr4zwNQqK",
-	"t4PXpp9869PtpDyvHRuexbWfYzgfyPwHh4N//P3v+b///e+j5H9/2mO6lqqUm/B0IzNZeEghl5TLPZQY",
-	"4M9rzXoZ4CH0xdVsgZQbjjU4qRgTC2MpRr19wqjXr0+etdR7ag1ujh6ySSHPv82ZIJeXz859huRh6jZb",
-	"CeyHpGJ2QleHBDFDBfn56uqcjL958oScvRxHG6N3hIbRx6cHl8+PLo5/Hvv3Al8RPFx8bQchIYxfnxz8",
-	"QA+mRwcvfvv9L7cH6T+/2+afT7+5/dM95cdKEN5O6ynmT6bdeG8psXPfyCfk4sXxd0+/+Sa5gRfMzGUO",
-	"wl+JRuNMMXQLBFAA2FpItk8o43VzJx0yIpf0n9D6GB2EfSFU3wfs/8aODwv2ijSOC6k1SsHtyQMTeDN+",
-	"32qlbigrg8I1vlTwfLmyAuiUsyKvPGnYNcDx81lI25kXJCQFlx9RTmlmSmVn+4Ny9gqQUnnw+zB651Ge",
-	"zmX5VfShMREdMGWleJcDKHDLsbsgk0gcJJeO++TPLVmDophTFV1AOnD39jb5hIIFo+0yWCNqfuQairao",
-	"Pg4ZLN42ftlBdq8mxBi7Icep9RE5nb5H+ZcZOuvdHRp/GrLzKeTK6Mh9iIk0dDBDxp3sneOwKYfcYx7V",
-	"YH8wG4CPCw8E5koV9CQv27oxiGDvjdUUeo8TOuyqWWxthGzkWsPdb0fHcA1X3R9DTR7iujhFYBBOOA36",
-	"d0s9vsfGenFjgO0WRQ9W4Lr57gN76uu5u1t4sC8XBeEK7tnJtdLEEQdhIofatKiI4FenJr/FegS72DMT",
-	"1wUcoyWh0eDuqQB7TvOxU5Dfj+o/dzO5pSN0WN00Ngpai3/widf4EKXeCm+2UictQm5dN8jn+/8W3K5l",
-	"URrmsH+FsZEd9zN9zxflIilQ4+qxeFcXvztcE7lkwgdjpnZHiDWr7qViM6rywjmNgTcA+Ja0VZ9BCAaH",
-	"f/n+uydPkmo03z7ZU7mZB19jWpxmbXng9p0KLoItee19WUi8327mDMzNVoJxQwXwXEgseEMtlwV3YYPJ",
-	"OXHInUhZMCp2SUN8h/lB/xtb+a29dj7EL/rW8Q0I9scn1GhuaDSjuQto3I7icfrAm26jhz5sJ8IJLA48",
-	"TXiL1oq+qyCLtK0FPMGWS0xX04WnDYWkk7uxx9Vdv1E/AoP6TsKrW+f2B6ZiHE3CCGpUua4RksSQcJOG",
-	"LgwxIxS7ibQbvcPRnpUPiSzytu85K5jxYzBt6KTges6qbWMmtorzb930s7/D/ZC4qhh52tFVabI7xqK4",
-	"s/Z+bLIYOSVcePZQv0HsbBCkVrlCqvJNy1WSY169OO4HuinNXDE9t+i2Ki9fsKRAW1JgDj3wIVddLJoQ",
-	"OKdxDxAg57diIGXx69Hg/fba+vsEGVSsfN6NpIIc8oyDeCE4bGHchZMIDIM3kUY5Oa+2bG+aiB6mvZ1t",
-	"Sv1wpsjqE0sNrYm7zGNXkj/rmn+UjfgwLkxVFfGsNBNZivw4pMvY9uDffvaK+vCk5O1VuxsqEmtWWoNc",
-	"czEr0mwq5EvHO78Kdw71qYggfrH7KfazfWJLXSZVYvAxF0tfnZwf5bliuuPh4eScUPweqke5VFFQQwBF",
-	"y/QafKgSKjsBtsYn5jgSTqPAIgx8YAUl0L8R7lAQx2eg9Cm9HxARtAGbo2cf77IAKaUOWsWFzv32hSYF",
-	"nzIrra597R0OjhG3Vt7vqNUA3gYiR9EX8jWlk99Q7fens9LTQ1DQdmC2IcRVL3tgm8Dz90uOEZw7bwGz",
-	"QzC9yWhz33W4ttiNnhBXA5R8jWRIVFwrE+EnYAGbTlOzjWg290p3HyuVU7t8/DXCSiZUQ9b2irlq3fly",
-	"Ndfuy4kyFRR3dqCkWt9I1VGfY+m+Rhnb88LU3YhrMrbUPa4VhHmYU98PxlDsuw1S54AHzAGL9NT5ahRc",
-	"IAdd9E7GqDcqyPioNPNXUrAxUbJwOaG6H9bZYml/Ni5k3EV9oFfYROYYbnohC6bXO67buXSl/o+bmF/z",
-	"gs1YfKRPbrHgXtBhHLu3yqzmrpC3nbL/8JUN0WrVWQDZxV6GrV0ttwgDqsnSdhZ9j5FfPilopEMUTWLe",
-	"HFzNBuv4lXzHOtyBIb7zAGtY1ysEGtvtj3zm7wj8WmbQgdHvY43CV5trFIZ6wq4OYAOch65LCAS0oCab",
-	"M0yV6wBTLJMzAfkA3cuQ/xIdEoE50j8ae/xQXopx9Y/TGGjh9og9E6gbWAQHyk+Eht+aVgbkjEnWtJ+l",
-	"NsdSaAnVT04xT3L84eT89GQwHLx8c3pyPhgOzp6fDkI8w2A4eIMlCU5ZzulgOPgbm7y2zVssU72rpaQA",
-	"uQhuqc0XECquJWak5dmcZIkTtcCczZ7er1ghmBmSy8ufh5iFDK1tPoRh5Bd2ODgRhhUFn1nSOS+ogSBc",
-	"xAIkqzjxZ2UUsGBV1JdsNZFU5QdveM7kwamECIdrpqyenDCRGj698wL8uPuSLk/J8S/nnUtrswsOjjoN",
-	"eBhnLF2nxFwE5arxqeOLs+bn/rmVPL2kUCRIqhDRof8ngeSqo0BVtrOQ4sAPcMMmSVFHYGduzLTS5EzR",
-	"5RySWiYhaxFtN2xygHpDRODa3FV16lyXCiXxzzD3QsZRYUqnYmoB5tIcc2a5l8YuXwVX8tZbCP3NaC9c",
-	"hhIZ3BkO6nTb3AnqjQMqSO/TlsgFD7FEu5R0af6g919bP47wMKt5+eb0YCMb2oJw75VfPQxKfP7/FjJu",
-	"5ZbbEHUL5wzZG5zQdgf2iYLxuAll4gvEIYoIHYfA3rC2skuRREO3wR7S9Zq7k6zzmUDJNUYDtS4nfdSJ",
-	"N8YWR7B2tTQ2of69kDMrzlb0k76bchekcAFyXpLlz5NpENytktRyNW6BjOv0Fn1gBtQ6t/NgeOfKecAn",
-	"LtI4cxmuyfTW32LN/cSDh9q9zoRkrRzHW0puh4PGY1mrMnsGSVpqJZFpmhgh2JJLxQ8Ug6z02e72ZK+e",
-	"y7qRNujrjjLgQeT1xS+o1dZyFYT8OFkG77qQ6Q7WchBChzFK0Q3qDiKICh1JcXQjR00tYGWDjxQY3DCX",
-	"ZjXQp+HL1IG5Te5Lm1FHBXGDRF3WJ+zaCGi6YP+c2hKNhsYp8vyKztoS7twXVdD6A16NLwM8EKE7ZzSH",
-	"rIppXqKLF8f/8c2331RXybeqWF1NofNBjkVXKe1Gxqh9ET56eGznU3BEAjowz3y378luD/C9/U02I7X0",
-	"FegDyLoOc4qONEKtSTavL04aldacyBQOoWVqLsXqkirD4X6D6KAPQlTUA50m+YsPz3TBSGJnG261nBRx",
-	"ptNg743g9IG4iF3vVNHZIngdeC9JXTHK7/tQ3Q4HmmWl4mZ1aYkaD8CPVPPsqGzLOgi8DL6To6rxe5oY",
-	"9Y7OTwbDARwT8Hi27aMD3tyYJboJcTGVzTlOmZqxPB2sCrcdiZsCa4+mE177JCSDp6MnIzCayyUTdMkH",
-	"h4Nv4SfIKDGHVfpsQfbvGYOLNOQzPsmh9q2J1sBgpbftvnnyxP4P5AG8giGeAsH7+n80Pt4jm9gmI01X",
-	"AilAVhVJXalLkjxSPrBvAJ2ntCzM3qB20z9XSqo28OBDzIBZobTB4a+/3/5mf6mko9q8DW+ePtRGpHmt",
-	"Wlbn6qVjpo3gwEujeBOiGzDiMgwWDu/HsSd/WjBDLbfstTmnvvFWm/R+UQwOf29CizpAgGD0cWCsGaC5",
-	"EW21LvdK4euCSfdA5+l4f2hST6+4XzHJ8pKabN7cqXP787q9gpfBH2W+eshtis+PzpHrEdLMN0++a8oG",
-	"l1gGaujyuceZgPF8JJRWtnCE89J8prLPVLYvKlt7LX2dBlNteT+FrvdPDWszFu2LJuKQH92FJXUbH5G6",
-	"19bdG0OJOUr6sJCn9zt90wbkdGdLBFandq1jETrnpv14WENvZvB1kjVqZ9qKuYfukcQ68+l8GJJbD87O",
-	"JEi+RBWonqfnq0+RNn93f53kt7jugmHW/SqFPoPfN9BoGOoB7rB17Gin++rTEJF3FEoez85+FAqzogtm",
-	"4Mb4tTVzajR7M3KSR8N317qHA277LqmZD4YDAb7Og+qepqx9mKy9nsn+tzpfiQmWN9OWa3uPNHQsF8vS",
-	"MIVTJRdI14e7U1nXyB8X2bVv69e/V1fnbom+O13v/HA7X9vvfe/yJ8dSupbfyllat703g+lrMVxDYvsX",
-	"kHtQ18MZdT4cqX8iRp1O5ve1C9CvbcHogmlkiR/ZQeuhjbYfM4eH6s+IhQc5gDDVRTLPAx/BTSTYfuKc",
-	"l0FZGB19RaEQuJNFHuVZOWOLr8GJv3ZojqnIWPHyzemxxZL4FM/PGVu0YKaBmAc5Uh6Wo4WpA/AYDlp9",
-	"TZ/mmfuJCSiXfMGwthaXIgQUfz57hi06EfTQZ7ALkA94FncBFkHZRiidubFyouJo6B//iR1Wt9Wfb8gG",
-	"apqYeejj2YDgcQijtUV9mpfkZTlZ8AQLxzJnn4+e+9yKnIc+fW1APIYD2Lauj/gMyt4urmfb+7c2l9oV",
-	"7+Zj8XKZlRAIgDX8Wutl7jlfJXCEdthiOQ+YHeIXrnkeY5xawAtZnqpwvuOiLbbJxTaESAtC3oREP5eQ",
-	"59NIMcZop6IgGdWsEmjlANgcoXHrmVajXqZm6mCqOBN5sYov9Gldvf5xILfDQamK5iQXrKAQS/n64pcQ",
-	"IWXk8qBg16zYZoJa/hmBqVEAuzh3W9nmSv6sjhQ2niI8QTTH6fLTrtPuH9XbYD1nGP5ub6T3BxCwckBD",
-	"BAysw/076WJxCCAdWGgLTu0K3ZWH+DhQUpqDZTkpeOb4++3/DwAA//9pyNWulpwBAA==",
+	"H4sIAAAAAAAC/+y9e3cbN5I4+lVw+Jtzktxfi7GTTHaif+4osp1obVm6ouTs2UzGBLtBEusmwAHQlDlZ",
+	"ffd7UHj2k02KlG3Z/yQyG49CoVCoKtTjz0HKF0vOCFNycPznQKZzssDw50mqKGdnbMrfXmKBF0QRcb1e",
+	"EvhIWLEYHP8++JnznGA2SAavi8WECP/HiRB4PUgGIyUom/k/3M8Xk/8hqfJ/mJ//SAZqvSSD44F0vd4f",
+	"6ZmeEZkKutTwwOxu1uPBCZqYv4cBBP0rgz+HFXCOBycMYf0n4lPbRg4DOPCdLCYky0iG/nN08Rpx+DKs",
+	"QFoeKGoIo9k1azjMQoaV9Ze7mzZyOLi7SxqxDmvGWUb1J5xfCr4kQlG9E1OcS5IMsoCgwfHgek4QZVMu",
+	"Flj/gvCEFwphtHQDIsrSvNBrpAxhdEWyKZVzhGFuNOUCqTmVSBDJC5ESDf4ymvTPwUme81s8yYnBLvxW",
+	"hwG7VhrVRNAUrXBeEIm4QFkhDHDmp8SAJOmKIIHZTDea+m+YaUhTQRaEKZwjqcjSjeWhDavDEuHlMqck",
+	"Q4qbj3ZpCosZgd2kiiwAbFbkuYZxcKxEQaoUeJcMBMHZBcvXlQbYUvL7o5yz2bPK4jU8BmNrJOc4zxFl",
+	"GU2xIkh1YOZB0ZDoFhmZUmYIQQP2ld/ZeGB7UgAAt3HyK5TmuJBEQ6i7OioaLUlKp3qtlLMhQi+4MLQu",
+	"EwthGTGCLAWRhKkKZqL5CU7n9rwsCBxshJpwzFm+RhOC3IAWdkCwxwuQn9ne+Ec1xwpJgH2NsF/mELZ4",
+	"RYSknJ1ovjA4Hqyevv3+7RNNHB5dl1gpItimg7A0zXal2iqxttBmxD77EWfKmcLACwSZFTkWiLzXSJQw",
+	"vcaMWdSEyPZd2nY9H5w0akTQd7Pf6Pmrl1J52+Ov+oT0wNgHYUtu5zWCsx1g1tiu9DQD4+WSYOH4isQL",
+	"4m48kRnq0L+PyziVYw/f1uTRC/o6ubRs+Q9NW77xnnscd9LHd6ZhK/QPI/pvco7f04UWP5v2YmE+2isL",
+	"6AAGIjncmtLMSLKW82eEpsHxgDL14w/9OS5lisxA/N3l4G0EGlgwQCuJWNGUIFksl1yo1jNZn5BxVbsb",
+	"OTsyM23mgd/ZA+F3gbKOXTAf2xckyL8KKj62begN9WRd3o0H3oRnWOFrWHET8kEd8fNqzLRgmTNyMR0c",
+	"//7n4C+CTAfHg//zbdAGv7Wq4LfteuBd4hVBvT9/3P1R35hd9qHnAjQiyBQXuQLm3IyMzLQw7KUFD4eW",
+	"qlQPOBA1UnSaU00YGScSiGUp+IpmhkNvSVx0isZXlmLHDhiJxnpR4yFCZ1M0dpQ0DjM6qMdGYx0n5gJ3",
+	"fMetbEWEYeFmRYojzNDVi9O/fffXn46cVgE7GXTgJpL+qyFpy9Q7dtIxScv5SLaPPWXOatG6p5alIK8G",
+	"9WHkFietXHvre7I88DaCbwvHaVjWRu7z1G6VYZNdW2UZ6Ue9VRbG/W9VaeAPu1Wv8aJli5gWyK3mHpiQ",
+	"3yAj1enRD8EMmyfvMkoBt3/Nu/n9mRVnvbxEBEFUc7V9XgMTb/LcQczeFixDfOQ9XixzkmiWXkgiAH+Y",
+	"ZWiJpbzlIosNGVgQxJfGVGh4N55IwtI6xqWHDIBJBckIUxTnZpBCkmwPN42mW90g3rsxgjGh94aLwZhd",
+	"uyWeDCts5AQtszFriz2aYEmyh7nqnXkEEKyR6AQXuAnBcKvJevx3rmEdKrhyjZRrt33z9T4hZbE52sdb",
+	"quYIl/EwNpgD/I8j4/XYGBJbWU51WK4JNgwt4Si63a7vxwlzVKXXzKfodk5ghMphj6RpxZGWO3MCR6QP",
+	"97nHGbwHOHegebuF/264a3i04O5NY1uWuG9b/fsja2a8LBnt//n17/jo3ydH//32D/vHk6Of3v7x/3zz",
+	"//79ayDL/7WD/+85kRLPyDf/+Mewuctfms5hfYHBnLrCOc0QzKLp0a3CG3sGdxq5p3yxLBQRo7VUZHHK",
+	"85zAMt+2fdjhYST1neGQlEceezwiyqTCLCWy/vphD7HePvJe6V+69CdofLT64a1rf5e4EYjCs97doXHo",
+	"S7PePWkW9VOWi/bqCY1Bz4rQ+GdPxfHKovJt3HuzzqglTNLxqmREKGluMyqjDS3Z0Hpi5opMD2BNxdHz",
+	"Xk7ZO2nMZd3Ah4V7AivYNuSlW9cGYeS9ekXZu97j+A6R/Nhrm6GxvrHJoncf3bbKVt3uN6MjPgBlok62",
+	"Z8j+tFcFeRw+bWAYnk8ALw4MmuobBB7qwjPSo2DLb41BaJdHabzCFMQve33JPm/N/6c8/fCKSLLxVFRA",
+	"Nn360Wal6wVZuAVrXPQmLRDD6qpPTxQ8GlopFNeSTXpFlFifcjals9h/5BmVGhn6KEOLE6XIYqmk/3d+",
+	"i9eyv2eIH+/Y/YmwAwEJPSJlM32OJ5wra5WKJzoemD9CL5zna9Oz3scBezw46ZpES5dGF9ECnkUpJZkd",
+	"FvgasH+zpldlgqquC3bJKIxN6iXeBElmh6ovfcPIYAaEbUW3NM8R3glTPSYJ9nc9GjVOEE24NC+IJRJz",
+	"M4WHRKPuQNMrssCUUTbb1CdSjKsA2REQtp2MWlAh+585VzvwR73GkjbQyxWHYqnnuxAZEfVDDT+TLMgj",
+	"MIm927DuTGS4+PTKQDPS6rhU+iqE9u7RVvKUYkUyoxpaEcYs3dJGSQjrJyg2IG8E8DVIi3f7kM14H5xY",
+	"a8k4gDM2TB3o1GNMduArSHllFFn93kwfFHEHYVYsc3MkzKPoEKE3VKgC5ygjK+plDWZgRXLOizxDCr8D",
+	"TT4lmTH3rPSWoeV8LfXhtH2HCBk8S7TAa0fGWj4FwKeCL9CiyBVd5sRPZ5xj5lgQP2ub2eZH+07YeMJa",
+	"bJHhvc22q/OabiZTey9cuNfJJ0nba/r93grvB7NziyArZzW2HQkzNjyGiBDgoqLJgDPo2GrsfdqE83DZ",
+	"NinB+ptzweNTNOe3MRiO7zpwS0vp/3TYRxhoUgh32ZB7L6kLs5oHvLa6fh2bwCIu4JcrMiVCn76x4x/6",
+	"GzIf9SFbEqGJFWHEGTlSdEGic3c7JyxmOBcrIgTNyDU4V4DRdHxDptSBM24yae7DQN+5opvnL84sl1v6",
+	"W4ozgvxqSp6F8FZue1V9A6/N+yHN6j4nDjjNc4LEZOFzfqQBxRfmgtIcdYiacPicgdQzRpIAtxufcn3d",
+	"FbyQY2ONV9F7lYajYyPcGKXNQBOSgkOkfUdSXuIKPpaABSxr229bb7CFh13ZwcTRISPE3sjNW299lCt3",
+	"X8fVpxHYLiMgdDo37q3WLhL1VOulZ5lgFNAiszvDGvETMuUCLO1rc+eR6ZSkaojQmdLozuk7kq+tNOwe",
+	"1KeUZdbl7O9WdRmODNLlGCkiFoa2IlnLOtxOEYVhp7xgWRI/0i/wO2LsxkQqWEoKq4pXYzdW6mOw4Bmd",
+	"rp2IFSyN8OoC5G3PShuI2zmJ7dGGtUeiaKGHF1yYw2F+cS+tVLYwD+9iAJ88bfc5QLqdFcfXIxJZkrtf",
+	"SaN1BN+Uil5USM/DWnCw8+XpQW/3vdnhLYSm85aFbbmmDlGwlRc349yKPBHS7TnhtjeaEqwKQe6FymaA",
+	"9iGMjC/gcBhrYJnLuxUYzlK6gUxzo14e4VTRFTkqmKL5UYpZSvJca7y2u/HdcXcQTJdErjiGhdmvznAw",
+	"Rniq7LNXx8XmjFJzvCL+FSxDskhTIuW00LJShXnHmMg43KM4d1P9fHYxamEGJYFt2Ewo5zxrefKFgWG0",
+	"Bc/A/UjfvCBARbSrG0gjW21YeERoe6QrgH9fEu6Bl9zhRtI2RotyUQjh99qeXQusM/CQ98oZO6QiOHPH",
+	"nWk9LjefjO4JPg9d4lzdb82T/B42cm+bF/AAi4s2TG9V4s62Ew5iRBgea4TlIBnUHOcxY9w8Nnh5WTqu",
+	"0CFga2lZi7FexwiWr9gk4G9hsy1oidXciETg1xBGqG/V2E0RJOVNkzTLG2G6oAC1mEasP/oDm0bcrF6i",
+	"E4djlqdEKCMNkR2UgV+VWmok3gjafIhvrs7KC++hm8ZakZ5gXDLNFIIeCbeZB9JbLdReyWbo1+vrS8QF",
+	"/N9yz51WAlduef+o5zuwNfqCFkGFTDxA3nvH+vKCmI/Rs19PL8Hb0MRVBB23XWFu4dI/GS69wbq9yfYW",
+	"mbbLTwjmStnazHYQF/0Gs1uAu2qA24fJzbhJP3Fe0KbLHIPDXBPGgMLMxB7CsrtVp1lwuhGyLucwS7ZB",
+	"FNSqW9tbR7E0r1FetDOwW6g3WcRGigMDuWAvcJE3SAJnsQBvuLBUfGmewMATcOfruTr33u5oZ7LpBXoj",
+	"dqyeeS0KqUh2zrMiJ85X7pq7Z6H6MbQdkOnhqAj6LayP5E6o6gJkX2jrAXsjrmyIXZfo0HI3VeUQKz3a",
+	"n+x1pVVbd4P1Nazafx/KrNoGuNdsjWzoQukOIjnc04chPD6W44Kb3y5x9Cj4WFwaKoaYRgolEHWOfSzq",
+	"uNxp7GEAa+KcU+Od3WiJidQ8vQmC5zkRuxjZBkmctsPagpPqA3JvV4vqw7Mx3kQ2IxvfG7cal9YVI6HV",
+	"sLRxht0Hb9lcq/lFXiqvOdMS6+V7/d8XOV8u14NkcJoNksGNnAySwa+Z/vtnyuWIqGKpf1c0p0DjyeAZ",
+	"xTP9f81hRnOS54OY6w2SwejZKRaZ/VXLm+A3seCKPBN0RewH/wilP6aaZ2yTMsXDdgwodXICcA6pP6AC",
+	"QIa3sNPMNfN62ekzfUSevXk29Csqj7TArJjiVBWCiK8kyiieMS4VTeEAzgQGCrTYq44+hZ9RRuU7lOk1",
+	"Dy1W44YYzbHIwnfYlupIdRPC0G5dteWlIEfQjPwXSQvgWc/ZigrO9LWFvr78r+ffDGNkh/U6vnaUEUln",
+	"DDwihG2mV6slKoh7WOAZGVZ2s7wkAV/MohItjc3hfYghOjodnUXR4ZZISr0ZGj1DKRbgzFOikfLexBeP",
+	"t1kHLTrikM5yMIypsQwxDAZ6FSPqlot3KOdBQQlE3gACfBiWyb8d0tqzX7eZIeLb5lyWwbaMQxP8URj5",
+	"ZvRzRCbh1HbSduGaOcrWe23/lJEn15uS0PNnTElaANJ6W5U0bJBvtN3WDFfbX/uqUdomZ7LrYmwNRvgG",
+	"b7wLo6QHE3V/VhP1KbFsY5m0GHX2mdoWtwtpnkjBLl5XxsuGv5LHXAUGwyPMsz8s9HhwwRDVX7xlMl2n",
+	"OUnqllX/0B2/XFZfKLwIdz0nLGlbmLdhdtnth/1201nK3Va+IjOc6ltKH6j+e2e7NeCMMghGDI//zgi9",
+	"CQkOhuYxdxivAR/lf+7geVdz6zb6VOzmhYNAxZ1M5b2/vY+h5FN1iwU5WlFJJ3l45pUJXAhgXbylau7i",
+	"wrXsucwxi5j/giy4WCfo9PLGvBTZEKzY4kgVSjFDGJT3IULPiMI0ty4RXEbzGqvUxL6rgj8FziWHuASi",
+	"gRa8mM03uRnuLeblQeNWIlf1bfyUnL+3EeksF2+W9K1e6zS56JIxdwJdYLH2pn4qFpo4HirpgAPOJjqy",
+	"MNr3mXxtqBeeFjWViYKBMQuA11rE+7/96J7j7Qu9IcToiZ6E6Rd4HeWRqkzd6DPZhhz74rTlrlmbxkPH",
+	"Kv0i8HJOU5yfciZ5TraE+lcuVW2Iu2Sgf2+P3n72eoTmXCpwUEiAn0DYIFujjC8qMYWHsmZ4AILKabYS",
+	"3L8Esa5U1pyth8FgXrP7zQWar5dErKjkYojQiQ+9d4QYz1PrHrsJmUw4KniWB7ENz+AR5jxyvYlXpYnW",
+	"uOWYS9qhfawn11c9F2jBBUHj55r0GVFnTBExxSkZRyzWosWJMR4TQMtnWe9wqLPM5MII0mZbLozQQoN4",
+	"8fzcOxsHbf/w2eKi5AmVw12GMGaOLtCNi/WoWGgOsOWRKffVg/GM5M2IWgqeFWkbmbpzUwNYN3+QcHHn",
+	"pFqaHV7JgtkvOI07kk9iWqeOm7avdNNCd430u+S3RIwUVqTbE2Cp25UdewKVbsmgozkPlX+oA1y9aKPe",
+	"c7Eb9da63yWDERH0PhdIub8f0OXDbfSyghbuPa1CLw8lnzQBUcK13udC9qZL21x3hDGue8iM1bel0LEa",
+	"l9oed3qW7Tn41Gga0W1nEdacY/URGddjUYiRVIG5fOTe1GMF9+Wb87NLrb8/P++v3ppOPgbCGdN9Mj2M",
+	"Zg4A/V0fJ/1/ZuN/na6E0cs350dnl+hrQTIqQnTwS7KecCyyBL2hGeEJOueQIXdFBDq7/EYvXvGUgwlM",
+	"A35/SJi++509K40maEBuo6y5n9TSdWBrqfECaylrlq073UVs7oHFPgJ040qPHMye5cBskw9S9k4dsB29",
+	"HjazgKq8NA0RGgOFj4NTQMgeMgWtjGVceN9pS8WOaMDzxcHe+mz7vU/YdsqZveFHJlWw7JuT0yfZsv0S",
+	"JMgMiywHu/nUQ5TEibkMJ0wxc0BudEl5oGSdqcdDbWER/BW68/nFNuB5p4j1Jo3ykgvVKiSb/e+F1IOE",
+	"0+mZEZaSzpjLLetZyCYMjUyzVqfyzoxEbsOoRMQM0MSx9px2yOHbSzw1ILrXvOMbvtc6NvFr3PR2/FhE",
+	"jLrAvI8rMBJnKxiVdR5mHQEbUgudXZ6fbSuxxmu5tKT1hUN/5By6rrKNft3Xxl+TnG2dIqV1tN/IZMTT",
+	"d1sP6Pv5Rd6XbXWdsUfPtozV65wKwU11maAK2VevZPDs7Px8kAx+XU8EaKngINE/d4ruXXql89qI/oQW",
+	"bm4XxgG/5mRF8iFCZyyjK5oVOIffJbCBCbG9zI1mAWueA6M5fK7PY1tilkVTyp5zWieRaEYfMWKnrqwO",
+	"fC3sO+IWyLCtWtGBBTEJnbFP4BjGcFbjBc9Io+pWs5dueWGZJ8XKKxVlaEYYERAAoTDN6/dRA9U1pHWa",
+	"gOOQeQO12SfthGGJgc1WDmmJz+7k5FoF8lB2wT2usyu9MlGCpjvEdOxsLLvmCucGlwaVv9Cfm3da6Zal",
+	"iIfKs8yReZCGl2+Lmq+vTs6/SdCCYAldKEO/0J+Hu0UPbE4C3bV/C14wZeUBtwK7Oe4gLAux5JKgFc+x",
+	"ojkx4Lu1wON8WMeMTuhkrYjd0oJRSHH0C/15fThHW3jCJUxpaC1Yj9XVNsq91sryDHl05ZorGci2STx3",
+	"QRbDM6ZIPjw5vx6eQhzuyzfnWp4hTG0v88FYJwtVG+kuaZ5sxPM9TRaNVJ/sF6B9Ra6CMfOavyNs90lb",
+	"R6xPfmXSJ+wDr/WhWqfbB2brQ9WnGxWTBY0gOrVuWrvN2Dha26QBrn1MWhltv6kQ+5/QR8TZ7mmJv3h+",
+	"jsh7RZiMsEXaDTsNtga9wTvSRd3AeE+C2HY5EAL4mPU9fwLPr0/N+1B7MgRoiE7Or41lSaNQi2T2Xcl4",
+	"VpZipOJYkJNTrTOenm7xjKa7HA9OsgVlyAKHNHTesIWmRZ4jrBtQqbSEuCLo5Ztz66/o/REKaSKUXB2A",
+	"Uxj41KTXKY1sH2IlIu+XOU1pua9LBmm9iq3/uE0UFM1LpaYoBs8bnfk2zQp75Kq0U5ntN6g3smEdO4kN",
+	"SjMvTk3oMIvUW7dxcQFb9wGyAdMOyhaEa4iXxuV1F5x30vk9OaI/BeEu0WDwpdqVQx7m4O2k47awg0Op",
+	"utsvzIYle5+kjCgiFvDMmBVA03o0F/wYD6rV6RSyV6AJsSm0Kn7J1DndwbF9+eY86LrtXkdWN9W0A848",
+	"hU8Yp8kifrmPCOC+mxNgO9TW7Lw8d2DDPiQoI4KuSGZiZH4bHZ1jhv5VEMiUqDgan5xfv42EePvUNrb5",
+	"i87O3758cx5/P7kca0rg9h0LKj3bPMwOMgtNgkyqPILG5Qe8UhZeNK4yhTGQwI0kwsqjfUihxE4tsjQ/",
+	"CGxqH3tfB+rQNLB5XfVNr51U4yWbIfLelp6G5Hnu9BE03qSxjZNamyZNxRaeGW/Qq30SqvsHK+/jRniE",
+	"8uSh+KejtXB51KXNKMTMPdibMA0Ic70kLKNs5vTpZPBcCL5NTLIZ6Hhw0gCjqWZNZRQAYRKtmQQdShC8",
+	"sPb/SvBY23qjbOoN5yxa4sZhnO8BxGEQnEEIs5G1Ilcm4FIGJWHEaBTjHxQnC6njNO7oMXKLKRhxoVpd",
+	"bwF7kwztNmNTxvqt9mpC1C0hLETO2mScLgCrvAH98+Z30bUbW38fnVz6txy3axv3fueZ+5NGgiaFQox3",
+	"Ia9MPr2AcoAQBmUKTNp0R2OQH9W8pUXMooXotqQBm1YVcu1M9IZTKQuLhorPDHbk60k30lJ8uHfONYcH",
+	"om4h5k6mObp4dT+mObp49dEzzTqMuzPNtvVuyTQ7htmRaeoRd2KapuPHwjS32atDMs2ODdovj7w/JRyA",
+	"R8bEdHAeWcXAR8cj7+FW1yCr6+VWZfVm/58vppt7mW4ezHJzqEt0H3sTYPtwlpsNMsK+LDeC5JCyxnnP",
+	"DdstNhF/62uxKXGBoXcD3KvhRoP1GA03YV1Nhpu92G3CS26r3ab82Ntpt4lGO6jdZru74BEabfZu8eyj",
+	"eLzmyld6NkWfiVTw9y/mSUdLi4RR+OOaLggv1BYOp6anATwSPQTRNEOyRs3YyjzDCIbaAEa02TxAvLxj",
+	"YE0eZVZkKxXcLluLAzacucn1XQq+WEZSWUblMsdrK5jFwpiqLlwu9RjDCJs+RDAemrxfAlShFEo8QLbx",
+	"eTPC/EYJN4JvDnkdNm9O64tlvGPbTtxnU1snLu/0hsmLDkJIosQTPvV+eF+lDJ2cnls/3jKN9LKAtJGQ",
+	"KazC49l2pKWNaK+AcItlRMATG+oCU2Q0s7gBqovTGkUOlspMjpZEUL7hDbjBN25bX2dfrx2ZwhkSYbQ0",
+	"mlZ5Yx3JuJMdkVNdnVAt9Q5eUfZO7wtlK/7O1XTtynper9JDVd6gorwQlLDMaqWcQaKGevdt7lk7kL1p",
+	"ATc7oubR3a51srMH92eerT8YBX7Z2f3tbNnf8/DbaXSgI74i4ujVyesvzGUnNH0G5PjgjGYDyr/s+L53",
+	"vMu7fsftntkh9YbLORfqKAdbUCwRKz3H4+c1DhV9MPEZEdd+2MpWdPZl//a6f0Z72yHU0yl+aInXOceZ",
+	"s6qBwX5bdvH8/ZIaW7XWIduCAt8RZkwSJnAe0iNThq5enH7//fc/IcNDSrkAMqxMYcTBYTKLVaGx9vWG",
+	"FUPhpDpnrqQQKeHNLLiQ1izkLdyl4XGh5oSpKEfX/tMvxkD952/XFjAn2zu7aOmKrSY1q609qe75H/eP",
+	"9KmRpLPgtpG/5RGP9NA3hrztyKJ99eGSxPVZ2jScmNkHE58DVe1HBtiKwL5s3O4btxcTRftufdYWiVYK",
+	"+/zU0Rq1HZpNHMTg8GVDu4PCd99ICcNpja+E25Rn5PMUKwxCtsHHZ0Jk+2Ec96a3CtnX9dPauDCG2aHB",
+	"8eCfvz85+umPP3+8+8tgG50MC7wgEHpeU3d6LqSqisUL+eMLtd6bWusJMA5Eop+1aLWB4D7X+7hMfA/D",
+	"Kreiw+3ZJvr6x6OMzqj9V3AK4cxX7EsFIeybD8NgO5f/IZjtZ0b7+0jfEBw+75/f5uT8etesRw25KPbi",
+	"07r78j6bfDf3jiHZiOO+IST3op9Kft8HIZ7mhX0OlHMforknldwni9Z+ieQLVXTWWdr+JdVl2Vy6oeT2",
+	"CXRPuSCnvGAtpRdCinI/CUq5INJV/Akbs1VRhoPkVTfZX6Os6lX8tIHemO32B5Puth9y5msJt2K0FZ8A",
+	"gjzYDZRUAf8uGbziM93YE24vzOSm0yeGGAf1Zrw0E89f75kqubtioCXmhW7k2airVqo/4P/hgqp16djK",
+	"WunHh6mh1gbvJtQmaGnLkUQ4cE08DaKzqNLFUfT7C7yg+RrJUPsKogXPoXhsqTwZeja6fPL0+x/Qd8O/",
+	"aezlWBFxv+pu13ONScpmu9R8sV3jsHFTBqp7L3uWgCE2usJV42yrB2NiPvIcjT1O44Ki5fk19DbMJzS/",
+	"Xi+jmveOJiQan17ejNEcrwhaFLmiS4jkdKt2Oe831Zn56z3qzGyVwjpCeimNNQrEJn1PW022PN2EoJwu",
+	"qAqFg6IxYWLynqSF8td2CmkOIX8FDMC4cnWy4q7ewYdPp8ZrpWCpER+oWj8mWemKSHK/V2dJbN3Xtipv",
+	"j+9FGSr1B1nQl28MJY994mJTPNtVYDf1212tGXRyenmGoKop+rlQirMynSX22BdyDo1Mm3EpiGtJhMaX",
+	"3nCyKHJwp2QNA+tBEp8dYvyCi5RcTKfNgzWOcGGL8SdadVhwlq/RO8ZvGcISYTTlhTiSJOUsQ3OeZ+5a",
+	"MAVVJzDEozs3+3o/33iEYLY+JU39jRl6fCH0L4R+D0JvLg61n9KhLfaJLYqmWbieMyXWp3yxwCxrCY43",
+	"H5Hh/miJpaxVG9T/lCQnqQIqY4rEVYm/khV4H6bOegVwwI2tdWTRAmcRu7xO260hCZHMbhc02ucYEhkt",
+	"uBYbyQrMHO5og6Rmy+uj01dnm2qk/crVS7IeaVbJUvLMPB01b9Kcq3dEaxambVQmwKk28NqiOCLvaUvh",
+	"Pcju9DBb07Uliru3IcXL0m91kYUlxA1LShAXCaJTtzm3VM3LG5HoUQRRhWCOsHtsz6dXGzSupPylOGhl",
+	"zUAcv1E1PzeEcfrqrL7yMzu7rC65iRsHfmBIzmQQsXthye8r6fjUUU4ZCamf0Nenr86+6QiB2BPqDgv7",
+	"IcuxtkD+6IsajhRf/sy5umAvcJGruKjha33jDJLBCVubb/3zWboe5fJ9c17k+gblS9j4CeeQLgSzNZrq",
+	"5pAmBCYt9bNSooSGTDM/LROnfEXE2teqsXnSYEwotA0jIp6mhZCbMj7G4LZn5/AA3VKN99Iy6lPaHN/W",
+	"qmETH9pUJsFYkphOVlLH06mWGOyCMUuJ/Y4Uz4kwP3CBUrzEqbWABIT1hVxzdsoKkLM0DS+WIK60oq6B",
+	"aOB/ThFy9HJpbe2DZPCGClXAXxejQeK/5OtLLBSIq5CvyDar/qxn49KkNrq86SK7pSB6iXCrXIzKWAjJ",
+	"f3wzRBma4hUYlIIWpemmWkXPVAQxusuF+2aWPY7KId21nQC/hOPBSa0MoWYyShSp1d8m1ERsu2HRJOfp",
+	"O80fZ8BZhxYPTUMB2fgDosF1Gp0074vADaxJDcLCGVUJkkU6N3rUaIGFen12OjR7BddxFRmIMglpKofR",
+	"XjaBM2zda914jkV2iwU5mmAtay3d59aHUEdFuvPK/I0WOJ2b68GAhETBILCS1+zFjdQVj6UVZT5VW8DU",
+	"yUZKez4OZ2SsBxu7r+MofZEnQQjvpWyWkyYagQSDGZV4NhNkBoQc7NRxvjnH8sEiIWk1P6Mjohpszy5v",
+	"eoJVpjdnljV4skql3Inq6kBdjNpgYuhipDdvvl7qxUku0IqS2/LTcI1WaxO4ry3TgJJgSRZhfc0qe6bc",
+	"801Yj5FhFsb3DLJ85ubctp+GVnBKTXelFs4gj+SCCxLeQINVyJAMRlMqFrA+jc3y8YzoJj6HNbDtx3ZA",
+	"I8Ixli04k1peaTnSQ4Rc8LV0QkOsjYyrjgW2GEqpQu+49PbB9Ti3ldc63cmW7wzHCec5N3eFFU8rUHYy",
+	"ljbk7H1LHVD1Ha0wNL+LnnO9KYnQJa61evr2h7dPPKPQ0vWPRp8pdW24dldP33731AriFVnhWhRSkeyc",
+	"Z0VOXAa4a65lzlh4iBKs+zRx/dMYhnTZrzmyMyIzpcsbt7BWGS3mDONZ9MYFM2i1N1Q/tBkIfe/uzH59",
+	"cnfjhnlK2Q6bIe0a0K1B89tei6jvVa1g/H7siyE8f2+Wxpurs2Zryc3VGcLKVlCzKcilYeZtYAy7HrsO",
+	"4TCwA4wJKqRLMRgpdsZOoRlZOdkBWhA155nWQkbEaABfhaEpm/BC94F5v0JpjgtJnOeBG77kQtCmfn9n",
+	"GcSZ1taxzZzfbueg085VusJ8NIyGKFsW6jCWi52hQehsisYajHFSGYJKNKHeyRznti2cl1pjeNSws7hJ",
+	"eaGWhQoJ4Us5dds34HOyspk139/ms5EvPT7rj533rf3/Dgx+YXqGbKVuJoc0Y/puYN3RnA1vDsUCsyN9",
+	"xrGpXA9tD5O0pW2ugJ8TMZONZwgLgcHrzKEBi1mxsPoCVlCXSBYTqagqFAlpVkIzy2Vdf3j3yTl/RzJU",
+	"LKtfBZlRqQQYeqiW9MCRo+p/0YIhgHUXBH24ZSJ0ZlLuAkPAC30UF1hfaxLZX8fRFpXT3sfE6Fpd2ZHH",
+	"yDzNG3Zs3tmEzZqr79XxJRbYCu5GvgreXMZp0jJvR+UeZSsizDmwvpXw4mSfpLx4j2MXPdMwJrezltdS",
+	"mukrfUqJ8Bg+6MEYe3jGicZ3RqbU1qkFEcJ/tgmlvOhgV9YiOoSFjsiKCKrWvf0nfiU4V3M9wgVZ9O6l",
+	"20JWKSiyUObRtbRS+h6extpixdWthPMPcgivXpz++NOTp0duO/5zdPEaLTnIJdJf61Y67LEQeL/ES91S",
+	"UH0v14gLkCd5XhhIq1i7sW+lVkxHspjNiLRWR4ZA1eagVOcra3+mqrDJwMwzrXluPSxBO8cYswxHpG5C",
+	"LRqb4hvwaizIMscpqXaqHIEqx/Lvv1or99FBUX/KfB+bektW0DtSZNlSSiCnUhlTdcoXC8IyrdHr5juh",
+	"19PupjMU4Hpb/ufgbq90vYdl2VeWymS2HI5lvk7OH1eY0FjLSePwr+jkOGjHFy/HrVKoE7wDS8siy4gh",
+	"4fqeStu+So696D9McEWwbED2pkePGg5csXHrI2ydp/3jLGHFwpbKCdeBYxdjw52jW9jmnx8bR3GLuu0P",
+	"bQuOGu8kM1W/m6jjyJtLv+dpN43hzOPlMqepKdZjUObd7eqKc2w5A/Oa1WPisOggEtwz7R/uLapbvLrL",
+	"YrMd4BNVfuzPtrZcE8M1BeN8jkStg+Mq1uqKDWkfsNUB31en6zvJ3y3Whs/fK2CZZ2zKe+kofm/NM1mw",
+	"IhsAXKveV0RVh9z9UjB4qCkbhtx7g32XDNLGHAonTg6PRCQcbulI2nW70KR3Hcxh7R5Q3SWDRZs2fVLV",
+	"b0v4qug9zgfHfiyxjcMiYe9AVhkp0ETAU29u2sL5jgKD3CbQZuM5r4JNKqVjDwGtB2oTp6sJqlWBcAd3",
+	"e4DHgSehIGpZDPTvuAYKr/YEqbohUwCYWy9dxpIWedpnNPFhxNbR/ubqzBr7ItFdw1Jiiv2K3BlQNHd+",
+	"G8FTL2d3f1la7biku8Tiq/UVpQ9aHvTJpNeidjARXArKg/Rev73NVx+3Saw6VppbfhwRvn2B1SqTk3fH",
+	"T8ZN3mJzOpsTqfyQQ4TOWCoIhjcoqyG44BSnZWXEt4j7TZG65f7urkJjoiS9tc91TGwKcZJa1V1kJmy5",
+	"op2bMbwwQb0wodub2WukgjJOzGMrzI0D4oyHsxbdExuWazzhqERPLNoCkqX3GPfVWrcBusJbnS9dQ253",
+	"zS6bB+lfeLOViZvQpAOV2uwEHZYP4SI9YuwFUVBWdTMz+mDHLwBrltsJsFs8PJuucD6CQKaWW4vaRr6G",
+	"+CeADQdzos+kCdOSiV9ADwzpaQtGldQ3B0ScQ/jqqaPt1qvLFh7UNwV3ln7bZ4e77CHyB2wPcbPVq8Hi",
+	"5a/5+KXEMD8bhk6ypooEJfbwx70fWneQ8Ay79XdY1VCIRYjYiS2GqTMCYZTzGSJMiXUC8u4K2DrWmDfy",
+	"KnhSe0k4MsN9wvaNLi4fOVudaupL1RvCMi7AwwgMYf5wDZLBC+sZeLPMsCLQRhL9AWI0T9dp7n+85s/M",
+	"RSnBdzvPSaqeUTxjXCqaPsMKD5LBxfPz/v5czYMcu99R5j+Ap+kQ5o2XdOz+jVbwA5yjyLRSWd3x4NJF",
+	"ogaXyAK+hVLhQ7uKqDFkfGqgXs9XImTFc5gg1VT/Xh6/thHH7ifrhwC/Dv12xIOaMOHKcOXtOTa/OPFQ",
+	"UTYDS+8Up4qLtRN4rNO/l5VP3ZHZUt07CYfNaMWWyUgIO2CtWTFNl80ikR99O0GovKYHkYBKkDY+JtjX",
+	"hFd8BkG0OyTU2d67Ijj5lOB7KIeL2L5XheKLK8bjd8X4rBwgdrBNXAg6o+xiWmK/2zGFrkf80cZH+4Ny",
+	"hebH+TBl9FZnYwAO80K/KTvefh/qSyj99B7k4+05cakOUsxMNKQ1fVhHlJqZhrO0MopxTF/wlYtxKKUy",
+	"aduYv9Uf3rf0JbqmCyIVXixb5Au6qAIKwZDCuKQetIReyQ7XCchdMriRRJyUHL9HsNTmZdnoQq0clZ3F",
+	"46wOzJjhLExYSp5S8CLw8ZAlEn4I/fjm6pV7AqoAXoofoLIR3NqinPZsucqEhDRjfmnSyauyyJV7HYE0",
+	"EnFZvAYx7omhzRs7aXtedwDJW+xTXjD1cWB7N+AOjtNDeUlU0y9iltlMstLFgJZUGPKeSiWdowuIrT5u",
+	"19pq8lKEZpfm80lbGhrUqMjEcJITofciyl4J8eCjYmLc6LfIJgBDufxB0dWhry79bVibp6ExjRsMS5A0",
+	"tIZXELgvbMina7wplYCHtT1Qq00phkfv1JimQmipz4xQX+H2U3jqS9ACU6YI8zkFJNdnHsIz4FAaC65r",
+	"7eCxob/GZ8EmJuNwgFd6ZkZuvQGljuPe8Hrf6/ZtgLcdb8N0Dq72Qmhy1cb5LV5L77JaVji18OhKpFat",
+	"HyU+0sTOY/bhko5G+dhuAidcLGymNf9GBzKKEWENkxwO9sPGNwAVngB9VzAjedb+VTRdfy2nKmtFDOHi",
+	"5SAZ/IYFM2s6FVRBaHZ/o6DrAYYl+49oCz2R08WCZODXXGK2Fy8hPFQszPF3oJTNVE18ukQNbZpqwei/",
+	"igaFNb4f/KWhmQ1YMu3uSLqgORYhDHlfVNAFTi8qOMt22PzXrZJPLFiUrk3QQBbEBEbsZ+1hruodHU/W",
+	"Bwl6PTugwar8zQbTNvfgUgmBraozmhbVDAZ6vGBgtcv12Cg95WvdKV+HdW9yLIoCq+UnK80kg3/+fnL0",
+	"3/jo3zDF//3LNlaaC7MpZZEIbP4jBe8KEftjmgVNp+5RgLIZ/OT/YT6Bh3t/nqh7+ZrzZks1OvSYJEN8",
+	"OrUbHtYRMyHfZ0Fnc1XKCwSuESc3/2XGAvbJumYCUrXQNzSDD8PKcjXnVWSx5AKLNZIaY/6F2ErivVeQ",
+	"YoYUfudUZu7SPEQ5Qfl0Gmka0SZ0wqE7MVjg3uAItdVbkzJ4TMYZzhqSylYJzKVZHSSDXwROybTIR/NC",
+	"ZfyWRT9dEakwSOfQPvzz9YL6QYA4y5lgq69/o0IuCcvczpsHpwLMIS+KPI/a9iZov4DjwXUhDP6VuV5V",
+	"uNjzNfqacXY0swtC0i4S0sQ5+N0QrHGEYXX5xwONKqSHKc2ktz+ezP4kTDc/9rC+6mP4ofTat3kt3wwR",
+	"+pno8ydRTt8RYyCDJDqKguyYU0ZkgqY8z/mtkX01MFzUGjmzSWxSqxJBvOweS6yRVUd/f+6GlraOB79A",
+	"sRaQ+aNHXNA1RLFULhoFvKtsnhiGXp+f6V18/7cfXcITyLEJNkebD84/e8rE3GNEkXgGmyYOMhInIQFL",
+	"guY4V5WsQY2k4/nb4Nj8P3b0iihsAriwuTwWfGVPvU8HJ6PsLxhNCVaFAKGimg0nJDeS9Zfk+1GUe4AG",
+	"AHFeJqXwUZMUaSKhKls4HoyozQVtHBFt1ieXktmXjolyM/t8XQ65lnUc2z/q6DWXiGl/X2w6znU8+E1Q",
+	"lyIPGD+P+I3iKKPyHZqQKeRRsleGv5WodMkbfA4DGENxNCEOgZl5cHM35QSn71CJ9zeZEWI22JnXL9It",
+	"8hwpgZlN+wVhyOHiA8DsFRa1spkM9SGPWSNCN0uodgkJQjSDtWcKbAEmB5OXcsLLn8mL63TypEEmt16n",
+	"F9PpuMKp779K9jCL7FgVGzdcKvtbWYLwFPJI21bwzuLyPlle/fFssUVG9UbcBh3L4JRTvUcx5JLpvOzg",
+	"Zdy9LrnrTB/ILXDkuExGp+ATaO3W47CksTHlYIWo+gpextOcS5NbE2klrwr2kktJJ7nL1E/eY432JFzz",
+	"J6euC57kRFpLOUOE6ZE1f7NZ9Vl07euFVzoaExm8FjGVe5NTlaa25iKJmXvjKeyYvDTUtqf78HRr/ca9",
+	"/dB0k+a+Mu30Na+gJJCmMsat5TSjUlGWqtKmT/UV0WSSdJWASuSErV2bYqDocfkEjR1ROs8iY4Nd4LV1",
+	"fYwyKltbZzVtVJRlP4IyJMbo11vffZCttloRyMHUuGBi60GEkhtgcnU3LHRUNuRrKcBn0yfUpwvCC2Np",
+	"qMuwHxGXNd2nVEgVm8sVlu9MJkI81SKa9FJzQ/0OzxVAdtBNARBoXktIlNh89lI1ZG61IorxlK1NbbVT",
+	"IoGnGM6VcsaMaVI+1C3RoFQ8lNjzZbe2F9uMKrfNDs261b7IvrRHMfBBSNfphPeC3Gg2DwO3MS2Nazrl",
+	"boJZ+Qa5r1hVuesi0SrS83z24ZynOKf/Js7QYEt5RJpngHpOcwJ2dcG8IkolkgqWYwzm1dOsCnghQs9O",
+	"0YrnyjqVaT3X1KGdBkGsu6nT+b4IZPc4ZzWbwzYEOyEm1s9noGy2ScBTguawTkeAfpTb8sDWrNHeX4th",
+	"E4IysiQs02RtTRd104IrjOUnsF1TzqZ0VggtwZesIp8eZww2lm1gN/vEnB0+Tid7K6hSBNa0JEJSqTSK",
+	"bQbncBQ3CgMPcUm2WvZrCrFLnRyuEmfzrzBon53Z00RoGHDd+GBQe41yaUKTOO/ySGGWTdYX06nWp8MP",
+	"oyUWBBxQrolU5nehjBX/ZCJNvNAN81WiwgDPyJQIa+///wpKZAoTQdSN+xXndEoNKGQmcNb9/BVnng59",
+	"t6r7EK+qo4KDXZkd2iVXRlygjDgNiHEVsVQXfAdNFKhG7q7zNF5K+J3iJZ4YC4YJRQuFtiAJORC9UTLd",
+	"pLa+FaRKz22K1IBlm8TGVvvzcc7uDUofK1tjR4IG+6+CFLoNuYXHXCKNeuU3wowXrz1+1ctss2FMRg34",
+	"KvWx7XQfn6u2u0uUDNZS4IYOBcuImHFg1USa8h7CuIDFGeAhLgcvVWGTsQRGM4UdnBSzGWWzYYlKyxj+",
+	"V2G9eUqPgThNyVLBNgrMZsD4S2FZ/iiUR4uy7+rNgeTAkcgPyqegoHHbuEi3mcP66e2HVJgI32Jqyip4",
+	"Acnq57Frl7HSl1jChjmWWvDjJgI/K1iGWboGyCFftZ0UTTHN+UqzaGGNKL2gMAxoAwTSths2M6hN8Nvz",
+	"rHGUYmaTyrmXbM/EaptY2C+mwAA8ret+YX7DIdzh6fYnLHGhljvUZvdq5lEYRmgKZjFjB6ejni4uVYbT",
+	"dbfvlxX1kiKqp8jr2BDg49AOpdqbGFc7inEHw/Fb28DXdhkRboY85hyGiMsMsJscQhD5A/DEPkRwHy7Z",
+	"c/y988+uzYs3zPmP0HxdOukaECPap3wRV9L0NsUa121js31B6TU9LhTXO2ufTmNm7Rhy0gEjeAxHPrPu",
+	"7SWdw1ZSFlQezKxp3HCkiNCbOHk3ScfLtJXLXH6wktQ/tkdw3M34dzmZ8aWgGZrL/Nh2M/QkXHdnWL3T",
+	"fYn2rnJ/mKNCEADruVpOViQHZTWUkNOtK3XzW7WTmLPbFKclHqy1i5/gx/j4r56+dT/6I+t7N6Lf5r4s",
+	"4SqkVO2oNlOZFoCpqTqF3CGvvYSOcGfHHufhNZFlSEss6ZzmmSBdkesNQYLhG6qFjcQu+mWX5S0zjzUE",
+	"7O8z7VhI9eSecFYkDu8xSwDBxy3CL7YxNMa71PkhNL3bIoilBLNcuL+veJ4Xy3GbT7t7b9IDCZ7nqFii",
+	"RZErusxLE3GIrTWCgQ1FciPFpVbGHpNnzGYTd0gehyh6F7n4M5YEWSdWdBUCqSGjWshLVUoIYNZs+SY2",
+	"AlAMZ5oWIBpjGf+MXSqtVS32oTVs8qmtA+098xvSBBjCj8xVMZ26i1uLjSaOkEKSTmfsKnmvb0mxPjZz",
+	"f3kYyuRaXxopO+bzAjxgJc2Mk0/b2iKHcVnxGIdLkMtaGuF2X/GYppu3hEPV77wMv6e4UPYuPgqfGvod",
+	"az0ouo1xP1wKAd7Yjz1BkpCG+hAhQqc6yzOsMDrnGcn3E/XvbXXNV1QNezvstplin5tdrjXbDOauBXtC",
+	"oPraXdJcOIKK8q6WrutPOrrSJj644ly9fUXZu13EmVz300fESN9xvVCbNMTdxnCMKuyj9z7tkHzWQ9YN",
+	"E1imwLfGxwPCXWeCFYsJF5m+wAkUUa4t4FHsvW3iBGEqTc3rZubgxrM3P8pcc5fkty6wrp7Wh9L05rS5",
+	"Wrp4W5DQvpAOjgffCtPk29XTb2thW9WY7dXTerB2ZcXR3zvQ/DjqPg6xlS7TMLAjqDk+bVpeglzlT6tt",
+	"fhWt7it0c3U2ROgkz2snypTRo7FWHw8fCtk7l2erCmvq1oeBZMgUjMvXRq32/6oWgfM7UEkND0Q11KeE",
+	"vFe9s8S49neJG4FmW6SYifopG4vSq6cyCbcGlbjaLe+wuPfmm+wuGZxlvW/iM1ib57xdfeqs+i4ZuPjH",
+	"XpNBY8hEzLMiVa1lBPTHhiQMEQ+OFIBDJYqw1ewr8ZUBPi/0RV6BDeA16Sffu3Q7Mc9rxoZjcc3nGM6H",
+	"Yf6D48E///GP7P/+4x/D6H9/2WO6lrKUW6vMaSGFXFI291BkgL+sNOtlgIfQF1uzBVJuWNZgpWKTWNjU",
+	"c5XbJ4y6uTl71lDvqTG4OXjIRpWbf5sThkajZ5cuQ3ISu82WAvshqZie0NYhMZjBDP16fX2Jxt89eYIu",
+	"Xo6DjdE5QsPo4/Oj0fOTq9Nfx+69AGXGau0vvqaDEBHG70+OfsJH05OjF3/8+be7o/ifP2zzz6ff3f3l",
+	"QPmxIoQ303qM+bNpO94bSuwcGvkIXb04/eHpd99FN7CtSqspuDBG41QQ4xYIoACwlZBsl1DG6eZWOiSI",
+	"L/G/oPWpcRB2la9dH7D/Kz0+LNgp0mZcSK1RMKpPHpjA6/H7Wiu1Q2kZFK7xpYDny7UWQKeU5FnpSUOv",
+	"AY6fy0LazLwgISm4/LBiilNVCD3bR8rZS0By4cDvw+itR3k8l+ZXwYdGBXTAlKXiXRYgzy3H9oKMInEM",
+	"ubTcJ39tyBoUxJyy6ALSgb23t8kn5C0YTZdBh6j5iWsoUqP61GeweFv7ZQfZvZwQY2yHHMfWR8Pp5AHl",
+	"X6LwrHd3aPx5yM7nkCujJfehSaQhvRky7GTvHId1OeSAeVS9/UFtAD4s3BOYLVXQk7x069ogjLxXWlPo",
+	"PY7vsKtmsbURspZrzex+MzqSDq66P4YaPcS1cQrPIKxw6vXvhnp8j431mo0BtpvnPViB7ea6D/Spr+bu",
+	"buDBrlwUhCvYZyfbSiJLHIiwDGrTGkXEfLVq8ltTj2AXe2bkumDGaEhoNLh/KsCe03zqFOT2o/zP3Uxu",
+	"8QgtVjdpGnmtxT34hGs8MVJviTdrqRPnPreuHeTL/X8Hbtc8LxSx2L82sZEt9zN+TxfFIipQY+uxOFcX",
+	"tztUIr4kzAVjxnZHiDUr76UgMyyy3DqNgTcA+JY0VZ8xEAyO//bjD0+eRNVovn+yp3IzD77GuDhNZ3ng",
+	"5p3yLoINee1dWUhzv93OCZibtQRjh/Lg2ZBY8IZaLnNqwwajc2KRO+E8J5jtkob4HvOD/jfW8ltz7XyI",
+	"X3StwxsQ7I9LqFHf0GBGsxfQuBnF4/iBN95GB73fTgMnsDjwNKENWqvxXQVZpGkt4Am2XJp0NW142lBI",
+	"Orobe1zd1Rv1EzCo7yS82nVuf2BKxtEojKBClV2NDEkkiKo4dCExGaHIbaDd4B1u7FlZgnieNX3PSE6U",
+	"G4NIhSc5lXNSbhsysZWcf6umn/0d7ofEVcnI04yuUpPdMRbEnc77sc5i+BRR5thD9QbRs0GQWukKKcs3",
+	"DVdJZvLqhXE/0E2p5oLIuUa3VnnpgkQF2qICc8YDH3LVhaIJnnMq+wABcn4jBmIW340G57fX1N8lyMBs",
+	"7fJuRBXkDM84CheCxZaJu7ASgSLwJlIrJ+fUlu1NE8HDtLezTSEfzhRZfmKpoDVyl3nsSvIXXfNj2YgP",
+	"48JUVhEvCjXhBctOfbqMbQ/+3RevqA9PSs5etbuhIrJmxTXIJWWzPM6mgr62vPMbf+dgl4oI4hfbn2K/",
+	"2Ce21GViJcY85prSV2eXJ1kmiGx5eDi7RNh899WjbKooqCFgRMv4GnyoEio7AdbhE3MaCKdWYBEGPtKC",
+	"EujfBm5fEMdloHQpvR8QEbgGm6VnF++yACmlClrJhc7+9pVEOZ0SLa12vvYmg1ODWy3vt9RqAG8DlhnR",
+	"F/I1xZPfYun2p7XS00NQ0HZgNiHEVi97YJvA8/dLaiI4d94CoocgcpPR5tB1uLbYjZ4QlwOUXI1kSFRc",
+	"KRPhJiAem1ZT041wOndKdx8rlVW7XPy1gRVNsISs7SVzVdf5sjXXDuVEGQuKOztQYilvuWipz7G0X4OM",
+	"7Xhh7G5EJRpr6h5XCsI8zKnvB6Mv9t0EqXXAA+ZgivRU+WoQXCAHXfBONlFvmKHxSaHmrzkjYyR4bnNC",
+	"tT+sk8VS/6xsyLiN+jBeYROemXDTK54T2e24rueSpfo/dmK6ojmZkfBIH91i3r2gxTh2sMqs6r6QN52y",
+	"/3CVDY3VqrUAso299Fu7Xm4RBlSRpfUs8oCRXy4paKBDI5qEvDlmNRus49f8HWlxB4b4ziNTw7paIVDp",
+	"bh/zmb8n8J3MoAWjP4Yaha831yj09YRtHcAaOA9dlxAIaIFVOicmVa4FTJCUzxjkA7QvQ+5LcEgE5og/",
+	"Nvb4obwUw+ofpzFQw+0Qe8GMbqAR7Ck/Ehr+qFsZDGeMsqb9yqU65UxyqH5ybvIkhx/OLs/PBsng5Zvz",
+	"s8tBMrh4fj7w8QyDZPDGlCQ4JxnFg2TwG5nc6OYNlqne1VJigGwEN5fqKwgVl9xkpKXpHKWREzUzOZsd",
+	"vV+TnBGVoNHo18RkITPWNhfCMHQLOx6cMUXynM406VzmWEEQrsECJKs4c2dl6LGgVdSXZD3hWGRHb2hG",
+	"+NE5hwiHFRFaT46YSAWfznkBftx9SaNzdPrqsnVpTXbBwUmrAc/EGXPbKTIXQblq89Tx1UX9c//cSo5e",
+	"YigiJJWI6Nj9E0Fy1aGnKt2ZcXbkBrglk6ioI7AzO2ZcaXIm8HIOSS2jkLWAtlsyOTJ6Q0BgZ+6qKnV2",
+	"pUKJ/DPUQcg4KEzxVEQswFyamZxZ9qWxzVfBlrx1FkJ3M+oLlxiJDO4MC3W8bfYE9cYBZqj3aYvkgodY",
+	"ol5KvDR30PuvrR9HeJjVvHxzfrSRDW1BuAflVw+DEpf/v4GMG7nlNkTdwDl99gYrtN2DfRrBeFyHMvIF",
+	"ohBFZByHwN7QWdklj6Khm2D36XrV/UnW+kwYyTVEAzUuJ37UCTfGFkewcrXUNqH6PeczLc6W9JO+m3If",
+	"pFAGcl6U5c+RqRfctZLUcDVugYxVfIs+MANqnNt6MLyz5TzgE2VxnDn312R862+x5n7iwUPtXmtCskaO",
+	"4ywld8mg9ljWqMxeQJKWSklkHCdG8LbkQtAjQSArfbq7Pdmp57xqpPX6uqUMeBC5uXpltNpKrgKfHydN",
+	"4V0XMt3BWo586LCJUrSD2oMIokJLUhxZy1FTCVjZ4CMFBjeTS7Mc6FPzZWrB3Cb3pc2owwzZQYIu6xJ2",
+	"bQQ0XrB7Tm2IRjPGKfT8Gs+aEu4ciipw9QGvwpcBHojQnROcQVbFOC/R1YvT//ju++/Kq6RbVawup9D5",
+	"IMeirZR2LWPUvgjfeHhs51Nwgjw6TJ75dt+T3R7ge/ubbEZq4SrQe5BlFeYYHXGEWp1sbq7OapXWrMjk",
+	"D6FmajbF6hILReF+g+igD0JU2AEdJ/kLD894QVBkZ0u2Wk6MONVqsHdGcPxAXESvdyrwbOG9DpyXpCwZ",
+	"5fd9qO6SgSRpIahajzRRmwPwM5Y0PSmasg4CL4Pv6KRs/J5GRr2Ty7NBMoBjAh7Pun1wwJsrtTRuQpRN",
+	"eX2OcyJmJIsHK8OtR6IqN7VH4wlXLgnJ4OnwyRCM5nxJGF7SwfHge/gJMkrMYZUuW5D+e0bgIvX5jM8y",
+	"qH2rgjXQW+l1u++ePNH/A3nAXMEQT2HA+/Z/pHm8N2xim4w0bQmkAFllJLWlLonySLnAvgF0nuIiV3uD",
+	"2k7/XAgumsCDDyEDZonSBse//3n3h/6llI5q8za8efpQGxHntWpYna2XbjJteAdeHMQbH91gIi79YP7w",
+	"fhp78pcFUVhzy16bc+4ab7VJ7xf54PjPOrRGB/AQDD8NjNUDNDeirdLloBTeFUy6BzqPx/uoST2+4n43",
+	"SZaXWKXz+k5d6p+79gpeBn/m2fohtyk8P1pHrkdIM989+aEuG4xMGajE5nMPMwHj+UQorWjgCJeF+kJl",
+	"X6hsX1TWeS19GwdTbXk/+a6Hp4bOjEX7ookw5Cd3YXHZxEe47LV1B2MoIUdJHxby9LDT121AVnfWRKB1",
+	"ats6FKGzbtqPhzX0ZgbfRlmjdqatkHvogCTWmk/nw5BcNzg7kyD62qhA1Tw933yOtPmn/essuzPrzonJ",
+	"ul+m0Gfw+wYa9UM9wB3WxY52uq8+DxF5R6Hk8ezsJ6EwC7wgCm6M3xszpwazN0FnWTB8t607GVDdd4nV",
+	"fJAMGPg6D8p7GrP2JFp7NZP9H1W+EhIsb6Yt2/aANHTKF8tCEWGmii6Qtg/3p7K2kT8tsmve1m//LK/O",
+	"3hJ9d7ra+eF2vrLf+97lz46ltC2/kbM0bntvBtPXYthBYvsXkHtQ18MZdT4cqX8mRp1W5vetDdCvbMHw",
+	"ikjDEj+xg9ZDG20+ZhYP5Z8NFh7kAMJUV9E8D3wEN5Fg84mzXgZFrmTwFYVC4FYWeZRn5YIsvgUn/sqh",
+	"OcUsJfnLN+enGkvsczw/F2TRgJkaYh7kSDlYThaqCsBjOGjVNX3OZ27E8y9nrunMRYj5MGcuAPB4zlxY",
+	"0+d55n4hDEqUXxFTz45y5oP4v5w9RRatCHroM9gGyAc8i7sAa0DZRhGc2bEyJMJoJiblMzusdqu/SKU1",
+	"1NQx89DHswbB41AAK4v6PC9Ji4YvkmnbufuAomkNgkd07j534XRUTBY04j6nPCNfjp793Iichz59TUA8",
+	"hgPYtK7P+QwGTvTlDNbOYAU5H+YMloF4PGewvK5P+Azy3iFVF9vHU9WX2pZfweV+yHhaQOCpqRndWJ99",
+	"z/nRgSM0wxbKx8HsEC+7olmIqW8Az2cVLcP5jrKmWHobS+sjexF64xNLjiCvvOJsbKLr8xylWJJSYL8F",
+	"YHNE8J1jWrX67JKIo6mghGX5OniExnWc+8cd3yWDQuT1Sa5IjiF3x83VKx+Rr/jyKCcrkm8zQSXfITOp",
+	"+AC7Zu5adsO7Sr7WlpSJjiIcQdTHaYsLrNLux+rd2s0Zkj/1jfT+CAKkj7CPuIZ12H9HXTQOAaQjDW1O",
+	"sV6hvfIMPo4E5+poWUxymlr+fvf/BwAA///OSUpnsdoBAA==",
 }
 
 // GetSwagger returns the content of the embedded swagger specification file
diff --git a/redfish/internal/controller/http/v1/generated/types.gen.go b/redfish/internal/controller/http/v1/generated/types.gen.go
index d1b8cf36..7874fea8 100644
--- a/redfish/internal/controller/http/v1/generated/types.gen.go
+++ b/redfish/internal/controller/http/v1/generated/types.gen.go
@@ -101,6 +101,15 @@ const (
 	ComputerSystemOemIntelAMTKVMStatusPendingConsent ComputerSystemOemIntelAMTKVMStatus = "PendingConsent"
 )
 
+// Defines values for ComputerSystemOemIntelAMTSOLStatus.
+const (
+	ComputerSystemOemIntelAMTSOLStatusActive         ComputerSystemOemIntelAMTSOLStatus = "Active"
+	ComputerSystemOemIntelAMTSOLStatusDisabled       ComputerSystemOemIntelAMTSOLStatus = "Disabled"
+	ComputerSystemOemIntelAMTSOLStatusEnabled        ComputerSystemOemIntelAMTSOLStatus = "Enabled"
+	ComputerSystemOemIntelAMTSOLStatusError          ComputerSystemOemIntelAMTSOLStatus = "Error"
+	ComputerSystemOemIntelAMTSOLStatusPendingConsent ComputerSystemOemIntelAMTSOLStatus = "PendingConsent"
+)
+
 // Defines values for ComputerSystemOemIntelAMTUserConsentStatus.
 const (
 	Denied      ComputerSystemOemIntelAMTUserConsentStatus = "Denied"
@@ -187,19 +196,19 @@ const (
 
 // Defines values for ResourceState.
 const (
-	Absent             ResourceState = "Absent"
-	Deferring          ResourceState = "Deferring"
-	Degraded           ResourceState = "Degraded"
-	Disabled           ResourceState = "Disabled"
-	Enabled            ResourceState = "Enabled"
-	InTest             ResourceState = "InTest"
-	Qualified          ResourceState = "Qualified"
-	Quiesced           ResourceState = "Quiesced"
-	StandbyOffline     ResourceState = "StandbyOffline"
-	StandbySpare       ResourceState = "StandbySpare"
-	Starting           ResourceState = "Starting"
-	UnavailableOffline ResourceState = "UnavailableOffline"
-	Updating           ResourceState = "Updating"
+	ResourceStateAbsent             ResourceState = "Absent"
+	ResourceStateDeferring          ResourceState = "Deferring"
+	ResourceStateDegraded           ResourceState = "Degraded"
+	ResourceStateDisabled           ResourceState = "Disabled"
+	ResourceStateEnabled            ResourceState = "Enabled"
+	ResourceStateInTest             ResourceState = "InTest"
+	ResourceStateQualified          ResourceState = "Qualified"
+	ResourceStateQuiesced           ResourceState = "Quiesced"
+	ResourceStateStandbyOffline     ResourceState = "StandbyOffline"
+	ResourceStateStandbySpare       ResourceState = "StandbySpare"
+	ResourceStateStarting           ResourceState = "Starting"
+	ResourceStateUnavailableOffline ResourceState = "UnavailableOffline"
+	ResourceStateUpdating           ResourceState = "Updating"
 )
 
 // Defines values for SessionSessionTypes.
@@ -497,6 +506,9 @@ type ComputerSystemComputerSystem struct {
 	// ProcessorSummary The central processors of the system in general detail.
 	ProcessorSummary *ComputerSystemProcessorSummary `json:"ProcessorSummary,omitempty"`
 
+	// SerialConsole The information about the serial console services that this system provides.
+	SerialConsole *ComputerSystemHostSerialConsole `json:"SerialConsole,omitempty"`
+
 	// SerialNumber The serial number for this system.
 	SerialNumber *string `json:"SerialNumber"`
 
@@ -542,6 +554,27 @@ type ComputerSystemHostGraphicalConsole struct {
 	ServiceEnabled *bool `json:"ServiceEnabled,omitempty"`
 }
 
+// ComputerSystemHostSerialConsole The information about the serial console services that this system provides.
+type ComputerSystemHostSerialConsole struct {
+	// IPMI The information about a serial console service that this system provides.
+	IPMI *ComputerSystemSerialConsoleProtocol `json:"IPMI,omitempty"`
+
+	// MaxConcurrentSessions The maximum number of service sessions, regardless of protocol, that this system can support.
+	MaxConcurrentSessions *int64 `json:"MaxConcurrentSessions,omitempty"`
+
+	// Oem OEM extensions for the serial console service.
+	Oem *ComputerSystemOemSerialConsole `json:"Oem,omitempty"`
+
+	// SSH The information about a serial console service that this system provides.
+	SSH *ComputerSystemSerialConsoleProtocol `json:"SSH,omitempty"`
+
+	// Telnet The information about a serial console service that this system provides.
+	Telnet *ComputerSystemSerialConsoleProtocol `json:"Telnet,omitempty"`
+
+	// WebSocket The information about a WebSocket serial console service that this system provides.
+	WebSocket *ComputerSystemWebSocketConsole `json:"WebSocket,omitempty"`
+}
+
 // ComputerSystemMemoryMirroring defines model for ComputerSystem_MemoryMirroring.
 type ComputerSystemMemoryMirroring string
 
@@ -573,14 +606,23 @@ type ComputerSystemOemActions struct {
 	// HashOemIntelAMTCancelKVMConsent This action cancels a pending user consent request for KVM redirection.
 	HashOemIntelAMTCancelKVMConsent *ComputerSystemOemIntelAmtCancelKVMConsent `json:"#Oem.Intel.AMT.CancelKVMConsent,omitempty"`
 
+	// HashOemIntelAMTCancelSolConsent This action cancels a pending user consent request for Serial-over-LAN redirection.
+	HashOemIntelAMTCancelSolConsent *ComputerSystemOemIntelAmtCancelSolConsent `json:"#Oem.Intel.AMT.CancelSolConsent,omitempty"`
+
 	// HashOemIntelAMTGenerateRedirectionToken This action generates a short-lived redirection token.
 	HashOemIntelAMTGenerateRedirectionToken *ComputerSystemOemIntelAmtGenerateRedirectionToken `json:"#Oem.Intel.AMT.GenerateRedirectionToken,omitempty"`
 
 	// HashOemIntelAMTRequestKVMConsent This action requests user consent for KVM redirection.
 	HashOemIntelAMTRequestKVMConsent *ComputerSystemOemIntelAmtRequestKVMConsent `json:"#Oem.Intel.AMT.RequestKVMConsent,omitempty"`
 
+	// HashOemIntelAMTRequestSolConsent This action requests user consent for Serial-over-LAN redirection.
+	HashOemIntelAMTRequestSolConsent *ComputerSystemOemIntelAmtRequestSolConsent `json:"#Oem.Intel.AMT.RequestSolConsent,omitempty"`
+
 	// HashOemIntelAMTSubmitKVMConsentCode This action submits a user consent code for KVM redirection.
 	HashOemIntelAMTSubmitKVMConsentCode *ComputerSystemOemIntelAmtSubmitKVMConsentCode `json:"#Oem.Intel.AMT.SubmitKVMConsentCode,omitempty"`
+
+	// HashOemIntelAMTSubmitSolConsentCode This action submits a user consent code for Serial-over-LAN redirection.
+	HashOemIntelAMTSubmitSolConsentCode *ComputerSystemOemIntelAmtSubmitSolConsentCode `json:"#Oem.Intel.AMT.SubmitSolConsentCode,omitempty"`
 	AdditionalProperties                map[string]interface{}                         `json:"-"`
 }
 
@@ -632,6 +674,45 @@ type ComputerSystemOemIntelAMTGraphicalConsole_UserConsentStatus struct {
 // ComputerSystemOemIntelAMTKVMStatus The current operational status of the KVM redirection service on the Intel AMT device.
 type ComputerSystemOemIntelAMTKVMStatus string
 
+// ComputerSystemOemIntelAMTSOLStatus The current operational status of the SOL redirection service on the Intel AMT device.
+type ComputerSystemOemIntelAMTSOLStatus string
+
+// ComputerSystemOemIntelAMTSerialConsole Intel AMT-specific SOL options for the serial console service.
+type ComputerSystemOemIntelAMTSerialConsole struct {
+	// ControlMode The Intel AMT provisioning control mode of the device.
+	ControlMode *ComputerSystemOemIntelAMTSerialConsole_ControlMode `json:"ControlMode,omitempty"`
+
+	// SOLStatus The current operational status of the SOL redirection service.
+	SOLStatus *ComputerSystemOemIntelAMTSerialConsole_SOLStatus `json:"SOLStatus,omitempty"`
+
+	// UserConsentStatus The current user consent status for SOL access.
+	UserConsentStatus *ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus `json:"UserConsentStatus,omitempty"`
+}
+
+// ComputerSystemOemIntelAMTSerialConsoleControlMode1 defines model for .
+type ComputerSystemOemIntelAMTSerialConsoleControlMode1 = interface{}
+
+// ComputerSystemOemIntelAMTSerialConsole_ControlMode The Intel AMT provisioning control mode of the device.
+type ComputerSystemOemIntelAMTSerialConsole_ControlMode struct {
+	union json.RawMessage
+}
+
+// ComputerSystemOemIntelAMTSerialConsoleSOLStatus1 defines model for .
+type ComputerSystemOemIntelAMTSerialConsoleSOLStatus1 = interface{}
+
+// ComputerSystemOemIntelAMTSerialConsole_SOLStatus The current operational status of the SOL redirection service.
+type ComputerSystemOemIntelAMTSerialConsole_SOLStatus struct {
+	union json.RawMessage
+}
+
+// ComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1 defines model for .
+type ComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1 = interface{}
+
+// ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus The current user consent status for SOL access.
+type ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus struct {
+	union json.RawMessage
+}
+
 // ComputerSystemOemIntelAMTUserConsentStatus The current user consent status for KVM access on the Intel AMT device.
 type ComputerSystemOemIntelAMTUserConsentStatus string
 
@@ -647,6 +728,18 @@ type ComputerSystemOemIntelAmtCancelKVMConsent struct {
 // ComputerSystemOemIntelAmtCancelKVMConsentRequestBody This action cancels a pending user consent request for KVM redirection.
 type ComputerSystemOemIntelAmtCancelKVMConsentRequestBody = map[string]interface{}
 
+// ComputerSystemOemIntelAmtCancelSolConsent This action cancels a pending user consent request for Serial-over-LAN redirection.
+type ComputerSystemOemIntelAmtCancelSolConsent struct {
+	// Target Link to invoke action
+	Target *string `json:"target,omitempty"`
+
+	// Title Friendly action name
+	Title *string `json:"title,omitempty"`
+}
+
+// ComputerSystemOemIntelAmtCancelSolConsentRequestBody This action cancels a pending user consent request for Serial-over-LAN redirection.
+type ComputerSystemOemIntelAmtCancelSolConsentRequestBody = map[string]interface{}
+
 // ComputerSystemOemIntelAmtGenerateRedirectionToken This action generates a short-lived redirection token.
 type ComputerSystemOemIntelAmtGenerateRedirectionToken struct {
 	// Target Link to invoke action
@@ -680,6 +773,18 @@ type ComputerSystemOemIntelAmtRequestKVMConsent struct {
 // ComputerSystemOemIntelAmtRequestKVMConsentRequestBody This action requests user consent for KVM redirection.
 type ComputerSystemOemIntelAmtRequestKVMConsentRequestBody = map[string]interface{}
 
+// ComputerSystemOemIntelAmtRequestSolConsent This action requests user consent for Serial-over-LAN redirection.
+type ComputerSystemOemIntelAmtRequestSolConsent struct {
+	// Target Link to invoke action
+	Target *string `json:"target,omitempty"`
+
+	// Title Friendly action name
+	Title *string `json:"title,omitempty"`
+}
+
+// ComputerSystemOemIntelAmtRequestSolConsentRequestBody This action requests user consent for Serial-over-LAN redirection.
+type ComputerSystemOemIntelAmtRequestSolConsentRequestBody = map[string]interface{}
+
 // ComputerSystemOemIntelAmtSubmitKVMConsentCode This action submits a user consent code for KVM redirection.
 type ComputerSystemOemIntelAmtSubmitKVMConsentCode struct {
 	// Target Link to invoke action
@@ -695,12 +800,39 @@ type ComputerSystemOemIntelAmtSubmitKVMConsentCodeRequestBody struct {
 	ConsentCode string `json:"ConsentCode"`
 }
 
+// ComputerSystemOemIntelAmtSubmitSolConsentCode This action submits a user consent code for Serial-over-LAN redirection.
+type ComputerSystemOemIntelAmtSubmitSolConsentCode struct {
+	// Target Link to invoke action
+	Target *string `json:"target,omitempty"`
+
+	// Title Friendly action name
+	Title *string `json:"title,omitempty"`
+}
+
+// ComputerSystemOemIntelAmtSubmitSolConsentCodeRequestBody This action submits a user consent code for Serial-over-LAN redirection.
+type ComputerSystemOemIntelAmtSubmitSolConsentCodeRequestBody struct {
+	// ConsentCode The user consent code (6-digit code displayed on device screen).
+	ConsentCode string `json:"ConsentCode"`
+}
+
 // ComputerSystemOemIntelGraphicalConsole Intel-specific OEM extensions for the graphical console service.
 type ComputerSystemOemIntelGraphicalConsole struct {
 	// AMT Intel AMT-specific KVM options for the graphical console service.
 	AMT *ComputerSystemOemIntelAMTGraphicalConsole `json:"AMT,omitempty"`
 }
 
+// ComputerSystemOemIntelSerialConsole Intel-specific OEM extensions for the serial console service.
+type ComputerSystemOemIntelSerialConsole struct {
+	// AMT Intel AMT-specific SOL options for the serial console service.
+	AMT *ComputerSystemOemIntelAMTSerialConsole `json:"AMT,omitempty"`
+}
+
+// ComputerSystemOemSerialConsole OEM extensions for the serial console service.
+type ComputerSystemOemSerialConsole struct {
+	// Intel Intel-specific OEM extensions for the serial console service.
+	Intel *ComputerSystemOemIntelSerialConsole `json:"Intel,omitempty"`
+}
+
 // ComputerSystemProcessorSummary The central processors of the system in general detail.
 type ComputerSystemProcessorSummary struct {
 	// CoreCount The number of processor cores in the system.
@@ -739,6 +871,24 @@ type ComputerSystemResetRequestBody struct {
 	ResetType *ResourceResetType `json:"ResetType,omitempty"`
 }
 
+// ComputerSystemSerialConsoleProtocol The information about a serial console service that this system provides.
+type ComputerSystemSerialConsoleProtocol struct {
+	// ConsoleEntryCommand The command string passed to the service to select or enter the system's serial console.
+	ConsoleEntryCommand *string `json:"ConsoleEntryCommand"`
+
+	// HotKeySequenceDisplay The hotkey sequence available for the user to exit the serial console session.
+	HotKeySequenceDisplay *string `json:"HotKeySequenceDisplay"`
+
+	// Port The protocol port.
+	Port *int64 `json:"Port"`
+
+	// ServiceEnabled An indication of whether the service is enabled for this system.
+	ServiceEnabled *bool `json:"ServiceEnabled,omitempty"`
+
+	// SharedWithManagerCLI Indicates whether the serial console service is shared with access to the manager's command-line interface (CLI).
+	SharedWithManagerCLI *bool `json:"SharedWithManagerCLI,omitempty"`
+}
+
 // ComputerSystemStopBootOnFault defines model for ComputerSystem_StopBootOnFault.
 type ComputerSystemStopBootOnFault string
 
@@ -748,6 +898,18 @@ type ComputerSystemSystemType string
 // ComputerSystemTrustedModuleRequiredToBoot defines model for ComputerSystem_TrustedModuleRequiredToBoot.
 type ComputerSystemTrustedModuleRequiredToBoot string
 
+// ComputerSystemWebSocketConsole The information about a WebSocket serial console service that this system provides.
+type ComputerSystemWebSocketConsole struct {
+	// ConsoleURI The URI at which to access the WebSocket serial console.
+	ConsoleURI *string `json:"ConsoleURI,omitempty"`
+
+	// Interactive Indicates if the WebSocket serial console allows interactive input.
+	Interactive *bool `json:"Interactive,omitempty"`
+
+	// ServiceEnabled An indication of whether the service is enabled for this system.
+	ServiceEnabled *bool `json:"ServiceEnabled,omitempty"`
+}
+
 // MessageMessage The message that the Redfish service returns.
 type MessageMessage struct {
 	// Message The human-readable message.
@@ -1241,15 +1403,24 @@ type PostRedfishV1SystemsComputerSystemIdActionsComputerSystemResetJSONRequestBo
 // PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelKVMConsentJSONRequestBody defines body for PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelKVMConsent for application/json ContentType.
 type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelKVMConsentJSONRequestBody = ComputerSystemOemIntelAmtCancelKVMConsentRequestBody
 
+// PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentJSONRequestBody defines body for PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent for application/json ContentType.
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsentJSONRequestBody = ComputerSystemOemIntelAmtCancelSolConsentRequestBody
+
 // PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionTokenJSONRequestBody defines body for PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionToken for application/json ContentType.
 type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionTokenJSONRequestBody = ComputerSystemOemIntelAmtGenerateRedirectionTokenRequestBody
 
 // PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestKVMConsentJSONRequestBody defines body for PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestKVMConsent for application/json ContentType.
 type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestKVMConsentJSONRequestBody = ComputerSystemOemIntelAmtRequestKVMConsentRequestBody
 
+// PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentJSONRequestBody defines body for PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent for application/json ContentType.
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsentJSONRequestBody = ComputerSystemOemIntelAmtRequestSolConsentRequestBody
+
 // PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCodeJSONRequestBody defines body for PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCode for application/json ContentType.
 type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCodeJSONRequestBody = ComputerSystemOemIntelAmtSubmitKVMConsentCodeRequestBody
 
+// PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeJSONRequestBody defines body for PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode for application/json ContentType.
+type PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCodeJSONRequestBody = ComputerSystemOemIntelAmtSubmitSolConsentCodeRequestBody
+
 // Getter for additional properties for ComputerSystemOemActions. Returns the specified
 // element and whether it was found
 func (a ComputerSystemOemActions) Get(fieldName string) (value interface{}, found bool) {
@@ -1283,6 +1454,14 @@ func (a *ComputerSystemOemActions) UnmarshalJSON(b []byte) error {
 		delete(object, "#Oem.Intel.AMT.CancelKVMConsent")
 	}
 
+	if raw, found := object["#Oem.Intel.AMT.CancelSolConsent"]; found {
+		err = json.Unmarshal(raw, &a.HashOemIntelAMTCancelSolConsent)
+		if err != nil {
+			return fmt.Errorf("error reading '#Oem.Intel.AMT.CancelSolConsent': %w", err)
+		}
+		delete(object, "#Oem.Intel.AMT.CancelSolConsent")
+	}
+
 	if raw, found := object["#Oem.Intel.AMT.GenerateRedirectionToken"]; found {
 		err = json.Unmarshal(raw, &a.HashOemIntelAMTGenerateRedirectionToken)
 		if err != nil {
@@ -1299,6 +1478,14 @@ func (a *ComputerSystemOemActions) UnmarshalJSON(b []byte) error {
 		delete(object, "#Oem.Intel.AMT.RequestKVMConsent")
 	}
 
+	if raw, found := object["#Oem.Intel.AMT.RequestSolConsent"]; found {
+		err = json.Unmarshal(raw, &a.HashOemIntelAMTRequestSolConsent)
+		if err != nil {
+			return fmt.Errorf("error reading '#Oem.Intel.AMT.RequestSolConsent': %w", err)
+		}
+		delete(object, "#Oem.Intel.AMT.RequestSolConsent")
+	}
+
 	if raw, found := object["#Oem.Intel.AMT.SubmitKVMConsentCode"]; found {
 		err = json.Unmarshal(raw, &a.HashOemIntelAMTSubmitKVMConsentCode)
 		if err != nil {
@@ -1307,6 +1494,14 @@ func (a *ComputerSystemOemActions) UnmarshalJSON(b []byte) error {
 		delete(object, "#Oem.Intel.AMT.SubmitKVMConsentCode")
 	}
 
+	if raw, found := object["#Oem.Intel.AMT.SubmitSolConsentCode"]; found {
+		err = json.Unmarshal(raw, &a.HashOemIntelAMTSubmitSolConsentCode)
+		if err != nil {
+			return fmt.Errorf("error reading '#Oem.Intel.AMT.SubmitSolConsentCode': %w", err)
+		}
+		delete(object, "#Oem.Intel.AMT.SubmitSolConsentCode")
+	}
+
 	if len(object) != 0 {
 		a.AdditionalProperties = make(map[string]interface{})
 		for fieldName, fieldBuf := range object {
@@ -1333,6 +1528,13 @@ func (a ComputerSystemOemActions) MarshalJSON() ([]byte, error) {
 		}
 	}
 
+	if a.HashOemIntelAMTCancelSolConsent != nil {
+		object["#Oem.Intel.AMT.CancelSolConsent"], err = json.Marshal(a.HashOemIntelAMTCancelSolConsent)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling '#Oem.Intel.AMT.CancelSolConsent': %w", err)
+		}
+	}
+
 	if a.HashOemIntelAMTGenerateRedirectionToken != nil {
 		object["#Oem.Intel.AMT.GenerateRedirectionToken"], err = json.Marshal(a.HashOemIntelAMTGenerateRedirectionToken)
 		if err != nil {
@@ -1347,6 +1549,13 @@ func (a ComputerSystemOemActions) MarshalJSON() ([]byte, error) {
 		}
 	}
 
+	if a.HashOemIntelAMTRequestSolConsent != nil {
+		object["#Oem.Intel.AMT.RequestSolConsent"], err = json.Marshal(a.HashOemIntelAMTRequestSolConsent)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling '#Oem.Intel.AMT.RequestSolConsent': %w", err)
+		}
+	}
+
 	if a.HashOemIntelAMTSubmitKVMConsentCode != nil {
 		object["#Oem.Intel.AMT.SubmitKVMConsentCode"], err = json.Marshal(a.HashOemIntelAMTSubmitKVMConsentCode)
 		if err != nil {
@@ -1354,6 +1563,13 @@ func (a ComputerSystemOemActions) MarshalJSON() ([]byte, error) {
 		}
 	}
 
+	if a.HashOemIntelAMTSubmitSolConsentCode != nil {
+		object["#Oem.Intel.AMT.SubmitSolConsentCode"], err = json.Marshal(a.HashOemIntelAMTSubmitSolConsentCode)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling '#Oem.Intel.AMT.SubmitSolConsentCode': %w", err)
+		}
+	}
+
 	for fieldName, field := range a.AdditionalProperties {
 		object[fieldName], err = json.Marshal(field)
 		if err != nil {
@@ -2355,6 +2571,192 @@ func (t *ComputerSystemOemIntelAMTGraphicalConsole_UserConsentStatus) UnmarshalJ
 	return err
 }
 
+// AsComputerSystemOemIntelAMTControlMode returns the union data inside the ComputerSystemOemIntelAMTSerialConsole_ControlMode as a ComputerSystemOemIntelAMTControlMode
+func (t ComputerSystemOemIntelAMTSerialConsole_ControlMode) AsComputerSystemOemIntelAMTControlMode() (ComputerSystemOemIntelAMTControlMode, error) {
+	var body ComputerSystemOemIntelAMTControlMode
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromComputerSystemOemIntelAMTControlMode overwrites any union data inside the ComputerSystemOemIntelAMTSerialConsole_ControlMode as the provided ComputerSystemOemIntelAMTControlMode
+func (t *ComputerSystemOemIntelAMTSerialConsole_ControlMode) FromComputerSystemOemIntelAMTControlMode(v ComputerSystemOemIntelAMTControlMode) error {
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeComputerSystemOemIntelAMTControlMode performs a merge with any union data inside the ComputerSystemOemIntelAMTSerialConsole_ControlMode, using the provided ComputerSystemOemIntelAMTControlMode
+func (t *ComputerSystemOemIntelAMTSerialConsole_ControlMode) MergeComputerSystemOemIntelAMTControlMode(v ComputerSystemOemIntelAMTControlMode) error {
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+// AsComputerSystemOemIntelAMTSerialConsoleControlMode1 returns the union data inside the ComputerSystemOemIntelAMTSerialConsole_ControlMode as a ComputerSystemOemIntelAMTSerialConsoleControlMode1
+func (t ComputerSystemOemIntelAMTSerialConsole_ControlMode) AsComputerSystemOemIntelAMTSerialConsoleControlMode1() (ComputerSystemOemIntelAMTSerialConsoleControlMode1, error) {
+	var body ComputerSystemOemIntelAMTSerialConsoleControlMode1
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromComputerSystemOemIntelAMTSerialConsoleControlMode1 overwrites any union data inside the ComputerSystemOemIntelAMTSerialConsole_ControlMode as the provided ComputerSystemOemIntelAMTSerialConsoleControlMode1
+func (t *ComputerSystemOemIntelAMTSerialConsole_ControlMode) FromComputerSystemOemIntelAMTSerialConsoleControlMode1(v ComputerSystemOemIntelAMTSerialConsoleControlMode1) error {
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeComputerSystemOemIntelAMTSerialConsoleControlMode1 performs a merge with any union data inside the ComputerSystemOemIntelAMTSerialConsole_ControlMode, using the provided ComputerSystemOemIntelAMTSerialConsoleControlMode1
+func (t *ComputerSystemOemIntelAMTSerialConsole_ControlMode) MergeComputerSystemOemIntelAMTSerialConsoleControlMode1(v ComputerSystemOemIntelAMTSerialConsoleControlMode1) error {
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+func (t ComputerSystemOemIntelAMTSerialConsole_ControlMode) MarshalJSON() ([]byte, error) {
+	b, err := t.union.MarshalJSON()
+	return b, err
+}
+
+func (t *ComputerSystemOemIntelAMTSerialConsole_ControlMode) UnmarshalJSON(b []byte) error {
+	err := t.union.UnmarshalJSON(b)
+	return err
+}
+
+// AsComputerSystemOemIntelAMTSOLStatus returns the union data inside the ComputerSystemOemIntelAMTSerialConsole_SOLStatus as a ComputerSystemOemIntelAMTSOLStatus
+func (t ComputerSystemOemIntelAMTSerialConsole_SOLStatus) AsComputerSystemOemIntelAMTSOLStatus() (ComputerSystemOemIntelAMTSOLStatus, error) {
+	var body ComputerSystemOemIntelAMTSOLStatus
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromComputerSystemOemIntelAMTSOLStatus overwrites any union data inside the ComputerSystemOemIntelAMTSerialConsole_SOLStatus as the provided ComputerSystemOemIntelAMTSOLStatus
+func (t *ComputerSystemOemIntelAMTSerialConsole_SOLStatus) FromComputerSystemOemIntelAMTSOLStatus(v ComputerSystemOemIntelAMTSOLStatus) error {
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeComputerSystemOemIntelAMTSOLStatus performs a merge with any union data inside the ComputerSystemOemIntelAMTSerialConsole_SOLStatus, using the provided ComputerSystemOemIntelAMTSOLStatus
+func (t *ComputerSystemOemIntelAMTSerialConsole_SOLStatus) MergeComputerSystemOemIntelAMTSOLStatus(v ComputerSystemOemIntelAMTSOLStatus) error {
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+// AsComputerSystemOemIntelAMTSerialConsoleSOLStatus1 returns the union data inside the ComputerSystemOemIntelAMTSerialConsole_SOLStatus as a ComputerSystemOemIntelAMTSerialConsoleSOLStatus1
+func (t ComputerSystemOemIntelAMTSerialConsole_SOLStatus) AsComputerSystemOemIntelAMTSerialConsoleSOLStatus1() (ComputerSystemOemIntelAMTSerialConsoleSOLStatus1, error) {
+	var body ComputerSystemOemIntelAMTSerialConsoleSOLStatus1
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromComputerSystemOemIntelAMTSerialConsoleSOLStatus1 overwrites any union data inside the ComputerSystemOemIntelAMTSerialConsole_SOLStatus as the provided ComputerSystemOemIntelAMTSerialConsoleSOLStatus1
+func (t *ComputerSystemOemIntelAMTSerialConsole_SOLStatus) FromComputerSystemOemIntelAMTSerialConsoleSOLStatus1(v ComputerSystemOemIntelAMTSerialConsoleSOLStatus1) error {
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeComputerSystemOemIntelAMTSerialConsoleSOLStatus1 performs a merge with any union data inside the ComputerSystemOemIntelAMTSerialConsole_SOLStatus, using the provided ComputerSystemOemIntelAMTSerialConsoleSOLStatus1
+func (t *ComputerSystemOemIntelAMTSerialConsole_SOLStatus) MergeComputerSystemOemIntelAMTSerialConsoleSOLStatus1(v ComputerSystemOemIntelAMTSerialConsoleSOLStatus1) error {
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+func (t ComputerSystemOemIntelAMTSerialConsole_SOLStatus) MarshalJSON() ([]byte, error) {
+	b, err := t.union.MarshalJSON()
+	return b, err
+}
+
+func (t *ComputerSystemOemIntelAMTSerialConsole_SOLStatus) UnmarshalJSON(b []byte) error {
+	err := t.union.UnmarshalJSON(b)
+	return err
+}
+
+// AsComputerSystemOemIntelAMTUserConsentStatus returns the union data inside the ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus as a ComputerSystemOemIntelAMTUserConsentStatus
+func (t ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus) AsComputerSystemOemIntelAMTUserConsentStatus() (ComputerSystemOemIntelAMTUserConsentStatus, error) {
+	var body ComputerSystemOemIntelAMTUserConsentStatus
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromComputerSystemOemIntelAMTUserConsentStatus overwrites any union data inside the ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus as the provided ComputerSystemOemIntelAMTUserConsentStatus
+func (t *ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus) FromComputerSystemOemIntelAMTUserConsentStatus(v ComputerSystemOemIntelAMTUserConsentStatus) error {
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeComputerSystemOemIntelAMTUserConsentStatus performs a merge with any union data inside the ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus, using the provided ComputerSystemOemIntelAMTUserConsentStatus
+func (t *ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus) MergeComputerSystemOemIntelAMTUserConsentStatus(v ComputerSystemOemIntelAMTUserConsentStatus) error {
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+// AsComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1 returns the union data inside the ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus as a ComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1
+func (t ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus) AsComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1() (ComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1, error) {
+	var body ComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1 overwrites any union data inside the ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus as the provided ComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1
+func (t *ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus) FromComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1(v ComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1) error {
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1 performs a merge with any union data inside the ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus, using the provided ComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1
+func (t *ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus) MergeComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1(v ComputerSystemOemIntelAMTSerialConsoleUserConsentStatus1) error {
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+func (t ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus) MarshalJSON() ([]byte, error) {
+	b, err := t.union.MarshalJSON()
+	return b, err
+}
+
+func (t *ComputerSystemOemIntelAMTSerialConsole_UserConsentStatus) UnmarshalJSON(b []byte) error {
+	err := t.union.UnmarshalJSON(b)
+	return err
+}
+
 // AsActionInfoParameters returns the union data inside the ResolutionStepResolutionStep_ActionParameters_Item as a ActionInfoParameters
 func (t ResolutionStepResolutionStep_ActionParameters_Item) AsActionInfoParameters() (ActionInfoParameters, error) {
 	var body ActionInfoParameters
diff --git a/redfish/internal/controller/http/v1/handler/systems_actions.go b/redfish/internal/controller/http/v1/handler/systems_actions.go
index 8125f972..1397dcc5 100644
--- a/redfish/internal/controller/http/v1/handler/systems_actions.go
+++ b/redfish/internal/controller/http/v1/handler/systems_actions.go
@@ -117,6 +117,20 @@ func (s *RedfishServer) PostRedfishV1SystemsComputerSystemIdActionsOemIntelCompu
 	MethodNotAllowedError(c)
 }
 
+// PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent handles canceling SOL consent for a computer system.
+// This is a stub implementation.
+//
+//nolint:revive // Method name is generated from OpenAPI spec and cannot be changed
+func (s *RedfishServer) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent(c *gin.Context, computerSystemID string) {
+	if err := validateSystemID(computerSystemID); err != nil {
+		BadRequestError(c, fmt.Sprintf("Invalid system ID: %s", err.Error()))
+
+		return
+	}
+
+	MethodNotAllowedError(c)
+}
+
 // PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemGenerateRedirectionToken handles generating a redirection token for a computer system.
 // This is a stub implementation.
 //
@@ -145,6 +159,20 @@ func (s *RedfishServer) PostRedfishV1SystemsComputerSystemIdActionsOemIntelCompu
 	MethodNotAllowedError(c)
 }
 
+// PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent handles requesting SOL consent for a computer system.
+// This is a stub implementation.
+//
+//nolint:revive // Method name is generated from OpenAPI spec and cannot be changed
+func (s *RedfishServer) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent(c *gin.Context, computerSystemID string) {
+	if err := validateSystemID(computerSystemID); err != nil {
+		BadRequestError(c, fmt.Sprintf("Invalid system ID: %s", err.Error()))
+
+		return
+	}
+
+	MethodNotAllowedError(c)
+}
+
 // PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitKVMConsentCode handles submitting a KVM consent code for a computer system.
 // This is a stub implementation.
 //
@@ -158,3 +186,17 @@ func (s *RedfishServer) PostRedfishV1SystemsComputerSystemIdActionsOemIntelCompu
 
 	MethodNotAllowedError(c)
 }
+
+// PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode handles submitting a SOL consent code for a computer system.
+// This is a stub implementation.
+//
+//nolint:revive // Method name is generated from OpenAPI spec and cannot be changed
+func (s *RedfishServer) PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode(c *gin.Context, computerSystemID string) {
+	if err := validateSystemID(computerSystemID); err != nil {
+		BadRequestError(c, fmt.Sprintf("Invalid system ID: %s", err.Error()))
+
+		return
+	}
+
+	MethodNotAllowedError(c)
+}
diff --git a/redfish/internal/controller/http/v1/handler/systems_actions_test.go b/redfish/internal/controller/http/v1/handler/systems_actions_test.go
index a54f6710..159a79bf 100644
--- a/redfish/internal/controller/http/v1/handler/systems_actions_test.go
+++ b/redfish/internal/controller/http/v1/handler/systems_actions_test.go
@@ -399,3 +399,107 @@ func TestPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmit
 
 	assert.Equal(t, http.StatusBadRequest, w.Code)
 }
+
+// Stub implementation tests for SOL actions
+
+func TestPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent_Stub(t *testing.T) {
+	t.Parallel()
+
+	repo := NewTestSystemsComputerSystemRepository()
+	server := setupSystemActionsTestServer(repo)
+
+	req := httptest.NewRequest(http.MethodPost, "/redfish/v1/Systems/"+testSystemID+"/Actions/Oem/IntelComputerSystem.CancelSolConsent", http.NoBody)
+	w := httptest.NewRecorder()
+	ctx, _ := gin.CreateTestContext(w)
+	ctx.Request = req
+	ctx.Params = gin.Params{{Key: "computerSystemId", Value: testSystemID}}
+
+	server.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent(ctx, testSystemID)
+
+	assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
+}
+
+func TestPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent_InvalidSystemID(t *testing.T) {
+	t.Parallel()
+
+	repo := NewTestSystemsComputerSystemRepository()
+	server := setupSystemActionsTestServer(repo)
+
+	req := httptest.NewRequest(http.MethodPost, "/redfish/v1/Systems/../invalid/Actions/Oem/IntelComputerSystem.CancelSolConsent", http.NoBody)
+	w := httptest.NewRecorder()
+	ctx, _ := gin.CreateTestContext(w)
+	ctx.Request = req
+	ctx.Params = gin.Params{{Key: "computerSystemId", Value: "../invalid"}}
+
+	server.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemCancelSolConsent(ctx, "../invalid")
+
+	assert.Equal(t, http.StatusBadRequest, w.Code)
+}
+
+func TestPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent_Stub(t *testing.T) {
+	t.Parallel()
+
+	repo := NewTestSystemsComputerSystemRepository()
+	server := setupSystemActionsTestServer(repo)
+
+	req := httptest.NewRequest(http.MethodPost, "/redfish/v1/Systems/"+testSystemID+"/Actions/Oem/IntelComputerSystem.RequestSolConsent", http.NoBody)
+	w := httptest.NewRecorder()
+	ctx, _ := gin.CreateTestContext(w)
+	ctx.Request = req
+	ctx.Params = gin.Params{{Key: "computerSystemId", Value: testSystemID}}
+
+	server.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent(ctx, testSystemID)
+
+	assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
+}
+
+func TestPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent_InvalidSystemID(t *testing.T) {
+	t.Parallel()
+
+	repo := NewTestSystemsComputerSystemRepository()
+	server := setupSystemActionsTestServer(repo)
+
+	req := httptest.NewRequest(http.MethodPost, "/redfish/v1/Systems/test%00null/Actions/Oem/IntelComputerSystem.RequestSolConsent", http.NoBody)
+	w := httptest.NewRecorder()
+	ctx, _ := gin.CreateTestContext(w)
+	ctx.Request = req
+	ctx.Params = gin.Params{{Key: "computerSystemId", Value: "test%00null"}}
+
+	server.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemRequestSolConsent(ctx, "test%00null")
+
+	assert.Equal(t, http.StatusBadRequest, w.Code)
+}
+
+func TestPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode_Stub(t *testing.T) {
+	t.Parallel()
+
+	repo := NewTestSystemsComputerSystemRepository()
+	server := setupSystemActionsTestServer(repo)
+
+	req := httptest.NewRequest(http.MethodPost, "/redfish/v1/Systems/"+testSystemID+"/Actions/Oem/IntelComputerSystem.SubmitSolConsentCode", http.NoBody)
+	w := httptest.NewRecorder()
+	ctx, _ := gin.CreateTestContext(w)
+	ctx.Request = req
+	ctx.Params = gin.Params{{Key: "computerSystemId", Value: testSystemID}}
+
+	server.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode(ctx, testSystemID)
+
+	assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
+}
+
+func TestPostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode_InvalidSystemID(t *testing.T) {
+	t.Parallel()
+
+	repo := NewTestSystemsComputerSystemRepository()
+	server := setupSystemActionsTestServer(repo)
+
+	req := httptest.NewRequest(http.MethodPost, "/redfish/v1/Systems/<script>/Actions/Oem/IntelComputerSystem.SubmitSolConsentCode", http.NoBody)
+	w := httptest.NewRecorder()
+	ctx, _ := gin.CreateTestContext(w)
+	ctx.Request = req
+	ctx.Params = gin.Params{{Key: "computerSystemId", Value: "<script>"}}
+
+	server.PostRedfishV1SystemsComputerSystemIdActionsOemIntelComputerSystemSubmitSolConsentCode(ctx, "<script>")
+
+	assert.Equal(t, http.StatusBadRequest, w.Code)
+}
diff --git a/redfish/internal/usecase/computer_system.go b/redfish/internal/usecase/computer_system.go
index e34a7a2f..e0f1cd3f 100644
--- a/redfish/internal/usecase/computer_system.go
+++ b/redfish/internal/usecase/computer_system.go
@@ -558,29 +558,29 @@ func (uc *ComputerSystemUseCase) convertStateToGenerated(state string) *generate
 
 	switch state {
 	case StateEnabled:
-		stateEnum = generated.Enabled
+		stateEnum = generated.ResourceStateEnabled
 	case StateDisabled:
-		stateEnum = generated.Disabled
+		stateEnum = generated.ResourceStateDisabled
 	case StateStandbyOffline:
-		stateEnum = generated.StandbyOffline
+		stateEnum = generated.ResourceStateStandbyOffline
 	case StateStandbySpare:
-		stateEnum = generated.StandbySpare
+		stateEnum = generated.ResourceStateStandbySpare
 	case StateInTest:
-		stateEnum = generated.InTest
+		stateEnum = generated.ResourceStateInTest
 	case StateStarting:
-		stateEnum = generated.Starting
+		stateEnum = generated.ResourceStateStarting
 	case StateAbsent:
-		stateEnum = generated.Absent
+		stateEnum = generated.ResourceStateAbsent
 	case StateUnavailableOffline:
-		stateEnum = generated.UnavailableOffline
+		stateEnum = generated.ResourceStateUnavailableOffline
 	case StateDeferring:
-		stateEnum = generated.Deferring
+		stateEnum = generated.ResourceStateDeferring
 	case StateQuiesced:
-		stateEnum = generated.Quiesced
+		stateEnum = generated.ResourceStateQuiesced
 	case StateUpdating:
-		stateEnum = generated.Updating
+		stateEnum = generated.ResourceStateUpdating
 	case StateDegraded:
-		stateEnum = generated.Degraded
+		stateEnum = generated.ResourceStateDegraded
 	default:
 		return nil // Don't create state if unknown value
 	}
diff --git a/redfish/internal/usecase/computer_system_test.go b/redfish/internal/usecase/computer_system_test.go
index 7f3198a8..208b183c 100644
--- a/redfish/internal/usecase/computer_system_test.go
+++ b/redfish/internal/usecase/computer_system_test.go
@@ -151,3 +151,135 @@ func TestGetComputerSystemGraphicalConsoleDropsUnsupportedConnectTypes(t *testin
 		t.Fatalf("expected unsupported connect types to be omitted, got %#v", result.GraphicalConsole.ConnectTypesSupported)
 	}
 }
+
+func TestConvertStateToGenerated(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name      string
+		state     string
+		wantNil   bool
+		wantState generated.ResourceState
+	}{
+		{
+			name:      "StateEnabled",
+			state:     StateEnabled,
+			wantNil:   false,
+			wantState: generated.ResourceStateEnabled,
+		},
+		{
+			name:      "StateDisabled",
+			state:     StateDisabled,
+			wantNil:   false,
+			wantState: generated.ResourceStateDisabled,
+		},
+		{
+			name:      "StateStandbyOffline",
+			state:     StateStandbyOffline,
+			wantNil:   false,
+			wantState: generated.ResourceStateStandbyOffline,
+		},
+		{
+			name:      "StateStandbySpare",
+			state:     StateStandbySpare,
+			wantNil:   false,
+			wantState: generated.ResourceStateStandbySpare,
+		},
+		{
+			name:      "StateInTest",
+			state:     StateInTest,
+			wantNil:   false,
+			wantState: generated.ResourceStateInTest,
+		},
+		{
+			name:      "StateStarting",
+			state:     StateStarting,
+			wantNil:   false,
+			wantState: generated.ResourceStateStarting,
+		},
+		{
+			name:      "StateAbsent",
+			state:     StateAbsent,
+			wantNil:   false,
+			wantState: generated.ResourceStateAbsent,
+		},
+		{
+			name:      "StateUnavailableOffline",
+			state:     StateUnavailableOffline,
+			wantNil:   false,
+			wantState: generated.ResourceStateUnavailableOffline,
+		},
+		{
+			name:      "StateDeferring",
+			state:     StateDeferring,
+			wantNil:   false,
+			wantState: generated.ResourceStateDeferring,
+		},
+		{
+			name:      "StateQuiesced",
+			state:     StateQuiesced,
+			wantNil:   false,
+			wantState: generated.ResourceStateQuiesced,
+		},
+		{
+			name:      "StateUpdating",
+			state:     StateUpdating,
+			wantNil:   false,
+			wantState: generated.ResourceStateUpdating,
+		},
+		{
+			name:      "StateDegraded",
+			state:     StateDegraded,
+			wantNil:   false,
+			wantState: generated.ResourceStateDegraded,
+		},
+		{
+			name:    "UnknownState",
+			state:   "UnknownState",
+			wantNil: true,
+		},
+		{
+			name:    "EmptyState",
+			state:   "",
+			wantNil: true,
+		},
+	}
+
+	uc := &ComputerSystemUseCase{}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			validateConvertStateResult(t, uc, tt.state, tt.wantNil, tt.wantState)
+		})
+	}
+}
+
+// validateConvertStateResult validates the result of convertStateToGenerated.
+func validateConvertStateResult(t *testing.T, uc *ComputerSystemUseCase, state string, wantNil bool, wantState generated.ResourceState) {
+	t.Helper()
+
+	result := uc.convertStateToGenerated(state)
+
+	if wantNil {
+		if result != nil {
+			t.Fatalf("convertStateToGenerated(%q) expected nil, got %v", state, result)
+		}
+
+		return
+	}
+
+	if result == nil {
+		t.Fatalf("convertStateToGenerated(%q) expected non-nil result", state)
+	}
+
+	got, err := result.AsResourceState()
+	if err != nil {
+		t.Fatalf("Failed to convert result back to ResourceState: %v", err)
+	}
+
+	if got != wantState {
+		t.Errorf("convertStateToGenerated(%q) got %v, want %v", state, got, wantState)
+	}
+}
diff --git a/redfish/openapi/redfish-openapi.yaml b/redfish/openapi/redfish-openapi.yaml
index 048ca55e..d541a2c8 100644
--- a/redfish/openapi/redfish-openapi.yaml
+++ b/redfish/openapi/redfish-openapi.yaml
@@ -451,6 +451,98 @@ paths:
           description: Error condition
       security:
       - BasicAuth: []
+  /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.CancelSolConsent:
+    parameters:
+    - description: The value of the Id property of the ComputerSystem resource
+      in: path
+      name: ComputerSystemId
+      required: true
+      schema:
+        type: string
+    post:
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ComputerSystem_OemIntelAmtCancelSolConsentRequestBody'
+        required: true
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RedfishError'
+          description: The response contains the results of the CancelSolConsent action
+        default:
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RedfishError'
+          description: Error condition
+      security:
+      - BasicAuth: []
+  /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.RequestSolConsent:
+    parameters:
+    - description: The value of the Id property of the ComputerSystem resource
+      in: path
+      name: ComputerSystemId
+      required: true
+      schema:
+        type: string
+    post:
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ComputerSystem_OemIntelAmtRequestSolConsentRequestBody'
+        required: true
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RedfishError'
+          description: The response contains the results of the RequestSolConsent
+            action
+        default:
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RedfishError'
+          description: Error condition
+      security:
+      - BasicAuth: []
+  /redfish/v1/Systems/{ComputerSystemId}/Actions/Oem/IntelComputerSystem.SubmitSolConsentCode:
+    parameters:
+    - description: The value of the Id property of the ComputerSystem resource
+      in: path
+      name: ComputerSystemId
+      required: true
+      schema:
+        type: string
+    post:
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ComputerSystem_OemIntelAmtSubmitSolConsentCodeRequestBody'
+        required: true
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RedfishError'
+          description: The response contains the results of the SubmitSolConsentCode
+            action
+        default:
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RedfishError'
+          description: Error condition
+      security:
+      - BasicAuth: []
   /redfish/v1/odata:
     get:
       responses:
@@ -1140,6 +1232,12 @@ components:
           x-longDescription: This property shall contain the information about the
             graphical console (KVM-IP) service of this system.
           x-versionAdded: v1_13_0
+        SerialConsole:
+          $ref: '#/components/schemas/ComputerSystem_HostSerialConsole'
+          description: The serial console services that this system provides.
+          x-longDescription: This property shall contain information about the serial
+            console services of this system.
+          x-versionAdded: v1_13_0
         HostName:
           description: The DNS host name, without any domain information.
           nullable: true
@@ -1287,6 +1385,61 @@ components:
       x-patternProperties:
         ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
           description: This property shall specify a valid odata or Redfish property.
+    ComputerSystem_HostSerialConsole:
+      additionalProperties: false
+      description: The information about the serial console services that this system
+        provides.
+      properties:
+        IPMI:
+          $ref: '#/components/schemas/ComputerSystem_SerialConsoleProtocol'
+          description: The connection details for an IPMI Serial-over-LAN service.
+          x-longDescription: This property shall contain connection details for a
+            serial console service that uses the IPMI Serial-over-LAN (SOL) protocol.
+          x-versionAdded: v1_13_0
+        MaxConcurrentSessions:
+          description: The maximum number of service sessions, regardless of protocol,
+            that this system can support.
+          format: int64
+          minimum: 0
+          readOnly: true
+          type: integer
+          x-longDescription: This property shall contain the maximum number of concurrent
+            service sessions that this implementation supports.
+          x-versionAdded: v1_13_0
+        SSH:
+          $ref: '#/components/schemas/ComputerSystem_SerialConsoleProtocol'
+          description: The connection details for an SSH serial console service.
+          x-longDescription: This property shall contain connection details for a
+            serial console service that uses the Secure Shell (SSH) protocol.
+          x-versionAdded: v1_13_0
+        Telnet:
+          $ref: '#/components/schemas/ComputerSystem_SerialConsoleProtocol'
+          description: The connection details for a Telnet serial console service.
+          x-longDescription: This property shall contain connection details for a
+            serial console service that uses the Telnet protocol.
+          x-versionAdded: v1_13_0
+        WebSocket:
+          $ref: '#/components/schemas/ComputerSystem_WebSocketConsole'
+          description: The connection details for a WebSocket serial console service.
+          x-longDescription: This property shall contain connection details for a
+            serial console service that uses WebSockets as defined by the 'WebSocket
+            inbound access' clause of the Redfish Specification.  Services shall send
+            WebSocket packetized bytes in a manner that emulates a pty (pseudoterminal).
+          x-versionAdded: v1_26_0
+        Oem:
+          $ref: '#/components/schemas/ComputerSystem_OemSerialConsole'
+          description: The OEM extensions for the serial console, including Intel
+            AMT-specific SOL options.
+          x-longDescription: This property shall contain OEM extensions for the serial
+            console service. Intel AMT implementations shall populate the `Intel.AMT`
+            nested object with `ControlMode`, `SOLStatus`, and `UserConsentStatus`
+            properties, all of which are read-only.
+      type: object
+      x-longDescription: This type shall describe the serial console services for
+        a computer system.
+      x-patternProperties:
+        ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
+          description: This property shall specify a valid odata or Redfish property.
     ComputerSystem_MemoryMirroring:
       enum:
       - System
@@ -1363,6 +1516,12 @@ components:
           $ref: '#/components/schemas/ComputerSystem_OemIntelAmtSubmitKVMConsentCode'
         '#Oem.Intel.AMT.GenerateRedirectionToken':
           $ref: '#/components/schemas/ComputerSystem_OemIntelAmtGenerateRedirectionToken'
+        '#Oem.Intel.AMT.CancelSolConsent':
+          $ref: '#/components/schemas/ComputerSystem_OemIntelAmtCancelSolConsent'
+        '#Oem.Intel.AMT.RequestSolConsent':
+          $ref: '#/components/schemas/ComputerSystem_OemIntelAmtRequestSolConsent'
+        '#Oem.Intel.AMT.SubmitSolConsentCode':
+          $ref: '#/components/schemas/ComputerSystem_OemIntelAmtSubmitSolConsentCode'
       type: object
       x-longDescription: This type shall contain the available OEM-specific actions
         for this resource.
@@ -1473,6 +1632,77 @@ components:
         PendingConsent: This value shall indicate that a KVM redirection request has
           been issued and the service is awaiting explicit acceptance from the local
           user on the target device.
+    ComputerSystem_OemIntelAMTSOLStatus:
+      description: The current operational status of the SOL redirection service on
+        the Intel AMT device.
+      enum:
+      - Disabled
+      - Enabled
+      - Active
+      - PendingConsent
+      - Error
+      type: string
+      x-enumDescriptions:
+        Active: A SOL redirection session is currently active and streaming.
+        Disabled: The SOL redirection service is disabled on the AMT device.
+        Enabled: The SOL redirection service is enabled and ready to accept connections.
+        Error: The SOL service is in an error state.
+        PendingConsent: The SOL session is waiting for explicit user consent on the
+          target device.
+      x-enumLongDescriptions:
+        Active: This value shall indicate that a SOL redirection session is currently
+          active between a remote client and the AMT device.
+        Disabled: This value shall indicate that the SOL redirection service is not
+          enabled on the AMT device.
+        Enabled: This value shall indicate that the SOL redirection service is enabled
+          and ready to accept connections, but no session is currently active.
+        Error: This value shall indicate that the SOL service encountered an error
+          and is not operational.
+        PendingConsent: This value shall indicate that a SOL redirection request has
+          been issued and the service is awaiting explicit acceptance from the local
+          user on the target device.
+    ComputerSystem_OemIntelAMTSerialConsole:
+      additionalProperties: false
+      description: Intel AMT-specific SOL options for the serial console service.
+      properties:
+        ControlMode:
+          description: The Intel AMT provisioning control mode of the device.
+          oneOf:
+          - $ref: '#/components/schemas/ComputerSystem_OemIntelAMTControlMode'
+          - enum:
+            - null
+          readOnly: true
+          x-longDescription: This property shall contain the Intel AMT provisioning
+            control mode of the device. This value is determined during AMT device
+            provisioning and cannot be changed through this interface.
+        SOLStatus:
+          description: The current operational status of the SOL redirection service.
+          oneOf:
+          - $ref: '#/components/schemas/ComputerSystem_OemIntelAMTSOLStatus'
+          - enum:
+            - null
+          readOnly: true
+          x-longDescription: This property shall contain the current operational status
+            of the SOL redirection service on the AMT device, derived from WS-Man
+            queries to `AMT_RedirectionService` and related services. To enable or
+            disable the SOL service, use the `ServiceEnabled` property in `SerialConsole.WebSocket`.
+        UserConsentStatus:
+          description: The current user consent status for SOL access.
+          oneOf:
+          - $ref: '#/components/schemas/ComputerSystem_OemIntelAMTUserConsentStatus'
+          - enum:
+            - null
+          readOnly: true
+          x-longDescription: This property shall contain the current user consent
+            status for SOL access on the AMT device. This value is managed exclusively
+            through the `#Oem.Intel.AMT.RequestSolConsent`, `#Oem.Intel.AMT.SubmitSolConsentCode`,
+            and `#Oem.Intel.AMT.CancelSolConsent` actions.
+      type: object
+      x-longDescription: This type shall contain Intel AMT-specific SOL options for
+        the serial console service.
+      x-patternProperties:
+        ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
+          description: This property shall specify a valid odata or Redfish property.
     ComputerSystem_OemIntelAMTUserConsentStatus:
       description: The current user consent status for KVM access on the Intel AMT
         device.
@@ -1528,6 +1758,35 @@ components:
       x-patternProperties:
         ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
           description: This property shall specify a valid odata or Redfish property.
+    ComputerSystem_OemIntelAmtCancelSolConsent:
+      additionalProperties: false
+      description: This action cancels a pending user consent request for Serial-over-LAN
+        redirection.
+      properties:
+        target:
+          description: Link to invoke action
+          format: uri-reference
+          type: string
+        title:
+          description: Friendly action name
+          type: string
+      type: object
+      x-longDescription: This action shall cancel a pending user consent request for
+        Serial-over-LAN redirection.
+      x-patternProperties:
+        ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
+          description: This property shall specify a valid odata or Redfish property.
+    ComputerSystem_OemIntelAmtCancelSolConsentRequestBody:
+      additionalProperties: false
+      description: This action cancels a pending user consent request for Serial-over-LAN
+        redirection.
+      properties: {}
+      type: object
+      x-longDescription: This action shall cancel a pending user consent request for
+        Serial-over-LAN redirection.
+      x-patternProperties:
+        ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
+          description: This property shall specify a valid odata or Redfish property.
     ComputerSystem_OemIntelAmtGenerateRedirectionToken:
       additionalProperties: false
       description: This action generates a short-lived redirection token.
@@ -1604,6 +1863,33 @@ components:
       x-patternProperties:
         ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
           description: This property shall specify a valid odata or Redfish property.
+    ComputerSystem_OemIntelAmtRequestSolConsent:
+      additionalProperties: false
+      description: This action requests user consent for Serial-over-LAN redirection.
+      properties:
+        target:
+          description: Link to invoke action
+          format: uri-reference
+          type: string
+        title:
+          description: Friendly action name
+          type: string
+      type: object
+      x-longDescription: This action shall request user consent for Serial-over-LAN
+        redirection.
+      x-patternProperties:
+        ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
+          description: This property shall specify a valid odata or Redfish property.
+    ComputerSystem_OemIntelAmtRequestSolConsentRequestBody:
+      additionalProperties: false
+      description: This action requests user consent for Serial-over-LAN redirection.
+      properties: {}
+      type: object
+      x-longDescription: This action shall request user consent for Serial-over-LAN
+        redirection.
+      x-patternProperties:
+        ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
+          description: This property shall specify a valid odata or Redfish property.
     ComputerSystem_OemIntelAmtSubmitKVMConsentCode:
       additionalProperties: false
       description: This action submits a user consent code for KVM redirection.
@@ -1637,6 +1923,41 @@ components:
       x-patternProperties:
         ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
           description: This property shall specify a valid odata or Redfish property.
+    ComputerSystem_OemIntelAmtSubmitSolConsentCode:
+      additionalProperties: false
+      description: This action submits a user consent code for Serial-over-LAN redirection.
+      properties:
+        target:
+          description: Link to invoke action
+          format: uri-reference
+          type: string
+        title:
+          description: Friendly action name
+          type: string
+      type: object
+      x-longDescription: This action shall submit a user consent code for Serial-over-LAN
+        redirection.
+      x-patternProperties:
+        ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
+          description: This property shall specify a valid odata or Redfish property.
+    ComputerSystem_OemIntelAmtSubmitSolConsentCodeRequestBody:
+      additionalProperties: false
+      description: This action submits a user consent code for Serial-over-LAN redirection.
+      properties:
+        ConsentCode:
+          description: The user consent code (6-digit code displayed on device screen).
+          pattern: ^[0-9]{6}$
+          type: string
+          x-longDescription: This parameter shall contain the user consent code for
+            Serial-over-LAN redirection.
+      required:
+      - ConsentCode
+      type: object
+      x-longDescription: This action shall submit a user consent code for Serial-over-LAN
+        redirection.
+      x-patternProperties:
+        ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
+          description: This property shall specify a valid odata or Redfish property.
     ComputerSystem_OemIntelGraphicalConsole:
       additionalProperties: false
       description: Intel-specific OEM extensions for the graphical console service.
@@ -1652,6 +1973,36 @@ components:
       x-patternProperties:
         ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
           description: This property shall specify a valid odata or Redfish property.
+    ComputerSystem_OemIntelSerialConsole:
+      additionalProperties: false
+      description: Intel-specific OEM extensions for the serial console service.
+      properties:
+        AMT:
+          $ref: '#/components/schemas/ComputerSystem_OemIntelAMTSerialConsole'
+          description: Intel AMT-specific SOL options for the serial console.
+          x-longDescription: This property shall contain Intel AMT-specific SOL options
+            for the serial console service.
+      type: object
+      x-longDescription: This type shall contain Intel-specific OEM extensions for
+        the serial console service of a computer system.
+      x-patternProperties:
+        ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
+          description: This property shall specify a valid odata or Redfish property.
+    ComputerSystem_OemSerialConsole:
+      additionalProperties: false
+      description: OEM extensions for the serial console service.
+      properties:
+        Intel:
+          $ref: '#/components/schemas/ComputerSystem_OemIntelSerialConsole'
+          description: Intel OEM extensions for the serial console.
+          x-longDescription: This property shall contain Intel-specific OEM extensions
+            for the serial console service.
+      type: object
+      x-longDescription: This type shall contain OEM extensions for the serial console
+        service of a computer system.
+      x-patternProperties:
+        ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
+          description: This property shall specify a valid odata or Redfish property.
     ComputerSystem_ProcessorSummary:
       additionalProperties: false
       description: The central processors of the system in general detail.
@@ -1771,6 +2122,63 @@ components:
       x-patternProperties:
         ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
           description: This property shall specify a valid odata or Redfish property.
+    ComputerSystem_SerialConsoleProtocol:
+      additionalProperties: false
+      description: The information about a serial console service that this system
+        provides.
+      properties:
+        ConsoleEntryCommand:
+          description: The command string passed to the service to select or enter
+            the system's serial console.
+          nullable: true
+          readOnly: true
+          type: string
+          x-longDescription: This property shall contain a command string that can
+            be provided by a client to select or enter the system's serial console,
+            when the console is shared among several systems or a manager CLI.
+          x-versionAdded: v1_13_0
+        HotKeySequenceDisplay:
+          description: The hotkey sequence available for the user to exit the serial
+            console session.
+          nullable: true
+          readOnly: true
+          type: string
+          x-longDescription: This property shall contain a string that can be provided
+            to a user to describe the hotkey sequence used to exit the serial console
+            session, or, if shared with a manager CLI, to return to the CLI.
+          x-versionAdded: v1_13_0
+        Port:
+          description: The protocol port.
+          format: int64
+          minimum: 0
+          nullable: true
+          readOnly: false
+          type: integer
+          x-longDescription: This property shall contain the port assigned to the
+            protocol.
+          x-versionAdded: v1_13_0
+        ServiceEnabled:
+          description: An indication of whether the service is enabled for this system.
+          readOnly: false
+          type: boolean
+          x-longDescription: This property shall indicate whether the protocol for
+            the service is enabled.
+          x-versionAdded: v1_13_0
+        SharedWithManagerCLI:
+          description: Indicates whether the serial console service is shared with
+            access to the manager's command-line interface (CLI).
+          readOnly: true
+          type: boolean
+          x-longDescription: This property shall indicate whether the serial console
+            service is shared with access to the manager's command-line interface
+            (CLI).
+          x-versionAdded: v1_13_0
+      type: object
+      x-longDescription: This type shall describe a serial console service for a computer
+        system.
+      x-patternProperties:
+        ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
+          description: This property shall specify a valid odata or Redfish property.
     ComputerSystem_StopBootOnFault:
       enum:
       - Never
@@ -1846,6 +2254,42 @@ components:
         Disabled: This value shall indicate a Trusted Module is not required to boot.
         Required: This value shall indicate a functioning Trusted Module is required
           to boot.
+    ComputerSystem_WebSocketConsole:
+      additionalProperties: false
+      description: The information about a WebSocket serial console service that this
+        system provides.
+      properties:
+        ConsoleURI:
+          description: The URI at which to access the WebSocket serial console.
+          format: uri-reference
+          readOnly: true
+          type: string
+          x-longDescription: This property shall contain the URI at which to access
+            the WebSocket serial console, using the Redfish protocol and authentication
+            methods.  See the 'WebSocket inbound access' clause in the Redfish Specification.
+          x-versionAdded: v1_26_0
+        Interactive:
+          description: Indicates if the WebSocket serial console allows interactive
+            input.
+          readOnly: true
+          type: boolean
+          x-longDescription: This property shall indicate if the WebSocket serial
+            console allows interactive input.  If `true`, the WebSocket is bidirectional.  If
+            `false`, the WebSocket only allows console output from the service.
+          x-versionAdded: v1_26_0
+        ServiceEnabled:
+          description: An indication of whether the service is enabled for this system.
+          readOnly: false
+          type: boolean
+          x-longDescription: This property shall indicate whether the protocol for
+            the service is enabled.
+          x-versionAdded: v1_26_0
+      type: object
+      x-longDescription: This type shall describe a WebSocket serial console service
+        for a computer system.
+      x-patternProperties:
+        ^([a-zA-Z_][a-zA-Z0-9_]*)?@(odata|Redfish|Message)\.[a-zA-Z_][a-zA-Z0-9_]*$:
+          description: This property shall specify a valid odata or Redfish property.
     Message_Message:
       additionalProperties: false
       description: The message that the Redfish service returns.