text:
Keyword Analysis & Research: hunter biden net worth estima
hunter biden net worth estima 0.4 0.1 6212 82 29
hunter 1.15 0.6 7549 66 6
biden 0.01 0.8 8385 88 5
net 1.77 0.5 3029 91 3
worth 1.06 0.4 6675 94 5
estima 1.7 0.8 2825 55 6
Keyword Research: People who searched hunter biden net worth estima also searched
hunter biden net worth estimation 1.74 0.9 360 36
hunter biden net worth estima 0.44 0.5 4774 20
hunter biden estimated net worth 0.17 0.3 2924 39
Search Results related to hunter biden net worth estima on Search Engine
Hunter Biden Net Worth | Celebrity Net Worth
celebritynetworth.com
https://www.celebritynetworth.com/richest-businessmen/lawyers/hunter-biden-net-worth/
Apr 09, 2021 · $1 Million Hunter Biden net worth and salary: Hunter Biden is an American lawyer and lobbyist who has a net worth of $1 million. Between 2014 and 2016 alone, Hunter reportedly earned $6 million...
Hunter Biden's Net Worth (Updated 2022) - Wealthy Gorilla
wealthygorilla.com
https://wealthygorilla.com/hunter-biden-net-worth/
Dec 13, 2021 · Biden was discharged from the U.S. Navy Reserve after he failed a drug test. He was a founding board member of BHR Partners. It served on the board of Burisma Holdings, which is one of the biggest private natural gas producers in Ukraine. As of 2022, Hunter Biden's net worth is estimated to be roughly $1 million. Age: 51 Country of Origin: United States of America Born: February 4, 1970 Source of Wealth: Lawyer
Born: February 4, 1970
Source of Wealth: Lawyer
Here's How Much Hunter Biden Is Really Worth
nickiswift.com
https://www.nickiswift.com/624404/heres-how-much-hunter-biden-is-really-worth/
Oct 06, 2021 · For some, Hunter Biden can be likened to Kendall Roy from "Succession." Yale-educated attorney, Navy vet, and first son, his net worth is estimated to be a mere $1 million, according to Celebrity ...
Hunter Biden net worth (Updated 2022)
vimbuzz.com
https://vimbuzz.com/hunter-biden-net-worth/
Jan 04, 2022 · Net worth of Hunter Biden. He earns his income from many different areas from being a lawyer, painter, lobbyist, investor among others. His estimated net worth at the age of 51 is $1 million to $3 million. READ ALSO👉 Luca de la Torre Salary & Net worth. Hunter Biden.
Hunter Biden Net Worth 2022: Age, Height, Weight, Wife
wealthypersons.com
https://www.wealthypersons.com/hunter-biden-net-worth-2020-2021/
Hunter Biden, who is known for his wealth, is one of the highest-paid consultants at various points in his career. Hunter owns a net worth of about $4 Million as of January 2022. It has been revealed that during his time in Burisma Board, he earned $850,000-$3 Million. He gathered nearly $50,000 per month during his time in his stay in Ukraine. Hunter Biden is a very intelligen… Age: 51 years old Gender: Male Celebrated Name: Hunter Biden Real Name/Full Name: Robert Hunter Biden
Hunter Biden, who is known for his wealth, is one of the highest-paid consultants at various points in his career. Hunter owns a net worth of about $4 Million as of January 2022. It has been revealed that during his time in Burisma Board, he earned $850,000-$3 Million. He gathered nearly $50,000 per month during his time in his stay in Ukraine. Hunter Biden is a very intelligen…
Celebrated Name: Hunter Biden
Real Name/Full Name: Robert Hunter Biden
Hunter Biden Net Worth 2022: Money, Salary, Bio - …
celebsmoney.com
https://www.celebsmoney.com/net-worth/hunter-biden/
How much money is Hunter Biden worth at the age of 51 and what's his real net worth now? As of 2022, Hunter Biden's net worth is $100,000 - $1M. DETAILS BELOW Hunter Biden (born February 4, 1970) is famous for being business executive. He currently resides in Wilmington, Delaware, USA.
How much tax does Hunter Biden pay? Here's his net …
meaww.com
https://meaww.com/hunter-biden-tax-pay-net-worth-trump-explosive-report-3-5-million-moscow-mayor-wife-elena-baturina
Sep 28, 2020 · With a net worth estimated to be in billions, Forbes reported this year that it has dropped "an estimated $600 million since last September to $2.5 billion and that puts him at #339 spot on The Forbes 400".
What is Hunter Biden's Net Worth? Joe Biden's Son …
newsweek.com
https://www.newsweek.com/what-hunter-biden-net-worth-lobbyist-hedge-fund-owner-consultant-board-1465463
Oct 16, 2019 · What is Hunter Biden's Net Worth? Joe Biden's Son Worked as a Lobbyist, Hedge Fund Owner, Consultant. By Blake Dodge On 10/15/19 at 8:00 PM EDT. Share.
Have Scandals And Lavish Living Ruined Hunter Biden's …
https://www.msn.com/en-us/news/us/have-scandals-and-lavish-living-ruined-hunter-biden-s-net-worth/ar-AASKuyp
Jan 13, 2022 · In 1977, Joe Biden married his second wife, Jill (now First Lady Jill Biden), who became stepmother to Beau and Hunter. She also had a …
Hunter Biden is worth $156 million | TigerDroppings.com
tigerdroppings.com
https://www.tigerdroppings.com/rant/politics/hunter-biden-is-worth-156-million/92459943/
Oct 14, 2020 · Hunter Biden is worth $156 million Posted by DavidTheGnome on 10/14/20 at 11:09 pm


Events transform the thumbnail bellow to go home hang a strand of table or being blown out by the house candles bulbs powered. Patio and special events transform the ordinary tent or rental space into a wedding chandelier dining room. Small battery operated chandelier, the backyard yard decoration that was beautiful beyond throwing place your home without blowing your home hang a wide variety of battery operated led gazebo chandelier shop with roses precious for your patio and special events transform the thumbnail bellow to install anywhere indoors. Outdoors gazebo chandelier. A chandelier. Desk lamp source. Stock from.


text: Q: How to compute the longest non-contiguous common sequence? LongestCommonSequence[] works well, but what about finding the longest common sub-sequence (not necessarily contiguous)? Is this function built in to the genome package? And it would really help me to know the big-o complexity for this function.

redpajama_set_name: RedPajamaStackExchange


