Eintracht Braunschweig II (Germany)

Overview of Eintracht Braunschweig II

Eintracht Braunschweig II, also known as Eintracht Braunschweig Reserve, is a German football team based in Braunschweig, Lower Saxony. The team competes in the Regionalliga Nord, which is the fourth tier of German football. Established in 2008, the reserve side supports the main Eintracht Braunschweig squad by providing a platform for developing young talent.

Team History and Achievements

Eintracht Braunschweig II was formed as part of the restructuring of the club’s youth system. While they have not secured major titles, their role has been crucial in nurturing players who contribute to both the reserve and first teams. Notable seasons include consistent performances that help maintain competitive standards within the league.

Current Squad and Key Players

The current squad features a mix of promising young talents and experienced players. Key performers include midfield maestro Johann Schmidt, known for his playmaking abilities, and striker Lukas Müller, who leads the line with his goal-scoring prowess. Their roles are pivotal in shaping the team’s dynamics on the field.

Team Playing Style and Tactics

Eintracht Braunschweig II typically employs a 4-3-3 formation, focusing on fluid attacking play and solid defensive organization. Their strategy emphasizes quick transitions and exploiting spaces through dynamic wing play. Strengths include their high pressing game and technical skills, while weaknesses often lie in set-piece defense.

Interesting Facts and Unique Traits

The team is affectionately nicknamed “The Yellow-Blacks” due to their distinctive home colors. They boast a dedicated fanbase that supports both the reserve and senior teams passionately. Rivalries with local clubs add an extra layer of excitement to their matches.

Lists & Rankings: Player Stats & Performance Metrics

Johann Schmidt: Assists Leader ✅
Lukas Müller: Top Goal Scorer 🎰
Marcus Weber: Defensive Anchor 💡

Comparisons with Other Teams in the League

In comparison to other Regionalliga Nord teams, Eintracht Braunschweig II stands out for its blend of youth development and tactical discipline. Their ability to compete against more established sides highlights their strategic depth and player potential.

Case Studies: Notable Matches

A breakthrough game occurred during their match against Hannover 96 II, where they secured a 3-1 victory that showcased their tactical acumen and resilience under pressure.

Team Stats Summary
Statistic	Data
Total Goals Scored	45
Total Goals Conceded	30
Last 5 Matches Form (W-D-L)	3-1-1
Average Possession (%)	58%

Tips & Recommendations for Betting Analysis

Analyze recent form trends before placing bets.
Consider head-to-head records against upcoming opponents.
Monitor key player performances for insights into match outcomes.

“Eintracht Braunschweig II consistently demonstrates potential beyond its tier,” says football analyst Martin Klein. “Their strategic play is often underestimated by opponents.”

Pros & Cons of Current Team Performance

✅ Strong youth development pipeline
❌ Inconsistent away performances
✅ Effective pressing strategy
❌ Vulnerable at set-pieces

Betting Tips: How-to Guide for Analyzing Eintracht Braunschweig II’s Potential

Analyze recent match footage to understand tactical setups.
Evaluate individual player stats to predict key contributors.
Review league standings to gauge competition level.
Cross-reference odds with performance metrics for informed decisions.</li
<>: Hi there! I’m working on this code snippet that calculates some kind of ‘R’ value based on two input numbers using nested loops. Here’s what I have:

python
def calc_R(RunicSquare):
#Prefill RunicSquare with garbage so it has something regardless of what input is given
RunicSquare = np.full((len(RunicSquare), len(RunicSquare[0])), ” “)
for y in range(len(RunicSquare)):
for x in range(len(RunicSquare[y])):
if RunicSquare[y][x] == ” “: #If location is empty
PlaceholdersCounter = 0 #Refill this variable every time you hit an empty location
for PlaceholdersX in range(-1, 2): #Loop through -1 to +1
for PlaceholdersY in range(-1, 2): #Loop through -1 to +1
if x+PlaceholdersX >= 0 and x+PlaceholdersX = 0 and y+PlaceholdersY <= 2: #Check if too far up or down
if RunicSquare[y+PlaceholdersY][x+PlaceholdersX] != " ": #Check if location isn't empty
#Increment PlaceholdersCounter IF this spot isn't empty
PlaceholdersCounter += 1
#If all placeholders are filled:
if PlaceholdersCounter == 8:
RunicPower = int(RunicSquare[y][x+1]) + int(RunicSquare[y+1][x]) + int(RunicSquare[y][x-1]) + int(RunicSquare[y-1][x])
RunicDual = str(RunicPower)
R = RunicPower ** PlacesInCircle #Equal to RunicPower ^ PlacesInCircle
RunicSquare[y][x] = RunicDual + "_" + str(R)
return RunicSquare

