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