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