 do for Platinum’s personalities, and Kirk Thornton takes an original route for Jubei that is still fitting.
For the rest of the dub, the voice actors are well-used to their roles by now and do the best that they can with the material. The only voices I really have problems are those I’ve never liked from the games to begin with (Cristina Vee’s Noel Vermillion/Nu-13 & Lauren Landa’s Litchi are both miscast and no amount of experience in the roles will fix that). My favorites include Julie Ann Taylor, does a great job sounding like two entirely different people as unrelated characters Kakonoe and Tsubaki, and Doug Erholtz, who has the time of his life unleashing the ham as Hazama in the final episodes. I hope Erholtz is considered for voicing the Joker in future Batman productions, because this was really something. Overall, the dub is entertaining but can’t lift up the material. Strangely, both Taokaka and Iron Tager are uncredited in the English dub, but it’s obvious that both of their original voice actors returned.
Patrick Seitz wrote the dub scripts himself in addition to directing, and he makes two interesting deviations from the Japanese script. The first one is that the dialogue tends to be more direct and confrontational as opposed to the more meandering dialogue in the Japanese version. This choice is arguably better, as it is based on a fighting game after all, and you would expect the characters to be more eager to go at it. The second one is that gamer slang like “Pro tip” peppers a lot of the dialogue during the fights, which can be distracting at its worst. It’s up to you in the end whether these creative choices work or not; I like the decision to make the characters sound a bit more aggressive when fighting with each other (it’s just logic), but I find the gamer slang mostly annoying and not really contributing anything.
The Japanese version, for its part, brings everyone back regardless of how large or small their role ultimately is in this anime. Much like the English dub, it operates like clockwork, everyone used to their characters and making a professional go at it. The only issue I have with the Japanese version from a voice standpoint is Kanako Hondou’s Noel/Nu-13 (who both tend to be way too squeaky). Perhaps this reveals that I have a quite different view on what Noel should sound like compared to the Japanese and English directors. However, as mentioned before, the Japanese dialogue is surprisingly limp for a violent show, except for the parts where Hazama absolutely loses it. As a result, the dub actually has more impact in dramatic scenes compared to the Japanese version.
Extras are borderline negligible, lacking even episode commentaries. Just clean opening and closing themes, the US trailer, and the original Japanese trailer.
Overall, the BlazBlue anime adaptation, which was long begged-for by the game producers, is not what anyone was waiting for. BlazBlue: Alter Memory is just a limply-animated show that does a poor job hooking newcomers to the franchise or providing anything interesting for long-time fans. This series’ ultimate fate is the eternal dust-bin of poor video game adaptations.
1:18 a.m. — Warrant arrest on East F Street.
3:42 p.m. — Rape reported in Oakdale.
In response to Alan McKenna (August 3), Revealing Carbon Tax Hypocrisy (July 27) was not about clever point scoring. The authors discussed an issue with dire environmental and economic consequences. What John Petheram and Lawrie Wilson expose is faulty and unethical government decision-making by both the ALP and the Coalition.
They ask us to think – Can Australia put a price on CO2 released through fossil fuel burning locally, yet still sell the same fossil fuel overseas to result in a threefold CO2 release globally? The point is – if the burning happens elsewhere it’s still happening. It’s called ‘global’ warming because it’s a global problem.
Our federal and state governments are policy jugglers. Environmental policy in the air: a carbon price (let’s watch CO2 go down). Economic policy in the air: sell coal (but don’t mention the CO2 going up, and up, and up). It is political expediency. It lacks courage and foresight to do something real.
A carbon price makes a good beginning to change economic behaviour, but the scale of our addiction to fossil fuels needs policy-consistent decisions and a big picture view. Sleight of hand won’t fix anything. It is rightly called hypocrisy.
hey guys! well, after our first checkpoint, we sat down and really started getting into the details of the design, especially the software. After getting the two Xbee modules to communicate with each other, we realized that our code would need to be interrupt driven to successfully read, process, and send messages on time. We're allowing one module to handle the interface with the Xbee, saving us some complexity of having to check flags and all that. Check out our design to the right. ignore the doodles to the right./*
 * Copyright 2013-2014 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

@file:Suppress("NOTHING_TO_INLINE")

package ts2kt.utils

inline fun <T> Any?.cast(): T = this.unsafeCast<T>()

fun <T> List<T>.join(
        delimiter: String = ", ",
        start: String = "",
        end: String = "",
        startWithIfNotEmpty: String = "",
        endWithIfNotEmpty: String = "",
        filter: ((T) -> Boolean)? = null,
        stringify: ((T) -> String)? = null
): String {
    if (this.isEmpty()) return start + end

    var s = ""
    var first = true

    for (e in this) {
        if (filter!= null &&!filter(e)) continue

        if (!first) {
            s += delimiter
        }
        else {
            first = false
        }
        s += if (stringify == null) e.toString() else stringify(e)
    }

    if (first) return start + end

    return start + startWithIfNotEmpty + s + endWithIfNotEmpty + end
}

fun <T: Any> List<T>.merge(acceptor: (T) -> Boolean, comparator: (T, T) -> Boolean, merger: (T, T) -> T?): List<T> =
        toMutableList().apply { merge(acceptor, comparator, merger) }

private fun <T: Any> MutableList<T>.merge(acceptor: (T) -> Boolean, comparator: (T, T) -> Boolean, merger: (T, T) -> T?) {
    var i = 0
    while (i < size) {
        val current = this[i]
        if (!acceptor(current)) {
            i++
            continue
        }

        val candidates = arrayListOf<Int>()

        val size = size
        var j =  i + 1
        while (j < size) {
            val e = this[j]

            if (!acceptor(e)) {
                j++
                continue
            }

            if (comparator(current, e)) {
                candidates.add(j)
            }

            j++
        }

        if (!candidates.isEmpty()) {
            this.mergeAllTo(i, candidates, merger)
        }

        i++
    }
}

private fun <T: Any> MutableList<T>.mergeAllTo(mergeTo: Int, candidateIndexes: List<Int>, merger: (T, T) -> T?) {
    var acc = this[mergeTo]
    val indexesToRemove = mutableSetOf<Int>()
    for (i in candidateIndexes) {
        val result = merger(acc, this[i])
        if (result!= null) {
            acc = result
            indexesToRemove += i
        }
    }

    this[mergeTo] = acc

    indexesToRemove.sortedDescending().forEach { this.removeAt(it) }
}

// JS Array methods

//inline fun <T> Array<T>.push(vararg elements: T): Unit = asDynamic().push.apply(this, elements)
inline fun <T> Array<T>.push(element: T): Unit {
    asDynamic().push(element)
}

inline fun <T> Array<T>.shift(): T = asDynamic().shift().unsafeCast<T>()
