text:
After making waves at Sundance, A24 has released the first trailer for The Last Black Man in San Francisco. In the film, Jimmie Fails plays a cinematic version of himself who goes back to the Victorian-style home of childhood in San Francisco. The house was built by his grandfather in 1946 but is now under new ownership, leaving Fails to imagine the community as though it had never changed. Directed by Joe Talbot, the film also stars Jonathan Majors, Rob Morgan, Tichina Arnold, and Danny Glover and will be in theaters June 14, 2019.
The Truth About Wasabi
If you think you've ever tried wasabi, think again. Most sushi restaurants serve a concoction of horseradish and Chinese mustard tinted with green food coloring. Even the most authentic sushi restaurants serve the fraudulent condiment. The reason is the real stuff is one of the most expensive crops in the world. In this short document, eighth generation farmer Shigeo Iida shares the tradition of growing Wasabia Japonica.
Building A $3 Million Doomsday Bunker
During the height of the Cold War, the US government built 1,000 nuclear ICBM silos across the country, mostly in the Great Plains. As the threat of nuclear war with the Soviets waned, over half of the sites were decommissioned — making them ideal doomsday bunkers for the ultra-rich and paranoid. The Survival Condo Project repurposes these sites built to withstand sustained nuclear war, converting them into condos that can support a family nearly indefinitely.
Inside The World Of High-End Coffee
Never underestimate humanity's ability to make anything into a specialized profession. At $29 per cup, Sey Coffee in Brooklyn serves one of the most expensive cups of coffee you can find. It's the result of years of testing and communicating with coffee growers on a personal level, all in the name of extracting the best from the beans. The world of high-end coffee is the end-result of the Starbucks revolution, with small businesses and enthusiasts taking one of the world's favorite beverages into the rarified air of wine.
David Attenborough isn't even close to being done telling you about the wonders of the place we call home — and there's even more to be discovered. Our Planet is shot completely in UltraHD 4k resolution, using the latest in digital film equipment to bring the amazing breadth of life on this planet into your living room. The documentary series premieres April 5, 2019 on Netflix.
Bel-Air
Filmmaker Morgan Cooper gives The Fresh Prince of Bel-Air a gritty reboot with this fan-made trailer, reimagining the 90s sitcom for 2019.
During the beginning of a zombie apocalypse, Rose is separated from her daughter — and the journey begins to get her back. Rose joins up with a group of American refugees that are fighting to stay alive and find their loved ones. But the fight isn't just against zombies and the government — it's also against each other. Black Summer is a companion prequel to SyFy series Z Nation and premieres on Netflix Aprill 11, 2019.


text:
package docker

import (
	"crypto"
	"crypto/rand"
	"fmt"
	"io"
	"net"
	"net/url"
	"strings"
	"time"

	"github.com/fsouza/go-dockerclient"
	"github.com/tsuru/config"
	"github.com/tsuru/docker-cluster/cluster"
	"github.com/tsuru/docker-cluster/storage/mongodb"
	"github.com/tsuru/tsuru/action"
	"github.com/tsuru/tsuru/app"
	"github.com/tsuru/tsuru/log"
	"github.com/tsuru/tsuru/provision"
	"github.com/tsuru/tsuru/safe"
	"gopkg.in/mgo.v2/bson"
)

func buildClusterStorage() (cluster.Storage, error) {
	mongoUrl, _ := config.GetString("docker:cluster:mongo-url")
	mongoDatabase, _ := config.GetString("docker:cluster:mongo-database")
	if mongoUrl == "" || mongoDatabase == "" {
		return nil, fmt.Errorf("Cluster Storage: docker:cluster:{mongo-url,mongo-database} must be set.")
	}
	storage, err := mongodb.Mongodb(mongoUrl, mongoDatabase)
	if err != nil {
		return nil, fmt.Errorf("Cluster Storage: Unable to connect to mongodb: %s (docker:cluster:mongo-url = %q; docker:cluster:mongo-database = %q)",
			err.Error(), mongoUrl, mongoDatabase)
	}
	return storage, nil
}

func getPort() (string, error) {
	port, err := config.Get("docker:run-cmd:port")
	if err != nil {
		return "", err
	}
	return fmt.Sprint(port), nil
}

func urlToHost(urlStr string) string {
	url, _ := url.Parse(urlStr)
	host, _, _ := net.SplitHostPort(url.Host)
	if host == "" {
		return url.Host
	}
	return host
}

func (p *dockerProvisioner) hostToNodeAddress(host string) (string, error) {
	nodes, err := p.getCluster().Nodes()
	if err != nil {
		return "", err
	}
	for _, node := range nodes {
		if urlToHost(node.Address) == host {
			return node.Address, nil
		}
	}
	return "", fmt.Errorf("Host `%s` not found", host)
}

type container struct {
	ID                      string
	AppName                 string
	ProcessName             string
	Type                    string
	IP                      string
	HostAddr                string
	HostPort                string
	PrivateKey              string
	Status                  string
	Version                 string
	Image                   string
	Name                    string
	User                    string
	BuildingImage           string
	LastStatusUpdate        time.Time
	LastSuccessStatusUpdate time.Time
	LockedUntil             time.Time
	appCache                provision.App
	routable                bool
}

func (c *container) shortID() string {
	if len(c.ID) > 10 {
		return c.ID[:10]
	}
	return c.ID
}

// available returns true if the Status is Started or Unreachable.
func (c *container) available() bool {
	return c.Status == provision.StatusStarted.String() ||
		c.Status == provision.StatusStarting.String()
}

func (c *container) getAddress() *url.URL {
	return &url.URL{
		Scheme: "http",
		Host:   fmt.Sprintf("%s:%s", c.HostAddr, c.HostPort),
	}
}

func randomString() string {
	h := crypto.MD5.New()
	h.Write([]byte(time.Now().Format(time.RFC3339Nano)))
	io.CopyN(h, rand.Reader, 10)
	return fmt.Sprintf("%x", h.Sum(nil))[:20]
}

func (c *container) addEnvsToConfig(app provision.App, cfg *docker.Config) {
	sharedMount, _ := config.GetString("docker:sharedfs:mountpoint")
	sharedBasedir, _ := config.GetString("docker:sharedfs:hostdir")
	host, _ := config.GetString("host")
	for _, envData := range app.Envs() {
		cfg.Env = append(cfg.Env, fmt.Sprintf("%s=%s", envData.Name, envData.Value))
	}
	cfg.Env = append(cfg.Env, []string{
		fmt.Sprintf("%s=%s", "TSURU_HOST", host),
		fmt.Sprintf("%s=%s", "TSURU_PROCESSNAME", c.ProcessName),
	}...)
	if sharedMount != "" && sharedBasedir != "" {
		cfg.Volumes = map[string]struct{}{
			sharedMount: {},
		}
		cfg.Env = append(cfg.Env, fmt.Sprintf("TSURU_SHAREDFS_MOUNTPOINT=%s", sharedMount))
	}
}

// creates a new container in Docker.
func (c *container) create(args runContainerActionsArgs) error {
	port, err := getPort()
	if err != nil {
		log.Errorf("error on getting port for container %s - %s", c.AppName, port)
		return err
	}
	user := c.getUser()
	securityOpts, _ := config.GetList("docker:security-opts")
	var exposedPorts map[docker.Port]struct{}
	if !args.isDeploy {
		exposedPorts = map[docker.Port]struct{}{
			docker.Port(port + "/tcp"): {},
		}
	}
	config := docker.Config{
		Image:        args.imageID,
		Cmd:          args.commands,
		User:         user,
		ExposedPorts: exposedPorts,
		AttachStdin:  false,
		AttachStdout: false,
		AttachStderr: false,
		Memory:       args.app.GetMemory(),
		MemorySwap:   args.app.GetMemory() + args.app.GetSwap(),
		CPUShares:    int64(args.app.GetCpuShare()),
		SecurityOpts: securityOpts,
	}
	c.addEnvsToConfig(args.app, &config)
	opts := docker.CreateContainerOptions{Name: c.Name, Config: &config}
	var nodeList []string
	if len(args.destinationHosts) > 0 {
		nodeName, err := args.provisioner.hostToNodeAddress(args.destinationHosts[0])
		if err != nil {
			return err
		}
		nodeList = []string{nodeName}
	}
	schedulerOpts := []string{args.app.GetName(), args.processName}
	addr, cont, err := args.provisioner.getCluster().CreateContainerSchedulerOpts(opts, schedulerOpts, nodeList...)
	if err != nil {
		log.Errorf("error on creating container in docker %s - %s", c.AppName, err)
		return err
	}
	c.ID = cont.ID
	c.HostAddr = urlToHost(addr)
	c.User = user
	return nil
}

func (c *container) getUser() string {
	user, err := config.GetString("docker:user")
	if err != nil {
		user, _ = config.GetString("docker:ssh:user")
	}
	return user
}

type containerNetworkInfo struct {
	HTTPHostPort string
	IP           string
}

// networkInfo returns the IP and the host port for the container.
func (c *container) networkInfo(p *dockerProvisioner) (containerNetworkInfo, error) {
	var netInfo containerNetworkInfo
	port, err := getPort()
	if err != nil {
		return netInfo, err
	}
	dockerContainer, err := p.getCluster().InspectContainer(c.ID)
	if err != nil {
		return netInfo, err
	}
	if dockerContainer.NetworkSettings != nil {
		netInfo.IP = dockerContainer.NetworkSettings.IPAddress
		httpPort := docker.Port(port + "/tcp")
		for _, port := range dockerContainer.NetworkSettings.Ports[httpPort] {
			if port.HostPort != "" && port.HostIP != "" {
				netInfo.HTTPHostPort = port.HostPort
				break
			}
		}
	}
	return netInfo, err
}

func (c *container) setStatus(p *dockerProvisioner, status string, updateDB ...bool) error {
	c.Status = status
	c.LastStatusUpdate = time.Now().In(time.UTC)
	updateData := bson.M{
		"status":           c.Status,
		"laststatusupdate": c.LastStatusUpdate,
	}
	if c.Status == provision.StatusStarted.String() ||
		c.Status == provision.StatusStarting.String() {
		c.LastSuccessStatusUpdate = c.LastStatusUpdate
		updateData["lastsuccessstatusupdate"] = c.LastSuccessStatusUpdate
	}
	if len(updateDB) > 0 && !updateDB[0] {
		return nil
	}
	coll := p.collection()
	defer coll.Close()
	return coll.Update(bson.M{"id": c.ID, "status": bson.M{"$ne": provision.StatusBuilding.String()}}, bson.M{"$set": updateData})
}

func (c *container) setImage(p *dockerProvisioner, imageId string) error {
	c.Image = imageId
	coll := p.collection()
	defer coll.Close()
	return coll.Update(bson.M{"id": c.ID}, c)
}

func (p *dockerProvisioner) gitDeploy(app provision.App, version string, w io.Writer) (string, error) {
	commands, err := gitDeployCmds(app, version)
	if err != nil {
		return "", err
	}
	return p.deployPipeline(app, p.getBuildImage(app), commands, w)
}

