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