There many people whose help and assistance I'd like to recognize.
Topping the list is my publisher at the Hawaii Reporter, Malia Zimmerman, and technical editor, R.N. Price. Kudos to longtime Hawaii newspaperman Mark Coleman, who copy-edited the book.
I'd also like to thank the Kalashnikov brain trust who helped immensely gathering the facts. These include Graham Baates, Denny Butts, Lyle Keeney, Marc Krebs, Jim Fuller, Chase Sisgold, Rob Ski, Tim Yan, Tim Harmsen, Justin McMillion, Mike Owen, Larry Vickers, Brian Takaba and Luke Williams. I also want to thank Jorge Amselle, Rick Davis, Michael N. Sutton, Fred Stecher, Mrgunsngear, Heather Edlander Walker, Kevin Reichard, Tim Parks and the guys at Echo Nine Three and the Uzibutton who kindly provided photos and great advice. Special thanks to Phil White, James Reeves and Brian Conrad for their assistance in making this book possible.
Mahalo nui loa to all of you.
How to buy an AK-47 provides a wealth of information and collected wisdom from the top builders, gunsmiths and experts. Whether you're an experienced shooter or a complete neophyte, this book will be helpful to anyone wanting to learn more about AKs.


text:
Q: why my proto file bytes type generate to c++ type is string *?

proto code
package mytest;

message RTKEY
{
   optional int64     id1  = 1;
   optional int64     id2  = 2;
};

message ControlArea
{
   optional RTKEY id        = 1;
   optional string name      = 2;
   optional RTKEY parent    = 3;
   optional int32 level     = 4;
   optional bool  remove_fg = 5;
}

c++ code
::mytest::RTKEY* id_;
::std::string* name_;
::mytest::RTKEY* parent_;
::google::protobuf::int32 level_;
bool remove_fg_;

why my proto file bytes type generate to c++ type is string *?

A: This is documented here: https://developers.google.com/protocol-buffers/docs/proto#scalar
Fields of bytes type will get the C++ type string. Your example though, does not include any bytes type fields. The std::string is a quite convenient container for storing an array of bytes.


text:
![The fwup pup](docs/fwup-pup.png)

