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