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