text:
package playground

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

// PlaygroundServiceClient is the client API for PlaygroundService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type PlaygroundServiceClient interface {
	// Submit the job for an execution and get the pipeline uuid.
	RunCode(ctx context.Context, in *RunCodeRequest, opts ...grpc.CallOption) (*RunCodeResponse, error)
	// Get the status of pipeline execution.
	CheckStatus(ctx context.Context, in *CheckStatusRequest, opts ...grpc.CallOption) (*CheckStatusResponse, error)
	// Get the result of pipeline execution.
	GetRunOutput(ctx context.Context, in *GetRunOutputRequest, opts ...grpc.CallOption) (*GetRunOutputResponse, error)
	// Get the logs of pipeline execution.
	GetLogs(ctx context.Context, in *GetLogsRequest, opts ...grpc.CallOption) (*GetLogsResponse, error)
	// Get the string representation of the pipeline execution graph in DOT format.
	GetGraph(ctx context.Context, in *GetGraphRequest, opts ...grpc.CallOption) (*GetGraphResponse, error)
	// Get the error of pipeline execution.
	GetRunError(ctx context.Context, in *GetRunErrorRequest, opts ...grpc.CallOption) (*GetRunErrorResponse, error)
	// Get the result of pipeline validation.
	GetValidationOutput(ctx context.Context, in *GetValidationOutputRequest, opts ...grpc.CallOption) (*GetValidationOutputResponse, error)
	// Get the result of pipeline preparation.
	GetPreparationOutput(ctx context.Context, in *GetPreparationOutputRequest, opts ...grpc.CallOption) (*GetPreparationOutputResponse, error)
	// Get the result of pipeline compilation.
	GetCompileOutput(ctx context.Context, in *GetCompileOutputRequest, opts ...grpc.CallOption) (*GetCompileOutputResponse, error)
	// Cancel code processing
	Cancel(ctx context.Context, in *CancelRequest, opts ...grpc.CallOption) (*CancelResponse, error)
	// Get all precompiled objects from the cloud storage.
	GetPrecompiledObjects(ctx context.Context, in *GetPrecompiledObjectsRequest, opts ...grpc.CallOption) (*GetPrecompiledObjectsResponse, error)
	// Get precompiled object from the cloud storage.
	GetPrecompiledObject(ctx context.Context, in *GetPrecompiledObjectRequest, opts ...grpc.CallOption) (*GetPrecompiledObjectResponse, error)
	// Get the code of an PrecompiledObject.
	GetPrecompiledObjectCode(ctx context.Context, in *GetPrecompiledObjectCodeRequest, opts ...grpc.CallOption) (*GetPrecompiledObjectCodeResponse, error)
	// Get the precompiled details of an PrecompiledObject.
	GetPrecompiledObjectOutput(ctx context.Context, in *GetPrecompiledObjectOutputRequest, opts ...grpc.CallOption) (*GetPrecompiledObjectOutputResponse, error)
	// Get the logs of an PrecompiledObject.
	GetPrecompiledObjectLogs(ctx context.Context, in *GetPrecompiledObjectLogsRequest, opts ...grpc.CallOption) (*GetPrecompiledObjectLogsResponse, error)
	// Get the graph of an PrecompiledObject.
	GetPrecompiledObjectGraph(ctx context.Context, in *GetPrecompiledObjectGraphRequest, opts ...grpc.CallOption) (*GetPrecompiledObjectGraphResponse, error)
	// Get the default precompile object for the sdk.
	GetDefaultPrecompiledObject(ctx context.Context, in *GetDefaultPrecompiledObjectRequest, opts ...grpc.CallOption) (*GetDefaultPrecompiledObjectResponse, error)
}

type playgroundServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewPlaygroundServiceClient(cc grpc.ClientConnInterface) PlaygroundServiceClient {
	return &playgroundServiceClient{cc}
}

