Question: So I've been using Chris's article <https://css-tricks.com/multi-line-padded-text/> to help me get some centred text with a background. The only problem is I want the background to be semi transparent and I can't think of a way of doing it. I've played with line height and padding but can't come up with a solution. 

What I want to do is stop the backgrounds of each line overlapping but ensure that the space between each line is the same.

```
  <div class="ui-section__component">
   <div class="comp--hero-text">
    <h2>You're all clear, kid. Let's blow this thing and go home! You're all clear, kid. Let's blow this thing and go home!</h2>
   </div>
  </div>

$white: #fff;
$max-width: 1024px;
$small-spacing: 0.75em;

.ui-section__component{
  background-color: green; 
  display: flex; 
  height: 500px;
  width: 700px;
}

.comp--hero-text {
  align-self: center;
  margin: 0 auto;
  max-width: $max-width - 200px;
  text-align: center;
  width: 80%;

  h2 {
    background-color: rgba($white, 0.85);
    box-decoration-break: clone;
    box-shadow: $small-spacing / 2 0 0 rgba($white, 0.85), -$small-spacing / 2 0 0 rgba($white, 0.85);
    display: inline;
    line-height: 1.5;
    padding: 0.5em 0;
  }
}

```

My code can be found on Code Pen: <http://codepen.io/rmaspero/pen/VmVwNx>

Answer: 
This is not a *desired* behaviour, though not *explicitly* mentioned as undefined behaviour. This is a "Constraints violation".

Quoting `C11`, chapter 6.8.6.4

> 
> [...] A `return` statement without an expression shall only appear in a function
>  whose return type is `void`.
> 
> 
> 

and, from chapter §5.1.1.3, *Diagnostics*,

> 
> A conforming implementation shall produce at least one diagnostic message (identified in
>  an implementation-defined manner) if a preprocessing translation unit or translation unit
>  contains a violation of any syntax rule or constraint, even if the behavior is also explicitly
>  specified as undefined or implementation-defined. [....]
> 
> 
> 

In this case, compiler proceeds to generate the executable code, so, yes, executing this binary invokes [undefined behavior](https://en.wikipedia.org/wiki/Undefined_behavior).

Bottom line, for `main()` which is expected to return an `int` should not have a `return` statement without an expression. Refrain from writing code like that.

---

*[Note: [As per this discussion](https://groups.google.com/forum/#!topic/comp.std.c/WNVXRSCqrGU), there's a strong notion that this is undefined behaviour, but still, there's no **explicit** mention in the standard.]*
From the comments (not from the question), I understood that the main aim is to find what is returned by main by doing `return;`. I hope I am going in right direction.

**First thing** is few compiler allow writing just `return;` and some give a warning and a few compiler give implicitly add `return 0;` if nothing is returned by main.

**Second thing** returning 0 signifies successful execution of the program and if returning anything else will mean some runtime error(At least your environment thinks that way).

Now coming to your doubt: what is implicitly returned by main by writing `return;`. I checked with the tool you are using [ideone.com](http://ideone.com/) and C (gcc-5.1).

With `return;` it gave

```
Runtime error   time: 0 memory: 2164 signal:-1

```

With `return 0;` it gave

```
Success time: 0 memory: 2164 signal:0

```

With `return 1;` it again gave

```
Runtime error   time: 0 memory: 2164 signal:-1

```

In this signal signifies the returned value from `main`

If you use the terminal to run your program, you can use `echo $?` to get the returned value.

So now you can observe yourself that `return;` and `return 1;` give the same output (the implicit value returned can be garbage too). Still, we cannot guarantee this but now you have all the tools you need to find out.