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