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