func (p *dockerProvisioner) archiveDeploy(app provision.App, image, archiveURL string, w io.Writer) (string, error) {
	commands, err := archiveDeployCmds(app, archiveURL)
	if err != nil {
		return "", err
	}
	return p.deployPipeline(app, image, commands, w)
}

func (p *dockerProvisioner) deployPipeline(app provision.App, imageId string, commands []string, w io.Writer) (string, error) {
	actions := []*action.Action{
		&insertEmptyContainerInDB,
		&createContainer,
		&startContainer,
		&updateContainerInDB,
		&followLogsAndCommit,
	}
	pipeline := action.NewPipeline(actions...)
	buildingImage, err := appNewImageName(app.GetName())
	if err != nil {
		return "", log.WrapError(fmt.Errorf("error getting new image name for app %s", app.GetName()))
	}
	args := runContainerActionsArgs{
		app:           app,
		imageID:       imageId,
		commands:      commands,
		writer:        w,
		isDeploy:      true,
		buildingImage: buildingImage,
		provisioner:   p,
	}
	err = pipeline.Execute(args)
	if err != nil {
		log.Errorf("error on execute deploy pipeline for app %s - %s", app.GetName(), err)
		return "", err
	}
	return buildingImage, nil
}

func (p *dockerProvisioner) start(oldContainer *container, app provision.App, imageId string, w io.Writer, destinationHosts ...string) (*container, error) {
	commands, processName, err := runLeanContainerCmds(oldContainer.ProcessName, imageId, app)
	if err != nil {
		return nil, err
	}
	var actions []*action.Action
	if oldContainer != nil && oldContainer.Status == provision.StatusStopped.String() {
		actions = []*action.Action{
			&insertEmptyContainerInDB,
			&createContainer,
			&stopContainer,
			&updateContainerInDB,
			&setNetworkInfo,
		}
	} else {
		actions = []*action.Action{
			&insertEmptyContainerInDB,
			&createContainer,
			&startContainer,
			&updateContainerInDB,
			&setNetworkInfo,
		}
	}
	pipeline := action.NewPipeline(actions...)
	args := runContainerActionsArgs{
		app:              app,
		processName:      processName,
		imageID:          imageId,
		commands:         commands,
		destinationHosts: destinationHosts,
		provisioner:      p,
	}
	err = pipeline.Execute(args)
	if err != nil {
		return nil, err
	}
	c := pipeline.Result().(container)
	err = c.setImage(p, imageId)
	if err != nil {
		return nil, err
	}
	return &c, nil
}

func (c *container) getApp() (provision.App, error) {
	if c.appCache != nil {
		return c.appCache, nil
	}
	var err error
	c.appCache, err = app.GetByName(c.AppName)
	return c.appCache, err
}

// remove removes a docker container.
func (c *container) remove(p *dockerProvisioner) error {
	log.Debugf("Removing container %s from docker", c.ID)
	err := c.stop(p)
	if err != nil {
		log.Errorf("error on stop unit %s - %s", c.ID, err)
	}
	err = p.getCluster().RemoveContainer(docker.RemoveContainerOptions{ID: c.ID})
	if err != nil {
		log.Errorf("Failed to remove container from docker: %s", err)
	}
	log.Debugf("Removing container %s from database", c.ID)
	coll := p.collection()
	defer coll.Close()
	if err := coll.Remove(bson.M{"id": c.ID}); err != nil {
		log.Errorf("Failed to remove container from database: %s", err)
	}
	return nil
}

type pty struct {
	width  int
	height int
	term   string
}

func (c *container) shell(p *dockerProvisioner, stdin io.Reader, stdout, stderr io.Writer, pty pty) error {
	cmds := []string{"/usr/bin/env", "TERM=" + pty.term, "bash", "-l"}
	execCreateOpts := docker.CreateExecOptions{
		AttachStdin:  true,
		AttachStdout: true,
		AttachStderr: true,
		Cmd:          cmds,
		Container:    c.ID,
		Tty:          true,
		User:         c.getUser(),
	}
	exec, err := p.getCluster().CreateExec(execCreateOpts)
	if err != nil {
		return err
	}
	startExecOptions := docker.StartExecOptions{
		InputStream:  stdin,
		OutputStream: stdout,
		ErrorStream:  stderr,
		Tty:          true,
		RawTerminal:  true,
	}
	errs := make(chan error, 1)
	go func() {
		errs <- p.getCluster().StartExec(exec.ID, c.ID, startExecOptions)
	}()
	execInfo, err := p.getCluster().InspectExec(exec.ID, c.ID)
	for !execInfo.Running && err == nil {
		select {
		case startErr := <-errs:
			return startErr
		default:
			execInfo, err = p.getCluster().InspectExec(exec.ID, c.ID)
		}
	}
	if err != nil {
		return err
	}
	p.getCluster().ResizeExecTTY(exec.ID, c.ID, pty.height, pty.width)
	return <-errs
}

type execErr struct {
	code int
}

func (e *execErr) Error() string {
	return fmt.Sprintf("unexpected exit code: %d", e.code)
}

func (c *container) exec(p *dockerProvisioner, stdout, stderr io.Writer, cmd string, args ...string) error {
	cmds := []string{"/bin/bash", "-lc", cmd}
	cmds = append(cmds, args...)
	execCreateOpts := docker.CreateExecOptions{
		AttachStdin:  false,
		AttachStdout: true,
		AttachStderr: true,
		Tty:          false,
		Cmd:          cmds,
		Container:    c.ID,
		User:         c.getUser(),
	}
	exec, err := p.getCluster().CreateExec(execCreateOpts)
	if err != nil {
		return err
	}
	startExecOptions := docker.StartExecOptions{
		OutputStream: stdout,
		ErrorStream:  stderr,
	}
	err = p.getCluster().StartExec(exec.ID, c.ID, startExecOptions)
	if err != nil {
		return err
	}
	execData, err := p.getCluster().InspectExec(exec.ID, c.ID)
	if err != nil {
		return err
	}
	if execData.ExitCode != 0 {
		return &execErr{code: execData.ExitCode}
	}
	return nil

}

// commit commits an image in docker based in the container
// and returns the image repository.
func (c *container) commit(p *dockerProvisioner, writer io.Writer) (string, error) {
	log.Debugf("commiting container %s", c.ID)
	parts := strings.Split(c.BuildingImage, ":")
	if len(parts) < 2 {
		return "", log.WrapError(fmt.Errorf("error parsing image name, not enough parts: %s", c.BuildingImage))
	}
	repository := strings.Join(parts[:len(parts)-1], ":")
	tag := parts[len(parts)-1]
	opts := docker.CommitContainerOptions{Container: c.ID, Repository: repository, Tag: tag}
	image, err := p.getCluster().CommitContainer(opts)
	if err != nil {
		return "", log.WrapError(fmt.Errorf("error in commit container %s: %s", c.ID, err.Error()))
	}
	imgData, err := p.getCluster().InspectImage(c.BuildingImage)
	imgSize := ""
	if err == nil {
		imgSize = fmt.Sprintf("(%.02fMB)", float64(imgData.Size)/1024/1024)
	}
	fmt.Fprintf(writer, " ---> Sending image to repository %s\n", imgSize)
	log.Debugf("image %s generated from container %s", image.ID, c.ID)
	maxTry, _ := config.GetInt("docker:registry-max-try")
	if maxTry <= 0 {
		maxTry = 3
	}
	for i := 0; i < maxTry; i++ {
		err = p.pushImage(repository, tag)
		if err != nil {
			fmt.Fprintf(writer, "Could not send image, trying again. Original error: %s\n", err.Error())
			log.Errorf("error in push image %s: %s", c.BuildingImage, err.Error())
			time.Sleep(time.Second)
			continue
		}
		break
	}
	if err != nil {
		return "", log.WrapError(fmt.Errorf("error in push image %s: %s", c.BuildingImage, err.Error()))
	}
	return c.BuildingImage, nil
}

// stop stops the container.
func (c *container) stop(p *dockerProvisioner) error {
	if c.Status == provision.StatusStopped.String() {
		return nil
	}
	err := p.cluster.StopContainer(c.ID, 10)
	if err != nil {
		log.Errorf("error on stop container %s: %s", c.ID, err)
	}
	c.setStatus(p, provision.StatusStopped.String())
	return nil
}

func (c *container) start(p *dockerProvisioner, app provision.App, isDeploy bool) error {
	port, err := getPort()
	if err != nil {
		return err
	}
	sharedBasedir, _ := config.GetString("docker:sharedfs:hostdir")
	sharedMount, _ := config.GetString("docker:sharedfs:mountpoint")
	sharedIsolation, _ := config.GetBool("docker:sharedfs:app-isolation")
	sharedSalt, _ := config.GetString("docker:sharedfs:salt")
	hostConfig := docker.HostConfig{
		Memory:     app.GetMemory(),
		MemorySwap: app.GetMemory() + app.GetSwap(),
		CPUShares:  int64(app.GetCpuShare()),
	}
	if !isDeploy {
		hostConfig.RestartPolicy = docker.AlwaysRestart()
		hostConfig.PortBindings = map[docker.Port][]docker.PortBinding{
			docker.Port(port + "/tcp"): {{HostIP: "", HostPort: ""}},
		}
		hostConfig.LogConfig = docker.LogConfig{
			Type: "syslog",
			Config: map[string]string{
				"syslog-address": fmt.Sprintf("udp://localhost:%d", getBsSysLogPort()),
			},
		}
	}
	hostConfig.SecurityOpt, _ = config.GetList("docker:security-opts")
	if sharedBasedir != "" && sharedMount != "" {
		if sharedIsolation {
			var appHostDir string
			if sharedSalt != "" {
				h := crypto.SHA1.New()
				io.WriteString(h, sharedSalt+c.AppName)
				appHostDir = fmt.Sprintf("%x", h.Sum(nil))
			} else {
				appHostDir = c.AppName
			}
			hostConfig.Binds = append(hostConfig.Binds, fmt.Sprintf("%s/%s:%s:rw", sharedBasedir, appHostDir, sharedMount))
		} else {
			hostConfig.Binds = append(hostConfig.Binds, fmt.Sprintf("%s:%s:rw", sharedBasedir, sharedMount))
		}
	}
	err = p.getCluster().StartContainer(c.ID, &hostConfig)
	if err != nil {
		return err
	}
	initialStatus := provision.StatusStarting.String()
	if isDeploy {
		initialStatus = provision.StatusBuilding.String()
	}
	return c.setStatus(p, initialStatus, false)
}

// logs returns logs for the container.
func (c *container) logs(p *dockerProvisioner, w io.Writer) error {
	container, err := p.getCluster().InspectContainer(c.ID)
	if err != nil {
		return err
	}
	opts := docker.AttachToContainerOptions{
		Container:    c.ID,
		Logs:         true,
		Stdout:       true,
		Stderr:       true,
		OutputStream: w,
		ErrorStream:  w,
		RawTerminal:  container.Config.Tty,
		Stream:       true,
	}
	return p.getCluster().AttachToContainer(opts)
}

