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