#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ memcpy(char *, char *, int);
int /*<<< orphan*/ snprintf(char *, int, char *, ...);
int strlen(char *);
scalar_t__ strnstr(char *, char *, int);
int populate_gps_template(char **template_fields, char **template_field_format,
                          char **fields, int field_cnt, char *buffer,
                          int buffer_len) {
  int result = -1;
  int buffer_idx = 0, field_idx = 0;
  int tidx, fidx;
  int field_len, value_len, need_comma;
  tidx = 0;
  memcpy(buffer, "{ ", 2);
  buffer_idx = 2;
  need_comma = 0;
  while (template_fields[tidx] != NULL) {
    if (strnstr(template_field_format[tidx], "%s",
                strlen(template_field_format[tidx]))) {
      if (fields[field_idx] && strlen(fields[field_idx]) > 0) {
        if (buffer_idx + strlen(template_field_format[tidx]) +
                strlen(template_fields[tidx]) + strlen(fields[field_idx]) + 6 >
            buffer_len) {
          return -1;
        }
        if (need_comma) {
          snprintf(buffer + buffer_idx, buffer_len - buffer_idx,
                   ", \"%s\": ", template_fields[tidx]);
        } else {
          snprintf(buffer + buffer_idx, buffer_len - buffer_idx,
                   "\"%s\": ", template_fields[tidx]);
        }
        buffer_idx += strlen(buffer + buffer_idx);
        snprintf(buffer + buffer_idx, buffer_len - buffer_idx,
                 template_field_format[tidx], fields[field_idx]);
        buffer_idx += strlen(buffer + buffer_idx);
        need_comma = 1;
      }
      field_idx++;
    } else {
      if (buffer_idx + strlen(template_field_format[tidx]) +
              strlen(template_fields[tidx]) + 6 >
          buffer_len) {
        return -1;
      }
      if (need_comma) {
        snprintf(buffer + buffer_idx, buffer_len - buffer_idx,
                 ", \"%s\": \"%s\"", template_fields[tidx],
                 template_field_format[tidx]);
      } else {
        snprintf(buffer + buffer_idx, buffer_len - buffer_idx, "\"%s\": \"%s\"",
                 template_fields[tidx], template_field_format[tidx]);
      }
      buffer_idx += strlen(buffer + buffer_idx);
      need_comma = 1;
    }
    tidx++;
  }
  if (buffer_idx + 3 > buffer_len) {
    return -1;
  }
  snprintf(buffer + buffer_idx, 3, " }");
  buffer_idx += 2;
  *(buffer + buffer_idx) = 0;
  return 0;
}


