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