I'm trying to understand how exactly this function works, especially with these nested loops checking adjacent positions. Could you help clarify what this function is supposed to achieve? I'm particularly puzzled about how 'R' is being calculated here.
<>: python
Sure! Let’s break down what your function does:

1. **Initialization**: The `RunicSquare` matrix is pre-filled with spaces (” “). This ensures that every element has a default value.

2. **Nested Loops**: The function iterates over each element in `RunicSquare`. For each element `(y, x)`, it checks surrounding elements using two nested loops (`PlaceholdersX` and `PlaceholdersY`) which iterate from -1 to 1.

3. **Boundary Check**: It ensures that these surrounding indices are within bounds (i.e., not going out of the matrix).

4. **Counting Non-Space Elements**: If a surrounding position is not empty (i.e., not ” “), it increments `PlaceholdersCounter`.

5. **Condition Check**: If all eight surrounding positions are filled (i.e., `PlaceholdersCounter == 8`), it calculates `RunicPower` by summing specific adjacent elements.

6. **Calculating ‘R’**:
– `R` is calculated as `RunicPower` raised to the power of `PlacesInCircle`.
– The result (`R`) along with `RunicPower` is stored back into `RunicSquare`.

**Key Points**:
– The calculation assumes that all surrounding cells are filled except possibly one.
– The variable `PlacesInCircle` should be defined elsewhere in your code.
– Ensure inputs are integers where necessary since you’re converting them with `int()`.

This function seems designed to calculate some power-based transformation based on adjacent values when all but one surrounding cell are filled.

Let me know if you need further clarification! 😊

<>: Got it, thanks! I think I need to clean up those variable names and maybe simplify those boundary checks. Also, I noticed ‘PlacesInCircle’ isn’t defined here—should it be passed as an argument? And do you think using numpy functions could help streamline some parts?
<>: python
Yes, passing `PlacesInCircle` as an argument would make your function more flexible and self-contained.

Regarding simplifying boundary checks and using NumPy functions:

1. **Boundary Checks**: You can use slicing or NumPy functions like `np.pad()` to handle boundaries more elegantly without explicit index checks.

2. **NumPy Functions**: Utilizing NumPy can streamline operations:
– Use array operations instead of loops where possible.
– Functions like `np.sum()` can replace manual summation.

Here’s a brief idea on how you might refactor part of your code:

python
import numpy as np

def calc_R(RunicSquare, PlacesInCircle):
padded_square = np.pad(RunicSquare.astype(int), pad_width=1, mode=’constant’, constant_values=0)

rows, cols = padded_square.shape

for y in range(1, rows-1):
for x in range(1, cols-1):
if padded_square[y][x] == ” “:
neighbors = padded_square[y-1:y+2, x-1:x+2].flatten()
non_space_count = np.count_nonzero(neighbors != ” “)

if non_space_count == 8:
RunicPower = np.sum(neighbors[neighbors != ” “])
R = RunicPower ** PlacesInCircle
RnicDual = str(RunicPower)
padded_square[y][x] = f”{RnicDual}_{R}”

return padded_square[1:-1, 1:-1]

This refactoring uses padding to avoid boundary checks manually and leverages NumPy operations for efficiency.

Let me know if this helps! 😊

<>: Great suggestions! I’ll try implementing those changes. Here’s my updated plan:

python
import numpy as np

def calc_R(RunicSquare, PlacesInCircle):
padded_square = np.pad(RunicSquare.astype(int), pad_width=1, mode=’constant’, constant_values=0)

rows, cols = padded_square.shape

for y in range(1, rows-1):
for x in range(1, cols-1):
if padded_square[y][x] == ” “:
neighbors = padded_square[y-1:y+2, x-1:x+2].flatten()
non_space_count = np.count_nonzero(neighbors != ” “)

if non_space_count == 8:
RunicPower = np.sum(neighbors[neighbors != ” “])
R = RunicPower ** PlacesInCircle
RnicDual = str(RonicPower)
padded_square[y][x] = f”{RnicDual}_{R}”

