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