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