func (c *playgroundServiceClient) RunCode(ctx context.Context, in *RunCodeRequest, opts ...grpc.CallOption) (*RunCodeResponse, error) {
	out := new(RunCodeResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/RunCode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) CheckStatus(ctx context.Context, in *CheckStatusRequest, opts ...grpc.CallOption) (*CheckStatusResponse, error) {
	out := new(CheckStatusResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/CheckStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) GetRunOutput(ctx context.Context, in *GetRunOutputRequest, opts ...grpc.CallOption) (*GetRunOutputResponse, error) {
	out := new(GetRunOutputResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/GetRunOutput", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) GetLogs(ctx context.Context, in *GetLogsRequest, opts ...grpc.CallOption) (*GetLogsResponse, error) {
	out := new(GetLogsResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/GetLogs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) GetGraph(ctx context.Context, in *GetGraphRequest, opts ...grpc.CallOption) (*GetGraphResponse, error) {
	out := new(GetGraphResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/GetGraph", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) GetRunError(ctx context.Context, in *GetRunErrorRequest, opts ...grpc.CallOption) (*GetRunErrorResponse, error) {
	out := new(GetRunErrorResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/GetRunError", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) GetValidationOutput(ctx context.Context, in *GetValidationOutputRequest, opts ...grpc.CallOption) (*GetValidationOutputResponse, error) {
	out := new(GetValidationOutputResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/GetValidationOutput", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) GetPreparationOutput(ctx context.Context, in *GetPreparationOutputRequest, opts ...grpc.CallOption) (*GetPreparationOutputResponse, error) {
	out := new(GetPreparationOutputResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/GetPreparationOutput", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) GetCompileOutput(ctx context.Context, in *GetCompileOutputRequest, opts ...grpc.CallOption) (*GetCompileOutputResponse, error) {
	out := new(GetCompileOutputResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/GetCompileOutput", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) Cancel(ctx context.Context, in *CancelRequest, opts ...grpc.CallOption) (*CancelResponse, error) {
	out := new(CancelResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/Cancel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) GetPrecompiledObjects(ctx context.Context, in *GetPrecompiledObjectsRequest, opts ...grpc.CallOption) (*GetPrecompiledObjectsResponse, error) {
	out := new(GetPrecompiledObjectsResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/GetPrecompiledObjects", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) GetPrecompiledObject(ctx context.Context, in *GetPrecompiledObjectRequest, opts ...grpc.CallOption) (*GetPrecompiledObjectResponse, error) {
	out := new(GetPrecompiledObjectResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/GetPrecompiledObject", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) GetPrecompiledObjectCode(ctx context.Context, in *GetPrecompiledObjectCodeRequest, opts ...grpc.CallOption) (*GetPrecompiledObjectCodeResponse, error) {
	out := new(GetPrecompiledObjectCodeResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/GetPrecompiledObjectCode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) GetPrecompiledObjectOutput(ctx context.Context, in *GetPrecompiledObjectOutputRequest, opts ...grpc.CallOption) (*GetPrecompiledObjectOutputResponse, error) {
	out := new(GetPrecompiledObjectOutputResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/GetPrecompiledObjectOutput", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) GetPrecompiledObjectLogs(ctx context.Context, in *GetPrecompiledObjectLogsRequest, opts ...grpc.CallOption) (*GetPrecompiledObjectLogsResponse, error) {
	out := new(GetPrecompiledObjectLogsResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/GetPrecompiledObjectLogs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) GetPrecompiledObjectGraph(ctx context.Context, in *GetPrecompiledObjectGraphRequest, opts ...grpc.CallOption) (*GetPrecompiledObjectGraphResponse, error) {
	out := new(GetPrecompiledObjectGraphResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/GetPrecompiledObjectGraph", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *playgroundServiceClient) GetDefaultPrecompiledObject(ctx context.Context, in *GetDefaultPrecompiledObjectRequest, opts ...grpc.CallOption) (*GetDefaultPrecompiledObjectResponse, error) {
	out := new(GetDefaultPrecompiledObjectResponse)
	err := c.cc.Invoke(ctx, "/api.v1.PlaygroundService/GetDefaultPrecompiledObject", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// PlaygroundServiceServer is the server API for PlaygroundService service.
// All implementations should embed UnimplementedPlaygroundServiceServer
// for forward compatibility
type PlaygroundServiceServer interface {
	// Submit the job for an execution and get the pipeline uuid.
	RunCode(context.Context, *RunCodeRequest) (*RunCodeResponse, error)
	// Get the status of pipeline execution.
	CheckStatus(context.Context, *CheckStatusRequest) (*CheckStatusResponse, error)
	// Get the result of pipeline execution.
	GetRunOutput(context.Context, *GetRunOutputRequest) (*GetRunOutputResponse, error)
	// Get the logs of pipeline execution.
	GetLogs(context.Context, *GetLogsRequest) (*GetLogsResponse, error)
	// Get the string representation of the pipeline execution graph in DOT format.
	GetGraph(context.Context, *GetGraphRequest) (*GetGraphResponse, error)
	// Get the error of pipeline execution.
	GetRunError(context.Context, *GetRunErrorRequest) (*GetRunErrorResponse, error)
	// Get the result of pipeline validation.
	GetValidationOutput(context.Context, *GetValidationOutputRequest) (*GetValidationOutputResponse, error)
	// Get the result of pipeline preparation.
	GetPreparationOutput(context.Context, *GetPreparationOutputRequest) (*GetPreparationOutputResponse, error)
	// Get the result of pipeline compilation.
	GetCompileOutput(context.Context, *GetCompileOutputRequest) (*GetCompileOutputResponse, error)
	// Cancel code processing
	Cancel(context.Context, *CancelRequest) (*CancelResponse, error)
	// Get all precompiled objects from the cloud storage.
	GetPrecompiledObjects(context.Context, *GetPrecompiledObjectsRequest) (*GetPrecompiledObjectsResponse, error)
	// Get precompiled object from the cloud storage.
	GetPrecompiledObject(context.Context, *GetPrecompiledObjectRequest) (*GetPrecompiledObjectResponse, error)
	// Get the code of an PrecompiledObject.
	GetPrecompiledObjectCode(context.Context, *GetPrecompiledObjectCodeRequest) (*GetPrecompiledObjectCodeResponse, error)
	// Get the precompiled details of an PrecompiledObject.
	GetPrecompiledObjectOutput(context.Context, *GetPrecompiledObjectOutputRequest) (*GetPrecompiledObjectOutputResponse, error)
	// Get the logs of an PrecompiledObject.
	GetPrecompiledObjectLogs(context.Context, *GetPrecompiledObjectLogsRequest) (*GetPrecompiledObjectLogsResponse, error)
	// Get the graph of an PrecompiledObject.
	GetPrecompiledObjectGraph(context.Context, *GetPrecompiledObjectGraphRequest) (*GetPrecompiledObjectGraphResponse, error)
	// Get the default precompile object for the sdk.
	GetDefaultPrecompiledObject(context.Context, *GetDefaultPrecompiledObjectRequest) (*GetDefaultPrecompiledObjectResponse, error)
}

// UnimplementedPlaygroundServiceServer should be embedded to have forward compatible implementations.
type UnimplementedPlaygroundServiceServer struct {
}

func (UnimplementedPlaygroundServiceServer) RunCode(context.Context, *RunCodeRequest) (*RunCodeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCode not implemented")
}
func (UnimplementedPlaygroundServiceServer) CheckStatus(context.Context, *CheckStatusRequest) (*CheckStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckStatus not implemented")
}
func (UnimplementedPlaygroundServiceServer) GetRunOutput(context.Context, *GetRunOutputRequest) (*GetRunOutputResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRunOutput not implemented")
}
func (UnimplementedPlaygroundServiceServer) GetLogs(context.Context, *GetLogsRequest) (*GetLogsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLogs not implemented")
}
func (UnimplementedPlaygroundServiceServer) GetGraph(context.Context, *GetGraphRequest) (*GetGraphResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetGraph not implemented")
}
func (UnimplementedPlaygroundServiceServer) GetRunError(context.Context, *GetRunErrorRequest) (*GetRunErrorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRunError not implemented")
}
func (UnimplementedPlaygroundServiceServer) GetValidationOutput(context.Context, *GetValidationOutputRequest) (*GetValidationOutputResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetValidationOutput not implemented")
}
func (UnimplementedPlaygroundServiceServer) GetPreparationOutput(context.Context, *GetPreparationOutputRequest) (*GetPreparationOutputResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPreparationOutput not implemented")
}
func (UnimplementedPlaygroundServiceServer) GetCompileOutput(context.Context, *GetCompileOutputRequest) (*GetCompileOutputResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCompileOutput not implemented")
}
func (UnimplementedPlaygroundServiceServer) Cancel(context.Context, *CancelRequest) (*CancelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Cancel not implemented")
}
func (UnimplementedPlaygroundServiceServer) GetPrecompiledObjects(context.Context, *GetPrecompiledObjectsRequest) (*GetPrecompiledObjectsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrecompiledObjects not implemented")
}
func (UnimplementedPlaygroundServiceServer) GetPrecompiledObject(context.Context, *GetPrecompiledObjectRequest) (*GetPrecompiledObjectResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrecompiledObject not implemented")
}
func (UnimplementedPlaygroundServiceServer) GetPrecompiledObjectCode(context.Context, *GetPrecompiledObjectCodeRequest) (*GetPrecompiledObjectCodeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrecompiledObjectCode not implemented")
}
func (UnimplementedPlaygroundServiceServer) GetPrecompiledObjectOutput(context.Context, *GetPrecompiledObjectOutputRequest) (*GetPrecompiledObjectOutputResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrecompiledObjectOutput not implemented")
}
func (UnimplementedPlaygroundServiceServer) GetPrecompiledObjectLogs(context.Context, *GetPrecompiledObjectLogsRequest) (*GetPrecompiledObjectLogsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrecompiledObjectLogs not implemented")
}
func (UnimplementedPlaygroundServiceServer) GetPrecompiledObjectGraph(context.Context, *GetPrecompiledObjectGraphRequest) (*GetPrecompiledObjectGraphResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrecompiledObjectGraph not implemented")
}
func (UnimplementedPlaygroundServiceServer) GetDefaultPrecompiledObject(context.Context, *GetDefaultPrecompiledObjectRequest) (*GetDefaultPrecompiledObjectResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDefaultPrecompiledObject not implemented")
}

// UnsafePlaygroundServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to PlaygroundServiceServer will
// result in compilation errors.
type UnsafePlaygroundServiceServer interface {
	mustEmbedUnimplementedPlaygroundServiceServer()
}

func RegisterPlaygroundServiceServer(s grpc.ServiceRegistrar, srv PlaygroundServiceServer) {
	s.RegisterService(&PlaygroundService_ServiceDesc, srv)
}

func _PlaygroundService_RunCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCodeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).RunCode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/RunCode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).RunCode(ctx, req.(*RunCodeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_CheckStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CheckStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).CheckStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/CheckStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).CheckStatus(ctx, req.(*CheckStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_GetRunOutput_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRunOutputRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).GetRunOutput(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/GetRunOutput",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).GetRunOutput(ctx, req.(*GetRunOutputRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_GetLogs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLogsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).GetLogs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/GetLogs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).GetLogs(ctx, req.(*GetLogsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_GetGraph_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetGraphRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).GetGraph(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/GetGraph",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).GetGraph(ctx, req.(*GetGraphRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_GetRunError_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRunErrorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).GetRunError(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/GetRunError",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).GetRunError(ctx, req.(*GetRunErrorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_GetValidationOutput_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetValidationOutputRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).GetValidationOutput(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/GetValidationOutput",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).GetValidationOutput(ctx, req.(*GetValidationOutputRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_GetPreparationOutput_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPreparationOutputRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).GetPreparationOutput(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/GetPreparationOutput",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).GetPreparationOutput(ctx, req.(*GetPreparationOutputRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_GetCompileOutput_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCompileOutputRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).GetCompileOutput(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/GetCompileOutput",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).GetCompileOutput(ctx, req.(*GetCompileOutputRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_Cancel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CancelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).Cancel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/Cancel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).Cancel(ctx, req.(*CancelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_GetPrecompiledObjects_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPrecompiledObjectsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).GetPrecompiledObjects(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/GetPrecompiledObjects",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).GetPrecompiledObjects(ctx, req.(*GetPrecompiledObjectsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_GetPrecompiledObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPrecompiledObjectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).GetPrecompiledObject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/GetPrecompiledObject",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).GetPrecompiledObject(ctx, req.(*GetPrecompiledObjectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_GetPrecompiledObjectCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPrecompiledObjectCodeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).GetPrecompiledObjectCode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/GetPrecompiledObjectCode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).GetPrecompiledObjectCode(ctx, req.(*GetPrecompiledObjectCodeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_GetPrecompiledObjectOutput_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPrecompiledObjectOutputRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).GetPrecompiledObjectOutput(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/GetPrecompiledObjectOutput",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).GetPrecompiledObjectOutput(ctx, req.(*GetPrecompiledObjectOutputRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_GetPrecompiledObjectLogs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPrecompiledObjectLogsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).GetPrecompiledObjectLogs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/GetPrecompiledObjectLogs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).GetPrecompiledObjectLogs(ctx, req.(*GetPrecompiledObjectLogsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_GetPrecompiledObjectGraph_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPrecompiledObjectGraphRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).GetPrecompiledObjectGraph(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/GetPrecompiledObjectGraph",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).GetPrecompiledObjectGraph(ctx, req.(*GetPrecompiledObjectGraphRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PlaygroundService_GetDefaultPrecompiledObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDefaultPrecompiledObjectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PlaygroundServiceServer).GetDefaultPrecompiledObject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.PlaygroundService/GetDefaultPrecompiledObject",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PlaygroundServiceServer).GetDefaultPrecompiledObject(ctx, req.(*GetDefaultPrecompiledObjectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// PlaygroundService_ServiceDesc is the grpc.ServiceDesc for PlaygroundService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var PlaygroundService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "api.v1.PlaygroundService",
	HandlerType: (*PlaygroundServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RunCode",
			Handler:    _PlaygroundService_RunCode_Handler,
		},
		{
			MethodName: "CheckStatus",
			Handler:    _PlaygroundService_CheckStatus_Handler,
		},
		{
			MethodName: "GetRunOutput",
			Handler:    _PlaygroundService_GetRunOutput_Handler,
		},
		{
			MethodName: "GetLogs",
			Handler:    _PlaygroundService_GetLogs_Handler,
		},
		{
			MethodName: "GetGraph",
			Handler:    _PlaygroundService_GetGraph_Handler,
		},
		{
			MethodName: "GetRunError",
			Handler:    _PlaygroundService_GetRunError_Handler,
		},
		{
			MethodName: "GetValidationOutput",
			Handler:    _PlaygroundService_GetValidationOutput_Handler,
		},
		{
			MethodName: "GetPreparationOutput",
			Handler:    _PlaygroundService_GetPreparationOutput_Handler,
		},
		{
			MethodName: "GetCompileOutput",
			Handler:    _PlaygroundService_GetCompileOutput_Handler,
		},
		{
			MethodName: "Cancel",
			Handler:    _PlaygroundService_Cancel_Handler,
		},
		{
			MethodName: "GetPrecompiledObjects",
			Handler:    _PlaygroundService_GetPrecompiledObjects_Handler,
		},
		{
			MethodName: "GetPrecompiledObject",
			Handler:    _PlaygroundService_GetPrecompiledObject_Handler,
		},
		{
			MethodName: "GetPrecompiledObjectCode",
			Handler:    _PlaygroundService_GetPrecompiledObjectCode_Handler,
		},
		{
			MethodName: "GetPrecompiledObjectOutput",
			Handler:    _PlaygroundService_GetPrecompiledObjectOutput_Handler,
		},
		{
			MethodName: "GetPrecompiledObjectLogs",
			Handler:    _PlaygroundService_GetPrecompiledObjectLogs_Handler,
		},
		{
			MethodName: "GetPrecompiledObjectGraph",
			Handler:    _PlaygroundService_GetPrecompiledObjectGraph_Handler,
		},
		{
			MethodName: "GetDefaultPrecompiledObject",
			Handler:    _PlaygroundService_GetDefaultPrecompiledObject_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api/v1/api.proto",
}


Bright Brown Bracelet. Macaraya products are the latest fashion industry accessory.
Bright Brown leather link with stainless steel lock.
All our bracelets have been lovingly assembled by hand in the UK. They are all individual as no 2 will be exactly alike and are approximately 19 cm in length with a stainless steel locking hasp. Each bracelet is made of the finest synthetic leather which comes with 9 hand twisted chains per bracelet.


text:
Lucy Roth
Iowa vs. Northwestern, 10/26/19
Lucy Roth was a seemingly healthy 2-year-old, until her parents suspected that she had vision problems.
"We would see her playing with toys, and she would drop things," recalls Lucy's dad, Damien. "She would pat around with her hands until she could find the object. Sometimes we would call to her and she would look past us."
When screenings elsewhere seemed to indicate normal vision, Lucy's parents brought her to University of Iowa Stead Family Children's Hospital. Pediatric ophthalmologists ordered an MRI, after which the couple was asked to meet with a neurosurgeon.
"Why would we be meeting with a neurosurgeon? That doesn't make any sense. We were just here for her vision," Lucy's mom, Heather, remembers thinking. "A neurosurgery resident pulled up the MRI images. Nothing could've prepared us for what we saw."
"The MRI revealed that Lucy had a massive brain tumor that was pressing on her optic nerve," Heather continues. "As the images came up, we saw a massive, almost softball size, tumor." The family met with a pediatric oncologist and Lucy was immediately admitted to the pediatric intensive care unit to await surgery that would take place three days later.
During the 12-hour surgery, pediatric neurosurgeons removed a large amount of the tumor, but Lucy lost a significant amount of blood, leading to a stroke that paralyzed the right side of her body.
"It was an extremely difficult, dangerous surgery because the tumor was so big, it had wrapped itself around different blood vessels and was in a very difficult spot of the brain to access," Damien says. "They had replaced every ounce of her blood in her body two times because she had lost so much blood during the surgery."
"I just kept thinking, 'Is this the last time I'm going to see my daughter alive?'" Heather recalls. "It was just excruciating to wait, not knowing whether our little girl would be coming back to us."
Pathology tests revealed the brain tumor, an atypical meningioma, was cancerous. "This type of tumor usually isn't seen in children. Lucy's was extremely aggressive. It had been growing, basically, since she was born," Damien explains.
Heather recalls, "[Her neurosurgeon] said he had never seen this type of tumor in someone so young in his 40 years of surgery. There was only a handful of children in the world with a similar type of tumor and none of them as big as hers."
Lucy underwent more than two years of chemotherapy and twice-daily hormone injections to inhibit the tumor's growth.
"We were able to manage her brain tumor until she was 6 years old," explains Heather. "Then she had her second brain surgery, and we were so scared because of all the risks involved," Heather says. "But her neurosurgeons did an amazing job of removing more of the tumor."
The remaining tumor was treated with 33 consecutive days of radiation and is currently stable, though it will always need to be monitored with routine MRIs.
Through physical and occupational therapies, Lucy relearned how to crawl, stand, and walk, and continues to build her strength. Heather adds, "She still struggles daily with the many side effects of her treatments and surgeries, such as chronic headaches, short-term memory loss, hormonal and growth issues, dental issues, and orthopedic issues."
Though Lucy also copes with losing the use of her right hand, she would like to be an artist or art teacher, and she sees the positives in her children's hospital visits.
"This hospital is creative, peaceful, colorful, mindful," she says.
"While Lucy was going through her chemo treatments we would watch as the new children's hospital was being built. They put so much thought into what the experience would be like for the children. All of the little details, all of the new technologies, it just makes it so much easier to come here," Heather explains.
"We've been so thankful to live so close to a world-class children's hospital where Lucy has access to all the specialists she needs. Over the years, she's been seen by over a dozen departments and is still followed by most of them," Heather adds. "We can never thank Lucy's doctors enough for saving her life and for being so invested in her care as if she were their own child. The nurses, the child life specialists, the University of Iowa Dance Marathon students—all of them have been such an important part of Lucy's journey. We've learned that getting older is a privilege and every birthday is a milestone. Every year that goes by, we can't believe she's here with us, and to be such a happy, positive child."
View the full roster of 2019 Kid Captains here.

redpajama_set_name: RedPajamaCommonCrawl


From time to time I am asked 'what is involved in the recruiting process'. I can provide two answers, one for people looking for a job (job seekers) and one for people looking to fill a job (client companies).
The recruiting process for a job seeker is pretty straight-forward. It starts with the initial conversation we have where we dialog about what you are looking for, where you are looking in the U.S., and talking about your career goals. From there I look at the positions I'm working on and I also have access to jobs through other recruiters in my network that I can look at to determine if I have any jobs that fit your background.
Once we have identified an opportunity that you wish to pursue, I work with you to critique, prepare and submit your resume and arrange phone interviews and on-site interviews, providing you with interview preparation assistance and sharing with you the insights I have about the company you are working with. I do my best to walk you through every step of the process, from resume presentation to the offer acceptance. Our services are completely free to you, the job seeker.
CONFIDENTIALITY: Many of the people we assist in job searches are currently employed and wish to keep their search confidential which is why we NEVER submit a resume without first clearing the job with the applicant.
For those of you looking to fill an engineering job opening, the process starts with a conversation where we talk about what you are looking for. Having been in this business for over 30 years, I've learned the ropes and I can hold a technical conversation and get very specific on the type of engineer you are looking for. As part of this step, I can give you an honest appraisal of whether the search criteria you are using are realistic and/or competitive in the candidate marketplace. From there I tap into my network that includes many years' worth of contacts (engineers, other recruiters, and industry sources) and, if I'm able, I gather a few resumes to send along to you for your review. Generally speaking, I check references on candidates before-hand so that you can have confidence that the candidates presented are quality engineers.
Following presentation of the candidates, I help schedule phone & face-to-face interviews, gather additional references (if needed) and provide other pertinent information with regards to the relocation needs and compensation expectations of the candidates. After an offer has been accepted, I stay in touch with your new employee up to and beyond their start-date, assuring the completion of things like background checks and drug screening.


It doesn't have to look like exercise, it can look like fun!
Sometimes you need motivation to work out, and there's no problem with that. All it takes is a distraction to make exercise feel less like work and more like fun, and VR can be perfect for those distractions. All you really need is an exercise routine you're comfortable with repeating, and you're good to go!
We've got a couple of ideas for how you can use VR to make that exercise routine either more engaging or less like work. Pick the one that works best for you and give it a shot!


A lovely Royal Oak 36mm reference 14790, in original untouched conditions featuring an attractive tropical bronze color dial.
The case is thick with sharp beveled edges and original satin finish. The watch shows signs of regular wear but overall no dings or dents.
The dial is unique in it's bronze color and has no defects on the background or markers.
The bracelet will fit a 7 1/4 ' wrist.
The movement is running fine. No service history available.
A great classic for the savvy collector.


text:
Barbara "Bar" Winifred West (9 November 1913 – 4 November 2014) was a British hockey player, coach, and administrator. She and her twin Bridget West played Hockey for England and she was involved with British hockey for 50 years.

Life
West was born in Rugby in 1913, twenty minutes before her identical sister, Bridget. She had two other sisters and in time a half brother. She was known as "Bar". Her father Francis Charles Bartholomew (Frank) West, a vicar's son was called to the bar. He was of independent means and never practised. Her mother had attended Newnham College. Her father died as a soldier when she was a child. Her mother remarried and they had another son, Roger.

She trained to be a teacher at Froebel Institute in Roehampton. She then taught at Bartram Gables School, Downes School and Brighton and Hove High School. She taught at Chelsea College of Physical Education in Eastbourne for 22 years where she also coached. In her spare time she was a leader for the Girl Guides.

She was a member of the Women's Institutes and she helped her village of Alfriston to become the Best kept village competition.

West died in East Surrey Hospital in 2014 at the age of 100.

Hockey
She toured New Zealand as part of the England women's hockey team in 1938 when they won all of their fifteen matches. During the war she told the story of how a school game was interrupted when a passing German plane decide to machine gun the players. The only injury was a nettle sting as one girl dived for cover. After the war she played hockey for England touring the USA in 1947. The team included her sister Bridget West and Mary Russell Vick. They played 18 matches on that tour with one goalkeeper confused when two identical players both had a try at scoring a goal. The sisters were lifelong chums and in 1971 they were asked to look after the klaxon during a Scotland-England hockey match. They were so engrossed in the game that they forget to ring the klaxon and Scotland won the game 2-1.

West acted as a selector and a coach. The goalkeeper Hazel Feltwell and the forward Val Robinson were two of her mentees.

References

1913 births
2014 deaths
Sportspeople from Rugby, Warwickshire
English female field hockey players
People from Alfriston
British centenarians
Women centenarians
Twin sportspeople
English twins
English field hockey coaches
English sports executives and administrators
Identical twins

redpajama_set_name: RedPajamaWikipedia


text:
.gallery-items { font-size: 0; }

.gallery-item {
  display: inline-block;
  vertical-align: top;
  -webkit-transition: height 500ms ease;
  -o-transition: height 500ms ease;
  transition: height 500ms ease;
}

.gallery-expander {
  position: absolute;
  left: 0;
  right: 0;
  overflow: hidden;
  max-height: 0;
  -webkit-transition: max-height 500ms ease;
  -o-transition: max-height 500ms ease;
  transition: max-height 500ms ease;
}

.gallery-contents { position: relative; }

.gallery-contents:after {
  display: block;
  position: absolute;
  bottom: 0px;
  left: 50%;
  margin-left: -30px;
  width: 0;
  height: 0;
  content: '';
  border-left: 30px solid transparent;
  border-right: 30px solid transparent;
  border-bottom-style: solid;
  border-bottom-width: 0px;
  -webkit-transition: border-bottom-width 500ms ease;
  -o-transition: border-bottom-width 500ms ease;
  transition: border-bottom-width 500ms ease;
}

.gallery-item.active .gallery-contents:after { border-bottom-width: 30px; }

body {
/*  font-family: 'Nanum Barun Gothic';
  font-weight: 200;
  color: #555;*/
}

ul {
  margin: 0;
  padding: 0;
  list-style: none;
  text-align: center;
}

.gallery-item {
  text-align: left;
  font-size: 25px;
  margin: 0 10px;
  padding: 10px 0;
}

.gallery-item .thumbnail {
  position: relative;
/*  width: 300px;
  height: 300px;*/
  overflow: hidden;
  cursor: pointer;
}

.gallery-item .thumbnail > img {
  position: absolute;
  top: 50%;
  margin-top: -300px;
  max-width: 300px;
}

.gallery-item .title {
  text-align: center;
  margin-top: 20px;
  padding-bottom: 20px;
}

.gallery-contents:after { border-bottom-color: #F6F3ED; }

.gallery-expander { background: transparent; }

.gallery-expander-contents {
/*  margin: 0 auto;
  width: 1000px;

  padding: 20px 0;*/
}
@media (min-width: 640px) and (max-width: 999px) {

.gallery-expander-contents { width: 640px; }
}
@media (max-width: 639px) {

.gallery-expander-contents { width: 100%; }
}

.gallery-expander-contents:after {
  clear: both;
  display: table;
  content: '';
}

.gallery-expander-contents > div.col {
  float: left;
  width: 480px;
}
@media (min-width: 640px) and (max-width: 999px) {

.gallery-expander-contents > div.col { width: 310px; }
}
@media (max-width: 639px) {

.gallery-expander-contents > div.col {
  float: none;
  padding: 25px 20px 0;
  width: auto;
}
}

.gallery-expander-contents > div.col + div.col { margin-left: 40px; }
@media (min-width: 640px) and (max-width: 999px) {

.gallery-expander-contents > div.col + div.col { margin-left: 20px; }
}
@media (max-width: 639px) {

.gallery-expander-contents > div.col + div.col { margin-left: 0px; }
}

.gallery-expander-contents div.close {
  position: absolute;
  top: 10px;
  right: 20px;
}

.gallery-expander-contents div.title {
  font-weight: 500;
  color: #D28A3C;
}

.gallery-expander-contents div.contents {
  margin-top: 10px;
  border-top: 1px solid #BCB098;
  border-bottom: 1px solid #BCB098;
  padding: 10px 0;
  font-size: 14px;
  line-height: 24px;
  color: #797262;
}

.gallery-expander-contents div.image > img {
  width: 100%;
  display: block;
}

redpajama_set_name: RedPajamaGithub


text:
Home›Destinations›Europe›Italy›Northern Italy›The Veneto›Verona›In Depth
Side Trips
In Depth in Verona
Art Thou, Truly, Romeo?
Though the city has plenty else to recommend it as a sightseeing capital of the Veneto, the local tourism economy is underpinned by hordes of bus groups, Shakespearian pilgrims, and hopeless romantics. They come to wander the streets where Capulets and Montagues once fought, Romeo pined, and Juliet sighed from her (completely false) balcony.
Wealthy Veronese families called Capuleti and Montecchi did exist. Did they feud? Probably. That often was the way with local clans vying for city power in the Middle Ages. But did their two houses, so alike in dignity, ever harbor secret, star-crossed lovers? Did Romeo and Juliet really exist?
The story is based in an ancient legend; the core tragic elements go back at least to the Greeks. To trace the Shakespeare version: The basic story was put into novella form (based on a medieval Sienese version) in 1476 and then subsequently retold in 1524 by Veneto-born Luigi da Porto. He chose to set it in Verona in the years 1302 to 1304 during the reign of the Scaligeri, and renamed the young couple Romeo and Giulietta. The popular storia d'amore was translated into English, at which point Shakespeare obviously got hold of it and worked his own magic.
With the genius of Shakespeare's pen, the story turned into theatrical gold. Translated into dozens of languages and performed around the world (check out the number of Asian and eastern European tourists who flock to Juliet's House), this universal and timeless tale of pure love has forever since been set in the tempestuous days of this medieval city -- notwithstanding that version with Leo DiCaprio.
That said, Zeffirelli chose to film his classic 1968 interpretation in the tiny Tuscan town of Pienza, south of Siena. And, of course, the story emigrated to the New World and took up in the mean streets of New York as West Side Story.


text:
Diamond Bitch – pierwszy solowy, a czwarty w karierze, album studyjny polskiej piosenkarki Dody wydany przez Universal Music Polska 27 lipca 2007.

Zadebiutował na pierwszym miejscu listy sprzedaży OLiS i przebywał tam pięć tygodni z rzędu. 5 grudnia 2007 zdobył status platynowej płyty. 29 sierpnia 2008 ukazała się jego edycja specjalna. Album uzyskał łącznie nakład ponad 45 tysięcy zestawów.

Album Diamond Bitch spotkał się z negatywnym przyjęciem przez krytyków muzycznych (w przeciwieństwie do pozytywnego przyjęcia przez fanów).

Nagrywanie
W listopadzie 2006 w programie Dzień Dobry TVN Doda powiedziała, że nagrywa solowy album. Na producenta muzycznego został wybrany Mark Tysper oraz Marcin Trojanowicz. Tysper skomponował również utwory na album, a Doda zajęła się tekstami.

Pisząc słowa piosenek, Rabczewska inspirowała się ostatnimi dramatycznymi wydarzeniami w swoim życiu. Do byłego męża Radosława Majdana kierowane są ballady "Katharsis" i "Ostatni raz ci zaśpiewam". "Judasze" to wspomnienie byłego przyjaciela Tomasza Luberta, lidera grupy Virgin. "Dziękuję" to podziękowanie dla fanów. "Prowokacja" jest zaś adresowana do natrętnych dziennikarzy.

Dwanaście utworów z albumu to kompozycje głównie popowe, choć często z domieszką rocka. W "Całkiem innej" słychać mroczne, klawiszowe intro i ciężki riff, a "Diamond Bitch" jest czymś pomiędzy rockiem a metalem. Na albumie znajdują się muzyczne inspiracje amerykańskim pop metalem z lat 80. w rodzaju Bon Jovi ("Ćma", "Cheerleaderka"), ale tak jak i na wcześniejszych płytach Dody, z czasów Virgin, pojawiają się też odniesienia do tego, co robiły takie grupy, jak Bajm czy Banda i Wanda ("To jest to", "Prowokacja"). Na płycie są również ballady ("Ostatni raz ci zaśpiewam", "Rany").

Nagrania na album odbyły się wiosną 2007. Potem odbyło się miksowanie i mastering (między innymi w Studio 17 Buffo i Sun Studio). Tymczasem nagrania utworu "Nie daj się" promującego reedycję albumu odbyło się w czerwcu 2008 w Studio Buffo.

Wydanie i promocja
6 czerwca 2007 o godzinie 19:10 w radiu RMF FM odbyła się premiera pierwszego utworu promującego Diamond Bitch, "Katharsis". Jego emisję słuchało około 7 mln słuchaczy. W czerwcu został on wybrany na singla. 10 lipca w programie Viva Hits Polska, około godziny 20:00, w Vivie odbyła się premiera teledysku do singla.

27 lipca 2007 odbyła się premiera albumu Diamond Bitch. Doda planowała duże szczęście dla płyty, gdyż w dacie są trzy siódemki (27.07.07). Nazwała album bitch, co w języku angielskim oznacza suka, oraz diamond (diament), ponieważ wierzyła, że płyta osiągnie sprzedaż zapewniającą status diamentowy. Pudełko albumu jest zrobione w bardzo oryginalny sposób, niespotykany w "normalnych" albumach. Na krążku jest narysowany różowy misiek Dody, poza tym na płycie położone są różowe piórka. W albumie znajduje się kartka; na jego jednej stronie znajduje się plakat, a na drugiej – teksty piosenek, twórcy, podziękowania i sesja zdjęciowa Dody. Koło kartki znajdują się zaprojektowane przez Dodę plakaty. Poza tym każdy egzemplarz ma swój indywidualny numer.

We wrześniu odbyła się premiera singla "To jest to". W czerwcu 2008 rozpoczęła prace nad reedycją albumu. W czerwcu nagrała nowy utwór "Nie daj się" oraz teledysk, którego premiera odbyła się na portalu Plejada.pl.

29 sierpnia odbyła się premiera edycji specjalnej Diamond Bitch ze zmienioną okładką i bonusowymi utworami na CD: "Nie daj się", coverem "Like A Virgin" Madonny oraz wersjami instrumentalnymi "Nie daj się" i "Katharsis" (na płycie zabrakło jednak "To jest to" ze względu na podejrzenia o plagiat). Oprócz tego do albumu dołączono płytę DVD z wszystkimi teledyskami Dody i Virginu, kulisami nagrywania utworu i teledysku "Nie daj się" oraz domowym archiwum Dody – filmikami z dzieciństwa artystki. Tymczasem utwór "Rany" wykorzystano w filmie Krzysztofa Zanussiego Serce na dłoni, w którym Doda zagrała. W październiku ogłosiła wybór tej piosenki na singla.

W lutym 2009 odbyła się premiera singla "Rany", a 9 lutego na Plejada.pl pokazano teledysk. Utwór nie odniósł sukcesu. W kwietniu Doda potwierdziła wydanie piątego i ostatniego singla promującego Diamond Bitch, "Dziękuję". 2 kwietnia nakręciła teledysk, którego premiera odbyła się 5 maja na orangemusic.pl.

Recenzje
Album zebrał negatywne recenzje krytyków muzycznych. Marek Świdrowicz, dziennikarz czasopisma Teraz Rock, krytykował melodie zawartych na płycie piosenek, które podsumował mianem "niezbyt ambitnego popu". Diamond Bitch skwitował jako wydawnictwo "kiczowate i cukierkowe".

Promocja

Single
 "Katharsis" – pierwszy singel wydany w czerwcu 2007. Muzykę napisali Mikis Cupas i Mark Tysper, a słowa Doda. Tekst jest napisany po rozstaniu Rabczewskiej z Radosławem Majdanem. Sensację zdobył teledysk, który zdobył trzy nominacje i w tym dwie nagrody.
 "To jest to" – drugi singel wydany we wrześniu 2007. Muzykę napisali Lindfors i Tysper, a słowa – Doda. Utwór nie pojawia się na reedycji albumu ze względu na podejrzenia o plagiat.
 "Nie daj się" – trzeci singel wydany w czerwcu 2008 i promujący edycję specjalną albumu. Muzykę napisał Marek Kościkiewicz, a słowa – Doda. Wygrał konkurs na Polski Hit Lata 2008 na Sopot Hit Festiwalu.
 "Rany" – czwarty singel wydany w lutym 2009. Muzykę napisał Sebastian Piekarek, a słowa – Doda.
 "Dziękuję" – piąty i ostatni singel wydany w maju 2009. Muzykę napisał Tysper, a słowa – Doda. W maju odbyła się premiera jego teledysku. Piosenka zajęła pierwsze miejsce w plebiscycie "Przebój Lata 2009" organizowanym przez Onet.pl i wielu telewizyjnych listach przebojów.

Wykonania
 8 czerwca 2007: TOPtrendy ("Szansa", "Katharsis")
 15 czerwca 2007: KFPP Opole ("Katharsis")
 1 września 2007: Sopot Festival ("To jest to")
 4 października 2007: VIVA Comet ("Katharsis")
 31 grudnia 2007/1 stycznia 2008: Sylwester Jasny Od Gwiazd 2007/2008 we Wrocławiu emitowany przez TVP2 ("Dżaga", "Szansa", "Katharsis", cover "Material Girl" Madonny)
 4 lutego 2008: Telekamery ("Katharsis")
 14 czerwca 2008: KFPP Opole ("Katharsis", "Diamond Bitch", "Nie daj się")
 4 lipca 2008: TOPtrendy ("Katharsis", "Nie daj się")
 8 sierpnia 2008: Sopot Hit Festiwal ("Nie daj się")
 31 grudnia 2008/1 stycznia 2009: Sylwester Jasny Od Gwiazd we Wrocławiu emitowany przez TVP2 ("Dżaga", "Szansa", "Nie daj się", cover "What's Up" 4 Non Blondes)
 7 sierpnia 2009: Sopot Hit Festiwal ("Nie daj się", "Dżaga", cover "Boys (Summertime Love)" Sabriny, "Dziękuję")
 22 sierpnia 2009: Sopot Festival 2009 ("Znak pokoju")
 31 grudnia 2009/1 stycznia 2010: Odyseja Gwiazd / Sylwester z Dwójką w Łodzi (cover "Venus" Bananaramy, "Dżaga", "Dziękuję", "Szansa", "Nie daj się")
 25 lutego 2010: VIVA Comet 2010 ("Dziękuję", "Muzyki moc" z VIVA i Przyjaciele)

Lista utworów

Edycja specjalna

DVD

Notowania

Nagrody

Przypisy

Linki zewnętrzne
 Okładka

Albumy Dody
Albumy Universal Music Polska
Albumy numer jeden w Polsce
Albumy muzyczne wydane w roku 2007
Muzyczne albumy wideo
Albumy muzyczne wydane w roku 2008


Tom mentions that when he interviews a job candidate, he will ask at least one question that either does not have a correct answer, may have multiple correct answers, or is ambiguous. (For those of you who are not DBAs, data professionals often joke that the standard answer is, "it depends.") He is not looking for a singular correct answer; rather, he is looking for how the candidate answers.
This brought to mind a memory of a class I took in grad school. I missed a class because I was out sick, and it turned out that the material covered that day ended up as a question on the mid-term exam. I don't remember exactly how I answered that question, but I remember starting it something like this: "I don't remember going over this subject, but based on the nature of this question, this is what I think it means…" Not only did I end up answering the question correctly, I ended up getting a 97 (out of 100) on the exam.
So if you don't know the answer, how would you go about getting it? These days, technology makes it easy to look things up online. "Google it" has become a part of our lexicon. Trying to find answers is our basis for research; if we don't have the answer, we try to figure out what it is. That is how we learn. I'll go as far to say that not knowing an answer is better than trying to fake your way through providing an answer. Would you rather give an answer you don't know and end up giving a wrong answer, or would you rather take the time to do your homework and give a better answer?
Too many of us stress ourselves out because we try to be perfect. Any time we are tested — whether it's on an exam, a job interview, or any instance where we are expected to give testimony — we expect ourselves to be perfect. We expect to have the answer to every question. The reality is that this is impossible. We won't have every answer, and we shouldn't expect to. "I don't know" is a perfectly acceptable answer, and too many people don't realize that. Just say that you don't know, and explain how you'd go about finding out. And the next time you're asked the question, you'll have a better answer.
It brought to mind an important thought (and more 'blog article fodder): any time you produce something, regardless of what it is — a software application, documentation, a presentation, a music composition, a dish you cooked, etc. — always ask someone else to test it out before you send it out for public consumption.
That testing could take several different forms — it could be an end user trying your application, somebody reading your document, listening to your presentation or your music, trying your dish, and so on. Testing results in feedback, which results in improvements to your product.
Whenever we produce something, we have our own vision — and our own biases — as to how the product should come out. We expect our products to be perfect as resulting from our own visions, and we expect (and demand) that the consumers adhere to our visions and how we expect the products to be viewed or interpreted.
Unfortunately, we are blinded by our biases. The world does not share our same visions. People who use our products will never, ever, perfectly interpret how our products should be consumed. More often than not, we'll find that what we produce will be used or interpreted in ways that never occurred to us.
In a manner of speaking, creating products is a form of communication — in that what we produce results from an idea in our heads, and the end users — the consumers — are the ones "listening" to the communication — in this case, the end product. If you are familiar with the basic communication model, a sender creates a message, a receiver interprets the message, and the receiver reacts to the message in the form of feedback. Producing a products works in exactly the same way — a producer creates a product, a consumer uses the product, and the consumer reacts to the product, generating feedback. In between the sender and the receiver is "noise" that degrades the message or the product (it is not literally noise — the "noise" can simply be the fact that the sender's and receiver's interpretation of the message are not one and the same).
So, any time you create some kind of product, always ask someone else to try it out. You'll find that the person's feedback will result in tweaks to your product. And you will end up with a better product.
It's been said that (baseball) pitchers need to have short memories. Whenever a pitcher makes a mistake — say, gives up a home run — he needs to shake it off — forget about it and move on to the next batter.
That being said, he needs to remember it as well. He needs to figure out what he did wrong (e.g. "okay, he likes the fastball down and away") and remember not to make that same mistake the next time that batter comes up to hit. In other words, he learns from his mistake.
This pretty much happens to all of us. We're human. We're not perfect. We're going to make mistakes. The issue is when we become afraid of those mistakes. We become so afraid of mistakes that it discourages us from doing things.
Let me make one thing clear. I'm not talking about people who willfully make mistakes, don't care, or strive for mediocrity (which, by the way, is a huge pet peeve of mine, and one that I do not tolerate. That's another 'blog post for another time). I'm talking about people who genuinely care about what they're doing, who want to do a good job or get better, and are putting in an effort to reach that goal.
As a part-time musician who holds a leadership position, this particularly troubles me when it comes to making music. Someone doesn't want to play something because he or she is afraid of screwing up. Why? Music is an area where it makes the most sense to make mistakes. The time spent practicing or rehearsing music is when making mistakes makes the most sense. It's called practice for a reason. It's time spent to address areas that need to be improved — hence, why it's important to make mistakes. Mistakes tell us what needs work or what needs to be addressed. Mistakes are why we rehearse. We don't — and shouldn't — practice what we're doing right; we need to practice what we're doing wrong.
When it comes to music, I attribute part of it to stage fright. People don't want to make mistakes in front of other people. I say, who cares? So what if you make a mistake? What's going to happen? Are people going to think less of you? In all likelihood, probably not. For what it's worth, I've heard — and even seen — professional musicians make mistakes during concerts or live performances. More often than not, they'll keep going as if nothing happened. No big deal. It's funny, but I lost my fear of performing (or speaking) in front of groups a long time ago. I attribute it to realizing that making a mistake isn't the end of the world.
The same holds true on the job. Many of us are afraid to make mistakes at work. Why? Are we going to get fired? Unless the mistake is either (1) very large, or (2) numerous, it's unlikely. How many of you have had bad days at work? It happens sometimes. How many of you have lost your job because of them? I suspect, not many.
The ability to make mistakes is important. We learn from them. We get better because of them. They make us stronger. And once you can address them, overcome them, learn how to recover from them, or eliminate them, chances are that people will say that you're the master at your craft, whatever that craft may be.


text:
ALERTS CORONAVIRUS SUMMARY UPDATE JANUARY 7, 2021 Read On...
The School Crossing Guards are responsible for the safe crossing of elementary and middle school children who attend school within the confines of the Town of Brighton. There are presently 11 School Crossing Guards who attend to the needs of students from four different schools. The majority of School Crossing Guards are located by the school complex around the 12 Corners area of the Town. The remainder are assigned to various schools located throughout the Town.
We are very proud of our School Crossing Guards for the outstanding job they do in protecting the school children from the hazards of crossing some of the busiest streets located within the County of Monroe. It is with great pride that the School Crossing Guards have maintained a perfect record of crossing children to and from school in all types of weather during the school year.
For further information regarding School Crossing Guards and their posts or duties, contact Captain Michael DeSain at (585) 784-5109.
Identification Division
Use of Force Policy
Brighton Police
What are your hours?
Where is the Town Hall located?
Where is the Recreation Department located?
Where do I go for court?
Town Hall | 2300 Elmwood Avenue | Rochester, NY 14618 | Phone: 585-784-5250 | Fax: 585-784-5373
Home | Site Map | Contact Us | Accessibility | Website Policies | Government Websites by CivicPlus®


text:
Bremeria scabridior är en måreväxtart som först beskrevs av Herbert Fuller Wernham, och fick sitt nu gällande namn av Sylvain G. Razafimandimbison och Grecebio Jonathan D. Alejandro. Bremeria scabridior ingår i släktet Bremeria och familjen måreväxter.

Artens utbredningsområde är Madagaskar. Inga underarter finns listade i Catalogue of Life.

Källor

Måreväxter
scabridior