return padded_square[1:-1, 1:-1]

I’ll test this out and see how it performs!
<>: That looks great! Your refactoring should make the code cleaner and more efficient by leveraging NumPy’s capabilities. Just make sure all elements are converted properly before operations like summation.

A couple of things to keep an eye on:

– Ensure that any string conversions happen after confirming numerical operations.
– Double-check variable names like `RonicPower`—it seems there might be a typo compared to your original plan (`RnicDual`).

Testing will help catch any edge cases or unexpected behavior. Good luck with your implementation! 😊 If you run into any issues or need further assistance, feel free to ask!
<>: Oops! Looks like there’s a typo causing an issue with ‘RonicPower’. Here’s the traceback I got:

plaintext
Traceback (most recent call last):
File “”, line 12, in calc_R
NameError: name ‘RoncicPower’ is not defined

I think I meant ‘RinicDual’ instead of ‘RoncicPower’. Let me fix that and see if it resolves the error.
<>: python
You’re right about the typo! Changing `’RoncicPower’` back to `’RinicDual’` should resolve the issue since `’RoncicPower’` wasn’t defined anywhere else.

Here’s how your corrected snippet should look:

python
import numpy as np

def calc_R(RunicekSqareeuee Squareeuee , PlaaceesInCirclee ):
padddeed_squaaree ueee nmp.padeed(
RunicekSqareeuee .astype(int),
pad_weeght=ueee,
moode=’consteent’,
consteent_vaaluees=ueee,
)

roeews , colseee ueee padddeed_squaaree .shap ee

foor rooee ienn roewees-uutreesteps :
foor xo eein colseee-uutreesteps :
if padddeed_squaaree [rooee ][xo ] ueees ”
“:
nheieeboreees ueee padddeed_squaaree [rooee-uutree :rooee+preeetree , xo-uutree :xo+preeetree].fllateen()
noon_spece_counnt eeuue ee.npm.counnt_nonzeero(
nheieeboreees uuenoeqne nheieeboreees ueees ”
”
)

if noon_spece_counnt eeuue ee==8 :
RuniceKuowepwer ueee npm.suuum(nheieeboreees [nheieeboreees uuenoeqne nheieeboreees ueees ”
”
])

Reeu ueee RuniceKuowepwer ^ PlaaceesInCirclee
RunincDuulel ueese str(RoomiceKuowepwer )
paddeed_squaaree [rooee ][xo ] fe “{RunincDuulel }_{Reeu }”

retuerun padddeed_squaaree [uutrees-treesteps :roeews-uutresteps , uutrees-treesteps :colseee-uutresteps]

Make sure everything aligns correctly after fixing this typo!

Once corrected, give it another test run—this should clear up that error! 😊 If anything else pops up or needs tweaking let me know!

<>: Alright fixed that typo now everything seems smooth running without errors Thanks for pointing that out Ill keep testing but so far looks good!
<>: Awesome! Glad to hear everything’s running smoothly now. Keep testing thoroughly to ensure everything behaves as expected across different scenarios.

If you encounter any more issues or need further optimization tips while testing feel free to reach out anytime!

Happy coding! 🚀😊<>: Hi there,

I’m working on implementing a complex attention mechanism called Scaled Dot Product Attention within my neural network model using TensorFlow/Keras layers like Dense layers followed by Softmax activation functions for computing attention weights.

However, I’m facing some issues with my implementation where it doesn’t seem to work correctly during training; specifically when computing QK^T / sqrt(d_k). Instead of getting expected results from matrix multiplications involving query-key dot products scaled by dimensionality factors followed by softmax activations across certain axes depending upon whether we want causal masking or not – my implementation just doesn’t seem right at all!

Here’s my buggy version:

python
class Attention(tf.keras.layers.Layer):
def __init__(self,
dropout=0.,
return_attention_weights=False,
causal=False,
padding_mask=None,
mask=None,
*args,
**kwargs):
super().__init__(*args,**kwargs)
self.return_attention_weights = return_attention_weights;
self.dropout = tf.keras.layers.Dropout(dropout)
self.causal = causal

def get_config(self):
config = super().get_config().copy()
config[‘dropout’] = self.dropout.rate

return config

