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