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