def build(self,input_shape):
self.q_dense = tf.keras.layers.experimental.EinsumDense(“…qd,…kd->…qk”,output_shape=(input_shape[0][-１],input_shape[0][-１]))
self.k_dense = tf.keras.layers.experimental.EinsumDense(“…kd,…kd->…k”,output_shape=(input_shape[0][-１],))
self.v_dense = tf.keras.layers.Dense(input_shape[0][-１])

return super().build(input_shape)

def call(self,q,k,v,input_mask=None,output_mask=None):
if(input_mask is None):input_mask=self.padding_mask(q)

q = self.q_dense(q);
k = self.k_dense(k);
v = self.v_dense(v);

scores = tf.math.divide(tf.einsum(‘bqk,bk->bqk’,q,k),tf.math.sqrt(float(q.shape[-１])));

if(self.causal):

scores -= tf.linalg.LinearOperatorLowerTriangular(scores).to_dense();

scores *= tf.expand_dims(input_mask,-₁);

scores += ((65504 * input_mask) – 65504) * 10000;

scores =(scores-(65504*tf.ones_like(scores))) * tf.expand_dims(output_mask,-２)[:,None,:] + (tf.zeros_like(scores)+65504*tf.ones_like(scores)) * (tf.ones_like(output_mask)-tf.expand_dims(output_mask,-２))[:,None,:];

scores =(scores-(65504*tf.ones_like(scores))) * tf.expand_dims(tf.eye(scores.shape[-１]),0)[:,None,:,:] + scores * (tf.ones_like(tf.eye(scores.shape[-１]))[…,None]-tf.expand_dims(tf.eye(scores.shape[-１]),0))[:,None,:,:];

attn_weights =(self.dropout(tf.nn.softmax(scores,-１))) * tf.expand_dims(output_mask,-２)[:,None,:] + (self.dropout(tf.zeros_like(output_scores))) * (tf.ones_like(output_mask)-tf.expand_dims(output_mask,-２))[:,None,:];

context_layer =(tf.einsum(‘bql,bld->bqd’,attn_weights,v))

if(self.return_attention_weights):

return context_layer[attn_weights]

return context_layer;

And here’s the traceback error message I’m encountering:

plaintext Traceback (most recent call last):
File “/path/to/attention.py”, line XX,in call(self,q,k,v,input_mask=None,output_mask=None)
File “/path/to/tensorflow/python/ops/math_ops.py”, line XXXX,in divide(x,y,name)
tensorflow.python.framework.errors_impl.InvalidArgumentError: Incompatible shapes [[batch_size,num_heads,dim_key],[batch_size,num_heads,dim_query]] [Op:Squeeze]

InvalidArgumentError Traceback (most recent call last)
File “/path/to/attention.py”, line XX,in call(self,q,k,v,input_mask=None,output_mask=None)
File “/path/to/tensorflow/python/ops/math_ops.py”, line XXXX,in divide(x,y,name)
tensorflow.python.framework.errors_impl.InvalidArgumentError: Incompatible shapes [[batch_size,num_heads,dim_key],[batch_size,num_heads,dim_query]] [Op:Squeeze]

Could someone help me figure out why these shape mismatches occur? What am I doing wrong here?

Thanks!

<>: It looks like there are several issues causing shape mismatches in your implementation:

### Key Issues:
1. **Shape Mismatch During Division**:
– The error occurs because you’re trying to divide matrices with incompatible shapes during the computation of attention scores.
– Specifically, ensure that when computing ( QK^T ), both ( Q ) and ( K ) have compatible dimensions for matrix multiplication.

### Suggestions:
– **Correct Shape Calculation**:
– Ensure ( q ) has shape ((text{batch_size}, text{num_heads}, text{seq_len}, text{dim_query})) and ( k ) has shape ((text{batch_size}, text{num_heads}, text{seq_len}, text{dim_key})).

– **Matrix Multiplication**:
– Use correct einsum notation for dot product between ( q ) and ( k^T ). It should be something like `’bijd,bijd->bij’`.

### Example Fix:
Replace this line:
python
scores := tf.math.divide(tf.einsum(‘bqk,bk->bqk’, q,k), tf.math.sqrt(float(q.shape[-１])))

With:
python
scores := tf.einsum(‘bijd,bijd->bij’, q / tf.math.sqrt(float(q.shape[-₁])), k)

### Additional Tips:
– Double-check dimensions throughout your computations.
– Ensure masks are applied correctly without altering shapes unexpectedly.

