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