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