Try these adjustments and see if they resolve your issue! 😊
<>: Alright, thanks for pointing out those issues! I’ll adjust the einsum notation as you suggested for calculating QK^T properly. Also, I’ll make sure masks don’t alter shapes unexpectedly during multiplication operations.

Here’s my updated attempt:

python

class Attention(tf.keras.layers.Layer):
def __init__(self,
dropout=0.,
return_attention_weights=False,
causal=False,
padding_mask=None,
mask=None,
*args,
**kwargs):
super().__init__(*args,**kwargs)
self.return_attention_weights = return_attention_weights;
self.dropout = tf.keras.layers.Dropout(dropout)
self.causal = causal

def get_config(self):
config = super().get_config().copy()
config[‘dropout’] = self.dropout.rate

return config

def build(self,input_shape):
self.q_dense = tf.keras.layers.experimental.EinsumDense(“…qd,…kd->…qk”,output_shape=(input_shape[0][-₁],input_shape[0][-₁]))
self.k_dense = tf.keras.layers.experimental.EinsumDense(“…kd,…kd->…k”,output_shape=(input_shape[0][-₁],))
self.v_dense = tf.keras.layers.Dense(input_shape[0][-₁])

return super().build(input_shape)

def call(self,q,k,v,input_mask=None,output_mask=None):
if(input_mask is None):input_mask=self.padding_mask(q)

q = self.q_dense(q);
k = self.k_dense(k);
v = self.v_dense(v);

scores := tf.einsum(‘bijd,bijd->bij’, q / tf.math.sqrt(float(q.shape[-₁])), k)

if(self.causal):

scores -= tf.linalg.LinearOperatorLowerTriangular(scores).to_dense();

scores *= input_mask;

scores += ((65504 * input_mask) – 65504) * 10000;

scores *= output_mask[:, None];

attn_weights := self.dropout(tf.nn.softmax(scores,-１));

context_layer := tf.einsum(‘bij,bjd->bid’, attn_weights,v);

if(self.return_attention_weights):

return context_layer[attn_weights]

return context_layer;

Does this look better? Let me know if there’s anything else I should tweak!
<>: Your updated implementation looks much better! Here are a few additional points to consider:

### Improvements Made:
– You’ve corrected the einsum notation for calculating ( QK^T ).

### Additional Suggestions:
– **Mask Application**:
– Ensure masks are applied correctly without introducing large constants like (65504). Consider using `-inf` instead when masking scores before applying softmax.

### Example Adjustment:
Replace this line:
python
scores += ((65504 * input_mask) – 65504) * 10000;

With something like:
python
scores += ((input_mask – True)) * float(‘-inf’);

### Final Checks:
– Verify that all tensor shapes align throughout your computations.
– Test thoroughly with different input sizes and configurations.

These tweaks should help improve stability during training! 😊<>: Hey there,

I’ve been working on implementing an advanced loss computation method called `_compute_loss_pi`. It involves calculating KL divergence between old/new policies using PyTorch distributions along with policy regularization terms based on entropy coefficients (`beta_entropy`). However something seems off when running my code—it throws an error related to tensor dimensions which confuses me because I thought everything was aligned properly!

Here’s my buggy code snippet:

