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