x86 assembly (clang, -O0):
<populate_gps_template>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
movl   $0xffffffff,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe77(%rip),%rsi
mov    $0x2,%edx
call   1060 <memcpy@plt>
movl   $0x2,-0x3c(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     1459 <populate_gps_template+0x319>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    -0x60(%rbp),%rdi
mov    %eax,%edx
lea    0xe21(%rip),%rsi
call   1050 <strnstr@plt>
cmp    $0x0,%rax
je     1360 <populate_gps_template+0x220>
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     1352 <populate_gps_template+0x212>
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
cmp    $0x0,%eax
jle    1352 <populate_gps_template+0x212>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x6c(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x68(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x64(%rbp),%eax
add    %ecx,%eax
add    $0x6,%eax
cmp    -0x34(%rbp),%eax
jle    128a <populate_gps_template+0x14a>
movl   $0xffffffff,-0x4(%rbp)
jmp    14ae <populate_gps_template+0x36e>
cmpl   $0x0,-0x54(%rbp)
je     12c4 <populate_gps_template+0x184>
mov    -0x30(%rbp),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
mov    -0x34(%rbp),%esi
sub    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
lea    0xd4e(%rip),%rdx
mov    $0x0,%al
call   1040 <snprintf@plt>
jmp    12ef <populate_gps_template+0x1af>
mov    -0x30(%rbp),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
mov    -0x34(%rbp),%esi
sub    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
lea    0xd20(%rip),%rdx
mov    $0x0,%al
call   1040 <snprintf@plt>
mov    -0x30(%rbp),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
call   1030 <strlen@plt>
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
mov    -0x34(%rbp),%esi
sub    -0x3c(%rbp),%esi
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    $0x0,%al
call   1040 <snprintf@plt>
mov    -0x30(%rbp),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
call   1030 <strlen@plt>
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    144b <populate_gps_template+0x30b>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x74(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x70(%rbp),%eax
add    %ecx,%eax
add    $0x6,%eax
cmp    -0x34(%rbp),%eax
jle    13b1 <populate_gps_template+0x271>
movl   $0xffffffff,-0x4(%rbp)
jmp    14ae <populate_gps_template+0x36e>
cmpl   $0x0,-0x54(%rbp)
je     13f7 <populate_gps_template+0x2b7>
mov    -0x30(%rbp),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
mov    -0x34(%rbp),%esi
sub    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rdx
mov    (%rax,%rdx,8),%r8
lea    0xc24(%rip),%rdx
mov    $0x0,%al
call   1040 <snprintf@plt>
jmp    142e <populate_gps_template+0x2ee>
mov    -0x30(%rbp),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
mov    -0x34(%rbp),%esi
sub    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rdx
mov    (%rax,%rdx,8),%r8
lea    0xbea(%rip),%rdx
mov    $0x0,%al
call   1040 <snprintf@plt>
mov    -0x30(%rbp),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
call   1030 <strlen@plt>
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11a1 <populate_gps_template+0x61>
mov    -0x3c(%rbp),%eax
add    $0x3,%eax
cmp    -0x34(%rbp),%eax
jle    1474 <populate_gps_template+0x334>
movl   $0xffffffff,-0x4(%rbp)
jmp    14ae <populate_gps_template+0x36e>
mov    -0x30(%rbp),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
mov    $0x3,%esi
lea    0xb91(%rip),%rdx
mov    $0x0,%al
call   1040 <snprintf@plt>
mov    -0x3c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<populate_gps_template>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9d,0xc(%rsp)
mov    %rdx,0x20(%rsp)
mov    %rsi,%r13
mov    %rdi,%r15
lea    0xe9b(%rip),%rsi
mov    $0x2,%eax
mov    %rax,0x10(%rsp)
mov    %r8,0x18(%rsp)
mov    %r8,%rdi
mov    $0x2,%edx
call   1060 <memcpy@plt>
cmpq   $0x0,(%r15)
je     1383 <populate_gps_template+0x243>
mov    $0x2,%eax
mov    %rax,0x10(%rsp)
xor    %r12d,%r12d
movl   $0x0,0x8(%rsp)
xor    %ebp,%ebp
mov    %r13,0x38(%rsp)
mov    %r15,0x30(%rsp)
jmp    11c7 <populate_gps_template+0x87>
xchg   %ax,%ax
mov    %r14,%r15
add    $0x1,%ebp
cmpq   $0x0,0x8(%r15,%r12,1)
lea    0x8(%r12),%r12
je     1383 <populate_gps_template+0x243>
mov    0x0(%r13,%r12,1),%r14
mov    %r14,%rdi
call   1030 <strlen@plt>
mov    %r14,%rdi
lea    0xe25(%rip),%rsi
mov    %eax,%edx
call   1050 <strnstr@plt>
test   %rax,%rax
je     1300 <populate_gps_template+0x1c0>
mov    %r15,%r14
movslq %ebp,%r15
mov    0x20(%rsp),%rax
mov    (%rax,%r15,8),%rdi
test   %rdi,%rdi
je     11b0 <populate_gps_template+0x70>
call   1030 <strlen@plt>
test   %eax,%eax
jle    11b0 <populate_gps_template+0x70>
mov    %ebp,0x2c(%rsp)
mov    0x0(%r13,%r12,1),%rdi
call   1030 <strlen@plt>
mov    %eax,%ebp
mov    %r14,%r13
mov    (%r14,%r12,1),%rdi
call   1030 <strlen@plt>
mov    %r15,%rcx
mov    %eax,%r15d
mov    0x20(%rsp),%rbx
mov    %rcx,0x40(%rsp)
mov    (%rbx,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    0x10(%rsp),%r14
add    %r14d,%ebp
add    %r15d,%ebp
add    %ebp,%eax
add    $0x6,%eax
mov    0xc(%rsp),%r15d
cmp    %r15d,%eax
jg     13bf <populate_gps_template+0x27f>
movslq %r14d,%rax
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,1),%rbp
mov    %r15d,%esi
sub    %eax,%esi
cmpl   $0x0,0x8(%rsp)
mov    0x0(%r13,%r12,1),%rcx
lea    0xd86(%rip),%rdx
lea    0xd81(%rip),%rax
cmove  %rax,%rdx
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <snprintf@plt>
mov    %rbp,%rdi
call   1030 <strlen@plt>
add    %r14d,%eax
movslq %eax,%rbp
mov    0x18(%rsp),%rax
lea    (%rax,%rbp,1),%rbx
sub    %ebp,%r15d
mov    0x38(%rsp),%r13
mov    0x0(%r13,%r12,1),%rdx
mov    0x40(%rsp),%rax
mov    0x20(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
mov    %rbx,%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1040 <snprintf@plt>
mov    %rbx,%rdi
call   1030 <strlen@plt>
add    %ebp,%eax
mov    %rax,0x10(%rsp)
movl   $0x1,0x8(%rsp)
mov    0x30(%rsp),%r15
mov    0x2c(%rsp),%ebp
jmp    11b3 <populate_gps_template+0x73>
nopl   0x0(%rax)
mov    %ebp,%r14d
mov    0x0(%r13,%r12,1),%rdi
call   1030 <strlen@plt>
mov    %eax,%ebp
mov    (%r15,%r12,1),%rdi
call   1030 <strlen@plt>
mov    0x10(%rsp),%rbx
add    %ebx,%ebp
add    %ebp,%eax
add    $0x6,%eax
mov    0xc(%rsp),%esi
cmp    %esi,%eax
jg     13bf <populate_gps_template+0x27f>
movslq %ebx,%rbp
add    0x18(%rsp),%rbp
sub    %ebx,%esi
cmpl   $0x0,0x8(%rsp)
mov    (%r15,%r12,1),%rcx
mov    0x0(%r13,%r12,1),%r8
lea    0xcc0(%rip),%rdx
lea    0xcbb(%rip),%rax
cmove  %rax,%rdx
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <snprintf@plt>
mov    %rbp,%rdi
call   1030 <strlen@plt>
add    %eax,%ebx
mov    %rbx,0x10(%rsp)
movl   $0x1,0x8(%rsp)
mov    %r14d,%ebp
jmp    11b6 <populate_gps_template+0x76>
mov    0x10(%rsp),%rcx
lea    0x3(%rcx),%eax
mov    $0xffffffff,%ebp
cmp    0xc(%rsp),%eax
jg     13c4 <populate_gps_template+0x284>
movslq %ecx,%r14
mov    0x18(%rsp),%rbx
lea    (%rbx,%r14,1),%rdi
lea    0xc73(%rip),%rdx
xor    %ebp,%ebp
mov    $0x3,%esi
xor    %eax,%eax
call   1040 <snprintf@plt>
movb   $0x0,0x2(%rbx,%r14,1)
jmp    13c4 <populate_gps_template+0x284>
mov    $0xffffffff,%ebp
mov    %ebp,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"{ \00"
@.str.1 = [3 x i8] c"%s\00"
@.str.2 = [9 x i8] c", \22%s\22: \00"
@.str.3 = [7 x i8] c"\22%s\22: \00"
@.str.4 = [13 x i8] c", \22%s\22: \22%s\22\00"
@.str.5 = [11 x i8] c"\22%s\22: \22%s\22\00"
@.str.6 = [3 x i8] c" }\00"
define i32 @populate_gps_template(i8** %0, i8** %1, i8** %2, i32 %3, i8* %4, i32 %5) {
%7 = alloca i32
%8 = alloca i8**
%9 = alloca i8**
%10 = alloca i8**
%11 = alloca i32
%12 = alloca i8*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
store i8** %0, i8*** %8
store i8** %1, i8*** %9
store i8** %2, i8*** %10
store i32 %3, i32* %11
store i8* %4, i8** %12
store i32 %5, i32* %13
store i32 -1, i32* %14
store i32 0, i32* %15
store i32 0, i32* %16
store i32 0, i32* %17
%22 = load i8*, i8** %12
%23 = call i32 @memcpy(i8* %22, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32 2)
store i32 2, i32* %15
store i32 0, i32* %21
br label %24
24: ; preds = %223, %6
%25 = load i8**, i8*** %8
%26 = load i32, i32* %17
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i8*, i8** %25, i64 %27
%29 = load i8*, i8** %28
%30 = icmp ne i8* %29, null
br i1 %30, label %31, label %226
31: ; preds = %24
%32 = load i8**, i8*** %9
%33 = load i32, i32* %17
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i8*, i8** %32, i64 %34
%36 = load i8*, i8** %35
%37 = load i8**, i8*** %9
%38 = load i32, i32* %17
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8*, i8** %37, i64 %39
%41 = load i8*, i8** %40
%42 = call i32 @strlen(i8* %41)
%43 = call i64 @strnstr(i8* %36, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %42)
%44 = icmp ne i64 %43, 0
br i1 %44, label %45, label %154
45: ; preds = %31
%46 = load i8**, i8*** %10
%47 = load i32, i32* %16
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i8*, i8** %46, i64 %48
%50 = load i8*, i8** %49
%51 = icmp ne i8* %50, null
br i1 %51, label %52, label %151
52: ; preds = %45
%53 = load i8**, i8*** %10
%54 = load i32, i32* %16
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i8*, i8** %53, i64 %55
%57 = load i8*, i8** %56
%58 = call i32 @strlen(i8* %57)
%59 = icmp sgt i32 %58, 0
br i1 %59, label %60, label %151
60: ; preds = %52
%61 = load i32, i32* %15
%62 = load i8**, i8*** %9
%63 = load i32, i32* %17
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i8*, i8** %62, i64 %64
%66 = load i8*, i8** %65
%67 = call i32 @strlen(i8* %66)
%68 = add nsw i32 %61, %67
%69 = load i8**, i8*** %8
%70 = load i32, i32* %17
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8*, i8** %69, i64 %71
%73 = load i8*, i8** %72
%74 = call i32 @strlen(i8* %73)
%75 = add nsw i32 %68, %74
%76 = load i8**, i8*** %10
%77 = load i32, i32* %16
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds i8*, i8** %76, i64 %78
%80 = load i8*, i8** %79
%81 = call i32 @strlen(i8* %80)
%82 = add nsw i32 %75, %81
%83 = add nsw i32 %82, 6
%84 = load i32, i32* %13
%85 = icmp sgt i32 %83, %84
br i1 %85, label %86, label %87
86: ; preds = %60
store i32 -1, i32* %7
br label %244
87: ; preds = %60
%88 = load i32, i32* %21
%89 = icmp ne i32 %88, 0
br i1 %89, label %90, label %104
90: ; preds = %87
%91 = load i8*, i8** %12
%92 = load i32, i32* %15
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i8, i8* %91, i64 %93
%95 = load i32, i32* %13
%96 = load i32, i32* %15
%97 = sub nsw i32 %95, %96
%98 = load i8**, i8*** %8
%99 = load i32, i32* %17
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i8*, i8** %98, i64 %100
%102 = load i8*, i8** %101
%103 = call i32 (i8*, i32, i8*, ...) @snprintf(i8* %94, i32 %97, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), i8* %102)
br label %118
104: ; preds = %87
%105 = load i8*, i8** %12
%106 = load i32, i32* %15
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds i8, i8* %105, i64 %107
%109 = load i32, i32* %13
%110 = load i32, i32* %15
%111 = sub nsw i32 %109, %110
%112 = load i8**, i8*** %8
%113 = load i32, i32* %17
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i8*, i8** %112, i64 %114
%116 = load i8*, i8** %115
%117 = call i32 (i8*, i32, i8*, ...) @snprintf(i8* %108, i32 %111, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i8* %116)
br label %118
118: ; preds = %104, %90
%119 = load i8*, i8** %12
%120 = load i32, i32* %15
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i8, i8* %119, i64 %121
%123 = call i32 @strlen(i8* %122)
%124 = load i32, i32* %15
%125 = add nsw i32 %124, %123
store i32 %125, i32* %15
%126 = load i8*, i8** %12
%127 = load i32, i32* %15
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i8, i8* %126, i64 %128
%130 = load i32, i32* %13
%131 = load i32, i32* %15
%132 = sub nsw i32 %130, %131
%133 = load i8**, i8*** %9
%134 = load i32, i32* %17
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i8*, i8** %133, i64 %135
%137 = load i8*, i8** %136
%138 = load i8**, i8*** %10
%139 = load i32, i32* %16
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i8*, i8** %138, i64 %140
%142 = load i8*, i8** %141
%143 = call i32 (i8*, i32, i8*, ...) @snprintf(i8* %129, i32 %132, i8* %137, i8* %142)
%144 = load i8*, i8** %12
%145 = load i32, i32* %15
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds i8, i8* %144, i64 %146
%148 = call i32 @strlen(i8* %147)
%149 = load i32, i32* %15
%150 = add nsw i32 %149, %148
store i32 %150, i32* %15
store i32 1, i32* %21
br label %151
151: ; preds = %118, %52, %45
%152 = load i32, i32* %16
%153 = add nsw i32 %152, 1
store i32 %153, i32* %16
br label %223
154: ; preds = %31
%155 = load i32, i32* %15
%156 = load i8**, i8*** %9
%157 = load i32, i32* %17
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i8*, i8** %156, i64 %158
%160 = load i8*, i8** %159
%161 = call i32 @strlen(i8* %160)
%162 = add nsw i32 %155, %161
%163 = load i8**, i8*** %8
%164 = load i32, i32* %17
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds i8*, i8** %163, i64 %165
%167 = load i8*, i8** %166
%168 = call i32 @strlen(i8* %167)
%169 = add nsw i32 %162, %168
%170 = add nsw i32 %169, 6
%171 = load i32, i32* %13
%172 = icmp sgt i32 %170, %171
br i1 %172, label %173, label %174
173: ; preds = %154
store i32 -1, i32* %7
br label %244
174: ; preds = %154
%175 = load i32, i32* %21
%176 = icmp ne i32 %175, 0
br i1 %176, label %177, label %196
177: ; preds = %174
%178 = load i8*, i8** %12
%179 = load i32, i32* %15
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds i8, i8* %178, i64 %180
%182 = load i32, i32* %13
%183 = load i32, i32* %15
%184 = sub nsw i32 %182, %183
%185 = load i8**, i8*** %8
%186 = load i32, i32* %17
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i8*, i8** %185, i64 %187
%189 = load i8*, i8** %188
%190 = load i8**, i8*** %9
%191 = load i32, i32* %17
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds i8*, i8** %190, i64 %192
%194 = load i8*, i8** %193
%195 = call i32 (i8*, i32, i8*, ...) @snprintf(i8* %181, i32 %184, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.4, i64 0, i64 0), i8* %189, i8* %194)
br label %215
196: ; preds = %174
%197 = load i8*, i8** %12
%198 = load i32, i32* %15
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i8, i8* %197, i64 %199
%201 = load i32, i32* %13
%202 = load i32, i32* %15
%203 = sub nsw i32 %201, %202
%204 = load i8**, i8*** %8
%205 = load i32, i32* %17
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i8*, i8** %204, i64 %206
%208 = load i8*, i8** %207
%209 = load i8**, i8*** %9
%210 = load i32, i32* %17
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i8*, i8** %209, i64 %211
%213 = load i8*, i8** %212
%214 = call i32 (i8*, i32, i8*, ...) @snprintf(i8* %200, i32 %203, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i64 0, i64 0), i8* %208, i8* %213)
br label %215
215: ; preds = %196, %177
%216 = load i8*, i8** %12
%217 = load i32, i32* %15
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds i8, i8* %216, i64 %218
%220 = call i32 @strlen(i8* %219)
%221 = load i32, i32* %15
%222 = add nsw i32 %221, %220
store i32 %222, i32* %15
store i32 1, i32* %21
br label %223
223: ; preds = %215, %151
%224 = load i32, i32* %17
%225 = add nsw i32 %224, 1
store i32 %225, i32* %17
br label %24
226: ; preds = %24
%227 = load i32, i32* %15
%228 = add nsw i32 %227, 3
%229 = load i32, i32* %13
%230 = icmp sgt i32 %228, %229
br i1 %230, label %231, label %232
231: ; preds = %226
store i32 -1, i32* %7
br label %244
232: ; preds = %226
%233 = load i8*, i8** %12
%234 = load i32, i32* %15
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds i8, i8* %233, i64 %235
%237 = call i32 (i8*, i32, i8*, ...) @snprintf(i8* %236, i32 3, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%238 = load i32, i32* %15
%239 = add nsw i32 %238, 2
store i32 %239, i32* %15
%240 = load i8*, i8** %12
%241 = load i32, i32* %15
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds i8, i8* %240, i64 %242
store i8 0, i8* %243
store i32 0, i32* %7
br label %244
244: ; preds = %232, %231, %173, %86
%245 = load i32, i32* %7
ret i32 %245
}

LLVM IR (-O2):
@.str = [3 x i8] c"{ \00"
@.str.1 = [3 x i8] c"%s\00"
@.str.2 = [9 x i8] c", \22%s\22: \00"
@.str.3 = [7 x i8] c"\22%s\22: \00"
@.str.4 = [13 x i8] c", \22%s\22: \22%s\22\00"
@.str.5 = [11 x i8] c"\22%s\22: \22%s\22\00"
@.str.6 = [3 x i8] c" }\00"
define i32 @populate_gps_template(i8** nocapture %0, i8** nocapture %1, i8** nocapture %2, i32 %3, i8* %4, i32 %5) {
%7 = tail call i32 @memcpy(i8* %4, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32 2)
%8 = load i8*, i8** %0
%9 = icmp eq i8* %8, null
br i1 %9, label %93, label %10
10: ; preds = %6, %85
%11 = phi i64 [ %89, %85 ], [ 0, %6 ]
%12 = phi i8** [ %90, %85 ], [ %0, %6 ]
%13 = phi i32 [ %88, %85 ], [ 0, %6 ]
%14 = phi i32 [ %87, %85 ], [ 2, %6 ]
%15 = phi i32 [ %86, %85 ], [ 0, %6 ]
%16 = getelementptr inbounds i8*, i8** %1, i64 %11
%17 = load i8*, i8** %16
%18 = tail call i32 @strlen(i8* %17)
%19 = tail call i64 @strnstr(i8* %17, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %18)
%20 = icmp eq i64 %19, 0
br i1 %20, label %64, label %21
21: ; preds = %10
%22 = sext i32 %15 to i64
%23 = getelementptr inbounds i8*, i8** %2, i64 %22
%24 = load i8*, i8** %23
%25 = icmp eq i8* %24, null
br i1 %25, label %60, label %26
26: ; preds = %21
%27 = tail call i32 @strlen(i8* %24)
%28 = icmp sgt i32 %27, 0
br i1 %28, label %29, label %60
29: ; preds = %26
%30 = load i8*, i8** %16
%31 = tail call i32 @strlen(i8* %30)
%32 = load i8*, i8** %12
%33 = tail call i32 @strlen(i8* %32)
%34 = load i8*, i8** %23
%35 = tail call i32 @strlen(i8* %34)
%36 = add i32 %14, 6
%37 = add i32 %36, %31
%38 = add i32 %37, %33
%39 = add i32 %38, %35
%40 = icmp sgt i32 %39, %5
br i1 %40, label %104, label %41
41: ; preds = %29
%42 = icmp eq i32 %13, 0
%43 = sext i32 %14 to i64
%44 = getelementptr inbounds i8, i8* %4, i64 %43
%45 = sub nsw i32 %5, %14
%46 = load i8*, i8** %12
%47 = select i1 %42, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0)
%48 = tail call i32 (i8*, i32, i8*, ...) @snprintf(i8* %44, i32 %45, i8* %47, i8* %46)
%49 = getelementptr inbounds i8, i8* %4, i64 %43
%50 = tail call i32 @strlen(i8* %49)
%51 = add nsw i32 %50, %14
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i8, i8* %4, i64 %52
%54 = sub nsw i32 %5, %51
%55 = load i8*, i8** %16
%56 = load i8*, i8** %23
%57 = tail call i32 (i8*, i32, i8*, ...) @snprintf(i8* %53, i32 %54, i8* %55, i8* %56)
%58 = tail call i32 @strlen(i8* %53)
%59 = add nsw i32 %58, %51
br label %60
60: ; preds = %41, %26, %21
%61 = phi i32 [ %59, %41 ], [ %14, %26 ], [ %14, %21 ]
%62 = phi i32 [ 1, %41 ], [ %13, %26 ], [ %13, %21 ]
%63 = add nsw i32 %15, 1
br label %85
64: ; preds = %10
%65 = load i8*, i8** %16
%66 = tail call i32 @strlen(i8* %65)
%67 = load i8*, i8** %12
%68 = tail call i32 @strlen(i8* %67)
%69 = add i32 %14, 6
%70 = add i32 %69, %66
%71 = add i32 %70, %68
%72 = icmp sgt i32 %71, %5
br i1 %72, label %104, label %73
73: ; preds = %64
%74 = icmp eq i32 %13, 0
%75 = sext i32 %14 to i64
%76 = getelementptr inbounds i8, i8* %4, i64 %75
%77 = sub nsw i32 %5, %14
%78 = load i8*, i8** %12
%79 = load i8*, i8** %16
%80 = select i1 %74, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.4, i64 0, i64 0)
%81 = tail call i32 (i8*, i32, i8*, ...) @snprintf(i8* %76, i32 %77, i8* %80, i8* %78, i8* %79)
%82 = getelementptr inbounds i8, i8* %4, i64 %75
%83 = tail call i32 @strlen(i8* %82)
%84 = add nsw i32 %83, %14
br label %85
85: ; preds = %73, %60
%86 = phi i32 [ %63, %60 ], [ %15, %73 ]
%87 = phi i32 [ %61, %60 ], [ %84, %73 ]
%88 = phi i32 [ %62, %60 ], [ 1, %73 ]
%89 = add nuw i64 %11, 1
%90 = getelementptr inbounds i8*, i8** %0, i64 %89
%91 = load i8*, i8** %90
%92 = icmp eq i8* %91, null
br i1 %92, label %93, label %10
93: ; preds = %85, %6
%94 = phi i32 [ 2, %6 ], [ %87, %85 ]
%95 = add nsw i32 %94, 3
%96 = icmp sgt i32 %95, %5
br i1 %96, label %104, label %97
97: ; preds = %93
%98 = sext i32 %94 to i64
%99 = getelementptr inbounds i8, i8* %4, i64 %98
%100 = tail call i32 (i8*, i32, i8*, ...) @snprintf(i8* %99, i32 3, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%101 = add nsw i32 %94, 2
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i8, i8* %4, i64 %102
store i8 0, i8* %103
br label %104
104: ; preds = %64, %29, %93, %97
%105 = phi i32 [ 0, %97 ], [ -1, %93 ], [ -1, %29 ], [ -1, %64 ]
ret i32 %105
}