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