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