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