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