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