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