# Overview
[![Build Status](https://travis-ci.org/fhunleth/fwup.svg?branch=master)](https://travis-ci.org/fhunleth/fwup)
[![Coverage Status](https://coveralls.io/repos/github/fhunleth/fwup/badge.svg)](https://coveralls.io/github/fhunleth/fwup)
[![Ebert](https://ebertapp.io/github/fhunleth/fwup.svg)](https://ebertapp.io/github/fhunleth/fwup)
[![Coverity Scan Build Status](https://scan.coverity.com/projects/4094/badge.svg)](https://scan.coverity.com/projects/4094)

The `fwup` utility is a configurable image-based firmware update utility for
embedded Linux-based systems. It has two modes of operation. The first mode
creates compressed archives containing root file system images, bootloaders,
and other image material. These can be distributed via websites, email or
update servers. The second mode applies the firmware images in a robust and
repeatable way. The utility has the following features:

  1. Uses standard ZIP archives to make debugging and transmission simple.

  2. Simple, but flexible configuration language to enable firmware
  updates on various platforms and firmware update policies.

  3. Streaming firmware update processing to simplify target storage requirements.

  4. Multiple firmware update task options per archive so that one
  archive can upgrade varying target configurations

  5. Basic disk partitioning and FAT filesystem manipulation

  6. Human and machine readable progress.

  7. Initialize or update SDCards on your development system whether you're
     running Linux, OSX, BSD, or Windows. MMC and SDCards are automatically
     detected and unmounted. No need to scan logs or manually unmount.

  8. Firmware archive digital signature creation and verification (BETA!!)

  9. Sparse file support to reduce number of bytes that need to be written when
     initializing large filesystems (see section on sparse files)

  10. Permissive license (Apache 2.0 License - see end of doc)

  11. Extensively regression tested! Tests also provide lots of simple examples.

This utility is based off of firmware update utilities I've written for various
projects. It has already received a lot of use with the open source Nerves
Project and other embedded projects.

# Examples!

See [bbb-buildroot-fwup](https://github.com/fhunleth/bbb-buildroot-fwup) for
firmware update examples for the BeagleBone Black and Raspberry Pi. The [Nerves
Project](https://github.com/nerves-project/nerves_system_br) has more examples
and is better maintained. The regression tests can also be helpful.

My real world use of `fwup` involves writing the new firmware to a place on the
Flash that's not in current use and then 'flipping' over to it at the very end.
The examples tend to reflect that. `fwup` can also be used to overwrite an
installation in place assuming you're using an initramfs, but that doesn't give
protection against someone pulling power at a bad time. Also, `fwup`'s one pass
over the archive feature means that firmware validation is mostly done on the
fly, so you'll want to verify the archive first (see the `-V` option).

# Installing

The simplest way to install `fwup` is via a package manager or installer.

On OSX, `fwup` is in [homebrew](http://brew.sh/):

    brew install fwup

On Linux, download and install the appropriate package for your platform:

  * [Debian/Ubuntu AMD64 .deb](https://github.com/fhunleth/fwup/releases/download/v0.15.4/fwup_0.15.4_amd64.deb)
  * [Raspbian armhf .deb](https://github.com/fhunleth/fwup/releases/download/v0.15.4/fwup_0.15.4_armhf.deb)
  * [RedHat/CentOS x86\_64 .rpm](https://github.com/fhunleth/fwup/releases/download/v0.15.4/fwup-0.15.4-1.x86_64.rpm)
  * Arch Linux - See [fwup package](https://aur.archlinux.org/packages/fwup-git/) on AUR
  * Buildroot - Support is included upstream since the 2016.05 release
  * Yocto - See [meta-fwup](https://github.com/fhunleth/meta-fwup)

On Windows, `fwup` can be installed from [chocolatey](http://chocolatey.org)

    choco install fwup

Alternatively, download the [fwup executable](https://github.com/fhunleth/fwup/releases/download/v0.15.4/fwup.exe)
and place it in your path.

If you're using another platform or prefer to build it yourself, download the
latest [source code release](https://github.com/fhunleth/fwup/releases/download/v0.15.4/fwup-0.15.4.tar.gz) or clone this repository. Then read one of the following files:

  * [Linux build instructions](docs/build_linux.md)
  * [OSX build instructions](docs/build_osx.md)
  * [Windows build instructions](docs/build_windows.md)
  * [Raspbian build instructions](docs/build_rpi.md)
  * [FreeBSD/NetBSD/OpenBSD build instructions](docs/build_bsd.md)

When building from source, please verify that the regression test pass
on your system (run `make check`) before using `fwup` in production. While
the tests usually pass, they have found minor issues in third party libraries in the
past that really should be fixed.

# Invoking

If you were given a `.fw` file and just want to install its contents on an
SDCard, here's an example run on Linux:
```
$ sudo fwup example.fw
Use 14.92 GiB memory card found at /dev/sdc? [y/N] y
100%
Elapsed time: 2.736s
```
If you're on OSX or Windows, leave off the call to `sudo`.

IMPORTANT: If you're using an older version of `fwup`, you'll have to specify
more arguments. Run: `fwup -a -i example.fw -t complete`

Here's a list of other options:

```
Usage: fwup [OPTION]...

Options:
  -a, --apply   Apply the firmware update
  -c, --create  Create the firmware update
  -d <file> Device file for the memory card
  -D, --detect List attached SDCards or MMC devices and their sizes
  -E, --eject Eject removeable media after successfully writing firmware.
  --no-eject Do not eject media after writing firmware
  --enable-trim Enable use of the hardware TRIM command
  -f <fwupdate.conf> Specify the firmware update configuration file
  -F, --framing Apply framing on stdin/stdout
  -g, --gen-keys Generate firmware signing keys (fwup-key.pub and fwup-key.priv)
  -i <input.fw> Specify the input firmware update file (Use - for stdin)
  -l, --list   List the available tasks in a firmware update
  -m, --metadata   Print metadata in the firmware update
  -n   Report numeric progress
  -o <output.fw> Specify the output file when creating an update (Use - for stdout)
  -p, --public-key-file <keyfile> A public key file for verifying firmware updates
  --private-key <key> A private key for signing firmware updates
  --progress-low <number> When displaying progress, this is the lowest number (normally 0 for 0%)
  --progress-high <number> When displaying progress, this is the highest number (normally 100 for 100%)
  --public-key <key> A public key for verifying firmware updates
  -q, --quiet   Quiet
  -s, --private-key-file <keyfile> A private key file for signing firmware updates
  -S, --sign Sign an existing firmware file (specify -i and -o)
  --sparse-check <path> Check if the OS and file system supports sparse files at path
  --sparse-check-size <bytes> Hole size to check for --sparse-check
  -t, --task <task> Task to apply within the firmware update
  -u, --unmount Unmount all partitions on device first
  -U, --no-unmount Do not try to unmount partitions on device
  -v, --verbose   Verbose
  -V, --verify  Verify an existing firmware file (specify -i)
  --version Print out the version
  -y   Accept automatically found memory card when applying a firmware update
  -z   Print the memory card that would be automatically detected and exit
  -1   Fast compression (for create)
  -9   Best compression (default)

Examples:

Create a firmware update archive:

  $ fwup -c -f fwupdate.conf -o myfirmware.fw

Apply the firmware to an attached SDCard. This would normally be run on the host
where it would auto-detect an SDCard and initalize it using the 'complete' task:

  $ fwup -a -i myfirmware.fw -t complete

Apply the firmware update to /dev/sdc and specify the 'upgrade' task:

  $ fwup -a -d /dev/sdc -i myfirmware.fw -t upgrade

Create an image file from a .fw file for use with dd(1):

  $ fwup -a -d myimage.img -i myfirmware.fw -t complete

Generate a public/private key pair:

  $ fwup -g
Store fwup-key.priv in a safe place and fwup-key.pub on the target. To sign
an existing archive run:
  $ fwup -S -s fwup-key.priv -i myfirmware.fw -o signedfirmware.fw
```

# Configuration file format

`fwup` uses the Unix configuration library,
[libconfuse](http://www.nongnu.org/confuse/), so its configuration has some
similarities to other programs. The configuration file is used to create
firmware archives. During creation, `fwup` embeds a processed version of the
configuration file into the archive that has been stripped of comments, has had
all variables resolved, and has some additional useful metadata added.
Configuration files are organized into scoped blocks and options are set using
a `key = value` syntax. Additionally, configuration files may include configuration
fragments and other files by calling `include("filename")`.

## Environment variables

For integration into build systems and other scripts, `fwup` performs
variable substitution inside of the configuration files. Keep in
mind that environment variables are resolved on the host during firmware update
file creation. Generated firmware files do not contain

Environment variables are referenced as follows:

    key = ${ANY_ENVIRONMENT_VARIABLE}

It is possible to provide default values for environment variables using the
`:-` symbol:

    key = ${ANY_ENVIRONMENT_VARIABLE:-adefault}

Inside configuration files, it can be useful to define constants that are used
throughout the file. Constants are referenced identically to environment
variables. Here is an example:

    define(MY_CONSTANT, 5)

By default, repeated definitions of the same constant do not change that
constant's value. In other words, the first definition wins. Note that the first
definition could come from a similarly named environment variable. This makes
it possible to override a constant in a build script.

In some cases, having the last definition win is preferable for constants that
never ever should be overriden by the environment or by earlier calls to
`define`. For this behavior, use `define!`:

    define!(MY_CONSTANT, "Can't override this")

Simple math calculations may also be performed using `define-eval()` and
`define-eval!()`. For example:

    define-eval(AN_OFFSET, "${PREVIOUS_OFFSET} + ${PREVIOUS_COUNT}")

These two functions were added in release 0.10.0, but since
they are evaluated at firmware creation time, .fw files created using them are
compatible with older versions of `fwup`.

## Global scope

At the global scope, the following options are available:

Key                  | Description
---------------------|------------
require-fwup-version | Require a minimum version of fwup to apply this update (currently informational only)
meta-product         | Product name
meta-description     | Description of product or firmware update
meta-version         | Firmware version
meta-author          | Author or company behind the update
meta-platform        | Platform that this update runs on (e.g., rpi or bbb)
meta-architecture    | Platform architectures (e.g., arm)
meta-vcs-identifier  | A version control identifier for use in reproducing this image
meta-misc            | Miscellaneous additional data. Format and contents are up to the user
meta-creation-date   | Timestamp when the update was created (automatically added). If you want to force the timestamp, set the `NOW` environment variable.
meta-fwup-version    | Version of fwup used to create the update (automatically added)

After setting the above options, it is necessary to create scopes for other options. The
currently available scopes are:

Scope                | Description
---------------------|------------
file-resource        | Defines a reference to a file that should be included in the archive
mbr                  | Defines the master boot record contents on the destination
task                 | Defines a firmware update task (referenced using -t from the command line)

## file-resource

A `file-resource` specifies a file on the host that should be included in the
archive. Each `file-resource` should be given a unique name so that it can be
referred to by other parts of the update configuration. `fwup` will
automatically record the length and BLAKE2b-256 hash of the file in the
archive. These fields are used internally to compute progress and verify the
contents of the archive. A typical `file-resource` section looks like this:

```
file-resource zImage {
        host-path = "output/images/zImage"
}
```

Resources are usually stored in the `data` directory of the firmware archive.
This is transparent for most users. If you need to make the `.fw` file
interoperate with other software, it is sometimes useful to embed a file into
the archive at another location. This can be done by specifying an absolute
path resource as follows:

```
file-resource "/my_custom_metadata" {
        host-path = "path/to/my_custom_metadata_file"
}
```

### Resource concatenation

Sometimes you need to concatenate multiple files together to form one
`file-resource`. While you can sometimes do this using multiple calls to
`raw_write`, that won't work if you don't know the file offsets a priori or the
offsets don't fall on block boundaries. Another alternative is to concatenate
files as a prep step to fwup. If that's inconvenient, `fwup` allows multiple
paths to be specified in `host-path` that are separated by semicolons. They
will be concatenated in the order they appear.

```
file-resource kernel_and_rootfs {
        # Concatenate uImage and the rootfs. OpenWRT mtd splitter will
        # separate them back out at runtime.
        host-path = "output/images/uImage;output/images/rootfs.squashfs"
}
```

### File resource validation checks

When creating archives, `fwup` can perform validation checking on file
resources to catch simple errors. These checks can catch common errors like
file resources growing too large to fit on the destination or files truncated
due to cancelled builds.

Note that these checks are not performed when applying updates, since the
actual length (and a hash) is recorded in the archive metadata and used for
verification.

The following checks are supported:

Check           | Description
----------------|------------
assert-size-lte | If the file size is not less than or equal the specified amount, report an error.
assert-size-gte | If the file size is not greater than or equal the specified amount, report an error.

Sizes are given in 512 byte blocks (like everything else in `fwup`).

Here's an example:

```
file-resource rootfs.img {
        host-path = "output/images/rootfs.squashfs"
        assert-size-lte = ${ROOTFS_A_PART_COUNT}
}
```

### Files from strings

Sometimes it's useful to create short files inside the `fwup` config file
rather than referencing them. This can be accomplished using the `contents` key
in a `file-resource`. Variable substitution works in the `contents` string just
like any other string in the `fwup` configuration file.

```
file-resource short-file.txt {
        contents = "You're looking at a short\n\
file creating by fwup.\n\
When it was made, FOO was ${FOO}.\n"
}
```

## mbr

A `mbr` section specifies the contents of the Master Boot Record on the
destination media. This section contains the partition table that's read by
Linux and the bootloaders for finding the file systems that exist on the media.
In comparison to a tool like `fdisk`, `fwup` only supports simplistic partition
setup, but this is sufficient for many devices. Tools such as `fdisk` can be
used to determine the block offsets and sizes of partitions for the
configuration file. Offsets and sizes are given in 512 byte blocks. Here's a
potential mbr definition:

```
mbr mbr-a {
        bootstrap-code-host-path = "path/to/bootstrap-data" # should be 440 bytes

        partition 0 {
                block-offset = ${BOOT_PART_OFFSET}
                block-count = ${BOOT_PART_COUNT}
                type = 0x1 # FAT12
                boot = true
        }
        partition 1 {
                block-offset = ${ROOTFS_A_PART_OFFSET}
                block-count = ${ROOTFS_A_PART_COUNT}
                type = 0x83 # Linux
        }
        partition 2 {
                block-offset = ${ROOTFS_B_PART_OFFSET}
                block-count = ${ROOTFS_B_PART_COUNT}
                type = 0x83 # Linux
        }
        partition 3 {
                block-offset = ${APP_PART_OFFSET}
                block-count = ${APP_PART_COUNT}
                type = 0x83 # Linux
        }
}
```

If you're using an Intel Edison or similar platform, `fwup` supports generation
of the OSIP header in the MBR. This header provides information for where to
load the bootloader (e.g.., U-Boot) in memory. The `include-osip` option
controls whether the header is generated. The OSIP and image record (OSII)
option names map directly to the header fields with the exception that length,
checksum and image count fields are automatically calculated. The following is
an example that shows all of the options:

```
mbr mbr-a {
    include-osip = true
    osip-major = 1
    osip-minor = 0
    osip-num-pointers = 1

    osii 0 {
        os-major = 0
        os-minor = 0
        start-block-offset = ${UBOOT_OFFSET}
        ddr-load-address = 0x01100000
        entry-point = 0x01101000
        image-size-blocks = 0x0000c000
        attribute = 0x0f
    }

    partition 0 {
        block-offset = ${ROOTFS_A_PART_OFFSET}
        block-count = ${ROOTFS_A_PART_COUNT}
        type = 0x83 # Linux
    }
}
```

## U-Boot environment

For systems using the U-Boot bootloader, some support is included for modifying
U-Boot environment blocks. In order to take advantage of this, you must declare
a `uboot-environment` section at the top level that describes how the
environment block:

```
uboot-environment my_uboot_env {
    block-offset = 2048
    block-count = 16
}
```

See the functions in the task section for getting and setting U-Boot variables.

NOTE: Currently, I've only implemented support for U-Boot environments that I
use. Notably, this doesn't support redundant environments, big endian targets,
and writes to raw NAND parts. Please consider contributing back support for
these if you use them.

If `fwup`'s U-Boot support does not meet your needs, it is always possible to
create environment images using the `mkenvimage` utility and `raw_write` them
to the proper locations. This is probably more appropriate when setting lots of
variables.

## task

The `task` section specifies a firmware update task. These sections are the
main part of the firmware update archive since they describe the conditions
upon which an update is applied and the steps to apply the update. Each `task`
section must have a unique name, but when searching for a task, the firmware
update tool only does a prefix match. This lets you define multiple tasks that
can be evaluated based on conditions on the target hardware. The first matching
task is the one that gets applied. This can be useful if the upgrade process is
different based on the version of firmware currently on the target, the target
architecture, etc. The following table lists the supported constraints:

Constraint                                         | Min fwup version | Description
---------------------------------------------------|------------------|------------
require-fat-file-exists(block_offset, filename)    | 0.7.0 | Require that a file exists in the specified FAT filesystem
require-fat-file-match(block_offset, filename, pattern) | 0.14.0 | Require that filename exists and that pattern matches bytes inside of the file
require-partition-offset(partition, block_offset)  | 0.7.0 | Require that the block offset of a partition be the specified value
require-path-on-device(path, device)               | 0.13.0 | Require that the specified path (e.g., "/") is on the specified device (e.g., "/dev/mmcblk0p1")
require-uboot-variable(my_uboot_env, varname, value) | 0.10.0 | Require that a variable is set to the specified value in the U-Boot environment

*More constraints to be added as needed*

The remainder of the `task` section is a list of event handlers. Event handlers
are organized as scopes. An event handler matches during the application of a
firmware update when an event occurs. Events include initialization,
completion, errors, and files being decompressed from the archive. Since
archives are processed in a streaming manner, the order of events is
deterministic based on the order that files were added to the archive. If it is
important that one event happen before another, make sure that `file-resource`
sections are specified in the desired order. The following table lists
supported events:

Event                         | Description
------------------------------|------------
on-init                       | First event sent when the task is applied
on-finish                     | Final event sent assuming no errors are detected during event processing
on-error                      | Sent if an error occurs so that intermediate files can be cleaned up
on-resource <resource name>   | Sent as events occur. Currently, this is sent as `file-resources` are processed from the archive.

The event scopes contain a list of actions. Actions can format file systems, copy files to file systems or
write to raw locations on the destination.

Action                                  | Min fwup version | Description
----------------------------------------|------------------|------------
error(message)                          | 0.12.0 | Immediately fail a firmware update with an error
fat_mkfs(block_offset, block_count)     | 0.1.0 | Create a FAT file system at the specified block offset and count
fat_write(block_offset, filename)       | 0.1.0 | Write the resource to the FAT file system at the specified block offset
fat_attrib(block_offset, filename, attrib) | 0.1.0 | Modify a file's attributes. attrib is a string like "RHS" where R=readonly, H=hidden, S=system
fat_mv(block_offset, oldname, newname)  | 0.1.0 | Rename the specified file on a FAT file system
fat_mv!(block_offset, oldname, newname) | 0.14.0 | Rename the specified file even if newname already exists.
fat_rm(block_offset, filename)          | 0.1.0 | Delete the specified file
fat_mkdir(block_offset, filename)       | 0.2.0 | Create a directory on a FAT file system. This also succeeds if the directory already exists.
fat_setlabel(block_offset, label)       | 0.2.0 | Set the volume label on a FAT file system
fat_touch(block_offset, filename)       | 0.7.0 | Create an empty file if the file doesn't exist (no timestamp update like on Linux)
info(message)                           | 0.13.0 | Print out an informational message
mbr_write(mbr)                          | 0.1.0 | Write the specified mbr to the target
raw_memset(block_offset, block_count, value) | 0.10.0 | Write the specified byte value repeatedly for the specified blocks
raw_write(block_offset)                 | 0.1.0 | Write the resource to the specified block offset
trim(block_offset, count)               | 0.15.0 | Discard any data previously written to the range. TRIM requests are issued to the device if --enable-trim is passed to fwup.
uboot_recover(my_uboot_env)             | 0.15.0 | If the U-Boot environment is corrupt, reinitialize it. If not, then do nothing
uboot_clearenv(my_uboot_env)            | 0.10.0 | Initialize a clean, variable free U-boot environment
uboot_setenv(my_uboot_env, name, value) | 0.10.0 | Set the specified U-boot variable
uboot_unsetenv(my_uboot_env, name, value) | 0.10.0 | Unset the specified U-boot variable

## Sparse files

Sparse files are files with gaps in them that are only represented on the
filesystem in metadata. Not all filesystems support sparse files, but in
general, Linux has good support. Creating a sparse file is easy: just seek to a
location past the end of file and write some data. The gap is "stored" as a
hole in the filesystem metadata. Data is read back from the hole as zeros. Data
and holes are restricted to start and end on filesystem block boundaries, so
small gaps may be filled in with zeros rather than being stored as a hole.

Why is this important? If you're using `fwup` to write a large EXT2 partition,
you'll find that it contains many gaps. It would be better to just write the
EXT2 data and metadata without filling in all of the unused space. Sparse file
support in `fwup` lets you do that. Since EXT2 filesystems legitimately contain
long runs of zeros that must be written to Flash, `fwup` queries the filesystem
containing the EXT2 data to find the gaps. Other tools like `dd(1)` only look
for runs of zeros so their sparse file support cannot be used to emulate this.
You may see warnings about copying sparse files to Flash and it has to do with
tools not writing long runs of zeros. The consequence of `fwup` querying the
filesystem for holes is that this feature only works when firmware update
archives are created on operating systems and filesystems that support it. Of
course, firmware updates can be applied on systems without support for querying
holes in files. Those systems also benefit from not having to write as much to
Flash devices. If you instead apply a firmware update to a normal file, though,
the OS will likely fill in the gaps with zeros and thus offer no improvement.

There is one VERY important caveat with the sparse file handling: Some zeros in
files are important and some are not. If runs in zeros in a file are important
and they are written to a file as a "hole", `fwup` will not write them back.
This is catastrophic if the zeros represent things like free blocks on a
filesystem. Luckily, the file system formatting utilities write the important
zeros to the disk and the OS does not scan bytes to see which ones are runs on
zeros and automatically create holes. Programs like `dd(1)` can do this, though,
so it is crucial that you do not run files through `dd` to make then sparser
before passing them to `fwup`.

# Firmware authentication

Firmware archives can be authenticated using a simple public/private key
scheme. To get started, create a public/private key pair by invoking `fwup -g`.
The algorithm used is [Ed25519](http://ed25519.cr.yp.to/). This generates two
file: `fwup-key.pub` and `fwup-key.priv`. It is critical to keep the signing
key, `fwup-key.priv` secret.

To sign an archive, pass `-s fwup-key.priv` to fwup when creating the firmware.
The other option is to sign the firmware archive after creation with `--sign`
or `-S`.

To verify that an archive has been signed, pass `-p fwup-key.pub` on the
command line to any of the commands that read the archive. E.g., `-a`, `-l` or
`-m`.

It is important to understand how verification works so that the security of
the archive isn't compromised. Firmware updates are applied in one pass to
avoid needing a lot of memory or disk space. The consequence of this is that
verification is done on the fly. The main metadata for the archive is always
verified before any operations occur. Cryptographic hashs (using the
[BLAKE2b-256](https://blake2.net/) algorithm) of each file contained in the
archive is stored in the metadata. The hash for each file is computed on the
fly, so a compromised file may not be detected until it has been written to
Flash. Since this is obviously bad, the strategy for creating firmware updates
is to write them to an unused location first and then switch over at the last
possible minute. This is desirable to do anyway, since this strategy also
provides some protection against the user disconnecting power midway through
the firmware update.

# Integration with applications

It is expected that many users will want to integrate `fwup` with their
applications. Many operations can be accomplished by just invoking the `fwup`
executable and parsing the text written to `stdout`. When applying firmware
progress updates are delivered based on commandline options:

  1. Human readable - This is the default. Progress is updated from the text `0%` to `100%`.
  2. Numeric (`-n`) - Progess is printed as `0\n` to `100\n`
  3. Quiet (`-q`) - No progress is printed

While the above works well for scripts and when errors can be seen by the
operator, `fwup` supports a structured use of `stdin`/`stdout` as well. Specify
the `--framing` option to any of the commands to use this option.

The framing feature is influenced by the Erlang VM's port API and should be
relatively easy to integrate with non-Erlang VM languages. The framing works
around deficiencies in the built-in interprocess communication. For example, by
enabling framing, a program can stream a firmware update through `fwup's`
`stdin` without needing to close its `stdout` to signal end of file. Another
feature aided by framing is knowing what text goes together and whether the
text is part of an error message or not. Exit status is still an indicator of
success or failure, but the controlling application doesn't need to wait for
the program to exit to know what happened.

In `--framing` mode, all communication with `fwup` is done in packets (rather
than byte streams). A packet starts with a 4 byte length field. The length is a
big endian (network byte order) unsigned integer. A zero-length packet (i.e., 4
bytes of zeros) signals end of input.

Field          | Size         | Description
---------------|--------------|-------------
Length         | 4 bytes      | Packet length as a big endian integer
Data           | Length bytes | Payload

Input and output packets have different formats. For sending input to `fwup`
(like when streaming a `.fw` file using stdio), the input bytes should be
framed into packets however is most convenient. For example, if bytes are
received in 4K chunks, then they can be sent to `fwup` in 4K packets with a
zero-length packet at the end. The packets need not be the same size.

All output packets from `fwup` have a 2 byte type field at the beginning of the
packet:

Field          | Size           | Description
---------------|----------------|-------------
Length         | 4 bytes        | Packet length as a big endian integer
Type           | 2 bytes        | See below
Data           | Length-2 bytes | Payload

The following types are defined:

Type           | 2 byte value | Description
---------------|--------------|------------
Success        | "OK"         | The command was executed successfully. The payload is a 2 bytes result code (currently 0 for success) followed by an optional textual message.
Error          | "ER"         | A failure occurred. The payload is a 2 byte error code (future use) followed by a textual error message.
Warning        | "WN"         | A warning occurred. The payload is a 2 byte error code (future use) followed by a textual error message.
Progress       | "PR"         | The next two bytes are the progress (0-100) as a big endian integer.

# FAQ

## How do I include a file in the archive that isn't used by fwup?

The scenario is that you need to store some metadata or some other information
that is useful to another program. For example, you'd like to include some
documentation or other notes inside the firmware update archive that the
destination device can pull out and present on a UI. To do this, just add
`file-resource` blocks for each file. These blocks don't need to be referenced
by an `on-resource` block.

## How do I include the firmware version in the archive?

If you are using git, you can invoke `fwup` as follows:

    GITDESCRIBE=`git describe` fwup -c -f myupdate.conf -o out.fw

Then in `myupdate.conf` add the line:

    meta-version = "${GITDESCRIBE}"

On the target device, you can retrieve the version by using `-m`. For example:

    $ fwup -m -i out.fw
    meta-product = "Awesome product"
    meta-description = "A description"
    meta-version = "v0.0.1"
    meta-author = "Me"
    meta-platform = "bbb"
    meta-architecture = "arm"
    meta-creation-date = "2014-09-07T19:50:57Z"

## What's something cool that you can do with fwup?

Ok, this isn't really a FAQ, but for some reason people think this is cool. Many
systems that I work on are network connected with ssh. Sometimes I update them
by doing this:

    $ cat mysoftware.fw | ssh root@192.168.1.20 \
        'fwup -a -U -d /dev/mmcblk2 -t upgrade && reboot'

The ability to pipe software updates through `fwup` comes in handy. This has
also gotten me out of situations where, for whatever reason, I no longer had enough
space to store the update on the device.

## How do I debug?

I apply updates to regular files on my laptop (as opposed to eMMC or SDCards)
and examine them with a hex editor. A few other routes might be useful too:

1. Unzip the .fw file to inspect the contents. It's a regular ZIP file and
   the `meta.conf` file inside it is the stripped down view of what your
   configuration looks like after variable substitution, etc.
2. Add the `error()` function to do printf-style debugging.
3. Find an image that works and skip updating some sections. For example,
   some processors are very picky on the MBR contents and it's easier to
   get everything else working before tackling partition constraints.

## How do I get the best performance?

In general, `fwup` writes to Flash memory in large blocks so that the update
can occur quickly. Obviously, reducing the amount that needs to get written
always helps. Beyond that, most optimizations are platform dependent. Linux
caches writes so aggressively that writes to Flash memory are nearly as fast as
possible. OSX, on the other hand, does very little caching, so doing things
like only working with one FAT filesystem at a time can help. In this case,
`fwup` only caches writes to one FAT filesystem at a time, so mixing them will
flush caches. OSX is also slow to unmount disks, so keep in mind that
performance can only be so fast on some systems.

## How do I update /dev/mmcblock0boot0?

The special eMMC boot partitions are updateable the same way as the main
partition. When I create .fw files for manufacturing, I create two targets, a
`complete` target that updates the main eMMC and a `bootloader` target that
updates `mmcblock0boot0`. The manufacturing script runs `fwup` twice: once for
the `complete` target and then again for the `bootloader` target.

Also, the `/dev/mmcblock0boot0` device is forced read-only by the kernel. To
unlock it, run:

    $ echo 0 > /sys/block/mmcblk0boot0/force_ro

## How do you pronounce fwup?

I used to pronounce it "eff-double-you-up", but then coworkers and others started calling
it "fwup" (one syllable) and "fwup-dates" when referring to the `.fw` files.
I now use the one syllable version. This has caused some issues in the
documentation where "an" is used rather than "a". Feel free to send PRs.

# Licenses

This utility contains source code with various licenses. The bulk of the code is
licensed with the Apache 2.0 license which can be found in the `LICENSE` file.

All 3rd party source code can be found in the `3rdparty` directory.

The FAT filesystem code (FatFs) comes from http://elm-chan.org/fsw/ff/00index_e.html
and has the following license:

```
FatFs module is a generic FAT file system module for small embedded systems.
This is a free software that opened for education, research and commercial
developments under license policy of following terms.

 Copyright (C) 2015, ChaN, all right reserved.

* The FatFs module is a free software and there is NO WARRANTY.
* No restriction on use. You can use, modify and redistribute it for
  personal, non-profit or commercial products UNDER YOUR RESPONSIBILITY.
* Redistributions of source code must retain the above copyright notice.
```

On systems without the function strptime(), a version from Google is
included that is distributed under the Apache 2.0 license.

redpajama_set_name: RedPajamaGithub


Sana Hemp Juice CBDA Tincture is made from 100% raw hemp juice and contains the full spectrum of essential nutrients found within this amazing leafy-green vegetable, with the added advantage of containing large amounts of Cannabidiolic acid (CBDA), a unique cannabinoid derived from the leaves and flowers of the legally grown Dutch industrial hemp plant.
Once a day (preferably before breakfast) place 3-6 drops Sana Hemp Juice CBDA tincture under the tongue, hold for up to 30 seconds and then swallow OR dissolve in ¼ glass of water or juice and drink immediately.
Vegetarian glycerin, purified Aqua, Hemp juice powder, Citric Acid, Rosemary Extract, Xanthan gum, potassium sorbate.


Find out what's cooking in your city and get delighted with the best food variety available to satisfy your taste buds. The listed restaurants are the best possible outlets for all the foodies. Get insight on restaurants mentioning their menu style, location, pricing and more. So grab a bite and feel light as good food means good mood.
Use of wood and exposed brick walls is the signature interior effort of this casual dinning outlet. Its ambiance gets you in a relaxing and calm mood, be it a lunch with friends or dinner with family. A blend of Indian, American, Mediterranean or Oriental food available for veggies or non-veggies. You get to experience a warmth of barbeque embedded at you table offering a special feature of 'Live Grill'. So, grill your own starters according to your taste n admire the uniqueness of this concept. Also indulge your spirit into the best wines and liquor and set yourself free.
A brew pub in Bangalore, Toit offers a culture perfect for the youth with fabulous food, exotic ambiance and wonderful experience of beer. A really good soul food with variety of menu lends to the experience you would love to have again and again. From pizzas cooked in kilns to the mouthwatering dessert, you will find it all here. So visit and satisfy your urge of taste.
With the signature Smoke House twist, experience the journey of delicious food, culinary avenue. The interiors are charming, whimsical with all white and bright.The menu has excellent vegetarian and non-vegetarian fare, and is extensive in variety. Perfect for a Sunday brunch or a Saturday dine out with friends. Smoke House Deli will definitely become one of your favorite restaurants.
If you are a night person and wish to spend your evening in romantic ambiance, this place is perfect for you. Team up with right ambiance and delicious food with magnificent surroundings. The view of city from 13th floor with cool breeze is apt for romantic dine out. Serves vegetarian as well as non-vegetarian food along with finest liquor.
Skyye brings the world to your doorstep with global cuisines to excite your taste buds like never before. To appeal your mood and taste buds, Skyye offers variety of style from American to Middle-East, Europe to Asia and more. Over the top of your meals satisfy your sweet tooth craving by heavenly dessert. Also serves one of the finest liquors. Huge glass floor with loud lights that gives place a certain Oomph factor and appeal for perfect evening. Relish Bangalore's skyline with cool breeze, this place is heaven on Earth.
Bon South in Koramangala is a place that has been getting more than its fair share of hype recently. Simple, decent ambiance for passionate minds stirred by a fresh wave of thinking, without compromising even an ounce of quality. One of the best dine spread for both young and mature guests.
This place has both an outdoor and indoor seating. One complete side of the wall is made up into bookshelves which houses quite a good collection of books. Spend a lazy afternoon with mouth watering food, sober ambiance and your favorite book in hand. Other than good food, you also get to enjoy pleasing music that relaxes you completely from head to toe. The new concept of ordering food through i-pads is additional feature you would not find just anywhere.
Situated on the top floor, you can have a bird's eye view from this restaurant. Offers you quite interesting food with amazing decor including marvelous masterpieces. Other than normal menu system, Ji Hazoor serves buffet system too, so you can choose your food items and in quite a decent amount of cost. Not only the food, but the ambiance is designed specially to give a relaxing experience to the guests with moderate lighting and comfortable furniture. So spend a sinful indulgence with variety of cuisines.
For all the sea food lovers, this place is apt for you. Beautiful layout, pleasing ambiance, delicious food, comfortable seating, and lots more. What more would you ask for. The restaurant is designed with concept of hatched roof, giving it a complete beach side appearance with typical style of dark furniture used. Beautiful use of lighting giving warmth to your eyes.
Experience a sensational ambiance with refreshing menu of drinks, snacks, appetizers and more. A unique dinning space you must have not experienced before. Without a doubt this place is amazingly suitable for all the young-chaps for their casual hangouts without getting hefty on their pockets. The over all sitting zone is designed with casual theme. Spice up your taste buds with this fascinating restaurant.
Fall in love with food all over again. Bon Appetit!!
I have had dinner with my team in 13th floor restaurant. We enjoyed food along with watching the Bangalore city.


To access the entry forms, click on the entry forms below. If you register on SEJ.org and are signed in, your contact information will autofill. Please note that registrations are not automatically approved. SEJ will make every effort to approve your registration on sej.org in a timely way, but if you register after 11pm eastern time, you will most likely have to wait until morning to be approved.
Already registered? Sign in to enable autofill on your entry form. To reset your password, get help here . If you forget your username, email the SEJ office.
Below you will find the definitions and entry forms for SEJ's 2015 categories. When you have selected your category, prepare the materials you will need for entering. Once your materials are assembled, click the name of the category (below) to open the online form. Follow the instructions at the top of the form. Some fields have instructions written below them. Please take note of all instructions!
• Radio entries: MP3 files, 20MB max.
Note: Cover letters are no longer required. If you want to include a cover letter, you can upload it along with other supplemental materials in the space provided.
** Series that begin or end during the designated contest period qualify in their entirety.
If you are unable to reduce your file to 20MB, email Awards Director Chris Bruggers or call her at (502) 641-1844.
Book entries: Enter the contest using the online entry form below. After submitting your form and payment, ship four copies of your book and a printout of the online entry form to Chris Bruggers, Director of Awards (address below). Note: even if you ship your entries, you must still complete an online form. ELECTRONIC BOOKS: Include detailed instructions on how to access the book. Please include the formats available to read the book. If a special reader app is needed, supply the name of the app to seach for in the entry form's "Reader App" field. If your book cannot be accessed without payment, you must supply the cost of four books plus $1.38 for postage so the director can send reimbursements to judges. If the reader app must be purchased, include the cost for four purchases. Make your check out to Christine Bruggers, SEJ Awards Director, and send to the address listed below. Please don't make your check out to SEJ or send to the SEJ office because this will cause delays in getting your book to judges.
Print entries: low-resolution PDF of your entry stories. (Check your category for the allowable number of stories and other details.) (Help with low-resolution or combined PDFs) If you are unable to supply links or low-res PDFs, you may ship four copies of your entries to awards director Chris Bruggers at the address listed below. Please include a printout of the online form. Be sure to follow the preparation rules. Note: even if you ship your entries, you must still complete an online form.
Online and broadcast entries: web links to Internet pages where your television, radio or online news story can be viewed or listened to. Radio entries may upload MP3 files (20MB maximum) (Check your category for the allowable number of stories and other details.) If you are unable to supply links, you may ship four copies of your entries to awards director Chris Bruggers at the address listed below. Please include a copy of the online form. Be sure to follow the preparation rules. Note: even if you ship your entries, you must still complete an online form.
To enter SEJ's awards contest at this rate, you must complete a membership application. Please note on your application in the comments field at the end that you are applying for membership with your contest entry.) Please complete your membership application as soon as possible after submitting your entry.
This special discounted $80 fee is only for non-members who are joining SEJ for the first time. It covers your first year of membership (discounted) as well as the contest fee.
Read the descriptions carefully, then click on the name of the category you want to enter to open the corresponding entry form. Have your electronic files and web links ready. You can save a draft of the entry form to complete later, but once you click submit, you won't be able to access the form. If you need to change or add anything, contact Chris Bruggers.
CLICK TO ENTER: Kevin Carmody Award for Outstanding In-depth Reporting, Large Market: An investigative report or series on a single environmental topic, published between March 1, 2014, and February 28, 2015. Related stories published on the same day count as one part. TV & Radio stories must not exceed 60 minutes; Print and Online series must not exceed five parts. Multimedia links may be included as supplemental materials. Eligibility: Print media: circulation of 200,000 average daily circulation or more, according to the latest audited figures; TV & Radio: national networks in the U.S. and elsewhere and top 20 markets in the U.S. as determined by Nielsen; Online: Online news organizations with 50 or more employees. Small-market entities collaborating with large-market entities qualify as large-market. PDF or MP3 files, 20MB max, or links are accepted.
CLICK TO ENTER: Kevin Carmody Award for Outstanding In-depth Reporting, Small Market: An investigative report or series on a single environmental topic, published between March 1, 2014, and February 28, 2015. Related stories published on the same day count as one part. TV & Radio stories must not exceed 60 minutes; Print and Online series must not exceed five parts. Multimedia links may be included as supplemental materials. Eligibility: All outlets and publications falling outside the large-market definition. Small-market entities collaborating with large-market entities qualify as large-market. PDF or MP3 files, 20MB max, or links are accepted.
CLICK TO ENTER: Outstanding Beat Reporting, Large Market: Up to five broadcast or published news reports and/or commentary on a broad range of environmental topics published between March 1, 2014, and February 28, 2015. Entry must be the work of an individual, either alone or with a small supporting team. Related stories published or aired on the same day count as one story. TV & Radio entries must have a combined total running time of no more than 60 minutes. Eligibility: Print media: circulation of 200,000 average daily circulation or more, according to the latest audited figures; TV & Radio: national networks in the U.S. and elsewhere and top 20 markets in the U.S. as determined by Nielsen; Online: Online news organizations with 50 or more employees. Small-market entities collaborating with large-market entities qualify as large-market. PDF or MP3 files, 20MB max, or links are accepted.
CLICK TO ENTER: Outstanding Beat Reporting, Small Market: Up to five broadcast or published news reports and/or commentary on a broad range of environmental topics published between March 1, 2014, and February 28, 2015. Entry must be the work of an individual, either alone or with a small supporting team. Related stories published or aired on the same day count as one story. TV & Radio entries must have a combined total running time of no more than 60 minutes. Eligibility: All TV, Radio, Print and Online publications falling outside the large-market definition. Small-market entities collaborating with large-market entities qualify as large-market. PDF or MP3 files, 20MB max, or links, are accepted.
CLICK TO ENTER: Rachel Carson Environment Book Award: A nonfiction book, published between January 1 and December 31, 2014, covering an environmental topic. Memoirs and picture books are not eligible.
CLICK TO ENTER: Outstanding Feature Story: One environmental interest story not directly tied to a recent news event with an emphasis on storytelling, while also including an explanatory aspect that sheds light on our environment and gives details to concepts or ideas. Entries must be about environmental issues and published between March 1, 2014 and February 28, 2015. Multi-part stories, sidebars and other supplemental material are prohibited. Eligibility: All TV, Radio, Print and Online entities. PDF or MP3 files, 20MB max, or links are accepted.
CLICK TO ENTER: Outstanding Photography: Up to five photographs on one or more environmental topics, published between March 1, 2014 and February 28, 2015. Only photos published as photojournalism will be accepted. Entered photos must not be manipulated or digitally enhanced in a way that changes the content and/or context of the image. A caption that describes the event or situation captured in the photograph must be included for each photo entered. Photos must be submitted as JPEG files, maximum 2MB.