func (c *container) asUnit(a provision.App) provision.Unit {
	status := provision.Status(c.Status)
	if c.Status == "" {
		status = provision.StatusBuilding
	}
	cType := c.Type
	if cType == "" {
		cType = a.GetPlatform()
	}
	return provision.Unit{
		Name:        c.ID,
		AppName:     a.GetName(),
		Type:        cType,
		Ip:          c.HostAddr,
		Status:      status,
		ProcessName: c.ProcessName,
	}
}

// pushImage sends the given image to the registry server defined in the
// configuration file.
func (p *dockerProvisioner) pushImage(name, tag string) error {
	if _, err := config.GetString("docker:registry"); err == nil {
		var buf safe.Buffer
		pushOpts := docker.PushImageOptions{Name: name, Tag: tag, OutputStream: &buf}
		err = p.getCluster().PushImage(pushOpts, getRegistryAuthConfig())
		if err != nil {
			log.Errorf("[docker] Failed to push image %q (%s): %s", name, err, buf.String())
			return err
		}
	}
	return nil
}

func getRegistryAuthConfig() docker.AuthConfiguration {
	var authConfig docker.AuthConfiguration
	authConfig.Email, _ = config.GetString("docker:registry-auth:email")
	authConfig.Username, _ = config.GetString("docker:registry-auth:username")
	authConfig.Password, _ = config.GetString("docker:registry-auth:password")
	authConfig.ServerAddress, _ = config.GetString("docker:registry")
	return authConfig
}

redpajama_set_name: RedPajamaGithub


text:
@class F53OSCTimeTag;

NS_ASSUME_NONNULL_BEGIN

@interface F53OSCBundle : F53OSCPacket

+ (nullable F53OSCBundle *) bundleWithString:(NSString *)qscString;
+ (F53OSCBundle *) bundleWithTimeTag:(F53OSCTimeTag *)timeTag
                            elements:(NSArray<NSData *> *)elements; ///< Elements must be an array of NSData objects; convert F53OSCMessages using their packetData method.

@property (strong) F53OSCTimeTag *timeTag;
@property (strong) NSArray<NSData *> *elements;

// redeclare as nonnull for this subclass
- (NSData *) packetData;

@end

NS_ASSUME_NONNULL_END


Making the choice between public and private.
Choosing where to have your baby is a big decision. There are a few factors that might come into play – you may feel attached to the idea of going to the same hospital your friends or family went to. It might be important to you to give birth at the closest hospital to you regardless if it is private or public. Or you might be anticipating complications during the pregnancy and therefore want to be more in control of who treats you.
Whatever your motivation, you'll need to decide whether you want to give birth in a private or public hospital and if you want a private obstetrician or not. Here we explain what decisions you need to make about where you give birth, and which Medibank private health insurance cover is most suitable to meet your needs.
Included Obstetrics cover – where Medibank pays benefits towards overnight and same day accommodation in either a public or private hospital.
Restricted Obstetrics cover – where Medibank pays limited benefits. This means if you choose to be treated in a private hospital, the benefits paid will not cover all hospital costs and are likely to result in significant out-of-pocket expenses. For limited services in a public hospital, Medibank will pay minimum shared room benefits.
Excluded Obstetrics cover – where Medibank pays no benefits for obstetrics related services.
As a private patient in a private hospital. In this scenario, we recommend having Included Obstetrics cover in your policy.
As a private patient in a public hospital. In this scenario, we recommend having Restricted Obstetrics cover in your policy.
As a public patient in a public hospital. In this scenario, you may not need a cover that has obstetrics coverage.
As a self-pay patient in a private hospital. This is where your policy does not have Included or Restricted Obstetrics, and therefore you will need to pay for all costs associated with the pregnancy, birth and delivery.
One of the main things to remember is that if you're planning to have a baby, and you'd like to use your health insurance to give birth as a private patient, your cover must Include obstetrics. There is a 12-month waiting period before Medibank pay benefits for obstetrics, so you'll need to have had cover in place for at least 12 months before the baby is born. Babies can come early, so it's important to take this into account when planning your family.
When it comes to making the decision, talking to your family and friends about their experiences can help. So can getting advice from your GP. But it's important that you are aware of the pros and cons of each option so you can make your decision based on what's most important to you. The table below helps you to understand your options.
Source: *Medibank 2016/17 data. Data is based on all births at private hospitals between 1 July 2016 and 30 June 2017. ** Medibank 2016/17 data. Data is based on all Medibank-funded births at public hospitals between 1 July 2016 and 30 June 2017. *** Australian Institute of Health and Welfare 2017. Admitted patient care 2015–16: Australian hospital statistics. HSE 185. Canberra: AIHW. ****Medibank 2016/17 data. Data is based on all Medibank-funded births at private and public hospitals between 1 July 2016 and 30 June 2017.
Private Health Insurance Funds are only permitted to cover inpatient services. This means you need to have been admitted to a hospital in order for the benefit to be paid. During pregnancy, you are likely to have many outpatient appointments (when you are not admitted to hospital), including scans, tests, and visits with your obstetrician/GP. Private Health Insurance Funds are not able to provide benefits for these appointments.
Listen now for tips on choosing the right cover for mums-to-be.


text:
Henry Amike  (né le ) est un athlète nigérian, spécialiste du 400 m haies.

Biographie

Lors des Championnats du monde de Rome il établit le temps de  en demi-finale, record national qui tient jusqu'en 2022.

Palmarès

Records

Notes et références

Liens externes

Hurdleur nigérian
Coureur de 400 mètres haies
Champion d'Afrique d'athlétisme
Athlète (homme) aux Jeux olympiques d'été de 1984
Athlète (homme) aux Jeux olympiques d'été de 1988
Naissance en octobre 1961
Relayeur (athlétisme)
Médaillé d'or aux Jeux africains

redpajama_set_name: RedPajamaWikipedia


