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