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