text:
Morbidity and Mortality Weekly Report (MMWR)
Workers' Compensation Claim Rates and Costs for Musculoskeletal Disorders Related to Overexertion Among Construction Workers — Ohio, 2007–2017
Weekly / April 23, 2021 / 70(16);577–582
Harpriya Kaur, PhD1; Steven J. Wurzelbacher, PhD2; P. Tim Bushnell, PhD3; James W. Grosch, PhD1; Chih-Yu Tseng, MS2; Juliann C. Scholl, PhD1; Alysha R. Meyers, PhD2; Michael Lampl, MS4 (View author affiliations)
View suggested citation
What is already known about this topic?
Overexertion is the major cause of work-related musculoskeletal disorders (WMSDs) among U.S. construction workers.
What is added by this report?
Although the prevalence of workers' compensation WMSD claims from overexertion among construction workers during 2007–2017 in Ohio was highest among workers aged 35–44 years, the average claim was more costly and resulted in more days away from work among workers aged 45–54 years and 55–64 years.
What are the implications for public health practice?
Ergonomic design improvements and interventions are needed to make the workplace safer for workers of all ages. Age-specific WMSD prevention and risk communication efforts also might be helpful.
Altmetric:
Views equals page views plus PDF downloads
PDF pdf icon[304K]
Overexertion is a leading cause of work-related musculoskeletal disorders (WMSDs) among construction workers. Nearly 90% of construction jobs require manual handling of materials for approximately one half of the worker's time (1). In 2015, overexertion from lifting and lowering materials caused 30% of WMSDs among construction workers; overexertion involving pushing, pulling, holding, carrying, and catching materials caused an additional 37% of WMSDs (1). This study examined the rate and cost of WMSD claims from overexertion among Ohio construction workers during 2007–2017. Workers' compensation claims related to overexertion that were submitted to the Ohio Bureau of Worker's Compensation (OHBWC) by workers in the construction industry for injuries and illnesses occurring during 2007–2017 were analyzed. Rates and costs of allowed claims were measured by age group. Workers aged 35–44 years experienced the highest claim rate: 63 per 10,000 full-time employees (FTEs) for WMSDs from overexertion. However, claims by workers aged 45–54 years and 55–64 years were more costly on average and resulted in more days away from work. Ergonomic design improvements and interventions are needed to ensure that the majority of construction workers can safely perform jobs throughout their careers. Age-specific WMSD prevention and risk communication efforts also might be helpful.
From 1985 to 2015, the average age of construction workers increased from 36 years to 42.5 years (2). As workers age, they become more susceptible to losing muscle mass and strength (3). These and other age-related physical changes can affect workers' ability to perform physically demanding tasks, their vulnerability to WMSDs, and their ability to recover from WMSDs. As the U.S. workforce grows older, understanding the age-specific health and safety needs of workers is critical, especially in hazardous and physically demanding industries such as construction.
Data for this report came from workers' compensation claims for WMSDs filed by employees of state-insured private industry employers in Ohio* during 2007–2017. Ohio is the most populous of the four states (North Dakota, Ohio, Washington, and Wyoming) that have exclusive state-run workers' compensation systems. Ohio insures approximately two thirds of the state's workforce. In Ohio, only large employers (usually those with ≥500 employees) may self-insure. Lost-time claims (those with ≥8 days away from work) and medical-only claims (only medical treatment expenses paid and ≤7 lost work days) were analyzed. Claim data fields included employer information, worker age and gender, claim cost, lost work days, diagnosis billing codes (International Classification of Diseases, Ninth Revision, Clinical Modification [ICD-9-CM]), and a free-text narrative that described how the injury or illness occurred.
All claim narratives were auto-coded using two algorithms (4,5). The first algorithm identified claims that met the U.S. Bureau of Labor Statistics (BLS) case definition for a WMSD.† The second algorithm identified a subset of WMSD claims that met the BLS Occupational Injury and Illness Classification System definition for overexertion involving an outside source.§ High-cost (95th percentile or higher) claims and lost-time claims with low estimated probabilities of an accurately auto-coded diagnosis were manually reviewed by expert coders. When a claim had multiple ICD-9-CM diagnosis codes, an OHBWC algorithm was used to identify the diagnosis most likely to keep the worker off work for the longest period.
Worker's compensation claims were linked to Ohio unemployment insurance data to determine employer industry and employee count using methods developed by previous studies (6). The construction industry was identified by North American Industry Classification System code 23.¶ American Community Survey** yearly data contain information on number of hours worked per construction worker and were used to convert number of employees to number of FTEs. American Community Survey data also were used to estimate the percentage of the Ohio construction worker population within each age group, which was used to calculate age-specific rates. Cumulative claim rates were calculated by dividing the sum of the yearly claim counts by the sum of the yearly estimated FTEs for 2007–2017.
The most recently estimated total costs†† were used to calculate cost per claim and cost per FTE by age group. The number of lost work days associated with each claim was the number recorded as of June 30, 2019.§§ For each age group, the percentage of claims that were lost-time claims and the percentage of lost-time claims with ≥100 lost work days were calculated as indicators of claim severity. SAS (version 9.4; SAS Institute) was used to conduct all analyses. This activity was reviewed by CDC and was conducted consistent with applicable federal law and CDC policy.¶¶
During 2007–2017, OHBWC accepted 10,347 claims*** from construction workers for WMSDs resulting from overexertion. The rate of WMSD claims per 10,000 FTEs from overexertion among construction workers was highest among those aged 35–44 years (63.0), followed by claim rates among those aged 45–54 years (59.6) and those aged 25–34 years (55.5). The relationship between WMSD rate and age differed by diagnosis category. The claim rate for spinal disc disorders was highest among those aged 35–44 years (4.7) and 45–54 years (4.5), as was the rate of upper extremity sprains (18.5 among those aged 35–44 years and 18.6 among those aged 45–54 years). The rate of back sprain claims was highest among those aged 25–34 years (26.5) and 35–44 years (24.6) (Figure).
The severity of WMSDs, as measured by the percentage of claims classified as lost-time (≥8 lost work days), increased with age, peaking among those aged 55–64 years (Table 1). The percentage of lost-time claims with ≥100 work days lost was highest among those aged 45–54 years and lowest among those aged 18–24 years. Cost per claim was highest among those aged 45–54 years ($25,932) and 54–64 years ($25,572). Cost per FTE was highest among those aged 45–54 years ($154.56) (Table 2). The relationship between cost and age differed by diagnosis category; for example, cost per FTE for back and lower extremity sprains peaked among those aged 35–44 years and 25–34 years, respectively, whereas spinal disc disorders and upper extremity sprain costs per FTE peaked among those aged 45–54 years and 55–64 years, respectively.
The findings in this report are consistent with those of recent studies indicating that the rate of overexertion-related WMSD claims rise and then fall with increasing age (7,8). This pattern has at least two explanations. First, older workers might shift to other tasks or jobs with reduced WMSD risks. Second, workers experiencing severe pain might move out of the industry, leaving behind a healthier cohort. A longitudinal study among construction roofers found that the odds of leaving the roofing trade early were eight times higher for workers with WMSDs than for workers without such disorders (9). Additional analyses of WMSD rates that include former and current construction workers are needed to determine the actual rates and severity of overexertion-related WMSDs by age group for the construction industry.
The findings in this report are subject to at least three limitations. First, auto-coding methods used to identify WMSD claims entail some misclassification (4,5). Misclassification would not be expected to vary by age if claim records are similar in completeness and accuracy across age groups, but if misclassification varies by type of WMSDs, this could bias the comparison of the mix of WMSDs by age group. Overall, the auto-coding methods have been shown to have positive predictive values >85% when compared with manual coding (4,5). Second, not all work injuries and illnesses result in workers' compensation claims. For example, one study of six states estimated that workers' compensation claims accounted for approximately 65% to 95% of work-related lost-time cases (>3 or >7 lost work days) (10). Underreporting of WMSDs might differ by age group. Finally, data in Ohio are available only for insured private companies; therefore, the degree to which these results reflect age patterns among large, self-insured employers who do not purchase workers' compensation policies is uncertain.
WMSDs affect Ohio construction workers of all age groups, but do so differently. As age increases, the severity of WMSDs appears to rise, and the relative frequencies of WMSD types change. This suggests the potential usefulness of targeting some prevention efforts specifically to the needs of older workers. For example, differences between age groups in the rate and severity of specific WMSD types might be communicated to workers and their supervisors to help them focus on the most important risks. Considering the high rates of WMSDs among workers aged 25–44 years, and the fact that construction workers with WMSDs tend to leave the workforce prematurely (2), workplace ergonomic design and interventions for workers of all ages should be considered. These measures include modifying tasks, promoting the use of ergonomic tools and equipment, providing training in safe work practices, and other interventions.†††,§§§
Corresponding author: Harpriya Kaur, wdo6@cdc.gov, 513-533-8372.
1Division of Science Integration, National Institute for Occupational Safety and Health, CDC; 2Division of Field Studies and Engineering, National Institute for Occupational Safety and Health, CDC; 3Office of the Director, National Institute for Occupational Safety and Health, CDC; 4Ohio Bureau of Workers' Compensation, Columbus, Ohio.
All authors have completed and submitted the International Committee of Medical Journal Editors form for disclosure of potential conflicts of interest. No potential conflicts of interest were disclosed.
* All worker compensation claims were from OHBWC-insured, single- and multiple-location private industry employers. Large employers (usually with ≥500 employees) have the option to self-insure if they meet certain requirements. In 2017, 54% of those employers were estimated to have done so. Owners of sole proprietorships and partnerships do not have to insure themselves but must insure any employees they have. In 2017, 38% of sole proprietorships did not purchase OHBWC coverage.
† This analysis used a definition for musculoskeletal disorders that included Raynaud's phenomenon, tarsal tunnel syndrome, and herniated spinal discs, similar to the revised BLS case definition (2011 and forward). https://www.bls.gov/iif/oshdef.htmexternal icon
§ According to the Occupational Injury and Illness Classification System, overexertion involving outside sources (code 71), "applies to cases, usually non-impact, in which the injury or illness resulted from excessive physical effort directed at an outside source of injury or illness." Typically, an outside source refers to anything or any person against which the worker exerted force during the bodily motions thought to have caused the WMSD. This could involve, for example, pushing, pulling, or lifting. https://www.bls.gov/iif/osh_oiics_2010_2_4.pdfpdf iconexternal icon
¶ https://www.naics.com/six-digit-naics/?code=23external icon
** https://www.census.gov/programs-surveys/acsexternal icon
†† Costs were total incurred costs (not adjusted for inflation) as of June 30, 2019. Those include all costs for medical treatments and indemnity (partial lost wage replacement) paid up to that time, plus the amount set aside for reserves to pay projected future costs of the same set of claims. The costs of some claims for WMSDs occurring during 2007–2017 had not all been paid as of 2019 because some workers were still receiving medical care for the WMSD or were still entitled to indemnity payments to compensate for ongoing or recurring loss of work.
§§ The eventual total number of days lost is not known for those claims for which work days were lost after 2019.
¶¶ 45 C.F.R. part 46, 21 C.F.R. part 56; 42 U.S.C. Sect. 241(d); 5 U.S.C. Sect. 552a; 44 U.S.C. Sect. 3501 et seq.
*** This total excludes 95 claims for which age was missing.
††† https://www.cpwr.com/research/research-practice-library/construction-ergonomic-research-solutionsexternal icon
§§§ https://www.lhsfna.org/index.cfm/occupational-safety-and-health/ergonomics/?PAGENUM=1&WIPECACHE=falseexternal icon
Center for Construction Research and Training. The construction chart book: the U.S. construction industry and its workers. 6th ed. Silver Spring, MD: The Center for Construction Research and Training; 2018. https://www.cpwr.com/wp-content/uploads/publications/The_6th_Edition_Construction_eChart_Book.pdfpdf iconexternal icon
Sokas RK, Dong XS, Cain CT. Building a sustainable construction workforce. Int J Environ Res Public Health 2019;16:4202. https://doi.org/10.3390/ijerph16214202external icon PMID:31671567external icon
Schwatka NV, Butler LM, Rosecrance JR. An aging workforce and injury in the construction industry. Epidemiol Rev 2012;34:156–67. https://doi.org/10.1093/epirev/mxr020external icon PMID:22173940external icon
Meyers AR, Al-Tarawneh IS, Wurzelbacher SJ, et al. Applying machine learning to workers' compensation data to identify Industry-specific ergonomic and safety prevention priorities: Ohio, 2001 to 2011. J Occup Environ Med 2018;60:55–73. https://doi.org/10.1097/JOM.0000000000001162external icon PMID:28953071external icon
Bertke SJ, Meyers AR, Wurzelbacher SJ, Measure A, Lampl MP, Robins D. Comparison of methods for auto-coding causation of injury narratives. Accid Anal Prev 2016;88:117–23. https://doi.org/10.1016/j.aap.2015.12.006external icon PMID:26745274external icon
Wurzelbacher SJ, Al-Tarawneh IS, Meyers AR, et al. Development of methods for using workers' compensation data for surveillance and prevention of occupational injuries among state-insured private employers in Ohio. Am J Ind Med 2016;59:1087–104. https://doi.org/10.1002/ajim.22653external icon PMID:27667651external icon
Wang X, Dong XS, Choi SD, Dement J. Work-related musculoskeletal disorders among construction workers in the United States from 1992 to 2014. Occup Environ Med 2017;74:374–80. https://doi.org/10.1136/oemed-2016-103943external icon PMID:28039200external icon
Holmström E, Engholm G. Musculoskeletal disorders in relation to age and occupation in Swedish construction workers. Am J Ind Med 2003;44:377–84. https://doi.org/10.1002/ajim.10281external icon PMID:14502765external icon
Welch LS, Haile E, Boden LI, Hunting KL. Impact of musculoskeletal and medical conditions on disability retirement-a longitudinal study among construction roofers. Am J Ind Med 2010;53:552–60. https://doi.org/10.1002/ajim.20794external icon PMID:20112256external icon
Boden LI, Ozonoff A. Capture-recapture estimates of nonfatal workplace injuries and illnesses. Ann Epidemiol 2008;18:500–6. https://doi.org/10.1016/j.annepidem.2007.11.003external icon PMID:18083542external icon
FIGURE. Rate of work-related musculoskeletal disorder claims from overexertion per 10,000 full-time employees among construction workers, by diagnosis category* and age group — Ohio, 2007–2017
* Among these, 63% were single diagnoses. For multiple diagnoses, an algorithm was used to identify the diagnosis most limiting the ability to return to work.
TABLE 1. Age-specific numbers and rates of work-related musculoskeletal disorder (WMSD) claims from overexertion among construction workers — Ohio, 2007–2017
No. of claims, by age group (yrs)
Total (all overexertion WMSDs) 879 2,570 3,004 2,746 1,148
Diagnosis category
Spinal disc disorders 15 156 224 208 85
Upper extremity sprains 257 674 884 859 391
Lower extremity sprains 42 65 86 92 41
Back sprains 400 1,229 1,174 900 319
Other overexertion WMSDs* 165 446 636 687 312
No. of FTEs 193,702 463,026 476,862 460,729 234,751
Claims per 10,000 FTEs
Total (all overexertion WMSDs) 45.4 55.5 63.0 59.6 48.9
Spinal disc disorders 0.8 3.4 4.7 4.5 3.6
Upper extremity sprains 13.3 14.6 18.5 18.6 16.7
Lower extremity sprains 2.2 1.4 1.8 2.0 1.8
Back sprains 20.7 26.5 24.6 19.5 13.6
Other overexertion WMSDs* 8.5 9.6 13.3 14.9 13.3
Percentage of claims with high number of lost work days (≥8 days, ≥100 days)
Lost-time claims (≥8 lost work days) as percentage of all claims 18.0 23.8 32.0 38.6 40.5
Percentage of lost-time claims with ≥100 lost work days 31.6 40.6 43.6 45.0 42.4
Abbreviation: FTE = full-time employee.
* Other overexertion WMSDs include carpal tunnel syndrome, diseases of musculoskeletal and connective tissues, hernia of abdominal cavity, soft tissue/enthesopathy, other sprains, dislocation, spinal osteoarthritis, diseases of the nervous system and sense organ, injury to nerves and spinal cord, knee derangement, other joint disorders, and symptoms, signs, and ill-defined conditions, not elsewhere classified.
TABLE 2. Age-specific costs of work-related musculoskeletal disorder (WMSD) claims from overexertion among construction workers, by diagnosis — Ohio, 2007–2017
Cost per claim ($),* by age group (yrs)
Medical incurred cost (all diagnoses) 2,031 5,893 9,611 11,471 10,446
Medical cost by diagnosis category
Spinal disc disorders 22,272 58,169 66,306 70,422 54,379
Upper extremity sprains 1,462 3,195 6,216 7,783 9,095
Lower extremity sprains 1,269 4,240 3,229 2,218 1,604
Back sprain 1,102 1,369 2,187 1,918 1,776
Other overexertion WMSDs† 3,522 4,391 8,927 11,987 10,198
Indemnity incurred cost (all diagnoses) 1,461 5,918 10,749 14,461 15,126
Indemnity incurred cost by diagnosis category
Disc disorders 26,127 62,991 77,538 90,859 100,709
Upper extremity sprains 717 2,712 5,147 7,500 10,593
Lower extremity sprains 586 3,352 1,507 845 1,322
Back sprain 535 1,088 2,474 3,764 1,287
Other overexertion WMSDs† 2,847 4,483 11,537 15,869 13,454
Total cost (all diagnoses) 3,492 11,811 20,359 25,932 25,572
Total cost by diagnosis category
Spinal disc disorders 48,400 121,159 143,845 161,281 155,088
Upper extremity sprains 2,179 5,907 11,362 15,284 19,688
Cost per FTE
Medical incurred cost (all diagnoses) 9.22 32.71 60.54 68.37 51.09
Medical Incurred cost by diagnosis category
Spinal disc disorders 1.72 19.60 31.15 31.79 19.69
Upper extremity sprains 1.94 4.65 11.52 14.51 15.15
Lower extremity sprains 0.28 0.60 0.58 0.44 0.28
Back sprain 2.28 3.63 5.38 3.75 2.41
Other overexertion WMSDs† 3.00 4.23 11.91 17.87 13.55
Indemnity incurred cost (all diagnoses) 6.63 32.85 67.71 86.19 73.97
Upper extremity sprains 0.95 3.95 9.54 13.98 17.64
Total cost (all diagnoses) 15.85 65.56 128.26 154.56 125.05
Back sprain 3.38 6.52 11.48 11.10 4.16
* Costs were total incurred costs as of June 30, 2019, which include all costs paid up to that time, plus the amount set aside for reserves to pay projected future costs of the same set of claims.
† Other overexertion WMSDs include carpal tunnel syndrome, diseases of musculoskeletal and connective tissues, hernia of abdominal cavity, soft tissue/enthesopathy, other sprains, dislocation, spinal osteoarthritis, diseases of the nervous system and sense organ, injury to nerves and spinal cord, knee derangement, other joint disorders, and symptoms, signs, and ill-defined conditions, not elsewhere classified.
Suggested citation for this article: Kaur H, Wurzelbacher SJ, Bushnell PT, et al. Workers' Compensation Claim Rates and Costs for Musculoskeletal Disorders Related to Overexertion Among Construction Workers — Ohio, 2007–2017. MMWR Morb Mortal Wkly Rep 2021;70:577–582. DOI: http://dx.doi.org/10.15585/mmwr.mm7016a1external icon.
MMWR and Morbidity and Mortality Weekly Report are service marks of the U.S. Department of Health and Human Services.
Use of trade names and commercial sources is for identification only and does not imply endorsement by the U.S. Department of Health and Human Services.
References to non-CDC sites on the Internet are provided as a service to MMWR readers and do not constitute or imply endorsement of these organizations or their programs by CDC or the U.S. Department of Health and Human Services. CDC is not responsible for the content of pages found at these sites. URL addresses listed in MMWR were current as of the date of publication.
All HTML versions of MMWR articles are generated from final proofs through an automated process. This conversion might result in character translation or format errors in the HTML version. Users are referred to the electronic PDF version (https://www.cdc.gov/mmwr) and/or the original MMWR paper copy for printable versions of official text, figures, and tables.
Questions or messages regarding errors in formatting should be addressed to mmwrq@cdc.gov.
View Page In:pdf icon PDF [304K]
Page last reviewed: April 22, 2021
homeMMWR
Mpox Reports
COVID-19 Reportsplus icon
COVID-19 Vaccine Effectiveness and Safety
Weekly Reportplus icon
Past Volumes (1982-2022)
Recommendations and Reportsplus icon
Surveillance Summariesplus icon
Supplementsplus icon
MMWR Archive (1952-1981)
Notifiable Noninfectious Conditions
About MMWRplus icon
Subscriptionsplus icon
MMWR RSS Feed
Free Continuing Education
Reports by Select Topics
MMWR Podcasts

redpajama_set_name: RedPajamaCommonCrawl


text:
Q: Uneven rep in R I have a question on how to unevenly repeat number with each and times. I have the following code and have a hard time formatting it. For this example, I hope to repeat the number "1" for 10 times then "2" for 2 time, then repeat for 10 cycles
df <- rep(c("1","2"), each = c(10,2), times = 10)

in the end, it would be
1 1 1 1 1 1 1 1 1 1 2 2 1 1 1 1 1 1 1 1 1 1 2 2.....

or
10 cycles of
1 1 1 1 1 1 1 1 1 1 2 2

Thank you!

redpajama_set_name: RedPajamaStackExchange


Dr. Mandeep Chaudhary : Dr. Mandeep Chaudhary graduated from faculty of Veterinary Medicine in India in 1997 with honors. He then completed his Masters in Veterinary Surgery and Radiology in 1999 with honors. He started his career as veterinary officer with the state government before joining the Department of Surgery and Radiology, Ludhiana as Assistant professor. He has trained budding veterinary students and also imparted advanced training to veterinarians across the country in the field of Surgery and Radiology. During his tenure he has authored several published articles related to veterinary surgery.Dr. Chaudhary immigrated to Canada in 2006 and worked as a veterinarian in Yukon before coming to Ontario. He has special interests in orthopedics . The spare time is spent with his wife, son Harsh and daughter Samaria. He plays and is a big cricket fan . He loves trekking and outdoors whenever he gets a chance of the busy schedule.
Dr. Parminder Kauldhar : I graduated from College of Veterinary Medicine in India in 1994 and since then worked as a Veterinary Officer with a special interest in small animal surgery, preventive medicine and dermatology. I love animals and enjoy talking to people about their pets. Practice of veterinary medicine is my passion and surgery is an art to me. Licenced as a veterinarian from College of Veterinarians of Ontario, Guelph since 2006, I worked at the 24-hour North Town Veterinary Hospital and North Park Veterinary Hospital in Brampton untill 2010. My philosophy is centered on knowing you and your pet with ultimate aim of taking the time to address your concerns. I am very pleased to work with Dr. Chaudhary and Dr. Bangar who carry immense experience in veterinary practice and we also work at a pace where we can be personable to you and your pets. When not working, I enjoy time with my family, which includes wife, daughter, newly born baby boy and 2-year old hamster fondly called Hammy.


text:
Architects & Specification
Global website Export website
Small outlay for a big impact
/global/scaled/2085x907x0x274x1000x435/AAES-COM-about-us-news and media-2017-images-ADV_AA_Decathlon-image-Service2017_EN_PR.jpg
At Decathlon, Belgium, a service agreement makes all the difference to the day to day running of business
During opening hours, Decathlon's flagship store in Brussels enjoys a constant flow of shoppers – around 14,000 a week. If the main entrance fails to open, the disruption is just enough to break the flow and put a few shoppers off entering the store. But if the back doors fail, products cannot enter the store. And that's a big problem.
Maintenance and energy manager Joeri Moons is responsible not only for the Brussels store, but for every Decathlon store in Belgium – that's 27 stores plus 2 warehouses. But there's no need for him to know the state of every door, how it works, or how to fix it because Decathlon has a service agreement with ASSA ABLOY Entrance Systems.
If Decathlon didn't have a service agreement with ASSA ABLOY Entrance Systems, whenever there was an entrance problem in any one of the stores or warehouses, Joeri would have to drive to the site and try and resolve the problem. And he doesn't have the technical skill to fix the automatic doors, so he would spend time contacting different suppliers and managing their service visits. As he points out, this means that the doors wouldn't be fixed within an hour, or a day, but would remain unfixed for much longer.
Worry-free operations with service agreement
Having a service agreement in place with ASSA ABLOY Entrance Systems means Joeri does not need to worry about the entrances under his watch. Joeri tells us, "If the doors stay closed, it would be a big problem for us. But we would immediately call ASSA ABLOY." A service agreement means that all the Decathlon workers can feel safe and secure while at work and that Joeri, as maintenance and energy manager, can be confident that, in the event of a breakdown, a specialized ASSA ABLOY service technician is on hand to get the door back up and running and keep business moving.
The outlay might be small, but its impact on the their bottom line – and peace of mind – is huge.
If the doors stay closed, it would be a big problem for us. We would immediately call ASSA ABLOY Entrance Systems
Joeri Moons, Facility Manager, Decathlon, Brussels
Keeping your doors open for business is our business
Learn more about our service agreements
High-performance doors
Hangar doors
Modernization & upgrades
© ASSA ABLOY | Privacy center | info.entrance@assaabloy.com |


The government has attempted to downplay provisional figures showing carbon dioxide emissions rose by 1.25 per cent last year and instead argued the rise should motivate government, business and individuals to take action on reducing emissions.
Mr Miliband also pointed out the figure does not take into account the EU emissions trading scheme, which covers nearly half of UK emissions.
Despite efforts to reduce emissions, unusually high gas prices in 2006 meant more electricity was generated by coal, the environment secretary explained.
Mr Miliband said: "Any increase in carbon dioxide emissions is worrying, even though these figures do not include the effect of emissions trading. While these figures are provisional, they underline why concerted effort to tackle climate change, both from government and wider society, is absolutely critical."
Last year's 'blip' in carbon emissions justifies the UK's decision not to commit itself to annually binding targets in the climate change bill, he argued. Five-year targets are better able to absorb annual fluctuations caused by changing fuel prices, freak weather and so forth while still committing the UK to a long-term downwards trend.
The environment secretary maintained the UK is still on track to double its Kyoto commitment.
Despite the rise in carbon dioxide emissions, the main 'basket' of greenhouse gases are down overall, with the 'big six' 15 per cent below the base year. Carbon dioxide is the main greenhouse gas, accounting for 84 per cent of all emissions.
More importantly attitudes are changing, Mr Miliband argued. Household emissions have fallen as individuals make changes to their everyday lives and more companies are looking to reduce their emissions.
A report commissioned by the Worldwide Wildlife Fund warned yesterday emissions from power stations have soared and risk undermining small-scale changes. Emissions have increased by nearly a third in the past eight years, the report noted.
The Liberal Democrat environment spokesman, Chris Huhne, commented: "Ministers got lucky when the 'dash for gas' cut the carbon emissions from power generation, but now their luck has turned.
"The government must urgently set out a comprehensive energy efficiency and renewables strategy for moving to a low-carbon economy."


Cordova's defense was too much for the Panthers Friday night, as Bartlett managed only 59 total yards of offense at home.
The Wolves (3-0) would get the 48-0 win thanks in part to running back Jeremy Banks, who finished the game with 100 rushing yards and three touchdowns.
Conversely, Bartlett couldn't get anything going on the ground and quarterback JJ Vaden completed six of 13 passes for 22 yards.
The Panthers (2-1) will host Oakhaven this Friday at 7 p.m.
PICTURED: Philip Thompson puts a hard hit on the Cordova's Jacob Jacques after he makes the reception.


text:
Антон Доминикович Ивановский (1823 — ) — историк и богослов; родом поляк, служил 18 лет библиотекарем в Императорской публичной библиотеке. Последние четыре года своей жизни состоял профессором богословских наук при Римско-Католической Духовной академии.

Скончался , похоронен на римско-католическом кладбище в Санкт-Петербурге.

Опубликовал:
 «Дочь купца. Рус. нар. рассказ из минувшего времени [в стихах]» (СПб., 1861),
 «О киевском уроженце П. Дубровском» (Киев, 1869),
 «Археологические исследования государственного канцлера Н. П. Румянцева и митрополита Евгения и пр.» (Киев, 1869),
 «Ф. И. Прянишников и его картинная галерея» (СПб., 1870),
 «Иван Михайлович Снегирев и его дневник воспоминаний с 1821—1865 год» (СПб., 1871),
 «Высокопреподобный Евгений, митрополит киевский и галицкий» (1871),
 «Государственный канцлер граф Румянцев» (1871),
 «С. А. Хрулев» (1871),
 «Павел Александрович Муханов» (1872),
 «Беседы о Петре Великом»
 Каталог сочинений и изданий Императорской Публичной Библиотеки бывшего библиотекаря А. Ивановского. Спб. в т. Сущинского, 1871г. 32с.

Примечания

Источники

Писатели России XIX века
Русские писатели XIX века
Историки России
Историки по алфавиту
Богословы России
Деятели католицизма
Богословы XIX века
Похороненные на Выборгском римско-католическом кладбище


text:
Polystichum inadae är en träjonväxtart som beskrevs av Kurata. Polystichum inadae ingår i släktet Polystichum och familjen Dryopteridaceae. Inga underarter finns listade.

Källor

Kärlväxter
inadae


When a violent windstorm struck the Chicago area in July 2011, it left a lot of destruction in its wake – and 904,000 ComEd customers without power. The energy company struggled to respond effectively.
"It was a wakeup call for both us and decisionmakers that something very significant had to change," said Sheila Owens, vice president of economic and business development at ComEd.
The storm and its aftermath set in motion an effort to build support for upgrading the electric grid for northern Illinois and Chicago.
Three months after the storm, Illinois passed the Smart Grid Law, which enabled the company to make needed investments to strengthen and modernize the grid. It included technology that would meaningfully improve service reliability and bring the grid into the 21st Century.
"Making the smart grid 'smart' through automation has really resulted in significant improvement in reliability and fewer customer outages," said Michelle Blaise, senior vice president of technical services for ComEd.
Delivering on the smart grid promise took an extraordinary act of collaboration – not only across by the more than 6,000 employees across the company, but with public officials, and community leaders.
The six-year smart grid program also gave the local economy a much-needed boost in the form of new jobs creation and investment.
"ComEd has helped United Scrap Metal transform our company from 20 employees to over 400 team members," said Marsha Serlin, founder and CEO of United Scrap Metal.


text:
Carlo van Dam fights familiar problems
At the German Lausitzring, Dutch racing driver Carlo van Dam is fighting the same problems that determined his pace during the opening rounds of the Formula 3 Euroseries at Hockenheim earlier this month. His Dallara-Volkswagen ran by the new Kolles & Heinz Union-team is again suffering from a lack of top speed amongst several other problems. Consequently, Carlo, the 2007 German F3-champion and last year's Japanese F3-champion, today couldn't finish higher than in 19th position. Tomorrow round four of the Euroseries is run at the Lausitzring.
"I admit that this situation ultimately challenges your motivation", Carlo says. "I like the challenge of solving problems. That's motor racing and that's how one makes progress. The problems we have, though, were clear from the very first test earlier this year and haven't been solved since. That naturally means asking quite a lot from your patience and understanding. However, I of course can not do more than making clear what I find needs to be changed and why. Whether or not it is subsequently changed, I do not control in this case."
"We are not talking about fine tuning or tenths of a seconds here. This is about fundamental matters. In addition, the gearbox didn't work yesterday, which kept me out of free practice. Since it rained during qualifying today, I reckon I could have fought my way into the top ten somehow, but the differential turned out to have been set up wrongly and thus the car's handling was hopeless. On the straights we are still way too slow: at the start I got up from 22nd to 15th, but then everybody came sailing past me easily. The difference in top speed is still seriously obvious. If and when we will change a few crucial things will determine if and when we will have a car with which we have a realistic chance of performing properly."


With reckless abandon, your company makes a mad dash for the gates!
Forced: When at least 1 progress is placed on Furious Charge, each character gets -2 until the end of the round. If Thaurdir is Captain side faceup, flip him.
Response: After Furious Charge is defeated, add 10 progress to the main quest.


text:
Careers at DOL
Health Plans and Benefits
Industry-Recognized Apprenticeship Programs (IRAP)
International Labor Issues
Major Laws of DOL
Retirement Plans, Benefits and Savings
Spanish-Language Resources
Youth and Labor
Breaks and Meal Periods
Continuation of Health Coverage - COBRA
FMLA (Family and Medical Leave)
Office of the Secretary (OSEC)
Administrative Review Board (ARB)
Benefits Review Board (BRB)
Bureau of International Labor Affairs (ILAB)
Bureau of Labor Statistics (BLS)
Centers for Faith and Opportunity Initiatives (CFOI)
Employee Benefits Security Administration (EBSA)
Employees' Compensation Appeals Board (ECAB)
Employment and Training Administration (ETA)
Mine Safety and Health Administration (MSHA)
Occupational Safety and Health Administration (OSHA)
Office of Administrative Law Judges (OALJ)
Office of the Assistant Secretary for Administration and Management (OASAM)
Office of the Assistant Secretary for Policy (OASP)
Office of the Chief Financial Officer (OCFO)
Office of Congressional and Intergovernmental Affairs (OCIA)
Office of Disability Employment Policy (ODEP)
Office of Federal Contract Compliance Programs (OFCCP)
Office of Labor-Management Standards (OLMS)
Office of the Solicitor (SOL)
Office of Inspector General (OIG)
Office of Workers' Compensation Programs (OWCP)
Ombudsman for the Energy Employees Occupational Illness Compensation Program (EEOMBD)
Pension Benefit Guaranty Corporation (PBGC)
Veterans' Employment and Training Service (VETS)
Wage and Hour Division (WHD)
Women's Bureau (WB)
Agencies and Programs
Meet the Secretary of Labor
Budget, Performance and Planning
Directions to the National Office
Family and Medical Leave (FMLA)
The Fair Labor Standards Act (FLSA) does not require payment for time not worked, including attending a funeral. This type of benefit is generally a matter of agreement between an employer and an employee (or the employee's representative).


text:
Singapore FinTech Company, STACS, Co-Develops Blockchain Platform with EFG Bank
Project Funded by MAS under the Financial Sector Technology & Innovation (FSTI) Proof of Concept Grant
SINGAPORE / HONG KONG, CHINA - Media OutReach - 14 October 2020 - Hashstacs Pte Ltd (also known as "STACS"), a Singapore FinTech company focusing on Blockchain technology solutions, announced its partnership with EFG Bank ("EFG") to co-develop a Blockchain platform that will enhance and simplify the processes of structured products.
"Project Nathan -- Smart Structured Products", a collaboration between STACS and EFG, aims at using new Distributed Ledger Technology (DLT) to automate and manage the entire lifecycle of a structured product. The Nathan platform comprises the underlying STACS Blockchain and smart contracts, and a business application with an intuitive user interface.
The Nathan platform was awarded the Monetary Authority of Singapore ("MAS")'s Financial Sector Technology and Innovation (FSTI) Proof of Concept (POC) grant on 2 March 2020. The FSTI POC grant provides funding support for experimentation, development and dissemination of nascent innovative technologies in the financial services sector.
Project Nathan achieved many milestones through close collaboration work between STACS and EFG. It is currently in its first phase, where STACS worked with EFG to remodel the workflows involved in a structured product transaction, facilitated the internal efficiencies between various EFG departments involved in structured product transactions, as well as looked at the usage of smart contracts to automate aspects of trade inception and trade servicing.
Mr Benjamin Soh, Managing Director of STACS, said: "Tapping on the success of Phase 1 of Project Nathan, we are now able to proceed with further phases of commercialisation for the Nathan Platform, and look towards further rollout of our digitalisation initiatives towards the wider industry."
Workflow processes that are heavily manual today, such as the reconciliation of structured product trades and fixings, are now enhanced and simplified on the Nathan platform. EFG has reported a significant reduction in manhours and operational risks, and an increase in efficiency of more than 50%. Overall, the Nathan Platform has allowed the bank the ability to increase servicing capacity by close to 300%. Starting with FX Accumulators, the solution will be scaled up to include other types of structured products in future.
Mr Ivan Ferraroni, Managing Director of EFG Bank, Hong Kong said, "Participating in this MAS funded initiative was an exciting experience for EFG and our team members. This is in line with our efforts to change the speed and scope of digitalisation in our business. Working with STACS has been very smooth and seamless, and we certainly managed to learn from each other. The project is innovative, demonstrates significant efficiency gains and can be extended to other asset classes in the future."
Codeveloping Blockchain Use cases with market participants
With recent trends of blockchain adoption in the capital markets, STACS serves as a complete solutions partner. By co-developing a Blockchain project with EFG, STACS has provided a model for market
participants, providing them a solution for industry pain-points highlighted by the participants. STACS also provides a full suite of platforms covering different services in various live projects with multiple stock exchanges and commercial banks in both the EU and Asia.
"Project Nathan demonstrates the commitment of STACS as an innovative fintech development company to help financial institutions like EFG Bank to embrace digitalisation and seek new opportunities. This is an exciting time in the FinTech world as we see a growing number of institutions looking at Blockchain, and EFG has taken the lead to adopt this innovative approach to structured products. Adoption of new technologies by financial institutions will enable them to reap the benefits of reducing costs and improve efficiencies," added Mr Benjamin Soh.
5 Nov 2020 Singapore FinTech Company, STACS, Co-Develops Blockchain Platform with EFG Bank
19 Oct 2020 CORRECTING and REPLACING: Singapore FinTech Company, STACS, Co-Develops Blockchain Platform with EFG Bank
30 Jul 2020 Hashstacs Co-Develops Blockchain Project with Bursa Malaysia for Its Bonds Marketplace
About STACS
Hashstacs Pte Ltd or "STACS" is a Singapore fintech development company providing ready platforms that make global markets simpler for financial institutions. STACS is leading the way forward by digitalizing assets, processes and documents using next generation blockchain-based technology. Its clients and partners include investment banks, stock exchanges, custodian banks, asset managers and private banks. STACS is a recipient of the MAS FSTI POC grant, and a technology participant of the MAS Project Ubin.
About EFG Bank
EFG Bank is one of the largest Swiss private banks with strong roots in the home market and a global presence. EFG represents security and solidity, an entrepreneurial way of thinking and acting, and a powerful blend of agility and reliability. EFG's motto is: "Entrepreneurial thinking. Private banking".


text:
/**
 * Autogenerated by Thrift Compiler (0.9.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
package org.apache.hadoop.hive.metastore.api;

import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.thrift.scheme.IScheme;
import org.apache.thrift.scheme.SchemeFactory;
import org.apache.thrift.scheme.StandardScheme;

import org.apache.thrift.scheme.TupleScheme;
import org.apache.thrift.protocol.TTupleProtocol;
import org.apache.thrift.protocol.TProtocolException;
import org.apache.thrift.EncodingUtils;
import org.apache.thrift.TException;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.EnumMap;
import java.util.Set;
import java.util.HashSet;
import java.util.EnumSet;
import java.util.Collections;
import java.util.BitSet;
import java.nio.ByteBuffer;
import java.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SerDeInfo implements org.apache.thrift.TBase<SerDeInfo, SerDeInfo._Fields>, java.io.Serializable, Cloneable {
  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("SerDeInfo");

  private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)1);
  private static final org.apache.thrift.protocol.TField SERIALIZATION_LIB_FIELD_DESC = new org.apache.thrift.protocol.TField("serializationLib", org.apache.thrift.protocol.TType.STRING, (short)2);
  private static final org.apache.thrift.protocol.TField PARAMETERS_FIELD_DESC = new org.apache.thrift.protocol.TField("parameters", org.apache.thrift.protocol.TType.MAP, (short)3);

  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
  static {
    schemes.put(StandardScheme.class, new SerDeInfoStandardSchemeFactory());
    schemes.put(TupleScheme.class, new SerDeInfoTupleSchemeFactory());
  }

  private String name; // required
  private String serializationLib; // required
  private Map<String,String> parameters; // required

  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
    NAME((short)1, "name"),
    SERIALIZATION_LIB((short)2, "serializationLib"),
    PARAMETERS((short)3, "parameters");

    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

    static {
      for (_Fields field : EnumSet.allOf(_Fields.class)) {
        byName.put(field.getFieldName(), field);
      }
    }

    /**
     * Find the _Fields constant that matches fieldId, or null if its not found.
     */
    public static _Fields findByThriftId(int fieldId) {
      switch(fieldId) {
        case 1: // NAME
          return NAME;
        case 2: // SERIALIZATION_LIB
          return SERIALIZATION_LIB;
        case 3: // PARAMETERS
          return PARAMETERS;
        default:
          return null;
      }
    }

    /**
     * Find the _Fields constant that matches fieldId, throwing an exception
     * if it is not found.
     */
    public static _Fields findByThriftIdOrThrow(int fieldId) {
      _Fields fields = findByThriftId(fieldId);
      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
      return fields;
    }

    /**
     * Find the _Fields constant that matches name, or null if its not found.
     */
    public static _Fields findByName(String name) {
      return byName.get(name);
    }

    private final short _thriftId;
    private final String _fieldName;

    _Fields(short thriftId, String fieldName) {
      _thriftId = thriftId;
      _fieldName = fieldName;
    }

    public short getThriftFieldId() {
      return _thriftId;
    }

    public String getFieldName() {
      return _fieldName;
    }
  }

  // isset id assignments
  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
  static {
    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
    tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
    tmpMap.put(_Fields.SERIALIZATION_LIB, new org.apache.thrift.meta_data.FieldMetaData("serializationLib", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
    tmpMap.put(_Fields.PARAMETERS, new org.apache.thrift.meta_data.FieldMetaData("parameters", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
            new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING),
            new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
    metaDataMap = Collections.unmodifiableMap(tmpMap);
    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(SerDeInfo.class, metaDataMap);
  }

  public SerDeInfo() {
  }

  public SerDeInfo(
    String name,
    String serializationLib,
    Map<String,String> parameters)
  {
    this();
    this.name = name;
    this.serializationLib = serializationLib;
    this.parameters = parameters;
  }

  /**
   * Performs a deep copy on <i>other</i>.
   */
  public SerDeInfo(SerDeInfo other) {
    if (other.isSetName()) {
      this.name = other.name;
    }
    if (other.isSetSerializationLib()) {
      this.serializationLib = other.serializationLib;
    }
    if (other.isSetParameters()) {
      Map<String,String> __this__parameters = new HashMap<String,String>();
      for (Map.Entry<String, String> other_element : other.parameters.entrySet()) {

        String other_element_key = other_element.getKey();
        String other_element_value = other_element.getValue();

        String __this__parameters_copy_key = other_element_key;

        String __this__parameters_copy_value = other_element_value;

        __this__parameters.put(__this__parameters_copy_key, __this__parameters_copy_value);
      }
      this.parameters = __this__parameters;
    }
  }

  public SerDeInfo deepCopy() {
    return new SerDeInfo(this);
  }

  @Override
  public void clear() {
    this.name = null;
    this.serializationLib = null;
    this.parameters = null;
  }

  public String getName() {
    return this.name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public void unsetName() {
    this.name = null;
  }

  /** Returns true if field name is set (has been assigned a value) and false otherwise */
  public boolean isSetName() {
    return this.name != null;
  }

  public void setNameIsSet(boolean value) {
    if (!value) {
      this.name = null;
    }
  }

  public String getSerializationLib() {
    return this.serializationLib;
  }

  public void setSerializationLib(String serializationLib) {
    this.serializationLib = serializationLib;
  }

  public void unsetSerializationLib() {
    this.serializationLib = null;
  }

  /** Returns true if field serializationLib is set (has been assigned a value) and false otherwise */
  public boolean isSetSerializationLib() {
    return this.serializationLib != null;
  }

  public void setSerializationLibIsSet(boolean value) {
    if (!value) {
      this.serializationLib = null;
    }
  }

  public int getParametersSize() {
    return (this.parameters == null) ? 0 : this.parameters.size();
  }

  public void putToParameters(String key, String val) {
    if (this.parameters == null) {
      this.parameters = new HashMap<String,String>();
    }
    this.parameters.put(key, val);
  }

  public Map<String,String> getParameters() {
    return this.parameters;
  }

  public void setParameters(Map<String,String> parameters) {
    this.parameters = parameters;
  }

  public void unsetParameters() {
    this.parameters = null;
  }

  /** Returns true if field parameters is set (has been assigned a value) and false otherwise */
  public boolean isSetParameters() {
    return this.parameters != null;
  }

  public void setParametersIsSet(boolean value) {
    if (!value) {
      this.parameters = null;
    }
  }

  public void setFieldValue(_Fields field, Object value) {
    switch (field) {
    case NAME:
      if (value == null) {
        unsetName();
      } else {
        setName((String)value);
      }
      break;

    case SERIALIZATION_LIB:
      if (value == null) {
        unsetSerializationLib();
      } else {
        setSerializationLib((String)value);
      }
      break;

    case PARAMETERS:
      if (value == null) {
        unsetParameters();
      } else {
        setParameters((Map<String,String>)value);
      }
      break;

    }
  }

  public Object getFieldValue(_Fields field) {
    switch (field) {
    case NAME:
      return getName();

    case SERIALIZATION_LIB:
      return getSerializationLib();

    case PARAMETERS:
      return getParameters();

    }
    throw new IllegalStateException();
  }

  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
  public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case NAME:
      return isSetName();
    case SERIALIZATION_LIB:
      return isSetSerializationLib();
    case PARAMETERS:
      return isSetParameters();
    }
    throw new IllegalStateException();
  }

  @Override
  public boolean equals(Object that) {
    if (that == null)
      return false;
    if (that instanceof SerDeInfo)
      return this.equals((SerDeInfo)that);
    return false;
  }

  public boolean equals(SerDeInfo that) {
    if (that == null)
      return false;

    boolean this_present_name = true && this.isSetName();
    boolean that_present_name = true && that.isSetName();
    if (this_present_name || that_present_name) {
      if (!(this_present_name && that_present_name))
        return false;
      if (!this.name.equals(that.name))
        return false;
    }

    boolean this_present_serializationLib = true && this.isSetSerializationLib();
    boolean that_present_serializationLib = true && that.isSetSerializationLib();
    if (this_present_serializationLib || that_present_serializationLib) {
      if (!(this_present_serializationLib && that_present_serializationLib))
        return false;
      if (!this.serializationLib.equals(that.serializationLib))
        return false;
    }

    boolean this_present_parameters = true && this.isSetParameters();
    boolean that_present_parameters = true && that.isSetParameters();
    if (this_present_parameters || that_present_parameters) {
      if (!(this_present_parameters && that_present_parameters))
        return false;
      if (!this.parameters.equals(that.parameters))
        return false;
    }

    return true;
  }

  @Override
  public int hashCode() {
    HashCodeBuilder builder = new HashCodeBuilder();

    boolean present_name = true && (isSetName());
    builder.append(present_name);
    if (present_name)
      builder.append(name);

    boolean present_serializationLib = true && (isSetSerializationLib());
    builder.append(present_serializationLib);
    if (present_serializationLib)
      builder.append(serializationLib);

    boolean present_parameters = true && (isSetParameters());
    builder.append(present_parameters);
    if (present_parameters)
      builder.append(parameters);

    return builder.toHashCode();
  }

  public int compareTo(SerDeInfo other) {
    if (!getClass().equals(other.getClass())) {
      return getClass().getName().compareTo(other.getClass().getName());
    }

    int lastComparison = 0;
    SerDeInfo typedOther = (SerDeInfo)other;

    lastComparison = Boolean.valueOf(isSetName()).compareTo(typedOther.isSetName());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetName()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, typedOther.name);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetSerializationLib()).compareTo(typedOther.isSetSerializationLib());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetSerializationLib()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serializationLib, typedOther.serializationLib);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetParameters()).compareTo(typedOther.isSetParameters());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetParameters()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.parameters, typedOther.parameters);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    return 0;
  }

  public _Fields fieldForId(int fieldId) {
    return _Fields.findByThriftId(fieldId);
  }

  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
  }

  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
  }

  @Override
  public String toString() {
    StringBuilder sb = new StringBuilder("SerDeInfo(");
    boolean first = true;

    sb.append("name:");
    if (this.name == null) {
      sb.append("null");
    } else {
      sb.append(this.name);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("serializationLib:");
    if (this.serializationLib == null) {
      sb.append("null");
    } else {
      sb.append(this.serializationLib);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("parameters:");
    if (this.parameters == null) {
      sb.append("null");
    } else {
      sb.append(this.parameters);
    }
    first = false;
    sb.append(")");
    return sb.toString();
  }

  public void validate() throws org.apache.thrift.TException {
    // check for required fields
    // check for sub-struct validity
  }

  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
    try {
      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
    } catch (org.apache.thrift.TException te) {
      throw new java.io.IOException(te);
    }
  }

  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
    try {
      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
    } catch (org.apache.thrift.TException te) {
      throw new java.io.IOException(te);
    }
  }

  private static class SerDeInfoStandardSchemeFactory implements SchemeFactory {
    public SerDeInfoStandardScheme getScheme() {
      return new SerDeInfoStandardScheme();
    }
  }

  private static class SerDeInfoStandardScheme extends StandardScheme<SerDeInfo> {

    public void read(org.apache.thrift.protocol.TProtocol iprot, SerDeInfo struct) throws org.apache.thrift.TException {
      org.apache.thrift.protocol.TField schemeField;
      iprot.readStructBegin();
      while (true)
      {
        schemeField = iprot.readFieldBegin();
        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
          break;
        }
        switch (schemeField.id) {
          case 1: // NAME
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.name = iprot.readString();
              struct.setNameIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 2: // SERIALIZATION_LIB
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.serializationLib = iprot.readString();
              struct.setSerializationLibIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 3: // PARAMETERS
            if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map104 = iprot.readMapBegin();
                struct.parameters = new HashMap<String,String>(2*_map104.size);
                for (int _i105 = 0; _i105 < _map104.size; ++_i105)
                {
                  String _key106; // required
                  String _val107; // required
                  _key106 = iprot.readString();
                  _val107 = iprot.readString();
                  struct.parameters.put(_key106, _val107);
                }
                iprot.readMapEnd();
              }
              struct.setParametersIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          default:
            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();
      struct.validate();
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot, SerDeInfo struct) throws org.apache.thrift.TException {
      struct.validate();

      oprot.writeStructBegin(STRUCT_DESC);
      if (struct.name != null) {
        oprot.writeFieldBegin(NAME_FIELD_DESC);
        oprot.writeString(struct.name);
        oprot.writeFieldEnd();
      }
      if (struct.serializationLib != null) {
        oprot.writeFieldBegin(SERIALIZATION_LIB_FIELD_DESC);
        oprot.writeString(struct.serializationLib);
        oprot.writeFieldEnd();
      }
      if (struct.parameters != null) {
        oprot.writeFieldBegin(PARAMETERS_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.parameters.size()));
          for (Map.Entry<String, String> _iter108 : struct.parameters.entrySet())
          {
            oprot.writeString(_iter108.getKey());
            oprot.writeString(_iter108.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

  }

  private static class SerDeInfoTupleSchemeFactory implements SchemeFactory {
    public SerDeInfoTupleScheme getScheme() {
      return new SerDeInfoTupleScheme();
    }
  }

  private static class SerDeInfoTupleScheme extends TupleScheme<SerDeInfo> {

    @Override
    public void write(org.apache.thrift.protocol.TProtocol prot, SerDeInfo struct) throws org.apache.thrift.TException {
      TTupleProtocol oprot = (TTupleProtocol) prot;
      BitSet optionals = new BitSet();
      if (struct.isSetName()) {
        optionals.set(0);
      }
      if (struct.isSetSerializationLib()) {
        optionals.set(1);
      }
      if (struct.isSetParameters()) {
        optionals.set(2);
      }
      oprot.writeBitSet(optionals, 3);
      if (struct.isSetName()) {
        oprot.writeString(struct.name);
      }
      if (struct.isSetSerializationLib()) {
        oprot.writeString(struct.serializationLib);
      }
      if (struct.isSetParameters()) {
        {
          oprot.writeI32(struct.parameters.size());
          for (Map.Entry<String, String> _iter109 : struct.parameters.entrySet())
          {
            oprot.writeString(_iter109.getKey());
            oprot.writeString(_iter109.getValue());
          }
        }
      }
    }

    @Override
    public void read(org.apache.thrift.protocol.TProtocol prot, SerDeInfo struct) throws org.apache.thrift.TException {
      TTupleProtocol iprot = (TTupleProtocol) prot;
      BitSet incoming = iprot.readBitSet(3);
      if (incoming.get(0)) {
        struct.name = iprot.readString();
        struct.setNameIsSet(true);
      }
      if (incoming.get(1)) {
        struct.serializationLib = iprot.readString();
        struct.setSerializationLibIsSet(true);
      }
      if (incoming.get(2)) {
        {
          org.apache.thrift.protocol.TMap _map110 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32());
          struct.parameters = new HashMap<String,String>(2*_map110.size);
          for (int _i111 = 0; _i111 < _map110.size; ++_i111)
          {
            String _key112; // required
            String _val113; // required
            _key112 = iprot.readString();
            _val113 = iprot.readString();
            struct.parameters.put(_key112, _val113);
          }
        }
        struct.setParametersIsSet(true);
      }
    }
  }

}


At any rate, everyone LOVED this cake at Max's birthday celebration, and I didn't even have to turn on the oven or crack an egg. Good stuff, indeed.
Unwrap four ice cream sandwiches and place them snugly side-by-side on a serving plate that is large enough to hold the cake.
On a cutting board, disassemble the cookies & cream ice cream box so that it's exposed on all four sides and the top. Cut off about 1/3 of the rectangular prism, lengthwise, and place resulting rectangle onto the side-by-side ice cream sandwiches on the plate.
Add another layer of unwrapped sandwiches on top of the cookies & cream layer.
Cut another 1/3 of the cookies and cream and place on top of the second layer of sandwiches.
Top with the final four ice cream sandwiches. Cover with plastic wrap and place in the freezer until ice cream is hard. Be sure to wrap of up and freeze remaining 1/3 of the cookies & cream ice cream. Eat it later when the cake is gone.
During the last 15 minutes or so of the cake freezing, remove the vanilla ice cream from the freezer and let it sit at room temperature (for about 15 minutes). When ice cream is soft enough to scoop easily, but not at all melted, scoop about 1/4 gallon (half of a half gallon) into a bowl (preferably a standing mixer bowl). Stir with a spoon or paddle attachment on your mixer, until ice cream is smooth.
Get the cake out of the freezer and quickly frost the cake with the vanilla ice cream. Then decorate the edges with the mini Oreos.
Cover cake with plastic wrap and place in the freezer for at least two hours before serving.
Cut along the long side and then cut each of those large slices into three slices.


Today is the feast of our Mother Foundress, St. Madeleine Sophie. She seems so close to all of us as I know she watches over us from heaven. She wants each of us to live in union and conformity with the Heart of Jesus. She loves fidelity to the Holy Spirit and is concerned with the interior life of each of us. She always wants us to be humble, prayerful, and to seek only to be faithful to whatever God is asking of us. I find her presence in my life so consoling and encouraging. She often tells me to slow down and discern what the Lord is asking of me. I suspect she does this for all her daughters.
Time and again, as I read things written by Sophie, I come across these words - go... draw - in relation to the Heart of Jesus. In the 1815 Constitutions, for example, the novices were to go to the Heart of Jesus to draw from it a love of charity or poverty. Elsewhere, whether in conferences or personal letters, the same advice; the same words - go, draw, source, mainspring.
May these reflections be a source of peace and perspective as we continue to journey forward, and as a Society may we always remember our roots in Sophie.


craigecollinsart.com -Fuel Cell Cars A fuel cell vehicle (FCV) or fuel cell electric vehicle (FCEV) is a type of electric vehicle which uses a fuel cell, instead of a battery, or in combination with a battery or supercapacitor, to power its on-board electric motor. Fuel cells in vehicles generate electricity to power the motor, generally using oxygen from the air and compressed hydrogen.2019 uk guide to fuel cell vehicles. Fuel cells are devices that convert chemical energy (in this case hydrogen) directly into electrical energy, water and heat. In most hydrogen fuel cell cars, a high-power fuel cell and motor combination provide propulsion in place of an internal combustion engine.Fuel cell cars. Awaiting the arrival of the world's very first (FCV) fuel cell vehicle? You can test drive the technology of the future right now, with Fuel Cell Store's selection of fuel cell powered remote control cars.How do hydrogen fuel cell vehicles work?. Like other EVs, fuel cell cars and trucks can employ idle-off, which shuts down the fuel cell at stop signs or in traffic. In certain driving modes, regenerative braking is used to capture lost energy and charge the battery.


text:
Justia Trademarks Categories Electrical and scientific apparatus FLAMES OF AMBITION - Trademark Details
FLAMES OF AMBITION - Trademark Details
Status: 686 - Published For Opposition
FLAMES OF AMBITION
686 - Published For Opposition
Ann K. Ford
DAVIS, TRENTON MICHAEL
Downloadable mobile application software, namely, downloadable electronic game programs; downloadable computer game software for use with on-line interactive games; downloadable video game programs for mobile devices; downloadable electronic game programs; downloadable electronic game software; downloadable computer game programs; downloadable interactive game programs; downloadable interactive game software; downloadable computer game software offered via the internet and wireless devices; downloadable computer game software for use with computers and video game consoles; downloadable computer and video game software offered via the internet and wireless devices; pre-recorded electronic media devices featuring downloadable computer game software for use with computers and video game consoles; pre-recorded digital media in the nature of CD-ROMs and DVDs featuring computer games and video games, wallpapers, screensavers, digital music files, and graphics, videos, films, multimedia files, motion pictures, and animation in the field of video games and computer games; downloadable digital media, namely, downloadable images, downloadable artwork, downloadable text files, downloadable audio files, downloadable video files, downloadable game software, and downloadable motion pictures, all in the field of video games and computer games
Entertainment services, namely, providing on-line interactive computer games; online interactive games accessible via mobile phones and wireless devices; entertainment services, namely, providing information and entertainment in the nature of news, information, non-downloadable art pictures, non-downloadable video clips, and non-downloadable trailers relating to electronic computer games via the Internet; Providing non-downloadable electronic publications in the nature of books, magazines, journals and newspapers in the field of novels, comics and cartoons; movie film production; movie film distribution; television show production; rental of amusement machines and apparatus; rental of game machines and apparatus
009 - Scientific, nautical, surveying, electric, photographic, cinematographic, optical, weighing, measuring, signalling, checking (supervision), life-saving and teaching apparatus and instruments; apparatus for recording, transmission or reproduction of sound or images; magnetic data carriers, recording discs; automatic vending machines and mechanisms for coin-operated apparatus; cash registers, calculating machines, data processing equipment and computers; fire-extinguishing apparatus. - Scientific, nautical, surveying, electric, photographic, cinematographic, optical, weighing, measuring, signalling, checking (supervision), life-saving and teaching apparatus and instruments; apparatus for recording, transmission or reproduction of sound or images; magnetic data carriers, recording discs; automatic vending machines and mechanisms for coin-operated apparatus; cash registers, calculating machines, data processing equipment and computers; fire-extinguishing apparatus.
ZeniMax Media Inc.
Foreign Application Information
Filing Date Application Number Country Foreign Priority Claim In
2020-11-27 2020/24203 Honduras True