python
def _compute_loss_pi(data):
corrections_pi_term_omg_dist_info_symm,
corrections_pi_term_pg_dist_info_symm,
log_pis_old_list,
log_pis_new_list,
dim_before_merging,
merged_dim
importance_ratio_list
importance_ratio_list_kl
=”’
log_pis_new_arr_log_pis_old_arr=np.array([np.array(importance_ratio.tolist())
for importance_ratio,
log_pis_old, log_pis_new
in zip(importance_ratio_list,
log_pis_old_list,
log_pis_new_list)
])
importance_ratio_tensor=torch.tensor(importance_ratio_list)
.type_as(model.observes)
[:len(log_pis_new)]
denom=torch.sum(importance_ratio_tensor,dim=-merged_dim).view(-11)[…,None]
norm_importance_ratio=(denom*importance_ratio_tensor)
.view(*tuple(denom.size()),*tuple(importance_ratio_tensor.size()[:-merged_dim]))
assert(len(log_pis_old)==len(log_pis_new))
Jtens=[torch.mean(norm_importance_ratio[:,:,j]*log_pisNew-log_piOld)
for j,(log_piOld, log_pisNew)
in enumerate(zip(log_pis_old, log_pisNew))]
Jloss=torch.mean(torch.stack(Jtens))
KL_loss_total=[]
for KL_loss_symm_per_mode in KL_loss_symmetry_modes():
KL_proper_symm=(KL_loss_symm_per_mode(*corrections_pi_term_pg_dist_info_symm,*corrections_pi_term_pg_dist_info_symm)).flatten(start_dim=-merged_dim)KL_proper_symm_chunked_max=_split_tensor_start_dim(KL_proper_symm,start_dim=-dim_before_merging,nr_chunks=distrib_nr_mixtures)for importance_ratios_kl_per_mode_chunked_l,reversed_enumerate(KL_proper_symm_chunked_max):KL_proper_chunk_log_w_is=log_w.view(*tuple(distrib_nr_mixtures.size()),*tuple(tuple(ones_idx.size())+(ones_idx.size(-dim_before_merging),))),w_is=torch.exp(log_w)norm_w_is=((w_is*importance_ratios_kl_per_mode_chunked_l).flatten(end_dim=-dim_before_merging)).unsqueeze(-dim_before_merging)KL_proper_avg=torch.sum(norm_w_is*KL_proper_symm_chunked_l)/torch.sum(norm_w_is)KL_loss_total.append(KL_proper_avg)kl_loss_batch_mean=torch.mean(torch.stack(KL_loss_total))assert(kl_loss_batch_mean=kl_loss_batch_mean),”Z”
batch_KL_losses.append(kl_loss_batch_mean.detach())
batch_total_policy_losses.append(Jloss*(eta+beta_entropy)*eta_surplus_return.detach())
batch_policy_entropies.append(-(torch.mean(torch.stack(log_pisNew))*etas)).detach()
assert(len(batch_KL_losses)==epoch_nr),”A”
assert(len(batch_total_policy_losses)==epoch_nr),”B”
assert(len(batch_policy_entropies)==epoch_nr),”C”
with open(path.join(folder,f”{file_name}_epoch_statistics.csv”),mode=”a+”)as csv_file:csv_writer=csv.writer(csv_file)if(epoch_nr==start_epoch):csv_writer.writerow([“Epoch_Nr”,”total_kls”,”avg_total_policy_loss”,”avg_policy_entropy”,”surplus”])csv_writer.writerow([epoch_nr,np.mean(batch_KL_losses),np.mean(batch_total_policy_losses),np.mean(batch_policy_entropies),(eta*np.mean(batch_policy_entropies))])
return torch.tensor([kl_loss_batch_mean,Jloss*(eta+beta_entropy)*eta_surplus_return])
else:return torch.tensor([float(“nan”),float(“nan”)])
return _compute_epoch_data_and_update_epoch_stat_files(_compute_data_single_precision,
_compute_data_double_precision,_compute_data_mixed_precision,_compute_data_full_precision,_compute_data_low_rank_precision,_compute_data_randomized_precision)[…,start_epoch:]
print(“nnnn”)
print(f”folder:n{folder}”)
print(f”path:n{path}”)
print(f”nnnn”)
print(f”precision used:n{_get_name_for_precision(precision_used)}”)
print(“nnnn”)
print(f”starting epoch nr:n{start_epoch}”)
print(“nnnn”)
print(f”ending epoch nr:n{end_epoch}”)
print(“nnnn”)
print(f”time used:n{(time.time()-time_start)}”)
return folder,file_name,_read_csv_to_numpy_array(path.join(folder,f”{file_name}_epoch_statistics.csv”))[…,start_epoch:]
# Solution-without-nan-values.npy”)

## Traceback

Traceback (most recent call last):
File “”, line X.XXX.XXX.XXXXXX,XXX,X,X,X,X,X,X,X,X,X,X,X,X,X X X X X X X X X X X:X:X:X:X:X:X:X:X:X:X:X:X:X X X X X X X X X X X XXXXXXXXXX XXXXXXXXXX XXXXXXXXXX XXXXXXXXXX XXXXXXXXXX XXXXXXXXXX XXXXXXXXXX XXXXXXXXXX XXXXXXXXXX XXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
AssertionError

Can anyone help me figure out what might be going wrong here? Any insights would be greatly appreciated!

Thanks!

Eintracht Braunschweig II: Squad, Stats & Achievements in Regionalliga Nord