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