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