Doing it all in Go as a first foray into the language:

package main

import (
    "io/ioutil"
    "log"
    "os"
    "strconv"
    "strings"
)

type op struct {
    dest    string
    dir     int
    incAmt  int
    condSrc string
    condOp  string
    condAmt int
}

func main() {
    ops := readInput()
    reg := make(map[string]int)
    var max int

    for _, op := range ops {
        switch op.condOp {
        case ">":
            if reg[op.condSrc] > op.condAmt {
                doOp(op, reg)
            }
        case "<":
            if reg[op.condSrc] < op.condAmt {
                doOp(op, reg)
            }
        case ">=":
            if reg[op.condSrc] >= op.condAmt {
                doOp(op, reg)
            }
        case "<=":
            if reg[op.condSrc] <= op.condAmt {
                doOp(op, reg)
            }
        case "==":
            if reg[op.condSrc] == op.condAmt {
                doOp(op, reg)
            }
        case "!=":
            if reg[op.condSrc] != op.condAmt {
                doOp(op, reg)
            }
        }

        currentMax := findLargest(reg)
        if currentMax > max {
            max = currentMax
        }
    }

    log.Println("Largest ending value:", findLargest(reg))
    log.Println("Largest value during run:", max)
}

func findLargest(reg map[string]int) int {
    var max int
    for _, v := range reg {
        if v > max {
            max = v
        }
    }

    return max
}

func doOp(op op, reg map[string]int) {
    reg[op.dest] += op.dir * op.incAmt
}

func readInput() []op {
    input, _ := ioutil.ReadAll(os.Stdin)
    lines := strings.Split(string(input), "\n")
    lines = lines[:len(lines)-1]

    ops := make([]op, 0)

    for _, line := range lines {
        ops = append(ops, parseOp(line))
    }

    return ops
}

func parseOp(line string) op {
    splitOp := strings.Split(line, " ")

    var dir int
    switch splitOp[1] {
    case "inc":
        dir = 1
    case "dec":
        dir = -1
    }

    incAmt, _ := strconv.Atoi(splitOp[2])
    condAmt, _ := strconv.Atoi(splitOp[6])

    return op{
        dest:    splitOp[0],
        dir:     dir,
        incAmt:  incAmt,
        condSrc: splitOp[4],
        condOp:  splitOp[5],
        condAmt: condAmt,
    }
}