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