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