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