Please complete the following functions in "queue.c" using C. This must use the dynamic array provided in "dynarray.c"

--------------------------------------------------------------------------------------------

//queue.c

#include <stdlib.h>

#include "queue.h"
#include "dynarray.h"

/*
* This is the structure that will be used to represent a queue. This
* structure specifically contains a single field representing a dynamic array
* that should be used as the underlying data storage for the queue.
*
* You should not modify this structure.
*/
struct queue {
struct dynarray* array;
};

/*
* This function should allocate and initialize a new, empty queue and return
* a pointer to it.
*/
struct queue* queue_create() {
return NULL;
}

/*
* This function should free the memory associated with a queue. While this
* function should up all memory used in the queue itself, it should not free
* any memory allocated to the pointer values stored in the queue. This is the
* responsibility of the caller.
*
* Params:
* queue - the queue to be destroyed. May not be NULL.
*/
void queue_free(struct queue* queue) {
return;
}

/*
* This function should indicate whether a given queue is currently empty.
* Specifically, it should return 1 if the specified queue is empty (i.e.
* contains no elements) and 0 otherwise.
*
* Params:
* queue - the queue whose emptiness is being questioned. May not be NULL.
*/
int queue_isempty(struct queue* queue) {
return 1;
}

/*
* This function should enqueue a new value into a given queue. The value to
* be enqueued is specified as a void pointer. This function must have O(1)
* average runtime complexity.
*
* Params:
* queue - the queue into which a value is to be enqueued. May not be NULL.
* val - the value to be enqueued. Note that this parameter has type void*,
* which means that a pointer of any type can be passed.
*/
void queue_enqueue(struct queue* queue, void* val) {
return;
}

/*
* This function should return the value stored at the front of a given queue
* *without* removing that value. This function must have O(1) average runtime
* complexity.
*
* Params:
* queue - the queue from which to query the front value. May not be NULL.
*/
void* queue_front(struct queue* queue) {
return NULL;
}

/*
* This function should dequeue a value from a given queue and return the
* dequeued value. This function must have O(1) average runtime complexity.
*
* Params:
* queue - the queue from which a value is to be dequeued. May not be NULL.
*
* Return:
* This function should return the value that was dequeued.
*/
void* queue_dequeue(struct queue* queue) {
return NULL;
}

------------------------------------------------

// dynarray.c

#include <stdlib.h>
#include <assert.h>

#include "dynarray.h"

/*
* This structure is used to represent a single dynamic array.
*/
struct dynarray {
void** data;
int size;
int capacity;
};

#define DYNARRAY_INIT_CAPACITY 4

/*
* This function allocates and initializes a new, empty dynamic array and
* returns a pointer to it.
*/
struct dynarray* dynarray_create() {
struct dynarray* da = malloc(sizeof(struct dynarray));
assert(da);

da->data = malloc(DYNARRAY_INIT_CAPACITY * sizeof(void*));
assert(da->data);
da->size = 0;
da->capacity = DYNARRAY_INIT_CAPACITY;

return da;
}

/*
* This function frees the memory associated with a dynamic array. Freeing
* any memory associated with values stored in the array is the responsibility
* of the caller.
*
* Params:
* da - the dynamic array to be destroyed. May not be NULL.
*/
void dynarray_free(struct dynarray* da) {
assert(da);
free(da->data);
free(da);
}

/*
* This function returns the size of a given dynamic array (i.e. the number of
* elements stored in it, not the capacity).
*/
int dynarray_size(struct dynarray* da) {
assert(da);
return da->size;
}

/*
* Auxilliary function to perform a resize on a dynamic array's underlying
* storage array.
*/
void _dynarray_resize(struct dynarray* da, int new_capacity) {
assert(new_capacity > da->size);

/*
* Allocate space for the new array.
*/
void** new_data = malloc(new_capacity * sizeof(void*));
assert(new_data);

/*
* Copy data from the old array to the new one.
*/
for (int i = 0; i < da->size; i++) {
new_data[i] = da->data[i];
}

/*
* Put the new array into the dynarray struct.
*/
free(da->data);
da->data = new_data;
da->capacity = new_capacity;
}

/*
* This function inserts a new value to a given dynamic array. The new element
* is always inserted at the *end* of the array.
*
* Params:
* da - the dynamic array into which to insert an element. May not be NULL.
* val - the value to be inserted. Note that this parameter has type void*,
* which means that a pointer of any type can be passed.
*/
void dynarray_insert(struct dynarray* da, void* val) {
assert(da);

/*
* Make sure we have enough space for the new element. Resize if needed.
*/
if (da->size == da->capacity) {
_dynarray_resize(da, 2 * da->capacity);
}

/*
* Put the new element at the end of the array.
*/
da->data[da->size] = val;
da->size++;
}

/*
* This function removes an element at a specified index from a dynamic array.
* All existing elements following the specified index are moved forward to
* fill in the gap left by the removed element.
*
* Params:
* da - the dynamic array from which to remove an element. May not be NULL.
* idx - the index of the element to be removed. The value of `idx` must be
* between 0 (inclusive) and n (exclusive), where n is the number of
* elements stored in the array.
*/
void dynarray_remove(struct dynarray* da, int idx) {
assert(da);
assert(idx < da->size && idx >= 0);

/*
* Move all elements behind the one being removed forward one index,
* overwriting the element to be removed in the process.
*/
for (int i = idx; i < da->size - 1; i++) {
da->data[i] = da->data[i+1];
}

da->size--;
}

