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