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