/*
* This function returns the value of an existing element in a dynamic array.
*
* Params:
* da - the dynamic array from which to get a value. May not be NULL.
* idx - the index of the element whose value should be returned. The value
* of `idx` must be between 0 (inclusive) and n (exclusive), where n is the
* number of elements stored in the array.
*/
void* dynarray_get(struct dynarray* da, int idx) {
assert(da);
assert(idx < da->size && idx >= 0);

return da->data[idx];
}

/*
* This function updates (i.e. overwrites) the value of an existing element in
* a dynamic array.
*
* Params:
* da - the dynamic array in which to set a value. May not be NULL.
* idx - the index of the element whose value should be updated. The value
* of `idx` must be between 0 (inclusive) and n (exclusive), where n is the
* number of elements stored in the array.
* val - the new value to be set. Note that this parameter has type void*,
* which means that a pointer of any type can be passed.
*/
void dynarray_set(struct dynarray* da, int idx, void* val) {
assert(da);
assert(idx < da->size && idx >= 0);

da->data[idx] = val;
}

1) When an abundance of amino acids occurs in the body, excess nitrogen has to be removed. OnewayinwhichthisisdoneisbyUreaSynthesis.

Part A: Describe the metabolic pathway in which Urea is produced, starting with free ammonium (NH4+) in the mitrochondria. What key intermediates are created? Which enzymes are needed to perform these transformations? How does this cycle relate to the TCA cycle?

Part B: Purines also need to be catabolized and removed from the body. What chemical form(s) does/do these purine-degradation product take? How to these products differ between species (e.g., mammals, birds, amphibians)?

Part C: Describe what happens when there are defects in the purine catabolic pathways. What sorts of diseases are a results the buildup of purine degradation products?

2) The energetics of glycolysis has been well studied. While the overall process is exergonic, very few of the steps are significantly so.

Part A: Describe those steps that are exergonic in detail. What sorts of chemical processesarehappening? Howwouldyouclassifyeachtypeofreaction?

Part B: Justify the exergonic nature of each of these steps. What is it about each step that leads to its spontaneous nature? Are any of these steps reversible? Why or why not? If not, how does the body overcome this lack of reversibility?

Part C: Overall, what do you think about the effectiveness and impact of energy generation (ATP generation) of anaerobic vs. aerobic catabolism? If one is more effective vs. the other, why do both types exist?

A newborn girl appeared normal at birth, but within 24 hours she developed lethargy, hypothermia, and apnea. The attending physician suspects a metabolic disorder and orders a panel of labs. Which diagnostic would be the best to distinguish between a urea cycle disorder and a disorder in β -oxidation? (Please discuss your rationale for this choice) a. Blood glucose b. Urinary acids c. Serum fatty acids d. Plasma glutamine

A full blood work up was ordered for this female and the data is presented below. ● The initial blood ammonia level was elevated at 314 ug/dl (normal range = 17–80) and rapidly rose to 600 ug/dl. ● The urine orotic acid level was markedly elevated at 473 umol/L creatinine (nl = 0–3). ● The plasma citrulline level was normal at 10 uM/L (nl = 12–55). In this patient where orotic acid levels are elevated, list one urea cycle enzyme that is most likely deficient and one urea cycle enzyme that is least likely to be impaired. (Be sure to justify your answers)

A newborn girl appeared normal at birth, but within 24 hours she developed lethargy, hypothermia, and apnea. The attending physician suspects a metabolic disorder and orders a panel of labs.

Which diagnostic would be the best to distinguish between a urea cycle disorder and a disorder in ​β -oxidation? WHY IS THE OTHER ONES NOT AN OPTION

1. Blood glucose

2. Urinary acids

3. Serum fatty acids

4. Plasma glutamine

A full blood work up was ordered for this female and the data is presented below.

The initial blood ammonia level was elevated at 314 ug/dl (normal range = 17–80) and rapidly rose to 600 ug/dl.

The urine orotic acid level was markedly elevated at 473 umol/L creatinine (nl = 0–3). The plasma citrulline level was normal at 10 uM/L (nl = 12–55).

In this patient where orotic acid levels are elevated, list one urea cycle enzyme that is ​most likely deficient and one urea cycle enzyme that is ​least likely​​ to be impaired. EXPLAIN WHY NOT OTHER ENZYMES

Human FAV gene's coding region is 7440 bp long however the produced protein is 680 amino acid long. What is the reason? Explain scientifically using NUMBERS.

For a cow (ruminant)- Alfalfa hay and horse- Barley.
For the animal - feed ingredient combination listed. Fully describe each of the following.
Absorption of each nutrient. Be sure to describe the absorption of different minerals, vitamins, types of carbohydrates, types of amino acids, and types of lipids separately. Also, be sure to describe at the molecular level how each nutrient is absorbed into the animal’s body and where that absorption would occur.

1. First Describe a toeprint assay involving E. coli ribosomal subunits and a fictious mRNA in a cell-free extract that contains all the factors necessary for translation.

a) What results would you expect to see with 30S ribosomal subunits alone?

b) With 50S subunits alone?

c) With both subunits and all amino acids except leucine, which is required in the 20th position of the polypeptide?

A membrane spanning protein that is a channel for potassium ion transport is made up of six copies of a single polypeptide. Potassium ions are transported across the membrane using the channel.  What types of amino acids do you expect to find on the potassium ion channel polypeptides next to the heads of the membrane lipids? (multiple answers)